diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 00000000..ca65e8d9 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,30 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +### Added + +- **Typed Aggregate Result Accessors**: Added strongly-typed accessor methods to `AggregateResult` and `AggregateGroupByResult.Group` for safer and more convenient access to aggregation properties. See [Aggregate Result Accessors documentation](docs/AGGREGATE_RESULT_ACCESSORS.md) for details. + - Direct accessor methods: `Text()`, `Integer()`, `Number()`, `Boolean()`, `Date()` + - TryGet methods: `TryGetText()`, `TryGetInteger()`, `TryGetNumber()`, `TryGetBoolean()`, `TryGetDate()`, `TryGet()` + - Lambda pattern methods: `Property()`, `Match()`, `Match()` + +- **Typed Aggregate Results**: Added `ToTyped()` extension method to map aggregate results to strongly-typed objects. + - `AggregateResult` and `AggregateGroupByResult` typed result wrappers + - Suffix-based value extraction: use property names like `PriceSum`, `RatingMean`, `TitleCount` to extract specific values + - Full aggregate type mapping: use `Aggregate.Text`, `Aggregate.Number`, etc. for complete access + - Case-insensitive property name matching + +- **MetricsExtractor**: Added `MetricsExtractor.FromType()` to automatically extract `returnMetrics` from a type definition + - Analyzes property types and suffixes to generate the appropriate `Aggregate.Metric[]` + - Combines multiple suffixes for the same field into a single metric + - Works with both full `Aggregate.*` types and suffix-based properties + +- **Aggregate Property Analyzer**: Added Roslyn analyzers that validate types used with `ToTyped()` + - WEAVIATE002: Warns when a primitive property lacks a recognized suffix + - WEAVIATE003: Warns when a suffix is used with an incompatible type diff --git a/README.md b/README.md index 0854c51f..1e0312e3 100644 --- a/README.md +++ b/README.md @@ -51,6 +51,7 @@ For more detailed information on specific features, please refer to the official - **[RBAC API Usage](docs/RBAC_API_USAGE.md)**: Managing users, roles, permissions, and groups - **[Backup API Usage](docs/BACKUP_API_USAGE.md)**: Creating and restoring backups - **[Nodes API Usage](docs/NODES_API_USAGE.md)**: Querying cluster node information +- **[Aggregate Result Accessors](docs/AGGREGATE_RESULT_ACCESSORS.md)**: Type-safe access to aggregation results --- diff --git a/docs/AGGREGATE_RESULT_ACCESSORS.md b/docs/AGGREGATE_RESULT_ACCESSORS.md new file mode 100644 index 00000000..9fec2b24 --- /dev/null +++ b/docs/AGGREGATE_RESULT_ACCESSORS.md @@ -0,0 +1,1226 @@ +# Aggregate Result Accessors + +## Overview + +The Weaviate C# client provides **strongly-typed accessor methods** for working with aggregation results. These accessors eliminate the need to manually cast from the `Properties` dictionary, providing compile-time type safety and improved developer experience. + +### Benefits + +- **Type Safety**: No more manual casting from `object` to specific aggregation types +- **Null Safety**: Methods return `null` when property doesn't exist or is wrong type +- **TryGet Pattern**: Familiar .NET pattern for safe access with output parameters +- **Pattern Matching**: Lambda-based matching for flexible handling of different aggregation types +- **IDE Support**: Full IntelliSense for all accessor methods + +## Quick Start + +### Before (Manual Casting) + +```csharp +var result = await collection.Aggregate.OverAll( + returnMetrics: [Metrics.ForProperty("price").Number()] +); + +// Manual casting - error-prone +var priceAgg = result.Properties["price"] as Aggregate.Number; +if (priceAgg != null) +{ + Console.WriteLine($"Average price: {priceAgg.Mean}"); +} +``` + +### After (Typed Accessors) + +```csharp +var result = await collection.Aggregate.OverAll( + returnMetrics: [Metrics.ForProperty("price").Number()] +); + +// Option 1: Direct accessor +var priceAgg = result.Number("price"); +if (priceAgg != null) +{ + Console.WriteLine($"Average price: {priceAgg.Mean}"); +} + +// Option 2: TryGet pattern +if (result.TryGetNumber("price", out var price)) +{ + Console.WriteLine($"Average price: {price.Mean}"); +} + +// Option 3: Pattern matching +result.Match("price", + number: n => Console.WriteLine($"Average price: {n.Mean}") +); +``` + +## Direct Accessor Methods + +Simple methods that return the typed aggregation or `null`. + +### Available Methods + +| Method | Returns | Use Case | +|--------|---------|----------| +| `Text(propertyName)` | `Aggregate.Text?` | Text/string properties | +| `Integer(propertyName)` | `Aggregate.Integer?` | Int/long properties | +| `Number(propertyName)` | `Aggregate.Number?` | Float/double properties | +| `Boolean(propertyName)` | `Aggregate.Boolean?` | Boolean properties | +| `Date(propertyName)` | `Aggregate.Date?` | DateTime properties | + +### Example + +```csharp +var result = await collection.Aggregate.OverAll( + returnMetrics: [ + Metrics.ForProperty("title").Text(), + Metrics.ForProperty("price").Number(), + Metrics.ForProperty("quantity").Integer(), + Metrics.ForProperty("inStock").Boolean(), + Metrics.ForProperty("createdAt").Date() + ] +); + +// Access text aggregation +var titleAgg = result.Text("title"); +if (titleAgg != null) +{ + Console.WriteLine($"Title count: {titleAgg.Count}"); + foreach (var occurrence in titleAgg.TopOccurrences) + { + Console.WriteLine($" {occurrence.Value}: {occurrence.Count}"); + } +} + +// Access numeric aggregation +var priceAgg = result.Number("price"); +if (priceAgg != null) +{ + Console.WriteLine($"Price - Min: {priceAgg.Minimum}, Max: {priceAgg.Maximum}, Mean: {priceAgg.Mean}"); +} + +// Access integer aggregation +var quantityAgg = result.Integer("quantity"); +if (quantityAgg != null) +{ + Console.WriteLine($"Total quantity: {quantityAgg.Sum}"); +} + +// Access boolean aggregation +var inStockAgg = result.Boolean("inStock"); +if (inStockAgg != null) +{ + Console.WriteLine($"In stock: {inStockAgg.PercentageTrue:P0}"); +} + +// Access date aggregation +var dateAgg = result.Date("createdAt"); +if (dateAgg != null) +{ + Console.WriteLine($"Date range: {dateAgg.Minimum} to {dateAgg.Maximum}"); +} +``` + +## TryGet Methods + +Methods following the .NET `TryGet` pattern for safe access with output parameters. + +### Available Methods + +| Method | Output Parameter | Returns | +|--------|------------------|---------| +| `TryGetText(propertyName, out text)` | `Aggregate.Text` | `bool` | +| `TryGetInteger(propertyName, out integer)` | `Aggregate.Integer` | `bool` | +| `TryGetNumber(propertyName, out number)` | `Aggregate.Number` | `bool` | +| `TryGetBoolean(propertyName, out boolean)` | `Aggregate.Boolean` | `bool` | +| `TryGetDate(propertyName, out date)` | `Aggregate.Date` | `bool` | +| `TryGet(propertyName, out aggregation)` | `T` | `bool` | + +### Example + +```csharp +// Specific TryGet methods +if (result.TryGetNumber("price", out var price)) +{ + Console.WriteLine($"Average price: {price.Mean}"); + Console.WriteLine($"Price range: {price.Minimum} - {price.Maximum}"); +} +else +{ + Console.WriteLine("Price aggregation not available"); +} + +if (result.TryGetText("category", out var category)) +{ + Console.WriteLine($"Categories found: {category.Count}"); +} + +// Generic TryGet +if (result.TryGet("inStock", out var stockAgg)) +{ + Console.WriteLine($"In stock: {stockAgg.TotalTrue}, Out of stock: {stockAgg.TotalFalse}"); +} +``` + +## Pattern Matching Methods + +Lambda-based methods for flexible handling of aggregation types. + +### Property Method + +Execute an action or function on a specific type: + +```csharp +// Action variant - execute if matches +result.Property("price", price => +{ + Console.WriteLine($"Min: {price.Minimum}"); + Console.WriteLine($"Max: {price.Maximum}"); + Console.WriteLine($"Mean: {price.Mean}"); +}); + +// Func variant - return a value +var summary = result.Property("price", + price => $"Price range: ${price.Minimum} - ${price.Maximum}" +); +``` + +### Match Method + +Handle multiple types with a single call: + +```csharp +// Action variant - execute the matching handler +result.Match("field", + text: t => Console.WriteLine($"Text: {t.Count} occurrences"), + integer: i => Console.WriteLine($"Integer: sum={i.Sum}"), + number: n => Console.WriteLine($"Number: mean={n.Mean}"), + boolean: b => Console.WriteLine($"Boolean: {b.PercentageTrue:P0} true"), + date: d => Console.WriteLine($"Date range: {d.Minimum} to {d.Maximum}") +); + +// Func variant - return a value based on type +var description = result.Match("field", + text: t => $"Text with {t.TopOccurrences.Count} unique values", + integer: i => $"Integer ranging from {i.Minimum} to {i.Maximum}", + number: n => $"Number with mean {n.Mean:F2}", + boolean: b => $"Boolean: {b.PercentageTrue:P0} true", + date: d => $"Dates from {d.Minimum:d} to {d.Maximum:d}" +); + +Console.WriteLine(description ?? "Unknown type"); +``` + +### Handling All Properties + +Iterate through all properties with type-safe handling: + +```csharp +foreach (var (name, _) in result.Properties) +{ + var description = result.Match(name, + text: t => $"{name}: {t.Count} items, top: {t.TopOccurrences.FirstOrDefault()?.Value}", + integer: i => $"{name}: range [{i.Minimum}, {i.Maximum}], sum: {i.Sum}", + number: n => $"{name}: range [{n.Minimum:F2}, {n.Maximum:F2}], mean: {n.Mean:F2}", + boolean: b => $"{name}: {b.TotalTrue} true, {b.TotalFalse} false", + date: d => $"{name}: {d.Minimum:d} to {d.Maximum:d}" + ); + + Console.WriteLine(description ?? $"{name}: unsupported type"); +} +``` + +## GroupBy Results + +All accessor methods are also available on `AggregateGroupByResult.Group`: + +```csharp +var result = await collection.Aggregate.OverAll( + groupBy: "category", + returnMetrics: [Metrics.ForProperty("price").Number()] +); + +foreach (var group in result.Groups) +{ + Console.WriteLine($"Category: {group.GroupedBy.Value}"); + Console.WriteLine($" Count: {group.TotalCount}"); + + // Direct accessor + var priceAgg = group.Number("price"); + if (priceAgg != null) + { + Console.WriteLine($" Avg Price: {priceAgg.Mean:C}"); + } + + // Or use TryGet + if (group.TryGetNumber("price", out var price)) + { + Console.WriteLine($" Price Range: {price.Minimum:C} - {price.Maximum:C}"); + } + + // Or use Match + group.Match("price", + number: n => Console.WriteLine($" Median Price: {n.Median:C}") + ); +} +``` + +## Aggregation Property Types + +### Aggregate.Text + +For text/string properties: + +| Property | Type | Description | +|----------|------|-------------| +| `Count` | `long?` | Number of values | +| `TopOccurrences` | `List>` | Most frequent values | + +### Aggregate.Integer + +For integer/long properties: + +| Property | Type | Description | +|----------|------|-------------| +| `Count` | `long?` | Number of values | +| `Minimum` | `long?` | Minimum value | +| `Maximum` | `long?` | Maximum value | +| `Mean` | `double?` | Average value | +| `Median` | `double?` | Median value | +| `Mode` | `long?` | Most common value | +| `Sum` | `long?` | Sum of all values | + +### Aggregate.Number + +For float/double properties: + +| Property | Type | Description | +|----------|------|-------------| +| `Count` | `long?` | Number of values | +| `Minimum` | `double?` | Minimum value | +| `Maximum` | `double?` | Maximum value | +| `Mean` | `double?` | Average value | +| `Median` | `double?` | Median value | +| `Mode` | `double?` | Most common value | +| `Sum` | `double?` | Sum of all values | + +### Aggregate.Boolean + +For boolean properties: + +| Property | Type | Description | +|----------|------|-------------| +| `Count` | `long?` | Number of values | +| `TotalTrue` | `long` | Count of true values | +| `TotalFalse` | `long` | Count of false values | +| `PercentageTrue` | `double` | Percentage of true values (0-1) | +| `PercentageFalse` | `double` | Percentage of false values (0-1) | + +### Aggregate.Date + +For date/datetime properties: + +| Property | Type | Description | +|----------|------|-------------| +| `Count` | `long?` | Number of values | +| `Minimum` | `DateTime?` | Earliest date | +| `Maximum` | `DateTime?` | Latest date | +| `Median` | `DateTime?` | Median date | +| `Mode` | `DateTime?` | Most common date | + +## Best Practices + +### 1. Choose the Right Accessor + +```csharp +// Use direct accessor when you just need the value +var price = result.Number("price"); + +// Use TryGet when you need to handle missing properties +if (result.TryGetNumber("price", out var p)) +{ + // Use p +} + +// Use Match when handling multiple possible types +result.Match("unknownField", + text: t => /* handle text */, + number: n => /* handle number */ +); +``` + +### 2. Handle Null Gracefully + +```csharp +// Direct accessor returns null if not found or wrong type +var price = result.Number("price"); +var average = price?.Mean ?? 0; + +// Or use null-conditional operator +Console.WriteLine($"Mean: {result.Number("price")?.Mean}"); +``` + +### 3. Use Pattern Matching for Unknown Types + +```csharp +// When you don't know the type at compile time +foreach (var propertyName in propertyNames) +{ + result.Match(propertyName, + text: t => ProcessText(t), + integer: i => ProcessInteger(i), + number: n => ProcessNumber(n), + boolean: b => ProcessBoolean(b), + date: d => ProcessDate(d) + ); +} +``` + +## API Reference + +### AggregateResult Methods + +```csharp +// Direct accessors +Aggregate.Text? Text(string propertyName) +Aggregate.Integer? Integer(string propertyName) +Aggregate.Number? Number(string propertyName) +Aggregate.Boolean? Boolean(string propertyName) +Aggregate.Date? Date(string propertyName) + +// TryGet methods +bool TryGetText(string propertyName, out Aggregate.Text text) +bool TryGetInteger(string propertyName, out Aggregate.Integer integer) +bool TryGetNumber(string propertyName, out Aggregate.Number number) +bool TryGetBoolean(string propertyName, out Aggregate.Boolean boolean) +bool TryGetDate(string propertyName, out Aggregate.Date date) +bool TryGet(string propertyName, out T aggregation) where T : Aggregate.Property + +// Pattern matching +bool Property(string propertyName, Action action) where T : Aggregate.Property +TResult? Property(string propertyName, Func func) where T : Aggregate.Property +bool Match(string propertyName, + Action? text = null, + Action? integer = null, + Action? number = null, + Action? boolean = null, + Action? date = null) +TResult? Match(string propertyName, + Func? text = null, + Func? integer = null, + Func? number = null, + Func? boolean = null, + Func? date = null) +``` + +### AggregateGroupByResult.Group Methods + +All the same methods are available on `AggregateGroupByResult.Group`. + +## Typed Aggregate Results with ToTyped<T>() + +In addition to the accessor methods described above, you can use the `ToTyped()` extension method to automatically map aggregation results to a strongly-typed object. This is particularly useful when you want to work with aggregation data in a structured way. + +### How It Works + +1. Execute an aggregation query using the `AggregateClient` +2. Call `ToTyped()` on the result to map it to your custom type +3. Access the mapped properties directly + +The mapper supports two approaches for property definitions: + +1. **Full Aggregate Types**: Use `Aggregate.Text`, `Aggregate.Integer`, etc. as property types to get the complete aggregation data +2. **Suffix-Based Extraction**: Use primitive types with specific suffixes to extract individual values (e.g., `PriceSum`, `RatingMean`, `TitleCount`) + +### Example: Full Aggregation Types + +When you want access to all aggregation properties, use the full `Aggregate.*` types: + +```csharp +public class ArticleAggregations +{ + public Aggregate.Text? Title { get; set; } + public Aggregate.Integer? WordCount { get; set; } + public Aggregate.Number? Rating { get; set; } + public Aggregate.Boolean? IsPublished { get; set; } + public Aggregate.Date? PublishedDate { get; set; } +} + +// Execute aggregation and convert to typed result +var collection = weaviate.UseCollection("Articles"); +var result = await collection.Aggregate.OverAll( + returnMetrics: [ + Metrics.ForProperty("title").Text(), + Metrics.ForProperty("wordCount").Integer(), + Metrics.ForProperty("rating").Number(), + Metrics.ForProperty("isPublished").Boolean(), + Metrics.ForProperty("publishedDate").Date() + ] +); + +// Convert to typed result +var typed = result.ToTyped(); + +// Access typed properties directly +Console.WriteLine($"Title count: {typed.Properties.Title?.Count}"); +Console.WriteLine($"Average rating: {typed.Properties.Rating?.Mean}"); +Console.WriteLine($"Word count range: {typed.Properties.WordCount?.Minimum} - {typed.Properties.WordCount?.Maximum}"); +Console.WriteLine($"Published: {typed.Properties.IsPublished?.PercentageTrue:P0}"); +``` + +### Example: Suffix-Based Extraction + +Use property name suffixes to explicitly indicate which value to extract: + +```csharp +public class ArticleSummary +{ + // Field "title" + suffix "Count" = TitleCount + public long? TitleCount { get; set; } + + // Field "rating" + suffix "Mean" = RatingMean + public double? RatingMean { get; set; } + + // Field "wordCount" + suffix "Sum" = WordCountSum + public long? WordCountSum { get; set; } + + // Field "isPublished" + suffix "PercentageTrue" = IsPublishedPercentageTrue + public double? IsPublishedPercentageTrue { get; set; } + + // Field "publishedDate" + suffix "Minimum" = PublishedDateMinimum + public DateTime? PublishedDateMinimum { get; set; } +} + +var result = await collection.Aggregate.OverAll( + returnMetrics: [ + Metrics.ForProperty("title").Text(), + Metrics.ForProperty("rating").Number(), + Metrics.ForProperty("wordCount").Integer(), + Metrics.ForProperty("isPublished").Boolean(), + Metrics.ForProperty("publishedDate").Date() + ] +); + +// Convert to typed result with suffix-based extraction +var typed = result.ToTyped(); + +// Access extracted values directly +Console.WriteLine($"Articles with titles: {typed.Properties.TitleCount}"); +Console.WriteLine($"Average rating: {typed.Properties.RatingMean}"); +Console.WriteLine($"Total words: {typed.Properties.WordCountSum}"); +Console.WriteLine($"Percentage published: {typed.Properties.IsPublishedPercentageTrue:P0}"); +Console.WriteLine($"Earliest: {typed.Properties.PublishedDateMinimum}"); +``` + +### Available Suffixes + +| Suffix | Applicable Types | Expected Property Type | Description | +|--------|-----------------|------------------------|-------------| +| `Count` | All | `long`, `int` | Number of values | +| `Sum` | Integer, Number | `long`, `int`, `double`, `float` | Sum of all values | +| `Mean`, `Average` | Integer, Number | `double`, `float` | Average value | +| `Min`, `Minimum` | Integer, Number, Date | `long`, `int`, `double`, `DateTime` | Minimum value | +| `Max`, `Maximum` | Integer, Number, Date | `long`, `int`, `double`, `DateTime` | Maximum value | +| `Median` | Integer, Number, Date | `double`, `DateTime` | Median value | +| `Mode` | Integer, Number, Date | `long`, `int`, `double`, `DateTime` | Most common value | +| `TotalTrue` | Boolean | `long`, `int` | Count of true values | +| `TotalFalse` | Boolean | `long`, `int` | Count of false values | +| `PercentageTrue` | Boolean | `double`, `float` | Percentage of true (0.0-1.0) | +| `PercentageFalse` | Boolean | `double`, `float` | Percentage of false (0.0-1.0) | +| `TopOccurrence` | Text | `string` | Most frequent value | +| `TopOccurrences` | Text | `List>` | All top occurrences | + +### Mixed Mapping + +You can mix full types and suffix-based extraction in the same class: + +```csharp +public class ProductStats +{ + // Full type for complete access + public Aggregate.Number? Price { get; set; } + + // Extract specific values with suffixes + public double? PriceMean { get; set; } + public double? PriceSum { get; set; } + public long? QuantitySum { get; set; } + public long? CategoryCount { get; set; } +} +``` + +### Extracting Metrics from Types + +Instead of manually specifying the `returnMetrics` parameter, you can use `MetricsExtractor.FromType()` to automatically generate the appropriate metrics from your type definition: + +```csharp +using Weaviate.Client.Models.Typed; + +public class ProductStats +{ + public double? PriceMean { get; set; } + public double? PriceMin { get; set; } + public double? PriceMax { get; set; } + public long? QuantitySum { get; set; } + public Aggregate.Text? Category { get; set; } +} + +// Automatically extract metrics from the type +var metrics = MetricsExtractor.FromType(); + +// Use the extracted metrics in the query +var result = await collection.Aggregate.OverAll(returnMetrics: metrics); + +// Convert to typed result +var typed = result.ToTyped(); +``` + +The `MetricsExtractor` analyzes your type and: + +1. For **Aggregate.* types** (e.g., `Aggregate.Text`, `Aggregate.Number`), it enables all metric flags for that property +2. For **suffix-based properties** (e.g., `PriceMean`, `QuantitySum`), it enables only the specific metric flags needed + +This approach ensures the query only requests the metrics you actually need, and the type definition serves as the single source of truth for both the query and the result mapping. + +#### Example: Multiple Suffixes for Same Field + +When you have multiple properties with different suffixes for the same field, the metrics are combined: + +```csharp +public class PriceAnalysis +{ + public double? PriceMean { get; set; } + public double? PriceMin { get; set; } + public double? PriceMax { get; set; } + public long? PriceCount { get; set; } +} + +// This extracts a single Number metric for "price" with Mean, Minimum, Maximum, and Count enabled +var metrics = MetricsExtractor.FromType(); +``` + +#### Selective Metrics with Type-Specific Attributes + +When using full `Aggregate.*` types, you can specify which metrics to query using type-specific attributes. This provides excellent IntelliSense guidance and reduces network traffic by querying only the metrics you need: + +```csharp +using Weaviate.Client.Models.Typed; + +public class ProductStats +{ + // Query only Min, Max, Mean (not Sum, Median, Mode, Count) + [NumberMetrics(Minimum = true, Maximum = true, Mean = true)] + public Aggregate.Number? Price { get; set; } + + // Query all Integer metrics (no attribute) + public Aggregate.Integer? Quantity { get; set; } + + // Query Count and TopOccurrences with minimum threshold + [TextMetrics(Count = true, TopOccurrences = true, MinOccurrences = 5)] + public Aggregate.Text? Category { get; set; } + + // Query only specific Boolean metrics + [BooleanMetrics(TotalTrue = true, PercentageTrue = true)] + public Aggregate.Boolean? Featured { get; set; } +} + +var metrics = MetricsExtractor.FromType(); +var result = await collection.Aggregate.OverAll(returnMetrics: metrics); +var typed = result.ToTyped(); +``` + +**Available attributes:** + +| Attribute | Applicable Type | Available Properties | +|-----------|----------------|---------------------| +| `[TextMetrics]` | `Aggregate.Text` | `Count`, `TopOccurrences`, `MinOccurrences` | +| `[IntegerMetrics]` | `Aggregate.Integer` | `Count`, `Sum`, `Mean`, `Minimum`, `Maximum`, `Median`, `Mode` | +| `[NumberMetrics]` | `Aggregate.Number` | `Count`, `Sum`, `Mean`, `Minimum`, `Maximum`, `Median`, `Mode` | +| `[BooleanMetrics]` | `Aggregate.Boolean` | `Count`, `TotalTrue`, `TotalFalse`, `PercentageTrue`, `PercentageFalse` | +| `[DateMetrics]` | `Aggregate.Date` | `Count`, `Minimum`, `Maximum`, `Median`, `Mode` | + +**Benefits:** +- Excellent IntelliSense showing available metrics for each type +- Compile-time safety - C# compiler prevents mismatches +- Reduces network traffic by querying only needed metrics +- Clean, readable syntax with named boolean properties +- Properties without attributes query all metrics (backward compatible) + +**Example with IntelliSense:** + +When you type `[NumberMetrics(` in your IDE, IntelliSense will show exactly which properties are available (Minimum, Maximum, Mean, Sum, Count, Median, Mode), making it clear what metrics can be queried for Number types. + +**MinOccurrences parameter:** + +The `TextMetrics` attribute includes a special `MinOccurrences` parameter that sets the minimum occurrence threshold for top occurrences: + +```csharp +public class CategoryAnalysis +{ + // Only show categories that appear at least 10 times + [TextMetrics(TopOccurrences = true, MinOccurrences = 10)] + public Aggregate.Text? Category { get; set; } +} +``` + +**Analyzer validation:** + +If you use the wrong attribute type (e.g., `[NumberMetrics]` on an `Aggregate.Text` property), you'll get a **WEAVIATE007** warning at compile time pointing out the mismatch. + +### GroupBy with Typed Results + +Typed mapping also works with grouped aggregations using `ToTyped()`: + +```csharp +public class CategoryStats +{ + public Aggregate.Number? Rating { get; set; } + public double? RatingMean { get; set; } + public long? RatingCount { get; set; } +} + +var result = await collection.Aggregate.OverAll( + groupBy: new Aggregate.GroupBy("category"), + returnMetrics: [Metrics.ForProperty("rating").Number()] +); + +// Convert grouped result to typed +var typed = result.ToTyped(); + +foreach (var group in typed.Groups) +{ + Console.WriteLine($"Category: {group.GroupedBy.Value}"); + Console.WriteLine($" Count: {group.TotalCount}"); + Console.WriteLine($" Avg Rating: {group.Properties.Rating?.Mean}"); + // Or using suffix extraction: + Console.WriteLine($" Avg Rating: {group.Properties.RatingMean}"); +} +``` + +### GroupBy with Multiple Properties + +When grouping, you can aggregate multiple properties and access them all in a typed manner: + +```csharp +public class ProductCategoryAnalysis +{ + // Price statistics + public Aggregate.Number? Price { get; set; } + public double? PriceMean { get; set; } + public double? PriceMin { get; set; } + public double? PriceMax { get; set; } + + // Stock statistics + public Aggregate.Integer? StockQuantity { get; set; } + public long? StockQuantitySum { get; set; } + + // Availability + public double? InStockPercentageTrue { get; set; } +} + +var result = await collection.Aggregate.OverAll( + groupBy: new Aggregate.GroupBy("category"), + returnMetrics: [ + Metrics.ForProperty("price").Number(), + Metrics.ForProperty("stockQuantity").Integer(), + Metrics.ForProperty("inStock").Boolean() + ] +); + +var typed = result.ToTyped(); + +// Generate a report for each category +foreach (var group in typed.Groups) +{ + Console.WriteLine($"=== {group.GroupedBy.Value} ==="); + Console.WriteLine($"Products in category: {group.TotalCount}"); + Console.WriteLine($"Price range: ${group.Properties.PriceMin:F2} - ${group.Properties.PriceMax:F2}"); + Console.WriteLine($"Average price: ${group.Properties.PriceMean:F2}"); + Console.WriteLine($"Total stock: {group.Properties.StockQuantitySum}"); + Console.WriteLine($"In stock: {group.Properties.InStockPercentageTrue:P0}"); + Console.WriteLine(); +} +``` + +### Comparing Groups with LINQ + +The typed groups work seamlessly with LINQ for analysis: + +```csharp +public class SalesRegionStats +{ + public double? RevenueMean { get; set; } + public double? RevenueSum { get; set; } + public long? OrdersCount { get; set; } +} + +var result = await collection.Aggregate.OverAll( + groupBy: new Aggregate.GroupBy("region"), + returnMetrics: [ + Metrics.ForProperty("revenue").Number(), + Metrics.ForProperty("orders").Integer() + ] +); + +var typed = result.ToTyped(); + +// Find top performing regions +var topRegions = typed.Groups + .Where(g => g.Properties.RevenueSum.HasValue) + .OrderByDescending(g => g.Properties.RevenueSum) + .Take(5); + +foreach (var region in topRegions) +{ + Console.WriteLine($"{region.GroupedBy.Value}: ${region.Properties.RevenueSum:N0} total revenue"); +} + +// Calculate overall statistics +var totalRevenue = typed.Groups.Sum(g => g.Properties.RevenueSum ?? 0); +var avgRevenuePerRegion = typed.Groups.Average(g => g.Properties.RevenueMean ?? 0); + +Console.WriteLine($"Total revenue across all regions: ${totalRevenue:N0}"); +Console.WriteLine($"Average revenue per region: ${avgRevenuePerRegion:N0}"); +``` + +### Nested GroupBy Analysis + +Access group metadata alongside typed properties: + +```csharp +public class AuthorStats +{ + public long? ArticlesCount { get; set; } + public double? WordCountMean { get; set; } + public long? WordCountSum { get; set; } + public double? RatingMean { get; set; } +} + +var result = await collection.Aggregate.OverAll( + groupBy: new Aggregate.GroupBy("author"), + returnMetrics: [ + Metrics.ForProperty("title").Text(), + Metrics.ForProperty("wordCount").Integer(), + Metrics.ForProperty("rating").Number() + ] +); + +var typed = result.ToTyped(); + +// Build a dictionary for quick lookups +var authorLookup = typed.Groups.ToDictionary( + g => g.GroupedBy.Value?.ToString() ?? "Unknown", + g => g.Properties +); + +// Access specific author's stats +if (authorLookup.TryGetValue("John Doe", out var johnStats)) +{ + Console.WriteLine($"John Doe has written {johnStats.ArticlesCount} articles"); + Console.WriteLine($"Total words: {johnStats.WordCountSum:N0}"); + Console.WriteLine($"Average rating: {johnStats.RatingMean:F1}/5"); +} + +// Find the most prolific author +var mostProlific = typed.Groups + .OrderByDescending(g => g.Properties.ArticlesCount ?? 0) + .FirstOrDefault(); + +if (mostProlific != null) +{ + Console.WriteLine($"Most prolific author: {mostProlific.GroupedBy.Value} " + + $"with {mostProlific.Properties.ArticlesCount} articles"); +} +``` + +### Accessing the Untyped Result + +The typed result always preserves access to the underlying untyped result: + +```csharp +var result = await collection.Aggregate.OverAll( + returnMetrics: [Metrics.ForProperty("rating").Number()] +); + +var typed = result.ToTyped(); + +// Access untyped result when needed +var untypedResult = typed.Untyped; +Console.WriteLine($"Total count: {untypedResult.TotalCount}"); + +// Use accessor methods on untyped result +if (untypedResult.TryGetNumber("rating", out var rating)) +{ + Console.WriteLine($"Rating median: {rating.Median}"); +} +``` + +### Complete Example + +Here's a complete example showing different ways to work with aggregate results: + +```csharp +// Define your aggregation result type +public class ProductStats +{ + // Full aggregate types for complete access + public Aggregate.Number? Price { get; set; } + public Aggregate.Integer? Quantity { get; set; } + + // Suffix-based extraction for specific values + public double? PriceMean { get; set; } + public double? PriceMin { get; set; } + public double? PriceMax { get; set; } + public long? QuantitySum { get; set; } + public long? CategoryCount { get; set; } +} + +// Execute aggregation +var result = await collection.Aggregate.OverAll( + returnMetrics: [ + Metrics.ForProperty("price").Number(), + Metrics.ForProperty("quantity").Integer(), + Metrics.ForProperty("category").Text() + ] +); + +// Option 1: Use accessor methods directly +var avgPrice = result.Number("price")?.Mean; + +// Option 2: Use TryGet pattern +if (result.TryGetNumber("price", out var priceAgg)) +{ + Console.WriteLine($"Price range: {priceAgg.Minimum} - {priceAgg.Maximum}"); +} + +// Option 3: Convert to typed object +var stats = result.ToTyped(); +Console.WriteLine($"Average price: {stats.Properties.PriceMean}"); +Console.WriteLine($"Price range: {stats.Properties.PriceMin} - {stats.Properties.PriceMax}"); +Console.WriteLine($"Total quantity: {stats.Properties.QuantitySum}"); + +// Full aggregate access is also available +Console.WriteLine($"Price median: {stats.Properties.Price?.Median}"); +``` + +## Real-World Usage Scenarios + +### Scenario 1: E-Commerce Dashboard + +Build a product analytics dashboard with category breakdowns: + +```csharp +public class CategoryDashboard +{ + public long? ProductCount { get; set; } + public double? PriceMean { get; set; } + public double? PriceMin { get; set; } + public double? PriceMax { get; set; } + public long? StockSum { get; set; } + public double? InStockPercentageTrue { get; set; } + public double? RatingMean { get; set; } +} + +public async Task> GetCategoryDashboard( + CollectionClient collection) +{ + var result = await collection.Aggregate.OverAll( + groupBy: new Aggregate.GroupBy("category"), + returnMetrics: [ + Metrics.ForProperty("name").Text(), + Metrics.ForProperty("price").Number(), + Metrics.ForProperty("stockLevel").Integer(), + Metrics.ForProperty("inStock").Boolean(), + Metrics.ForProperty("rating").Number() + ] + ); + + var typed = result.ToTyped(); + + return typed.Groups.ToDictionary( + g => g.GroupedBy.Value?.ToString() ?? "Unknown", + g => g.Properties + ); +} + +// Usage +var dashboard = await GetCategoryDashboard(collection); +foreach (var (category, stats) in dashboard) +{ + Console.WriteLine($"Category: {category}"); + Console.WriteLine($" Products: {stats.ProductCount}"); + Console.WriteLine($" Price Range: ${stats.PriceMin:F2} - ${stats.PriceMax:F2}"); + Console.WriteLine($" Avg Price: ${stats.PriceMean:F2}"); + Console.WriteLine($" Total Stock: {stats.StockSum}"); + Console.WriteLine($" Availability: {stats.InStockPercentageTrue:P0}"); + Console.WriteLine($" Avg Rating: {stats.RatingMean:F1}/5"); +} +``` + +### Scenario 2: Content Analytics + +Analyze blog posts or articles by publication status and author: + +```csharp +public class ContentMetrics +{ + // Publication stats + public double? IsPublishedPercentageTrue { get; set; } + public long? ViewCountSum { get; set; } + public double? ViewCountMean { get; set; } + + // Content stats + public long? WordCountSum { get; set; } + public double? WordCountMean { get; set; } + + // Engagement + public long? CommentCountSum { get; set; } + public double? RatingMean { get; set; } + + // Categories + public Aggregate.Text? Category { get; set; } +} + +// Overall content metrics +var overallResult = await collection.Aggregate.OverAll( + returnMetrics: [ + Metrics.ForProperty("isPublished").Boolean(), + Metrics.ForProperty("viewCount").Integer(), + Metrics.ForProperty("wordCount").Integer(), + Metrics.ForProperty("commentCount").Integer(), + Metrics.ForProperty("rating").Number(), + Metrics.ForProperty("category").Text(topOccurrencesCount: 10) + ] +); + +var overall = overallResult.ToTyped(); +Console.WriteLine("=== Overall Content Metrics ==="); +Console.WriteLine($"Published: {overall.Properties.IsPublishedPercentageTrue:P0}"); +Console.WriteLine($"Total views: {overall.Properties.ViewCountSum:N0}"); +Console.WriteLine($"Total words written: {overall.Properties.WordCountSum:N0}"); +Console.WriteLine($"Average article length: {overall.Properties.WordCountMean:N0} words"); +Console.WriteLine($"Average rating: {overall.Properties.RatingMean:F1}/5"); + +// Top categories +Console.WriteLine("\nTop Categories:"); +foreach (var cat in overall.Properties.Category?.TopOccurrences ?? []) +{ + Console.WriteLine($" {cat.Value}: {cat.Count} articles"); +} + +// Per-author breakdown +var byAuthorResult = await collection.Aggregate.OverAll( + groupBy: new Aggregate.GroupBy("author"), + returnMetrics: [ + Metrics.ForProperty("isPublished").Boolean(), + Metrics.ForProperty("viewCount").Integer(), + Metrics.ForProperty("wordCount").Integer(), + Metrics.ForProperty("rating").Number() + ] +); + +var byAuthor = byAuthorResult.ToTyped(); +Console.WriteLine("\n=== Top Authors by Views ==="); +var topAuthors = byAuthor.Groups + .OrderByDescending(g => g.Properties.ViewCountSum ?? 0) + .Take(5); + +foreach (var author in topAuthors) +{ + Console.WriteLine($"{author.GroupedBy.Value}:"); + Console.WriteLine($" Articles: {author.TotalCount}"); + Console.WriteLine($" Total views: {author.Properties.ViewCountSum:N0}"); + Console.WriteLine($" Avg views: {author.Properties.ViewCountMean:N0}"); +} +``` + +### Scenario 3: Time-Based Analysis + +Analyze data grouped by time periods: + +```csharp +public class TimeSeriesStats +{ + public long? OrderCount { get; set; } + public double? RevenueSum { get; set; } + public double? RevenueMean { get; set; } + public long? ItemsSoldSum { get; set; } + public double? DiscountAppliedPercentageTrue { get; set; } +} + +// Monthly revenue analysis +var monthlyResult = await collection.Aggregate.OverAll( + groupBy: new Aggregate.GroupBy("orderMonth"), // Assuming pre-computed month field + returnMetrics: [ + Metrics.ForProperty("orderId").Text(), + Metrics.ForProperty("revenue").Number(), + Metrics.ForProperty("itemCount").Integer(), + Metrics.ForProperty("discountApplied").Boolean() + ] +); + +var monthly = monthlyResult.ToTyped(); + +// Sort by month and display +var sortedMonths = monthly.Groups + .OrderBy(g => g.GroupedBy.Value) + .ToList(); + +Console.WriteLine("Monthly Revenue Report:"); +Console.WriteLine("Month\t\tOrders\t\tRevenue\t\tAvg Order"); +Console.WriteLine(new string('-', 60)); + +foreach (var month in sortedMonths) +{ + Console.WriteLine($"{month.GroupedBy.Value}\t" + + $"{month.Properties.OrderCount}\t\t" + + $"${month.Properties.RevenueSum:N0}\t\t" + + $"${month.Properties.RevenueMean:N2}"); +} + +// Calculate growth +if (sortedMonths.Count >= 2) +{ + var lastMonth = sortedMonths[^1].Properties.RevenueSum ?? 0; + var prevMonth = sortedMonths[^2].Properties.RevenueSum ?? 0; + var growth = prevMonth > 0 ? (lastMonth - prevMonth) / prevMonth : 0; + Console.WriteLine($"\nMonth-over-month growth: {growth:P1}"); +} +``` + +### Scenario 4: Inventory Management + +Track inventory levels and identify issues: + +```csharp +public class InventoryStats +{ + public long? ProductCount { get; set; } + public long? StockLevelSum { get; set; } + public long? StockLevelMin { get; set; } + public double? StockLevelMean { get; set; } + public double? InStockPercentageTrue { get; set; } + public double? NeedsReorderPercentageTrue { get; set; } +} + +var warehouseResult = await collection.Aggregate.OverAll( + groupBy: new Aggregate.GroupBy("warehouse"), + returnMetrics: [ + Metrics.ForProperty("sku").Text(), + Metrics.ForProperty("stockLevel").Integer(), + Metrics.ForProperty("inStock").Boolean(), + Metrics.ForProperty("needsReorder").Boolean() + ] +); + +var byWarehouse = warehouseResult.ToTyped(); + +Console.WriteLine("Warehouse Inventory Summary:"); +foreach (var warehouse in byWarehouse.Groups.OrderBy(g => g.GroupedBy.Value)) +{ + var stats = warehouse.Properties; + Console.WriteLine($"\n{warehouse.GroupedBy.Value}:"); + Console.WriteLine($" SKUs: {stats.ProductCount}"); + Console.WriteLine($" Total units: {stats.StockLevelSum:N0}"); + Console.WriteLine($" Avg stock per SKU: {stats.StockLevelMean:F0}"); + Console.WriteLine($" In stock rate: {stats.InStockPercentageTrue:P0}"); + + if (stats.NeedsReorderPercentageTrue > 0.2) + { + Console.WriteLine($" ⚠️ {stats.NeedsReorderPercentageTrue:P0} of items need reorder!"); + } +} + +// Identify warehouses with issues +var lowStockWarehouses = byWarehouse.Groups + .Where(g => g.Properties.InStockPercentageTrue < 0.8) + .ToList(); + +if (lowStockWarehouses.Any()) +{ + Console.WriteLine("\n⚠️ Warehouses needing attention:"); + foreach (var wh in lowStockWarehouses) + { + Console.WriteLine($" - {wh.GroupedBy.Value}: only {wh.Properties.InStockPercentageTrue:P0} in stock"); + } +} +``` + +### Scenario 5: Survey/Feedback Analysis + +Analyze customer feedback data: + +```csharp +public class FeedbackStats +{ + public long? ResponseCount { get; set; } + public double? SatisfactionMean { get; set; } + public double? NpsMean { get; set; } + public double? WouldRecommendPercentageTrue { get; set; } + public Aggregate.Text? TopIssues { get; set; } +} + +var feedbackResult = await collection.Aggregate.OverAll( + groupBy: new Aggregate.GroupBy("productLine"), + returnMetrics: [ + Metrics.ForProperty("responseId").Text(), + Metrics.ForProperty("satisfactionScore").Number(), + Metrics.ForProperty("npsScore").Number(), + Metrics.ForProperty("wouldRecommend").Boolean(), + Metrics.ForProperty("issueCategory").Text(topOccurrencesCount: 5) + ] +); + +var feedback = feedbackResult.ToTyped(); + +Console.WriteLine("Customer Feedback Analysis by Product Line:"); +foreach (var product in feedback.Groups.OrderByDescending(g => g.Properties.SatisfactionMean)) +{ + var stats = product.Properties; + Console.WriteLine($"\n{product.GroupedBy.Value}:"); + Console.WriteLine($" Responses: {stats.ResponseCount}"); + Console.WriteLine($" Satisfaction: {stats.SatisfactionMean:F1}/5"); + Console.WriteLine($" NPS: {stats.NpsMean:F0}"); + Console.WriteLine($" Would recommend: {stats.WouldRecommendPercentageTrue:P0}"); + + if (stats.TopIssues?.TopOccurrences.Any() == true) + { + Console.WriteLine(" Top reported issues:"); + foreach (var issue in stats.TopIssues.TopOccurrences.Take(3)) + { + Console.WriteLine($" - {issue.Value}: {issue.Count} reports"); + } + } +} +``` + +### Analyzer Support + +The Weaviate client includes a Roslyn analyzer that validates types used with `ToTyped()` and `MetricsExtractor.FromType()`. When you call either of these methods, the analyzer checks the type `T` for correct suffix usage: + +```csharp +public class ProductStats +{ + public double? PriceMean { get; set; } // Valid - suffix with correct type + public long? QuantitySum { get; set; } // Valid - suffix with correct type + public Aggregate.Text? Category { get; set; } // Valid - full aggregate type +} + +// The analyzer validates ProductStats when ToTyped() or MetricsExtractor.FromType() is called: +var stats = result.ToTyped(); +var metrics = MetricsExtractor.FromType(); + +// If ProductStats had invalid properties, you'd see warnings: +// - Property 'Price' with no suffix: WEAVIATE002 +// - Property 'PriceSum' with wrong type (string instead of numeric): WEAVIATE003 +``` + +The analyzer produces these diagnostics at the `ToTyped()` or `MetricsExtractor.FromType()` call site: + +- **WEAVIATE002**: Warning when a property has a primitive type but no recognized suffix +- **WEAVIATE003**: Warning when a suffix is used with an incompatible type (e.g., `TitleSum` for a text field) + +## See Also + +- [Weaviate Aggregation Documentation](https://weaviate.io/developers/weaviate/search/aggregate) +- [Typed Client Wrappers](TYPED_CLIENT_WRAPPER.md) diff --git a/src/Weaviate.Client.Analyzers.Tests/AggregatePropertySuffixAnalyzerTests.cs b/src/Weaviate.Client.Analyzers.Tests/AggregatePropertySuffixAnalyzerTests.cs new file mode 100644 index 00000000..aba13a10 --- /dev/null +++ b/src/Weaviate.Client.Analyzers.Tests/AggregatePropertySuffixAnalyzerTests.cs @@ -0,0 +1,252 @@ +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.Testing; +using Xunit; +using VerifyCS = Microsoft.CodeAnalysis.CSharp.Testing.XUnit.AnalyzerVerifier; + +namespace Weaviate.Client.Analyzers.Tests; + +public class AggregatePropertySuffixAnalyzerTests +{ + private const string TestStubCode = + @" +using System; +using System.Collections.Generic; + +namespace Weaviate.Client.Models +{ + public class AggregateResult { } +} + +namespace Weaviate.Client.Models.Typed +{ + using Weaviate.Client.Models; + + public static class TypedResultConverter + { + public static AggregateResult ToTyped(this AggregateResult result) where T : new() + { + return new AggregateResult(); + } + } + + public static class MetricsExtractor + { + public static string[] FromType() => Array.Empty(); + } + + public class AggregateResult where T : new() + { + public T Properties { get; set; } = new T(); + } +} + +namespace Weaviate.Client.Models.Aggregate +{ + public class Text { } + public class Integer { } + public class Number { } + public class Boolean { } + public class Date { } +} + +namespace Weaviate.Client.Models.Typed +{ + [AttributeUsage(AttributeTargets.Property)] + public class TextMetricsAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + public class IntegerMetricsAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + public class NumberMetricsAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + public class BooleanMetricsAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + public class DateMetricsAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + public class MetricsForPropertyAttribute : Attribute + { + public MetricsForPropertyAttribute(string propertyName) { } + } +} +"; + + #region WEAVIATE005 - Missing Suffix Tests + + [Fact] + public async Task MissingSuffix_OnToTypedCall_ReportsDiagnostic() + { + var testCode = + TestStubCode + + @" +namespace Test +{ + using Weaviate.Client.Models; + using Weaviate.Client.Models.Typed; + + public class MyModel + { + public int Age { get; set; } + } + + public class TestClass + { + public void TestMethod() + { + var result = new AggregateResult(); + var typed = result.ToTyped(); + } + } +}"; + + var expected = VerifyCS + .Diagnostic(AggregatePropertySuffixAnalyzer.MissingSuffixDiagnosticId) + .WithArguments("Age", "MyModel") + .WithSpan("/0/Test0.cs", 81, 40, 81, 47); + + await VerifyCS.VerifyAnalyzerAsync(testCode, expected); + } + + [Fact] + public async Task ValidSuffixAsCount_NoDiagnostic() + { + var testCode = + TestStubCode + + @" +namespace Test +{ + using Weaviate.Client.Models; + using Weaviate.Client.Models.Typed; + + public class MyModel + { + public long? AgeAsCount { get; set; } + } + + public class TestClass + { + public void TestMethod() + { + var result = new AggregateResult(); + var typed = result.ToTyped(); + } + } +}"; + + await VerifyCS.VerifyAnalyzerAsync(testCode); + } + + #endregion + + #region WEAVIATE006 - Invalid Suffix Type Tests + + [Fact] + public async Task InvalidSuffixType_CountOnString_ReportsDiagnostic() + { + var testCode = + TestStubCode + + @" +namespace Test +{ + using Weaviate.Client.Models; + using Weaviate.Client.Models.Typed; + + public class MyModel + { + public string NameAsCount { get; set; } + } + + public class TestClass + { + public void TestMethod() + { + var result = new AggregateResult(); + var typed = result.ToTyped(); + } + } +}"; + + var expected = VerifyCS + .Diagnostic(AggregatePropertySuffixAnalyzer.InvalidSuffixTypeDiagnosticId) + .WithArguments("NameAsCount", "MyModel", "Count", "long or int or double", "string") + .WithSpan("/0/Test0.cs", 81, 40, 81, 47); + + await VerifyCS.VerifyAnalyzerAsync(testCode, expected); + } + + #endregion + + #region WEAVIATE004 - Wrong Attribute Type Tests + + [Fact] + public async Task WrongAttributeType_NumberMetricsOnText_ReportsDiagnostic() + { + var testCode = + TestStubCode + + @" +namespace Test +{ + using Weaviate.Client.Models; + using Weaviate.Client.Models.Typed; + using Weaviate.Client.Models.Aggregate; + + public class MyModel + { + [NumberMetrics] + public Text Name { get; set; } + } + + public class TestClass + { + public void TestMethod() + { + var result = new AggregateResult(); + var typed = result.ToTyped(); + } + } +}"; + + var expected = VerifyCS + .Diagnostic(AggregatePropertySuffixAnalyzer.WrongAttributeTypeDiagnosticId) + .WithArguments("Name", "Text", "Number") + .WithSpan("/0/Test0.cs", 83, 40, 83, 47); + + await VerifyCS.VerifyAnalyzerAsync(testCode, expected); + } + + [Fact] + public async Task ValidAttributeType_NumberMetricsOnNumber_NoDiagnostic() + { + var testCode = + TestStubCode + + @" +namespace Test +{ + using Weaviate.Client.Models; + using Weaviate.Client.Models.Typed; + using Weaviate.Client.Models.Aggregate; + + public class MyModel + { + [NumberMetrics] + public Number Price { get; set; } + } + + public class TestClass + { + public void TestMethod() + { + var result = new AggregateResult(); + var typed = result.ToTyped(); + } + } +}"; + + await VerifyCS.VerifyAnalyzerAsync(testCode); + } + + #endregion +} diff --git a/src/Weaviate.Client.Analyzers/AggregatePropertySuffixAnalyzer.cs b/src/Weaviate.Client.Analyzers/AggregatePropertySuffixAnalyzer.cs new file mode 100644 index 00000000..a2f97d43 --- /dev/null +++ b/src/Weaviate.Client.Analyzers/AggregatePropertySuffixAnalyzer.cs @@ -0,0 +1,605 @@ +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Linq; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.CodeAnalysis.Diagnostics; + +namespace Weaviate.Client.Analyzers; + +/// +/// Analyzer that validates aggregate property suffix usage in types used with the ToTyped<T>() extension method +/// for mapping aggregate results to strongly-typed objects. +/// +[DiagnosticAnalyzer(LanguageNames.CSharp)] +public class AggregatePropertySuffixAnalyzer : DiagnosticAnalyzer +{ + public const string MissingSuffixDiagnosticId = "WEAVIATE005"; + public const string InvalidSuffixTypeDiagnosticId = "WEAVIATE006"; + public const string WrongAttributeTypeDiagnosticId = "WEAVIATE007"; + private const string Category = "Usage"; + + private static readonly LocalizableString MissingSuffixTitle = + "Aggregate property missing suffix"; + private static readonly LocalizableString MissingSuffixMessageFormat = + "Property '{0}' in type '{1}' has a primitive type but no recognized aggregate suffix"; + private static readonly LocalizableString MissingSuffixDescription = + "Properties in aggregate result types used with ToTyped() must either use full Aggregate types or have a recognized suffix."; + + private static readonly LocalizableString InvalidSuffixTypeTitle = + "Invalid type for aggregate suffix"; + private static readonly LocalizableString InvalidSuffixTypeMessageFormat = + "Property '{0}' in type '{1}' with suffix '{2}' should be of type '{3}', not '{4}'"; + private static readonly LocalizableString InvalidSuffixTypeDescription = + "Properties with aggregate suffixes must use compatible types."; + + private static readonly DiagnosticDescriptor MissingSuffixRule = new DiagnosticDescriptor( + MissingSuffixDiagnosticId, + MissingSuffixTitle, + MissingSuffixMessageFormat, + Category, + DiagnosticSeverity.Warning, + isEnabledByDefault: true, + description: MissingSuffixDescription + ); + + private static readonly DiagnosticDescriptor InvalidSuffixTypeRule = new DiagnosticDescriptor( + InvalidSuffixTypeDiagnosticId, + InvalidSuffixTypeTitle, + InvalidSuffixTypeMessageFormat, + Category, + DiagnosticSeverity.Warning, + isEnabledByDefault: true, + description: InvalidSuffixTypeDescription + ); + + private static readonly LocalizableString WrongAttributeTypeTitle = + "Wrong metrics attribute for aggregate type"; + private static readonly LocalizableString WrongAttributeTypeMessageFormat = + "Property '{0}' is Aggregate.{1} but has [{2}Metrics] attribute"; + private static readonly LocalizableString WrongAttributeTypeDescription = + "Use the metrics attribute that matches the aggregate property type."; + + private static readonly DiagnosticDescriptor WrongAttributeTypeRule = new DiagnosticDescriptor( + WrongAttributeTypeDiagnosticId, + WrongAttributeTypeTitle, + WrongAttributeTypeMessageFormat, + Category, + DiagnosticSeverity.Warning, + isEnabledByDefault: true, + description: WrongAttributeTypeDescription + ); + + /// + /// Recognized suffixes and their expected types. + /// + private static readonly Dictionary SuffixExpectedTypes = new Dictionary< + string, + string[] + > + { + // Numeric suffixes - can be long, int, double, float, decimal + { + "Count", + new[] + { + "long", + "int", + "double", + "float", + "decimal", + "long?", + "int?", + "double?", + "float?", + "decimal?", + } + }, + { + "Sum", + new[] + { + "long", + "int", + "double", + "float", + "decimal", + "long?", + "int?", + "double?", + "float?", + "decimal?", + } + }, + { "Mean", new[] { "double", "float", "decimal", "double?", "float?", "decimal?" } }, + { "Average", new[] { "double", "float", "decimal", "double?", "float?", "decimal?" } }, + { + "Min", + new[] + { + "long", + "int", + "double", + "float", + "decimal", + "long?", + "int?", + "double?", + "float?", + "decimal?", + } + }, + { + "Minimum", + new[] + { + "long", + "int", + "double", + "float", + "decimal", + "long?", + "int?", + "double?", + "float?", + "decimal?", + } + }, + { + "Max", + new[] + { + "long", + "int", + "double", + "float", + "decimal", + "long?", + "int?", + "double?", + "float?", + "decimal?", + } + }, + { + "Maximum", + new[] + { + "long", + "int", + "double", + "float", + "decimal", + "long?", + "int?", + "double?", + "float?", + "decimal?", + } + }, + { "Median", new[] { "double", "float", "decimal", "double?", "float?", "decimal?" } }, + { + "Mode", + new[] + { + "long", + "int", + "double", + "float", + "decimal", + "long?", + "int?", + "double?", + "float?", + "decimal?", + } + }, + // Boolean-specific suffixes + { "TotalTrue", new[] { "long", "int", "long?", "int?" } }, + { "TotalFalse", new[] { "long", "int", "long?", "int?" } }, + { + "PercentageTrue", + new[] { "double", "float", "decimal", "double?", "float?", "decimal?" } + }, + { + "PercentageFalse", + new[] { "double", "float", "decimal", "double?", "float?", "decimal?" } + }, + // Text-specific suffixes + { "TopOccurrence", new[] { "string", "string?" } }, + { + "TopOccurrences", + new[] + { + "List>", + "IReadOnlyList>", + "IList>", + "IEnumerable>", + } + }, + }; + + /// + /// Date-specific suffixes that require DateTime types. + /// + private static readonly HashSet DateSuffixes = new HashSet + { + "Minimum", + "Min", + "Maximum", + "Max", + "Median", + "Mode", + }; + + /// + /// The fully qualified name of the ToTyped extension method container. + /// + private const string TypedResultConverterFullName = + "Weaviate.Client.Models.Typed.TypedResultConverter"; + + /// + /// The fully qualified name of the MetricsExtractor class. + /// + private const string MetricsExtractorFullName = "Weaviate.Client.Models.Typed.MetricsExtractor"; + + public override ImmutableArray SupportedDiagnostics => + ImmutableArray.Create(MissingSuffixRule, InvalidSuffixTypeRule, WrongAttributeTypeRule); + + public override void Initialize(AnalysisContext context) + { + context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); + context.EnableConcurrentExecution(); + + // Register for invocation expressions to detect ToTyped() calls + context.RegisterSyntaxNodeAction( + AnalyzeInvocationExpression, + SyntaxKind.InvocationExpression + ); + } + + private static void AnalyzeInvocationExpression(SyntaxNodeAnalysisContext context) + { + var invocation = (InvocationExpressionSyntax)context.Node; + + // Check if this is a ToTyped() or MetricsExtractor.FromType() call + TypeSyntax? typeArgument = null; + if ( + !IsToTypedCall(invocation, context.SemanticModel, out typeArgument) + && !IsFromTypeCall(invocation, context.SemanticModel, out typeArgument) + ) + return; + + // Get the type symbol for the type argument + if (typeArgument == null) + return; + + var typeInfo = context.SemanticModel.GetTypeInfo(typeArgument); + var typeSymbol = typeInfo.Type as INamedTypeSymbol; + if (typeSymbol == null) + return; + + // Analyze all properties of the type + AnalyzeTypeProperties(context, typeArgument, typeSymbol); + } + + private static bool IsToTypedCall( + InvocationExpressionSyntax invocation, + SemanticModel semanticModel, + out TypeSyntax? typeArgument + ) + { + typeArgument = null; + + // Look for member access like result.ToTyped() + if (invocation.Expression is MemberAccessExpressionSyntax memberAccess) + { + // Check if the method name is ToTyped and has type arguments + if (memberAccess.Name is GenericNameSyntax genericName) + { + if ( + genericName.Identifier.Text == "ToTyped" + && genericName.TypeArgumentList.Arguments.Count == 1 + ) + { + // Verify this is actually the TypedResultConverter.ToTyped method + var symbolInfo = semanticModel.GetSymbolInfo(invocation); + if (symbolInfo.Symbol is IMethodSymbol methodSymbol) + { + var containingType = methodSymbol.ContainingType?.ToDisplayString(); + if (containingType == TypedResultConverterFullName) + { + typeArgument = genericName.TypeArgumentList.Arguments[0]; + return true; + } + } + } + } + } + + return false; + } + + private static bool IsFromTypeCall( + InvocationExpressionSyntax invocation, + SemanticModel semanticModel, + out TypeSyntax? typeArgument + ) + { + typeArgument = null; + + // Look for MetricsExtractor.FromType() call + if (invocation.Expression is MemberAccessExpressionSyntax memberAccess) + { + // Check if the method name is FromType and has type arguments + if (memberAccess.Name is GenericNameSyntax genericName) + { + if ( + genericName.Identifier.Text == "FromType" + && genericName.TypeArgumentList.Arguments.Count == 1 + ) + { + // Verify this is actually the MetricsExtractor.FromType method + var symbolInfo = semanticModel.GetSymbolInfo(invocation); + if (symbolInfo.Symbol is IMethodSymbol methodSymbol) + { + var containingType = methodSymbol.ContainingType?.ToDisplayString(); + if (containingType == MetricsExtractorFullName) + { + typeArgument = genericName.TypeArgumentList.Arguments[0]; + return true; + } + } + } + } + } + + return false; + } + + private static void AnalyzeTypeProperties( + SyntaxNodeAnalysisContext context, + TypeSyntax typeArgumentSyntax, + INamedTypeSymbol typeSymbol + ) + { + // Get all public instance properties + var properties = typeSymbol + .GetMembers() + .OfType() + .Where(p => p.DeclaredAccessibility == Accessibility.Public && !p.IsStatic); + + foreach (var property in properties) + { + var propertyType = property.Type; + + // Check for wrong metrics attribute on Aggregate.* types + if (IsAggregateType(propertyType)) + { + ValidateMetricsAttribute(context, property, propertyType, typeArgumentSyntax); + continue; + } + + // Only analyze primitive/value types and string + if (!IsPrimitiveOrValueType(propertyType)) + continue; + + var propertyName = property.Name; + var suffix = GetSuffix(propertyName); + + if (suffix == null) + { + // Property has a primitive type but no recognized suffix + var diagnostic = Diagnostic.Create( + MissingSuffixRule, + typeArgumentSyntax.GetLocation(), + propertyName, + typeSymbol.Name + ); + context.ReportDiagnostic(diagnostic); + continue; + } + + // Validate the type is appropriate for the suffix + ValidateSuffixType( + context, + typeArgumentSyntax, + typeSymbol.Name, + propertyName, + suffix, + propertyType + ); + } + } + + private static bool IsAggregateType(ITypeSymbol type) + { + var displayName = type.ToDisplayString(); + return displayName.StartsWith("Weaviate.Client.Models.Aggregate.", StringComparison.Ordinal) + || displayName == "Weaviate.Client.Models.Aggregate.Text" + || displayName == "Weaviate.Client.Models.Aggregate.Integer" + || displayName == "Weaviate.Client.Models.Aggregate.Number" + || displayName == "Weaviate.Client.Models.Aggregate.Boolean" + || displayName == "Weaviate.Client.Models.Aggregate.Date" + || displayName == "Weaviate.Client.Models.Aggregate.Property"; + } + + private static bool IsPrimitiveOrValueType(ITypeSymbol type) + { + // Handle nullable types + if (type is INamedTypeSymbol namedType && namedType.IsGenericType) + { + var originalDef = namedType.OriginalDefinition.SpecialType; + if (originalDef == SpecialType.System_Nullable_T) + { + type = namedType.TypeArguments[0]; + } + } + + return type.SpecialType == SpecialType.System_Int32 + || type.SpecialType == SpecialType.System_Int64 + || type.SpecialType == SpecialType.System_Double + || type.SpecialType == SpecialType.System_Single + || type.SpecialType == SpecialType.System_Decimal + || type.SpecialType == SpecialType.System_String + || type.SpecialType == SpecialType.System_DateTime + || type.SpecialType == SpecialType.System_Boolean; + } + + private static string? GetSuffix(string propertyName) + { + foreach (var suffix in SuffixExpectedTypes.Keys) + { + if ( + propertyName.Length > suffix.Length + && propertyName.EndsWith(suffix, StringComparison.Ordinal) + ) + { + return suffix; + } + } + + return null; + } + + private static void ValidateSuffixType( + SyntaxNodeAnalysisContext context, + TypeSyntax typeArgumentSyntax, + string typeName, + string propertyName, + string suffix, + ITypeSymbol propertyType + ) + { + var typeDisplayName = GetSimpleTypeName(propertyType); + + // DateTime properties with date suffixes are valid + if ( + DateSuffixes.Contains(suffix) + && ( + propertyType.SpecialType == SpecialType.System_DateTime + || IsNullableDateTime(propertyType) + ) + ) + { + return; // Valid - DateTime with date suffix + } + + if (!SuffixExpectedTypes.TryGetValue(suffix, out var expectedTypes)) + return; + + // Check if the type matches any of the expected types + if (!expectedTypes.Contains(typeDisplayName)) + { + var diagnostic = Diagnostic.Create( + InvalidSuffixTypeRule, + typeArgumentSyntax.GetLocation(), + propertyName, + typeName, + suffix, + string.Join(" or ", expectedTypes.Take(3)), + typeDisplayName + ); + context.ReportDiagnostic(diagnostic); + } + } + + private static bool IsNullableDateTime(ITypeSymbol type) + { + if (type is INamedTypeSymbol namedType && namedType.IsGenericType) + { + var originalDef = namedType.OriginalDefinition.SpecialType; + if (originalDef == SpecialType.System_Nullable_T) + { + return namedType.TypeArguments[0].SpecialType == SpecialType.System_DateTime; + } + } + + return false; + } + + private static string GetSimpleTypeName(ITypeSymbol type) + { + // Handle nullable types + if (type is INamedTypeSymbol namedType && namedType.IsGenericType) + { + var originalDef = namedType.OriginalDefinition.SpecialType; + if (originalDef == SpecialType.System_Nullable_T) + { + var innerType = namedType.TypeArguments[0]; + return GetSimpleTypeName(innerType) + "?"; + } + } + + return type.SpecialType switch + { + SpecialType.System_Int32 => "int", + SpecialType.System_Int64 => "long", + SpecialType.System_Double => "double", + SpecialType.System_Single => "float", + SpecialType.System_Decimal => "decimal", + SpecialType.System_String => "string", + SpecialType.System_DateTime => "DateTime", + SpecialType.System_Boolean => "bool", + _ => type.ToDisplayString(), + }; + } + + private static void ValidateMetricsAttribute( + SyntaxNodeAnalysisContext context, + IPropertySymbol property, + ITypeSymbol aggregateType, + TypeSyntax typeArgumentSyntax + ) + { + var aggregateTypeName = GetAggregateTypeName(aggregateType); + if (aggregateTypeName == null) + return; + + // Check if they're using the wrong attribute type + var attributes = property.GetAttributes(); + var metricsAttrs = attributes + .Where(a => a.AttributeClass?.Name?.EndsWith("MetricsAttribute") == true) + .ToList(); + + if (metricsAttrs.Count == 0) + return; // No attribute is fine + + var expectedAttrName = $"{aggregateTypeName}MetricsAttribute"; + var wrongAttr = metricsAttrs.FirstOrDefault(a => + a.AttributeClass?.Name != expectedAttrName + ); + + if (wrongAttr != null) + { + var wrongTypeName = + wrongAttr.AttributeClass?.Name?.Replace("MetricsAttribute", "") ?? "Unknown"; + var diagnostic = Diagnostic.Create( + WrongAttributeTypeRule, + typeArgumentSyntax.GetLocation(), + property.Name, + aggregateTypeName, + wrongTypeName + ); + context.ReportDiagnostic(diagnostic); + } + } + + private static string? GetAggregateTypeName(ITypeSymbol type) + { + var displayName = type.ToDisplayString(); + if (displayName == "Weaviate.Client.Models.Aggregate.Text") + return "Text"; + if (displayName == "Weaviate.Client.Models.Aggregate.Integer") + return "Integer"; + if (displayName == "Weaviate.Client.Models.Aggregate.Number") + return "Number"; + if (displayName == "Weaviate.Client.Models.Aggregate.Boolean") + return "Boolean"; + if (displayName == "Weaviate.Client.Models.Aggregate.Date") + return "Date"; + return null; + } +} diff --git a/src/Weaviate.Client.Analyzers/AnalyzerReleases.Shipped.md b/src/Weaviate.Client.Analyzers/AnalyzerReleases.Shipped.md index edacf875..81a09f9c 100644 --- a/src/Weaviate.Client.Analyzers/AnalyzerReleases.Shipped.md +++ b/src/Weaviate.Client.Analyzers/AnalyzerReleases.Shipped.md @@ -8,3 +8,6 @@ WEAVIATE001 | Usage | Warning | AutoArrayUsageAnalyzer - AutoArray should on WEAVIATE002 | Usage | Error | VectorizerFactoryAnalyzer - Missing property initialization WEAVIATE003 | Usage | Error | VectorizerFactoryAnalyzer - Missing field in Weights calculation WEAVIATE004 | Usage | Error | Hybrid search requires at least one of 'query' or 'vectors' parameters +WEAVIATE005 | Usage | Warning | AggregatePropertySuffixAnalyzer: Aggregate property missing suffix. Triggers when ToTyped() or MetricsExtractor.FromType() is called with the type. +WEAVIATE006 | Usage | Warning | AggregatePropertySuffixAnalyzer: Invalid type for aggregate suffix. Triggers when ToTyped() or MetricsExtractor.FromType() is called with the type. +WEAVIATE007 | Usage | Warning | AggregatePropertySuffixAnalyzer: Wrong metrics attribute for aggregate type. Triggers when using mismatched attribute (e.g., NumberMetrics on Aggregate.Text). diff --git a/src/Weaviate.Client.Analyzers/AnalyzerReleases.Unshipped.md b/src/Weaviate.Client.Analyzers/AnalyzerReleases.Unshipped.md index 41541c87..b0e55213 100644 --- a/src/Weaviate.Client.Analyzers/AnalyzerReleases.Unshipped.md +++ b/src/Weaviate.Client.Analyzers/AnalyzerReleases.Unshipped.md @@ -2,4 +2,4 @@ ### New Rules Rule ID | Category | Severity | Notes -------------|----------|----------|----------------------------------------------------- +------------|----------|----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/src/Weaviate.Client.Tests/Unit/TestAggregateResultAccessors.cs b/src/Weaviate.Client.Tests/Unit/TestAggregateResultAccessors.cs new file mode 100644 index 00000000..bb3d8b44 --- /dev/null +++ b/src/Weaviate.Client.Tests/Unit/TestAggregateResultAccessors.cs @@ -0,0 +1,660 @@ +using Weaviate.Client.Models; + +namespace Weaviate.Client.Tests.Unit; + +public class TestAggregateResultAccessors +{ + private static AggregateResult CreateTestResult() + { + return new AggregateResult + { + TotalCount = 100, + Properties = new Dictionary + { + ["textField"] = new Aggregate.Text + { + Count = 10, + TopOccurrences = + [ + new Aggregate.TopOccurrence { Value = "hello", Count = 5 }, + new Aggregate.TopOccurrence { Value = "world", Count = 3 }, + ], + }, + ["intField"] = new Aggregate.Integer + { + Count = 20, + Minimum = 1, + Maximum = 100, + Mean = 50.5, + Median = 50, + Mode = 42, + Sum = 1000, + }, + ["numberField"] = new Aggregate.Number + { + Count = 15, + Minimum = 1.5, + Maximum = 99.5, + Mean = 50.0, + Median = 49.5, + Mode = 42.0, + Sum = 750.0, + }, + ["boolField"] = new Aggregate.Boolean + { + Count = 50, + TotalTrue = 30, + TotalFalse = 20, + PercentageTrue = 0.6, + PercentageFalse = 0.4, + }, + ["dateField"] = new Aggregate.Date + { + Count = 25, + Minimum = new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc), + Maximum = new DateTime(2023, 12, 31, 0, 0, 0, DateTimeKind.Utc), + Median = new DateTime(2023, 6, 15, 0, 0, 0, DateTimeKind.Utc), + Mode = new DateTime(2023, 3, 15, 0, 0, 0, DateTimeKind.Utc), + }, + }, + }; + } + + #region Typed Accessor Tests + + [Fact] + public void Text_ReturnsTextAggregation_WhenPropertyExists() + { + var result = CreateTestResult(); + + var text = result.Text("textField"); + + Assert.NotNull(text); + Assert.Equal(10, text.Count); + Assert.Equal(2, text.TopOccurrences.Count); + Assert.Equal("hello", text.TopOccurrences[0].Value); + } + + [Fact] + public void Text_ReturnsNull_WhenPropertyDoesNotExist() + { + var result = CreateTestResult(); + + var text = result.Text("nonExistent"); + + Assert.Null(text); + } + + [Fact] + public void Text_ReturnsNull_WhenPropertyIsWrongType() + { + var result = CreateTestResult(); + + var text = result.Text("intField"); + + Assert.Null(text); + } + + [Fact] + public void Integer_ReturnsIntegerAggregation_WhenPropertyExists() + { + var result = CreateTestResult(); + + var integer = result.Integer("intField"); + + Assert.NotNull(integer); + Assert.Equal(20, integer.Count); + Assert.Equal(1, integer.Minimum); + Assert.Equal(100, integer.Maximum); + Assert.Equal(50.5, integer.Mean); + } + + [Fact] + public void Number_ReturnsNumberAggregation_WhenPropertyExists() + { + var result = CreateTestResult(); + + var number = result.Number("numberField"); + + Assert.NotNull(number); + Assert.Equal(15, number.Count); + Assert.Equal(1.5, number.Minimum); + Assert.Equal(99.5, number.Maximum); + } + + [Fact] + public void Boolean_ReturnsBooleanAggregation_WhenPropertyExists() + { + var result = CreateTestResult(); + + var boolean = result.Boolean("boolField"); + + Assert.NotNull(boolean); + Assert.Equal(50, boolean.Count); + Assert.Equal(30, boolean.TotalTrue); + Assert.Equal(20, boolean.TotalFalse); + Assert.Equal(0.6, boolean.PercentageTrue); + } + + [Fact] + public void Date_ReturnsDateAggregation_WhenPropertyExists() + { + var result = CreateTestResult(); + + var date = result.Date("dateField"); + + Assert.NotNull(date); + Assert.Equal(25, date.Count); + Assert.Equal(new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc), date.Minimum); + Assert.Equal(new DateTime(2023, 12, 31, 0, 0, 0, DateTimeKind.Utc), date.Maximum); + } + + #endregion + + #region TryGet Tests + + [Fact] + public void TryGetText_ReturnsTrue_WhenPropertyExists() + { + var result = CreateTestResult(); + + var success = result.TryGetText("textField", out var text); + + Assert.True(success); + Assert.NotNull(text); + Assert.Equal(10, text.Count); + } + + [Fact] + public void TryGetText_ReturnsFalse_WhenPropertyDoesNotExist() + { + var result = CreateTestResult(); + + var success = result.TryGetText("nonExistent", out _); + + Assert.False(success); + } + + [Fact] + public void TryGetText_ReturnsFalse_WhenPropertyIsWrongType() + { + var result = CreateTestResult(); + + var success = result.TryGetText("intField", out _); + + Assert.False(success); + } + + [Fact] + public void TryGetInteger_ReturnsTrue_WhenPropertyExists() + { + var result = CreateTestResult(); + + var success = result.TryGetInteger("intField", out var integer); + + Assert.True(success); + Assert.NotNull(integer); + Assert.Equal(20, integer.Count); + } + + [Fact] + public void TryGetNumber_ReturnsTrue_WhenPropertyExists() + { + var result = CreateTestResult(); + + var success = result.TryGetNumber("numberField", out var number); + + Assert.True(success); + Assert.NotNull(number); + Assert.Equal(15, number.Count); + } + + [Fact] + public void TryGetBoolean_ReturnsTrue_WhenPropertyExists() + { + var result = CreateTestResult(); + + var success = result.TryGetBoolean("boolField", out var boolean); + + Assert.True(success); + Assert.NotNull(boolean); + Assert.Equal(50, boolean.Count); + } + + [Fact] + public void TryGetDate_ReturnsTrue_WhenPropertyExists() + { + var result = CreateTestResult(); + + var success = result.TryGetDate("dateField", out var date); + + Assert.True(success); + Assert.NotNull(date); + Assert.Equal(25, date.Count); + } + + [Fact] + public void TryGet_Generic_ReturnsTrue_WhenPropertyExistsAndMatchesType() + { + var result = CreateTestResult(); + + var success = result.TryGet("textField", out var text); + + Assert.True(success); + Assert.NotNull(text); + Assert.Equal(10, text.Count); + } + + [Fact] + public void TryGet_Generic_ReturnsFalse_WhenPropertyIsWrongType() + { + var result = CreateTestResult(); + + var success = result.TryGet("intField", out _); + + Assert.False(success); + } + + #endregion + + #region Property Lambda Tests + + [Fact] + public void Property_Action_ExecutesAction_WhenPropertyMatches() + { + var result = CreateTestResult(); + long? capturedCount = null; + + var matched = result.Property("textField", t => capturedCount = t.Count); + + Assert.True(matched); + Assert.Equal(10, capturedCount); + } + + [Fact] + public void Property_Action_ReturnsFalse_WhenPropertyDoesNotMatch() + { + var result = CreateTestResult(); + var executed = false; + + var matched = result.Property("intField", _ => executed = true); + + Assert.False(matched); + Assert.False(executed); + } + + [Fact] + public void Property_Func_ReturnsResult_WhenPropertyMatches() + { + var result = CreateTestResult(); + + var count = result.Property("textField", t => t.Count); + + Assert.Equal(10, count); + } + + [Fact] + public void Property_Func_ReturnsDefault_WhenPropertyDoesNotMatch() + { + var result = CreateTestResult(); + + var count = result.Property("intField", t => t.Count); + + Assert.Null(count); + } + + [Fact] + public void Property_Func_WithValueType_ReturnsValue_WhenMatches() + { + var result = CreateTestResult(); + + var minimum = result.Property("intField", i => i.Minimum); + + Assert.Equal(1, minimum); + } + + #endregion + + #region Match Tests + + [Fact] + public void Match_Action_ExecutesCorrectAction_ForTextProperty() + { + var result = CreateTestResult(); + string? capturedType = null; + + var matched = result.Match( + "textField", + text: _ => + { + capturedType = "text"; + }, + integer: _ => + { + capturedType = "integer"; + }, + number: _ => + { + capturedType = "number"; + }, + boolean: _ => + { + capturedType = "boolean"; + }, + date: _ => + { + capturedType = "date"; + } + ); + + Assert.True(matched); + Assert.Equal("text", capturedType); + } + + [Fact] + public void Match_Action_ExecutesCorrectAction_ForIntegerProperty() + { + var result = CreateTestResult(); + string? capturedType = null; + + var matched = result.Match( + "intField", + text: _ => + { + capturedType = "text"; + }, + integer: _ => + { + capturedType = "integer"; + } + ); + + Assert.True(matched); + Assert.Equal("integer", capturedType); + } + + [Fact] + public void Match_Action_ExecutesCorrectAction_ForNumberProperty() + { + var result = CreateTestResult(); + string? capturedType = null; + + var matched = result.Match( + "numberField", + number: _ => + { + capturedType = "number"; + } + ); + + Assert.True(matched); + Assert.Equal("number", capturedType); + } + + [Fact] + public void Match_Action_ExecutesCorrectAction_ForBooleanProperty() + { + var result = CreateTestResult(); + string? capturedType = null; + + var matched = result.Match( + "boolField", + boolean: _ => + { + capturedType = "boolean"; + } + ); + + Assert.True(matched); + Assert.Equal("boolean", capturedType); + } + + [Fact] + public void Match_Action_ExecutesCorrectAction_ForDateProperty() + { + var result = CreateTestResult(); + string? capturedType = null; + + var matched = result.Match( + "dateField", + date: _ => + { + capturedType = "date"; + } + ); + + Assert.True(matched); + Assert.Equal("date", capturedType); + } + + [Fact] + public void Match_Action_ReturnsFalse_WhenPropertyDoesNotExist() + { + var result = CreateTestResult(); + var executed = false; + + var matched = result.Match( + "nonExistent", + text: _ => + { + executed = true; + }, + integer: _ => + { + executed = true; + } + ); + + Assert.False(matched); + Assert.False(executed); + } + + [Fact] + public void Match_Action_ReturnsFalse_WhenNoMatchingHandler() + { + var result = CreateTestResult(); + var executed = false; + + // textField exists but we only provide integer handler + var matched = result.Match( + "textField", + integer: _ => + { + executed = true; + } + ); + + Assert.False(matched); + Assert.False(executed); + } + + [Fact] + public void Match_Func_ReturnsCorrectValue_ForTextProperty() + { + var result = CreateTestResult(); + + var description = result.Match( + "textField", + text: t => $"Text with {t.Count} items", + integer: i => $"Integer range [{i.Minimum}, {i.Maximum}]" + ); + + Assert.Equal("Text with 10 items", description); + } + + [Fact] + public void Match_Func_ReturnsCorrectValue_ForIntegerProperty() + { + var result = CreateTestResult(); + + var description = result.Match( + "intField", + text: t => $"Text with {t.Count} items", + integer: i => $"Integer range [{i.Minimum}, {i.Maximum}]" + ); + + Assert.Equal("Integer range [1, 100]", description); + } + + [Fact] + public void Match_Func_ReturnsDefault_WhenPropertyDoesNotExist() + { + var result = CreateTestResult(); + + var description = result.Match( + "nonExistent", + text: t => $"Text: {t.Count}", + integer: i => $"Integer: {i.Count}" + ); + + Assert.Null(description); + } + + [Fact] + public void Match_Func_ReturnsDefault_WhenNoMatchingHandler() + { + var result = CreateTestResult(); + + var description = result.Match("textField", integer: i => $"Integer: {i.Count}"); + + Assert.Null(description); + } + + #endregion + + #region GroupByResult Tests + + private static AggregateGroupByResult CreateTestGroupByResult() + { + return new AggregateGroupByResult + { + Groups = + [ + new AggregateGroupByResult.Group + { + GroupedBy = new AggregateGroupByResult.Group.By( + "category", + "A", + typeof(string) + ), + TotalCount = 50, + Properties = new Dictionary + { + ["textField"] = new Aggregate.Text + { + Count = 5, + TopOccurrences = + [ + new Aggregate.TopOccurrence { Value = "test", Count = 3 }, + ], + }, + ["intField"] = new Aggregate.Integer + { + Count = 10, + Minimum = 1, + Maximum = 50, + }, + }, + }, + new AggregateGroupByResult.Group + { + GroupedBy = new AggregateGroupByResult.Group.By( + "category", + "B", + typeof(string) + ), + TotalCount = 30, + Properties = new Dictionary + { + ["textField"] = new Aggregate.Text + { + Count = 3, + TopOccurrences = + [ + new Aggregate.TopOccurrence { Value = "other", Count = 2 }, + ], + }, + }, + }, + ], + }; + } + + [Fact] + public void Group_Text_ReturnsTextAggregation_WhenPropertyExists() + { + var result = CreateTestGroupByResult(); + var group = result.Groups[0]; + + var text = group.Text("textField"); + + Assert.NotNull(text); + Assert.Equal(5, text.Count); + } + + [Fact] + public void Group_TryGetText_ReturnsTrue_WhenPropertyExists() + { + var result = CreateTestGroupByResult(); + var group = result.Groups[0]; + + var success = group.TryGetText("textField", out var text); + + Assert.True(success); + Assert.NotNull(text); + Assert.Equal(5, text.Count); + } + + [Fact] + public void Group_Property_Action_ExecutesAction_WhenPropertyMatches() + { + var result = CreateTestGroupByResult(); + var group = result.Groups[0]; + long? capturedCount = null; + + var matched = group.Property("textField", t => capturedCount = t.Count); + + Assert.True(matched); + Assert.Equal(5, capturedCount); + } + + [Fact] + public void Group_Match_Action_ExecutesCorrectAction() + { + var result = CreateTestGroupByResult(); + var group = result.Groups[0]; + string? capturedType = null; + + var matched = group.Match( + "textField", + text: _ => + { + capturedType = "text"; + }, + integer: _ => + { + capturedType = "integer"; + } + ); + + Assert.True(matched); + Assert.Equal("text", capturedType); + } + + [Fact] + public void Group_Match_Func_ReturnsCorrectValue() + { + var result = CreateTestGroupByResult(); + var group = result.Groups[0]; + + var description = group.Match( + "intField", + text: t => $"Text: {t.Count}", + integer: i => $"Integer range [{i.Minimum}, {i.Maximum}]" + ); + + Assert.Equal("Integer range [1, 50]", description); + } + + #endregion +} diff --git a/src/Weaviate.Client.Tests/Unit/TestTypedAggregateResults.cs b/src/Weaviate.Client.Tests/Unit/TestTypedAggregateResults.cs new file mode 100644 index 00000000..8d66b7aa --- /dev/null +++ b/src/Weaviate.Client.Tests/Unit/TestTypedAggregateResults.cs @@ -0,0 +1,1157 @@ +using Weaviate.Client.Models; +using Weaviate.Client.Models.Typed; + +namespace Weaviate.Client.Tests.Unit; + +/// +/// Tests for typed aggregate results (AggregateResult{T}, AggregateGroupByResult{T}, AggregatePropertyMapper). +/// +public class TestTypedAggregateResults +{ + #region Test Types + + /// + /// Maps full Aggregate.* types by matching property names. + /// + private class ArticleAggregations + { + public Aggregate.Text? Title { get; set; } + public Aggregate.Integer? WordCount { get; set; } + public Aggregate.Number? Rating { get; set; } + public Aggregate.Boolean? IsPublished { get; set; } + public Aggregate.Date? PublishedDate { get; set; } + } + + /// + /// Uses suffixes to extract specific values from aggregations. + /// + private class ArticleSummary + { + // Text aggregation - extract count + public long? TitleCount { get; set; } + + // Number aggregation - extract mean + public double? RatingMean { get; set; } + + // Integer aggregation - extract sum + public long? WordCountSum { get; set; } + + // Boolean aggregation - extract percentage true + public double? IsPublishedPercentageTrue { get; set; } + + // Date aggregation - extract minimum + public DateTime? PublishedDateMinimum { get; set; } + } + + /// + /// Tests various suffix combinations. + /// + private class NumericSuffixTests + { + // Integer suffixes + public long? QuantityCount { get; set; } + public long? QuantitySum { get; set; } + public double? QuantityMean { get; set; } + public double? QuantityAverage { get; set; } + public long? QuantityMin { get; set; } + public long? QuantityMinimum { get; set; } + public long? QuantityMax { get; set; } + public long? QuantityMaximum { get; set; } + public double? QuantityMedian { get; set; } + public long? QuantityMode { get; set; } + + // Number suffixes + public double? PriceSum { get; set; } + public double? PriceMean { get; set; } + public double? PriceMin { get; set; } + public double? PriceMax { get; set; } + } + + /// + /// Tests Boolean aggregation suffixes. + /// + private class BooleanSuffixTests + { + public long? InStockTotalTrue { get; set; } + public long? InStockTotalFalse { get; set; } + public double? InStockPercentageTrue { get; set; } + public double? InStockPercentageFalse { get; set; } + public long? InStockCount { get; set; } + } + + /// + /// Tests Text aggregation suffixes. + /// + private class TextSuffixTests + { + public long? CategoryCount { get; set; } + public string? CategoryTopOccurrence { get; set; } + public List>? CategoryTopOccurrences { get; set; } + } + + /// + /// Tests Date aggregation suffixes. + /// + private class DateSuffixTests + { + public DateTime? CreatedAtMinimum { get; set; } + public DateTime? CreatedAtMaximum { get; set; } + public DateTime? CreatedAtMedian { get; set; } + public DateTime? CreatedAtMode { get; set; } + public long? CreatedAtCount { get; set; } + } + + /// + /// Tests mixing full types with suffixes. + /// + private class MixedMappingTests + { + // Full type mapping + public Aggregate.Number? Price { get; set; } + + // Suffix-based extraction from same field + public double? PriceMean { get; set; } + public double? PriceSum { get; set; } + + // Another full type + public Aggregate.Text? Title { get; set; } + + // Suffix extraction + public long? TitleCount { get; set; } + } + + #endregion + + #region Test Data + + private static AggregateResult CreateTestAggregateResult() + { + return new AggregateResult + { + TotalCount = 100, + Properties = new Dictionary + { + ["title"] = new Aggregate.Text + { + Count = 100, + TopOccurrences = + [ + new Aggregate.TopOccurrence { Value = "Introduction", Count = 15 }, + new Aggregate.TopOccurrence { Value = "Summary", Count = 10 }, + ], + }, + ["wordCount"] = new Aggregate.Integer + { + Count = 100, + Minimum = 100, + Maximum = 5000, + Mean = 1500.5, + Median = 1200, + Mode = 1000, + Sum = 150050, + }, + ["rating"] = new Aggregate.Number + { + Count = 95, + Minimum = 1.0, + Maximum = 5.0, + Mean = 3.8, + Median = 4.0, + Mode = 4.5, + Sum = 361.0, + }, + ["isPublished"] = new Aggregate.Boolean + { + Count = 100, + TotalTrue = 75, + TotalFalse = 25, + PercentageTrue = 0.75, + PercentageFalse = 0.25, + }, + ["publishedDate"] = new Aggregate.Date + { + Count = 75, + Minimum = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc), + Maximum = new DateTime(2023, 12, 31, 0, 0, 0, DateTimeKind.Utc), + Median = new DateTime(2022, 6, 15, 0, 0, 0, DateTimeKind.Utc), + Mode = new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc), + }, + }, + }; + } + + private static AggregateGroupByResult CreateTestGroupByResult() + { + return new AggregateGroupByResult + { + Groups = + [ + new AggregateGroupByResult.Group + { + GroupedBy = new AggregateGroupByResult.Group.By( + "category", + "Tech", + typeof(string) + ), + TotalCount = 60, + Properties = new Dictionary + { + ["title"] = new Aggregate.Text + { + Count = 60, + TopOccurrences = + [ + new Aggregate.TopOccurrence + { + Value = "AI Guide", + Count = 10, + }, + ], + }, + ["wordCount"] = new Aggregate.Integer + { + Count = 60, + Minimum = 500, + Maximum = 5000, + Mean = 2000.0, + Sum = 120000, + }, + ["rating"] = new Aggregate.Number + { + Count = 58, + Mean = 4.2, + Sum = 243.6, + }, + }, + }, + new AggregateGroupByResult.Group + { + GroupedBy = new AggregateGroupByResult.Group.By( + "category", + "Science", + typeof(string) + ), + TotalCount = 40, + Properties = new Dictionary + { + ["title"] = new Aggregate.Text + { + Count = 40, + TopOccurrences = + [ + new Aggregate.TopOccurrence + { + Value = "Research Paper", + Count = 8, + }, + ], + }, + ["wordCount"] = new Aggregate.Integer + { + Count = 40, + Minimum = 1000, + Maximum = 8000, + Mean = 3000.0, + Sum = 120000, + }, + ["rating"] = new Aggregate.Number + { + Count = 37, + Mean = 3.5, + Sum = 129.5, + }, + }, + }, + ], + }; + } + + #endregion + + #region Full Aggregate Type Mapping Tests + + [Fact] + public void ToTyped_MapsFullAggregateTypes() + { + var untyped = CreateTestAggregateResult(); + + var typed = untyped.ToTyped(); + + Assert.NotNull(typed.Properties.Title); + Assert.Equal(100, typed.Properties.Title.Count); + Assert.Equal(2, typed.Properties.Title.TopOccurrences.Count); + + Assert.NotNull(typed.Properties.WordCount); + Assert.Equal(100, typed.Properties.WordCount.Minimum); + Assert.Equal(5000, typed.Properties.WordCount.Maximum); + + Assert.NotNull(typed.Properties.Rating); + Assert.Equal(3.8, typed.Properties.Rating.Mean); + + Assert.NotNull(typed.Properties.IsPublished); + Assert.Equal(75, typed.Properties.IsPublished.TotalTrue); + + Assert.NotNull(typed.Properties.PublishedDate); + Assert.Equal( + new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc), + typed.Properties.PublishedDate.Minimum + ); + } + + [Fact] + public void ToTyped_PreservesTotalCount() + { + var untyped = CreateTestAggregateResult(); + + var typed = untyped.ToTyped(); + + Assert.Equal(100, typed.TotalCount); + } + + [Fact] + public void ToTyped_PreservesUntypedResult() + { + var untyped = CreateTestAggregateResult(); + + var typed = untyped.ToTyped(); + + Assert.Same(untyped, typed.Untyped); + } + + #endregion + + #region Suffix-Based Mapping Tests + + [Fact] + public void ToTyped_ExtractsValuesBySuffix() + { + var untyped = CreateTestAggregateResult(); + + var typed = untyped.ToTyped(); + + Assert.Equal(100, typed.Properties.TitleCount); + Assert.Equal(3.8, typed.Properties.RatingMean); + Assert.Equal(150050, typed.Properties.WordCountSum); + Assert.Equal(0.75, typed.Properties.IsPublishedPercentageTrue); + Assert.Equal( + new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc), + typed.Properties.PublishedDateMinimum + ); + } + + [Fact] + public void ToTyped_IntegerSuffixes_ExtractCorrectValues() + { + var result = new AggregateResult + { + TotalCount = 50, + Properties = new Dictionary + { + ["quantity"] = new Aggregate.Integer + { + Count = 50, + Sum = 1000, + Mean = 20.0, + Minimum = 1, + Maximum = 100, + Median = 15.5, + Mode = 10, + }, + }, + }; + + var typed = result.ToTyped(); + + Assert.Equal(50, typed.Properties.QuantityCount); + Assert.Equal(1000, typed.Properties.QuantitySum); + Assert.Equal(20.0, typed.Properties.QuantityMean); + Assert.Equal(20.0, typed.Properties.QuantityAverage); + Assert.Equal(1, typed.Properties.QuantityMin); + Assert.Equal(1, typed.Properties.QuantityMinimum); + Assert.Equal(100, typed.Properties.QuantityMax); + Assert.Equal(100, typed.Properties.QuantityMaximum); + Assert.Equal(15.5, typed.Properties.QuantityMedian); + Assert.Equal(10, typed.Properties.QuantityMode); + } + + [Fact] + public void ToTyped_NumberSuffixes_ExtractCorrectValues() + { + var result = new AggregateResult + { + TotalCount = 25, + Properties = new Dictionary + { + ["price"] = new Aggregate.Number + { + Count = 25, + Sum = 500.0, + Mean = 20.0, + Minimum = 5.0, + Maximum = 50.0, + }, + }, + }; + + var typed = result.ToTyped(); + + Assert.Equal(500.0, typed.Properties.PriceSum); + Assert.Equal(20.0, typed.Properties.PriceMean); + Assert.Equal(5.0, typed.Properties.PriceMin); + Assert.Equal(50.0, typed.Properties.PriceMax); + } + + [Fact] + public void ToTyped_BooleanSuffixes_ExtractCorrectValues() + { + var result = new AggregateResult + { + TotalCount = 100, + Properties = new Dictionary + { + ["inStock"] = new Aggregate.Boolean + { + Count = 100, + TotalTrue = 80, + TotalFalse = 20, + PercentageTrue = 0.8, + PercentageFalse = 0.2, + }, + }, + }; + + var typed = result.ToTyped(); + + Assert.Equal(80, typed.Properties.InStockTotalTrue); + Assert.Equal(20, typed.Properties.InStockTotalFalse); + Assert.Equal(0.8, typed.Properties.InStockPercentageTrue); + Assert.Equal(0.2, typed.Properties.InStockPercentageFalse); + Assert.Equal(100, typed.Properties.InStockCount); + } + + [Fact] + public void ToTyped_TextSuffixes_ExtractCorrectValues() + { + var result = new AggregateResult + { + TotalCount = 50, + Properties = new Dictionary + { + ["category"] = new Aggregate.Text + { + Count = 50, + TopOccurrences = + [ + new Aggregate.TopOccurrence { Value = "Electronics", Count = 20 }, + new Aggregate.TopOccurrence { Value = "Books", Count = 15 }, + ], + }, + }, + }; + + var typed = result.ToTyped(); + + Assert.Equal(50, typed.Properties.CategoryCount); + Assert.Equal("Electronics", typed.Properties.CategoryTopOccurrence); + Assert.NotNull(typed.Properties.CategoryTopOccurrences); + Assert.Equal(2, typed.Properties.CategoryTopOccurrences.Count); + Assert.Equal("Electronics", typed.Properties.CategoryTopOccurrences[0].Value); + } + + [Fact] + public void ToTyped_DateSuffixes_ExtractCorrectValues() + { + var minDate = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc); + var maxDate = new DateTime(2023, 12, 31, 0, 0, 0, DateTimeKind.Utc); + var medianDate = new DateTime(2022, 6, 15, 0, 0, 0, DateTimeKind.Utc); + var modeDate = new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc); + + var result = new AggregateResult + { + TotalCount = 75, + Properties = new Dictionary + { + ["createdAt"] = new Aggregate.Date + { + Count = 75, + Minimum = minDate, + Maximum = maxDate, + Median = medianDate, + Mode = modeDate, + }, + }, + }; + + var typed = result.ToTyped(); + + Assert.Equal(minDate, typed.Properties.CreatedAtMinimum); + Assert.Equal(maxDate, typed.Properties.CreatedAtMaximum); + Assert.Equal(medianDate, typed.Properties.CreatedAtMedian); + Assert.Equal(modeDate, typed.Properties.CreatedAtMode); + Assert.Equal(75, typed.Properties.CreatedAtCount); + } + + #endregion + + #region Mixed Mapping Tests + + [Fact] + public void ToTyped_MixedFullTypesAndSuffixes() + { + var result = new AggregateResult + { + TotalCount = 50, + Properties = new Dictionary + { + ["price"] = new Aggregate.Number + { + Count = 50, + Mean = 29.99, + Sum = 1499.50, + }, + ["title"] = new Aggregate.Text { Count = 50, TopOccurrences = [] }, + }, + }; + + var typed = result.ToTyped(); + + // Full type should be mapped + Assert.NotNull(typed.Properties.Price); + Assert.Equal(29.99, typed.Properties.Price.Mean); + + // Suffix extractions should also work + Assert.Equal(29.99, typed.Properties.PriceMean); + Assert.Equal(1499.50, typed.Properties.PriceSum); + + // Full text type + Assert.NotNull(typed.Properties.Title); + Assert.Equal(50, typed.Properties.Title.Count); + + // Suffix extraction + Assert.Equal(50, typed.Properties.TitleCount); + } + + #endregion + + #region GroupBy Result Tests + + [Fact] + public void GroupByToTyped_MapsAllGroups() + { + var untyped = CreateTestGroupByResult(); + + var typed = untyped.ToTyped(); + + Assert.Equal(2, typed.Groups.Count); + } + + [Fact] + public void GroupByToTyped_PreservesGroupedByInfo() + { + var untyped = CreateTestGroupByResult(); + + var typed = untyped.ToTyped(); + + Assert.Equal("category", typed.Groups[0].GroupedBy.Property); + Assert.Equal("Tech", typed.Groups[0].GroupedBy.Value); + Assert.Equal("Science", typed.Groups[1].GroupedBy.Value); + } + + [Fact] + public void GroupByToTyped_PreservesTotalCountPerGroup() + { + var untyped = CreateTestGroupByResult(); + + var typed = untyped.ToTyped(); + + Assert.Equal(60, typed.Groups[0].TotalCount); + Assert.Equal(40, typed.Groups[1].TotalCount); + } + + [Fact] + public void GroupByToTyped_MapsFullTypesPerGroup() + { + var untyped = CreateTestGroupByResult(); + + var typed = untyped.ToTyped(); + + // First group (Tech) + Assert.NotNull(typed.Groups[0].Properties.Title); + Assert.NotNull(typed.Groups[0].Properties.Title!.Count); + Assert.Equal(60, typed.Groups[0].Properties.Title!.Count!); + Assert.NotNull(typed.Groups[0].Properties.WordCount); + Assert.NotNull(typed.Groups[0].Properties.WordCount!.Mean); + Assert.Equal(2000.0, typed.Groups[0].Properties.WordCount!.Mean!.Value); + + // Second group (Science) + Assert.NotNull(typed.Groups[1].Properties.Title); + Assert.NotNull(typed.Groups[1].Properties.Title!.Count); + Assert.Equal(40, typed.Groups[1].Properties.Title!.Count!); + Assert.NotNull(typed.Groups[1].Properties.WordCount); + Assert.NotNull(typed.Groups[1].Properties.WordCount!.Mean); + Assert.Equal(3000.0, typed.Groups[1].Properties.WordCount!.Mean!.Value); + } + + [Fact] + public void GroupByToTyped_ExtractsSuffixValuesPerGroup() + { + var untyped = CreateTestGroupByResult(); + + var typed = untyped.ToTyped(); + + // First group (Tech) + Assert.Equal(60, typed.Groups[0].Properties.TitleCount); + Assert.Equal(4.2, typed.Groups[0].Properties.RatingMean); + Assert.Equal(120000, typed.Groups[0].Properties.WordCountSum); + + // Second group (Science) + Assert.Equal(40, typed.Groups[1].Properties.TitleCount); + Assert.Equal(3.5, typed.Groups[1].Properties.RatingMean); + Assert.Equal(120000, typed.Groups[1].Properties.WordCountSum); + } + + [Fact] + public void GroupByToTyped_PreservesUntypedResult() + { + var untyped = CreateTestGroupByResult(); + + var typed = untyped.ToTyped(); + + Assert.Same(untyped, typed.Untyped); + Assert.Same(untyped.Groups[0], typed.Groups[0].Untyped); + Assert.Same(untyped.Groups[1], typed.Groups[1].Untyped); + } + + #endregion + + #region Edge Cases + + [Fact] + public void ToTyped_HandlesEmptyProperties() + { + var result = new AggregateResult + { + TotalCount = 0, + Properties = new Dictionary(), + }; + + var typed = result.ToTyped(); + + Assert.Equal(0, typed.TotalCount); + Assert.Null(typed.Properties.Title); + Assert.Null(typed.Properties.WordCount); + } + + [Fact] + public void GroupByToTyped_HandlesEmptyGroups() + { + var result = new AggregateGroupByResult { Groups = [] }; + + var typed = result.ToTyped(); + + Assert.Empty(typed.Groups); + } + + [Fact] + public void ToTyped_IgnoresPropertiesWithoutMatchingSuffix() + { + var result = new AggregateResult + { + TotalCount = 10, + Properties = new Dictionary + { + ["unknownField"] = new Aggregate.Text { Count = 5 }, + }, + }; + + var typed = result.ToTyped(); + + // All properties should be null since no suffix matches + Assert.Null(typed.Properties.TitleCount); + Assert.Null(typed.Properties.RatingMean); + } + + [Fact] + public void ToTyped_HandlesNullValues() + { + var result = new AggregateResult + { + TotalCount = 5, + Properties = new Dictionary + { + ["wordCount"] = new Aggregate.Integer + { + Count = 5, + // Sum is null + }, + }, + }; + + var typed = result.ToTyped(); + + // Sum is null, so WordCountSum should be null + Assert.Null(typed.Properties.WordCountSum); + } + + [Fact] + public void ToTyped_HandlesCaseInsensitiveFieldMatching() + { + var result = new AggregateResult + { + TotalCount = 10, + Properties = new Dictionary + { + ["RATING"] = new Aggregate.Number { Mean = 4.5 }, + }, + }; + + var typed = result.ToTyped(); + + // Should match Rating property (case-insensitive) + Assert.NotNull(typed.Properties.Rating); + Assert.Equal(4.5, typed.Properties.Rating.Mean); + } + + [Fact] + public void ToTyped_WrongSuffixForAggregationType_ReturnsNull() + { + // Test that boolean suffixes don't work on text aggregations + var result = new AggregateResult + { + TotalCount = 10, + Properties = new Dictionary + { + // This is a Text aggregation, not Boolean + ["inStock"] = new Aggregate.Text { Count = 10 }, + }, + }; + + var typed = result.ToTyped(); + + // Boolean-specific suffixes should not extract from Text + Assert.Null(typed.Properties.InStockTotalTrue); + Assert.Null(typed.Properties.InStockTotalFalse); + Assert.Null(typed.Properties.InStockPercentageTrue); + + // But Count should work (it's available on all types) + Assert.Equal(10, typed.Properties.InStockCount); + } + + #endregion + + #region MetricsExtractor Tests + + /// + /// Type with full Aggregate.* types for MetricsExtractor testing. + /// + private class FullAggregateTypeMetrics + { + public Aggregate.Text? Title { get; set; } + public Aggregate.Integer? Quantity { get; set; } + public Aggregate.Number? Price { get; set; } + public Aggregate.Boolean? InStock { get; set; } + public Aggregate.Date? CreatedAt { get; set; } + } + + /// + /// Type with suffix-based properties for MetricsExtractor testing. + /// + private class SuffixBasedMetrics + { + public double? PriceMean { get; set; } + public long? QuantitySum { get; set; } + public long? TitleCount { get; set; } + public double? InStockPercentageTrue { get; set; } + public DateTime? CreatedAtMinimum { get; set; } + } + + /// + /// Type with multiple suffixes for the same field. + /// + private class MultipleSuffixesPerField + { + public double? PriceMean { get; set; } + public double? PriceMin { get; set; } + public double? PriceMax { get; set; } + public long? PriceCount { get; set; } + } + + /// + /// Type with mixed aggregate types and suffixes. + /// + private class MixedMetrics + { + public Aggregate.Text? Title { get; set; } + public double? PriceMean { get; set; } + public long? QuantitySum { get; set; } + } + + [Fact] + public void FromType_ExtractsFullAggregateTypes() + { + var metrics = MetricsExtractor.FromType(); + + Assert.Equal(5, metrics.Length); + + var textMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "title"); + Assert.NotNull(textMetric); + Assert.True(textMetric.Count); + Assert.True(textMetric.TopOccurrencesCount); + Assert.True(textMetric.TopOccurrencesValue); + + var intMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "quantity"); + Assert.NotNull(intMetric); + Assert.True(intMetric.Count); + Assert.True(intMetric.Sum); + Assert.True(intMetric.Mean); + Assert.True(intMetric.Minimum); + Assert.True(intMetric.Maximum); + Assert.True(intMetric.Median); + Assert.True(intMetric.Mode); + + var numMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "price"); + Assert.NotNull(numMetric); + + var boolMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "inStock"); + Assert.NotNull(boolMetric); + Assert.True(boolMetric.TotalTrue); + Assert.True(boolMetric.TotalFalse); + Assert.True(boolMetric.PercentageTrue); + Assert.True(boolMetric.PercentageFalse); + + var dateMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "createdAt"); + Assert.NotNull(dateMetric); + Assert.True(dateMetric.Minimum); + Assert.True(dateMetric.Maximum); + Assert.True(dateMetric.Median); + Assert.True(dateMetric.Mode); + } + + [Fact] + public void FromType_ExtractsSuffixBasedMetrics() + { + var metrics = MetricsExtractor.FromType(); + + Assert.Equal(5, metrics.Length); + + // Price with Mean suffix -> Number with only Mean enabled + var priceMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "price"); + Assert.NotNull(priceMetric); + Assert.True(priceMetric.Mean); + Assert.False(priceMetric.Sum); + + // Quantity with Sum suffix -> Number with only Sum enabled + var quantityMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "quantity"); + Assert.NotNull(quantityMetric); + Assert.True(quantityMetric.Sum); + Assert.False(quantityMetric.Mean); + + // Title with Count suffix -> Integer with only Count enabled + var titleMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "title"); + Assert.NotNull(titleMetric); + Assert.True(titleMetric.Count); + Assert.False(titleMetric.Sum); + + // InStock with PercentageTrue suffix -> Boolean + var inStockMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "inStock"); + Assert.NotNull(inStockMetric); + Assert.True(inStockMetric.PercentageTrue); + Assert.False(inStockMetric.TotalTrue); + + // CreatedAt with Minimum suffix -> Date + var dateMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "createdAt"); + Assert.NotNull(dateMetric); + Assert.True(dateMetric.Minimum); + Assert.False(dateMetric.Maximum); + } + + [Fact] + public void FromType_CombinesMultipleSuffixesForSameField() + { + var metrics = MetricsExtractor.FromType(); + + // Should have only one metric for "price" with all flags combined + Assert.Single(metrics); + var priceMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "price"); + Assert.NotNull(priceMetric); + Assert.True(priceMetric.Mean); + Assert.True(priceMetric.Minimum); + Assert.True(priceMetric.Maximum); + Assert.True(priceMetric.Count); + Assert.False(priceMetric.Sum); // Not specified in the type + } + + [Fact] + public void FromType_HandlesMixedTypes() + { + var metrics = MetricsExtractor.FromType(); + + Assert.Equal(3, metrics.Length); + + // Full Text type should have all flags + var textMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "title"); + Assert.NotNull(textMetric); + Assert.True(textMetric.Count); + Assert.True(textMetric.TopOccurrencesCount); + Assert.True(textMetric.TopOccurrencesValue); + + // Suffix-based should have only specific flags + var priceMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "price"); + Assert.NotNull(priceMetric); + Assert.True(priceMetric.Mean); + Assert.False(priceMetric.Sum); + } + + [Fact] + public void FromType_IgnoresPropertiesWithoutSuffix() + { + var metrics = MetricsExtractor.FromType(); + + // Only properties with recognized suffixes or Aggregate types should be extracted + Assert.Empty(metrics); + } + + private class PropertiesWithoutSuffix + { + public string? Name { get; set; } + public int? Price { get; set; } // No suffix + public double? Rating { get; set; } // No suffix + } + + [Fact] + public void FromType_HandlesTextSuffixes() + { + var metrics = MetricsExtractor.FromType(); + + Assert.Single(metrics); + var textMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "title"); + Assert.NotNull(textMetric); + Assert.True(textMetric.TopOccurrencesCount); + Assert.True(textMetric.TopOccurrencesValue); + } + + private class TextSuffixMetrics + { + public string? TitleTopOccurrence { get; set; } + } + + [Fact] + public void FromType_HandlesBooleanSuffixes() + { + var metrics = MetricsExtractor.FromType(); + + Assert.Single(metrics); + var boolMetric = metrics + .OfType() + .FirstOrDefault(m => m.Name == "active"); + Assert.NotNull(boolMetric); + Assert.True(boolMetric.TotalTrue); + Assert.True(boolMetric.TotalFalse); + Assert.True(boolMetric.PercentageTrue); + Assert.True(boolMetric.PercentageFalse); + } + + private class BooleanSuffixMetrics + { + public long? ActiveTotalTrue { get; set; } + public long? ActiveTotalFalse { get; set; } + public double? ActivePercentageTrue { get; set; } + public double? ActivePercentageFalse { get; set; } + } + + [Fact] + public void FromType_NonGenericOverload_Works() + { + var metrics = MetricsExtractor.FromType(typeof(SuffixBasedMetrics)); + + Assert.Equal(5, metrics.Length); + } + + #endregion + + #region MetricsExtractor Attribute Tests + + private class SelectiveMetrics + { + [NumberMetrics(Minimum = true, Maximum = true, Mean = true)] + public Aggregate.Number? Price { get; set; } + + [TextMetrics(Count = true, TopOccurrences = true, MinOccurrences = 5)] + public Aggregate.Text? Category { get; set; } + + [BooleanMetrics(TotalTrue = true, PercentageTrue = true)] + public Aggregate.Boolean? InStock { get; set; } + } + + [Fact] + public void FromType_WithAttributes_EnablesOnlySpecifiedMetrics() + { + var metrics = MetricsExtractor.FromType(); + + Assert.Equal(3, metrics.Length); + + // Price: Only Min, Max, Mean + var price = metrics.OfType().First(m => m.Name == "price"); + Assert.True(price.Minimum); + Assert.True(price.Maximum); + Assert.True(price.Mean); + Assert.False(price.Sum); + Assert.False(price.Count); + Assert.False(price.Median); + + // Category: Count + TopOccurrences with MinOccurrences + var category = metrics.OfType().First(m => m.Name == "category"); + Assert.True(category.Count); + Assert.True(category.TopOccurrencesCount); + Assert.True(category.TopOccurrencesValue); + Assert.Equal(5u, category.MinOccurrences); + + // InStock: Only TotalTrue, PercentageTrue + var inStock = metrics.OfType().First(m => m.Name == "inStock"); + Assert.True(inStock.TotalTrue); + Assert.True(inStock.PercentageTrue); + Assert.False(inStock.TotalFalse); + Assert.False(inStock.PercentageFalse); + Assert.False(inStock.Count); + } + + [Fact] + public void FromType_NoAttribute_EnablesAll() + { + var metrics = MetricsExtractor.FromType(); + + var quantity = metrics.OfType().First(m => m.Name == "quantity"); + Assert.True(quantity.Count); + Assert.True(quantity.Sum); + Assert.True(quantity.Mean); + Assert.True(quantity.Minimum); + Assert.True(quantity.Maximum); + Assert.True(quantity.Median); + Assert.True(quantity.Mode); + } + + private class NoAttributeMetrics + { + public Aggregate.Integer? Quantity { get; set; } + } + + [Fact] + public void FromType_MixedAttributes_WorksCorrectly() + { + var metrics = MetricsExtractor.FromType(); + + Assert.Equal(2, metrics.Length); + + // Price has attribute - only specified metrics + var price = metrics.OfType().First(m => m.Name == "price"); + Assert.True(price.Minimum); + Assert.True(price.Maximum); + Assert.False(price.Mean); + Assert.False(price.Sum); + + // Quantity has no attribute - all metrics + var quantity = metrics.OfType().First(m => m.Name == "quantity"); + Assert.True(quantity.Count); + Assert.True(quantity.Sum); + Assert.True(quantity.Mean); + } + + private class MixedAttributes + { + [NumberMetrics(Minimum = true, Maximum = true)] + public Aggregate.Number? Price { get; set; } + + public Aggregate.Integer? Quantity { get; set; } + } + + [Fact] + public void FromType_EmptyAttribute_EnablesAll() + { + var metrics = MetricsExtractor.FromType(); + + var price = metrics.OfType().First(m => m.Name == "price"); + + // Empty attribute with no true values - enables all + Assert.True(price.Count); + Assert.True(price.Sum); + Assert.True(price.Mean); + Assert.True(price.Minimum); + Assert.True(price.Maximum); + Assert.True(price.Median); + Assert.True(price.Mode); + } + + private class EmptyAttributeMetrics + { + [NumberMetrics] // All properties default to false - enables all + public Aggregate.Number? Price { get; set; } + } + + [Fact] + public void FromType_IntegerMetricsAttribute_EnablesOnlySpecifiedMetrics() + { + var metrics = MetricsExtractor.FromType(); + + var quantity = metrics.OfType().First(m => m.Name == "quantity"); + Assert.True(quantity.Sum); + Assert.True(quantity.Count); + Assert.False(quantity.Mean); + Assert.False(quantity.Minimum); + Assert.False(quantity.Maximum); + } + + private class IntegerAttributeMetrics + { + [IntegerMetrics(Sum = true, Count = true)] + public Aggregate.Integer? Quantity { get; set; } + } + + [Fact] + public void FromType_DateMetricsAttribute_EnablesOnlySpecifiedMetrics() + { + var metrics = MetricsExtractor.FromType(); + + var createdAt = metrics.OfType().First(m => m.Name == "createdAt"); + Assert.True(createdAt.Minimum); + Assert.True(createdAt.Maximum); + Assert.False(createdAt.Median); + Assert.False(createdAt.Mode); + Assert.False(createdAt.Count); + } + + private class DateAttributeMetrics + { + [DateMetrics(Minimum = true, Maximum = true)] + public Aggregate.Date? CreatedAt { get; set; } + } + + #endregion +} diff --git a/src/Weaviate.Client/Models/Aggregate.cs b/src/Weaviate.Client/Models/Aggregate.cs index 0ce5a440..94f01c96 100644 --- a/src/Weaviate.Client/Models/Aggregate.cs +++ b/src/Weaviate.Client/Models/Aggregate.cs @@ -12,6 +12,284 @@ public record By(string Property, object Value, Type Type); public IReadOnlyDictionary Properties { get; init; } = new Dictionary(); public long TotalCount { get; init; } = 0; + + #region Typed Accessor Methods + + /// + /// Gets the text aggregation for the specified property. + /// + /// The name of the property. + /// The text aggregation, or null if not found or wrong type. + public Aggregate.Text? Text(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Text : null; + + /// + /// Gets the integer aggregation for the specified property. + /// + /// The name of the property. + /// The integer aggregation, or null if not found or wrong type. + public Aggregate.Integer? Integer(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Integer : null; + + /// + /// Gets the number aggregation for the specified property. + /// + /// The name of the property. + /// The number aggregation, or null if not found or wrong type. + public Aggregate.Number? Number(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Number : null; + + /// + /// Gets the boolean aggregation for the specified property. + /// + /// The name of the property. + /// The boolean aggregation, or null if not found or wrong type. + public Aggregate.Boolean? Boolean(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Boolean : null; + + /// + /// Gets the date aggregation for the specified property. + /// + /// The name of the property. + /// The date aggregation, or null if not found or wrong type. + public Aggregate.Date? Date(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Date : null; + + #endregion + + #region TryGet Methods + + /// + /// Tries to get the text aggregation for the specified property. + /// + /// The name of the property. + /// The text aggregation if found and of correct type. + /// True if the property exists and is a text aggregation; otherwise, false. + public bool TryGetText(string propertyName, out Aggregate.Text text) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Text t) + { + text = t; + return true; + } + + text = null!; + return false; + } + + /// + /// Tries to get the integer aggregation for the specified property. + /// + /// The name of the property. + /// The integer aggregation if found and of correct type. + /// True if the property exists and is an integer aggregation; otherwise, false. + public bool TryGetInteger(string propertyName, out Aggregate.Integer integer) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Integer i) + { + integer = i; + return true; + } + + integer = null!; + return false; + } + + /// + /// Tries to get the number aggregation for the specified property. + /// + /// The name of the property. + /// The number aggregation if found and of correct type. + /// True if the property exists and is a number aggregation; otherwise, false. + public bool TryGetNumber(string propertyName, out Aggregate.Number number) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Number n) + { + number = n; + return true; + } + + number = null!; + return false; + } + + /// + /// Tries to get the boolean aggregation for the specified property. + /// + /// The name of the property. + /// The boolean aggregation if found and of correct type. + /// True if the property exists and is a boolean aggregation; otherwise, false. + public bool TryGetBoolean(string propertyName, out Aggregate.Boolean boolean) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Boolean b) + { + boolean = b; + return true; + } + + boolean = null!; + return false; + } + + /// + /// Tries to get the date aggregation for the specified property. + /// + /// The name of the property. + /// The date aggregation if found and of correct type. + /// True if the property exists and is a date aggregation; otherwise, false. + public bool TryGetDate(string propertyName, out Aggregate.Date date) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Date d) + { + date = d; + return true; + } + + date = null!; + return false; + } + + /// + /// Tries to get the aggregation for the specified property as the specified type. + /// + /// The expected aggregation type. + /// The name of the property. + /// The aggregation if found and of correct type. + /// True if the property exists and is of the specified type; otherwise, false. + public bool TryGet(string propertyName, out T aggregation) + where T : Aggregate.Property + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is T t) + { + aggregation = t; + return true; + } + + aggregation = null!; + return false; + } + + #endregion + + #region Match Methods + + /// + /// Executes an action on the property if it exists and matches the expected type. + /// + /// The expected aggregation type. + /// The name of the property. + /// The action to execute if the property matches. + /// True if the property was matched and the action executed; otherwise, false. + public bool Property(string propertyName, Action action) + where T : Aggregate.Property + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is T t) + { + action(t); + return true; + } + + return false; + } + + /// + /// Executes a function on the property if it exists and matches the expected type. + /// + /// The expected aggregation type. + /// The return type. + /// The name of the property. + /// The function to execute if the property matches. + /// The result of the function, or default if the property doesn't match. + public TResult? Property(string propertyName, Func func) + where T : Aggregate.Property + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is T t) + { + return func(t); + } + + return default; + } + + /// + /// Matches the property against all possible aggregation types and executes the corresponding action. + /// + /// The name of the property. + /// Action to execute if the property is a text aggregation. + /// Action to execute if the property is an integer aggregation. + /// Action to execute if the property is a number aggregation. + /// Action to execute if the property is a boolean aggregation. + /// Action to execute if the property is a date aggregation. + /// True if the property was found and matched; otherwise, false. + public bool Match( + string propertyName, + Action? text = null, + Action? integer = null, + Action? number = null, + Action? boolean = null, + Action? date = null + ) + { + if (!Properties.TryGetValue(propertyName, out var prop)) + return false; + + switch (prop) + { + case Aggregate.Text t when text is not null: + text(t); + return true; + case Aggregate.Integer i when integer is not null: + integer(i); + return true; + case Aggregate.Number n when number is not null: + number(n); + return true; + case Aggregate.Boolean b when boolean is not null: + boolean(b); + return true; + case Aggregate.Date d when date is not null: + date(d); + return true; + default: + return false; + } + } + + /// + /// Matches the property against all possible aggregation types and returns the result of the corresponding function. + /// + /// The return type. + /// The name of the property. + /// Function to execute if the property is a text aggregation. + /// Function to execute if the property is an integer aggregation. + /// Function to execute if the property is a number aggregation. + /// Function to execute if the property is a boolean aggregation. + /// Function to execute if the property is a date aggregation. + /// The result of the matched function, or default if no match. + public TResult? Match( + string propertyName, + Func? text = null, + Func? integer = null, + Func? number = null, + Func? boolean = null, + Func? date = null + ) + { + if (!Properties.TryGetValue(propertyName, out var prop)) + return default; + + return prop switch + { + Aggregate.Text t when text is not null => text(t), + Aggregate.Integer i when integer is not null => integer(i), + Aggregate.Number n when number is not null => number(n), + Aggregate.Boolean b when boolean is not null => boolean(b), + Aggregate.Date d when date is not null => date(d), + _ => default, + }; + } + + #endregion } public List Groups { get; init; } = new(); @@ -91,6 +369,284 @@ public partial record AggregateResult public long TotalCount { get; init; } + #region Typed Accessor Methods + + /// + /// Gets the text aggregation for the specified property. + /// + /// The name of the property. + /// The text aggregation, or null if not found or wrong type. + public Aggregate.Text? Text(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Text : null; + + /// + /// Gets the integer aggregation for the specified property. + /// + /// The name of the property. + /// The integer aggregation, or null if not found or wrong type. + public Aggregate.Integer? Integer(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Integer : null; + + /// + /// Gets the number aggregation for the specified property. + /// + /// The name of the property. + /// The number aggregation, or null if not found or wrong type. + public Aggregate.Number? Number(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Number : null; + + /// + /// Gets the boolean aggregation for the specified property. + /// + /// The name of the property. + /// The boolean aggregation, or null if not found or wrong type. + public Aggregate.Boolean? Boolean(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Boolean : null; + + /// + /// Gets the date aggregation for the specified property. + /// + /// The name of the property. + /// The date aggregation, or null if not found or wrong type. + public Aggregate.Date? Date(string propertyName) => + Properties.TryGetValue(propertyName, out var prop) ? prop as Aggregate.Date : null; + + #endregion + + #region TryGet Methods + + /// + /// Tries to get the text aggregation for the specified property. + /// + /// The name of the property. + /// The text aggregation if found and of correct type. + /// True if the property exists and is a text aggregation; otherwise, false. + public bool TryGetText(string propertyName, out Aggregate.Text text) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Text t) + { + text = t; + return true; + } + + text = null!; + return false; + } + + /// + /// Tries to get the integer aggregation for the specified property. + /// + /// The name of the property. + /// The integer aggregation if found and of correct type. + /// True if the property exists and is an integer aggregation; otherwise, false. + public bool TryGetInteger(string propertyName, out Aggregate.Integer integer) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Integer i) + { + integer = i; + return true; + } + + integer = null!; + return false; + } + + /// + /// Tries to get the number aggregation for the specified property. + /// + /// The name of the property. + /// The number aggregation if found and of correct type. + /// True if the property exists and is a number aggregation; otherwise, false. + public bool TryGetNumber(string propertyName, out Aggregate.Number number) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Number n) + { + number = n; + return true; + } + + number = null!; + return false; + } + + /// + /// Tries to get the boolean aggregation for the specified property. + /// + /// The name of the property. + /// The boolean aggregation if found and of correct type. + /// True if the property exists and is a boolean aggregation; otherwise, false. + public bool TryGetBoolean(string propertyName, out Aggregate.Boolean boolean) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Boolean b) + { + boolean = b; + return true; + } + + boolean = null!; + return false; + } + + /// + /// Tries to get the date aggregation for the specified property. + /// + /// The name of the property. + /// The date aggregation if found and of correct type. + /// True if the property exists and is a date aggregation; otherwise, false. + public bool TryGetDate(string propertyName, out Aggregate.Date date) + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is Aggregate.Date d) + { + date = d; + return true; + } + + date = null!; + return false; + } + + /// + /// Tries to get the aggregation for the specified property as the specified type. + /// + /// The expected aggregation type. + /// The name of the property. + /// The aggregation if found and of correct type. + /// True if the property exists and is of the specified type; otherwise, false. + public bool TryGet(string propertyName, out T aggregation) + where T : Aggregate.Property + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is T t) + { + aggregation = t; + return true; + } + + aggregation = null!; + return false; + } + + #endregion + + #region Match Methods + + /// + /// Executes an action on the property if it exists and matches the expected type. + /// + /// The expected aggregation type. + /// The name of the property. + /// The action to execute if the property matches. + /// True if the property was matched and the action executed; otherwise, false. + public bool Property(string propertyName, Action action) + where T : Aggregate.Property + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is T t) + { + action(t); + return true; + } + + return false; + } + + /// + /// Executes a function on the property if it exists and matches the expected type. + /// + /// The expected aggregation type. + /// The return type. + /// The name of the property. + /// The function to execute if the property matches. + /// The result of the function, or default if the property doesn't match. + public TResult? Property(string propertyName, Func func) + where T : Aggregate.Property + { + if (Properties.TryGetValue(propertyName, out var prop) && prop is T t) + { + return func(t); + } + + return default; + } + + /// + /// Matches the property against all possible aggregation types and executes the corresponding action. + /// + /// The name of the property. + /// Action to execute if the property is a text aggregation. + /// Action to execute if the property is an integer aggregation. + /// Action to execute if the property is a number aggregation. + /// Action to execute if the property is a boolean aggregation. + /// Action to execute if the property is a date aggregation. + /// True if the property was found and matched; otherwise, false. + public bool Match( + string propertyName, + Action? text = null, + Action? integer = null, + Action? number = null, + Action? boolean = null, + Action? date = null + ) + { + if (!Properties.TryGetValue(propertyName, out var prop)) + return false; + + switch (prop) + { + case Aggregate.Text t when text is not null: + text(t); + return true; + case Aggregate.Integer i when integer is not null: + integer(i); + return true; + case Aggregate.Number n when number is not null: + number(n); + return true; + case Aggregate.Boolean b when boolean is not null: + boolean(b); + return true; + case Aggregate.Date d when date is not null: + date(d); + return true; + default: + return false; + } + } + + /// + /// Matches the property against all possible aggregation types and returns the result of the corresponding function. + /// + /// The return type. + /// The name of the property. + /// Function to execute if the property is a text aggregation. + /// Function to execute if the property is an integer aggregation. + /// Function to execute if the property is a number aggregation. + /// Function to execute if the property is a boolean aggregation. + /// Function to execute if the property is a date aggregation. + /// The result of the matched function, or default if no match. + public TResult? Match( + string propertyName, + Func? text = null, + Func? integer = null, + Func? number = null, + Func? boolean = null, + Func? date = null + ) + { + if (!Properties.TryGetValue(propertyName, out var prop)) + return default; + + return prop switch + { + Aggregate.Text t when text is not null => text(t), + Aggregate.Integer i when integer is not null => integer(i), + Aggregate.Number n when number is not null => number(n), + Aggregate.Boolean b when boolean is not null => boolean(b), + Aggregate.Date d when date is not null => date(d), + _ => default, + }; + } + + #endregion + internal static AggregateResult FromGrpcReply(V1.AggregateReply reply) { return new AggregateResult diff --git a/src/Weaviate.Client/Models/Typed/AggregateMetricsAttributes.cs b/src/Weaviate.Client/Models/Typed/AggregateMetricsAttributes.cs new file mode 100644 index 00000000..22c20b45 --- /dev/null +++ b/src/Weaviate.Client/Models/Typed/AggregateMetricsAttributes.cs @@ -0,0 +1,73 @@ +namespace Weaviate.Client.Models.Typed; + +/// +/// Specifies which metrics to query for an Aggregate.Text property. +/// Without this attribute, all metrics are queried by default. +/// +[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)] +public sealed class TextMetricsAttribute : Attribute +{ + public bool Count { get; init; } + public bool TopOccurrences { get; init; } + public uint MinOccurrences { get; init; } +} + +/// +/// Specifies which metrics to query for an Aggregate.Integer property. +/// Without this attribute, all metrics are queried by default. +/// +[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)] +public sealed class IntegerMetricsAttribute : Attribute +{ + public bool Count { get; init; } + public bool Sum { get; init; } + public bool Mean { get; init; } + public bool Minimum { get; init; } + public bool Maximum { get; init; } + public bool Median { get; init; } + public bool Mode { get; init; } +} + +/// +/// Specifies which metrics to query for an Aggregate.Number property. +/// Without this attribute, all metrics are queried by default. +/// +[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)] +public sealed class NumberMetricsAttribute : Attribute +{ + public bool Count { get; init; } + public bool Sum { get; init; } + public bool Mean { get; init; } + public bool Minimum { get; init; } + public bool Maximum { get; init; } + public bool Median { get; init; } + public bool Mode { get; init; } +} + +/// +/// Specifies which metrics to query for an Aggregate.Boolean property. +/// Without this attribute, all metrics are queried by default. +/// +[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)] +public sealed class BooleanMetricsAttribute : Attribute +{ + public bool Count { get; init; } + public bool TotalTrue { get; init; } + public bool TotalFalse { get; init; } + public bool PercentageTrue { get; init; } + public bool PercentageFalse { get; init; } +} + +/// +/// Specifies which metrics to query for an Aggregate.Date property. +/// Without this attribute, all metrics are queried by default. +/// +[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)] +public sealed class DateMetricsAttribute : Attribute +{ + public bool Count { get; init; } + public bool Minimum { get; init; } + public bool Maximum { get; init; } + public bool Median { get; init; } + public bool Mode { get; init; } +} diff --git a/src/Weaviate.Client/Models/Typed/TypedAggregateResults.cs b/src/Weaviate.Client/Models/Typed/TypedAggregateResults.cs new file mode 100644 index 00000000..12808d21 --- /dev/null +++ b/src/Weaviate.Client/Models/Typed/TypedAggregateResults.cs @@ -0,0 +1,939 @@ +using System.Reflection; + +namespace Weaviate.Client.Models.Typed; + +/// +/// Strongly-typed aggregate result that maps aggregation properties to a user-defined type. +/// Properties of type T are mapped to their corresponding aggregation types. +/// +/// The type whose properties define the aggregation structure. +public record AggregateResult + where T : class, new() +{ + /// + /// The underlying untyped aggregate result. + /// + public required AggregateResult Untyped { get; init; } + + /// + /// The strongly-typed aggregation properties. + /// + public required T Properties { get; init; } + + /// + /// The total count of objects aggregated. + /// + public long TotalCount => Untyped.TotalCount; + + /// + /// Creates a typed aggregate result from an untyped result. + /// + internal static AggregateResult FromUntyped(AggregateResult result) + { + var typed = AggregatePropertyMapper.MapToType(result.Properties); + return new AggregateResult { Untyped = result, Properties = typed }; + } +} + +/// +/// Strongly-typed group-by aggregate result. +/// +/// The type whose properties define the aggregation structure. +public record AggregateGroupByResult + where T : class, new() +{ + /// + /// The underlying untyped group-by result. + /// + public required AggregateGroupByResult Untyped { get; init; } + + /// + /// The strongly-typed groups. + /// + public required IReadOnlyList Groups { get; init; } + + /// + /// A strongly-typed group within a group-by aggregation. + /// + public record Group + { + /// + /// The underlying untyped group. + /// + public required AggregateGroupByResult.Group Untyped { get; init; } + + /// + /// Information about what this group is grouped by. + /// + public AggregateGroupByResult.Group.By GroupedBy => Untyped.GroupedBy; + + /// + /// The total count of objects in this group. + /// + public long TotalCount => Untyped.TotalCount; + + /// + /// The strongly-typed aggregation properties for this group. + /// + public required T Properties { get; init; } + } + + /// + /// Creates a typed group-by result from an untyped result. + /// + internal static AggregateGroupByResult FromUntyped(AggregateGroupByResult result) + { + var typedGroups = result + .Groups.Select(g => new Group + { + Untyped = g, + Properties = AggregatePropertyMapper.MapToType(g.Properties), + }) + .ToList(); + + return new AggregateGroupByResult { Untyped = result, Groups = typedGroups }; + } +} + +/// +/// Maps aggregate properties to strongly-typed objects. +/// +internal static class AggregatePropertyMapper +{ + /// + /// Recognized suffixes for extracting specific values from aggregation properties. + /// + internal static readonly string[] Suffixes = + [ + "Count", + "Sum", + "Mean", + "Average", + "Min", + "Minimum", + "Max", + "Maximum", + "Median", + "Mode", + "TotalTrue", + "TotalFalse", + "PercentageTrue", + "PercentageFalse", + "TopOccurrence", + "TopOccurrences", + ]; + + /// + /// Maps a dictionary of aggregate properties to a strongly-typed object. + /// Property names are matched using case-insensitive comparison. + /// For primitive types, a suffix must be used to indicate which value to extract + /// (e.g., PriceSum, QuantityMean, TitleCount). + /// + public static T MapToType(IReadOnlyDictionary properties) + where T : class, new() + { + var result = new T(); + var targetProperties = typeof(T) + .GetProperties(BindingFlags.Public | BindingFlags.Instance) + .Where(p => p.CanWrite) + .ToList(); + + // Create a case-insensitive lookup for properties + var propertiesLookup = new Dictionary( + StringComparer.OrdinalIgnoreCase + ); + foreach (var kvp in properties) + { + propertiesLookup[kvp.Key] = kvp.Value; + } + + foreach (var targetProperty in targetProperties) + { + var propertyName = targetProperty.Name; + var targetType = targetProperty.PropertyType; + + // Check if target type is a full Aggregate.* type (direct mapping by name) + if (IsAggregateType(targetType)) + { + var fieldName = propertyName.Decapitalize(); + if ( + propertiesLookup.TryGetValue(fieldName, out var aggregation) + && targetType.IsAssignableFrom(aggregation.GetType()) + ) + { + targetProperty.SetValue(result, aggregation); + } + + continue; + } + + // For primitive types, look for suffix-based mapping + var (fieldName2, suffix) = ParsePropertyNameWithSuffix(propertyName); + if (suffix == null || !propertiesLookup.TryGetValue(fieldName2, out var agg)) + continue; + + var value = ExtractValueBySuffix(agg, suffix, targetType); + if (value != null) + { + targetProperty.SetValue(result, value); + } + } + + return result; + } + + /// + /// Maps a dictionary of aggregate properties to a strongly-typed object. + /// + public static T MapToType(IDictionary properties) + where T : class, new() + { + // Create a read-only wrapper and cast explicitly + IReadOnlyDictionary readOnly = new Dictionary< + string, + Aggregate.Property + >(properties); + return MapToType(readOnly); + } + + private static bool IsAggregateType(Type type) + { + return type == typeof(Aggregate.Text) + || type == typeof(Aggregate.Integer) + || type == typeof(Aggregate.Number) + || type == typeof(Aggregate.Boolean) + || type == typeof(Aggregate.Date) + || type == typeof(Aggregate.Property); + } + + /// + /// Parses a property name to extract the field name and suffix. + /// Returns (fieldName, suffix) where suffix is null if no recognized suffix is found. + /// + internal static (string fieldName, string? suffix) ParsePropertyNameWithSuffix( + string propertyName + ) + { + foreach (var suffix in Suffixes) + { + if ( + propertyName.Length > suffix.Length + && propertyName.EndsWith(suffix, StringComparison.Ordinal) + ) + { + var fieldName = propertyName[..^suffix.Length].Decapitalize(); + return (fieldName, suffix); + } + } + + return (propertyName.Decapitalize(), null); + } + + /// + /// Extracts a value from an aggregation property based on the suffix. + /// + private static object? ExtractValueBySuffix( + Aggregate.Property aggregation, + string suffix, + Type targetType + ) + { + var underlyingType = Nullable.GetUnderlyingType(targetType) ?? targetType; + + return suffix switch + { + // Count - available on all types + "Count" => ConvertToNumeric(aggregation.Count, underlyingType), + + // Sum - Integer and Number + "Sum" => aggregation switch + { + Aggregate.Integer i => ConvertToNumeric(i.Sum, underlyingType), + Aggregate.Number n => ConvertToNumeric(n.Sum, underlyingType), + _ => null, + }, + + // Mean/Average - Integer and Number + "Mean" or "Average" => aggregation switch + { + Aggregate.Integer i => ConvertToNumeric(i.Mean, underlyingType), + Aggregate.Number n => ConvertToNumeric(n.Mean, underlyingType), + _ => null, + }, + + // Min/Minimum - Integer, Number, Date + "Min" or "Minimum" => aggregation switch + { + Aggregate.Integer i => ConvertToNumeric(i.Minimum, underlyingType), + Aggregate.Number n => ConvertToNumeric(n.Minimum, underlyingType), + Aggregate.Date d when underlyingType == typeof(DateTime) => d.Minimum, + _ => null, + }, + + // Max/Maximum - Integer, Number, Date + "Max" or "Maximum" => aggregation switch + { + Aggregate.Integer i => ConvertToNumeric(i.Maximum, underlyingType), + Aggregate.Number n => ConvertToNumeric(n.Maximum, underlyingType), + Aggregate.Date d when underlyingType == typeof(DateTime) => d.Maximum, + _ => null, + }, + + // Median - Integer, Number, Date + "Median" => aggregation switch + { + Aggregate.Integer i => ConvertToNumeric(i.Median, underlyingType), + Aggregate.Number n => ConvertToNumeric(n.Median, underlyingType), + Aggregate.Date d when underlyingType == typeof(DateTime) => d.Median, + _ => null, + }, + + // Mode - Integer, Number, Date, Text + "Mode" => aggregation switch + { + Aggregate.Integer i => ConvertToNumeric(i.Mode, underlyingType), + Aggregate.Number n => ConvertToNumeric(n.Mode, underlyingType), + Aggregate.Date d when underlyingType == typeof(DateTime) => d.Mode, + _ => null, + }, + + // TotalTrue - Boolean + "TotalTrue" => aggregation switch + { + Aggregate.Boolean b => ConvertToNumeric(b.TotalTrue, underlyingType), + _ => null, + }, + + // TotalFalse - Boolean + "TotalFalse" => aggregation switch + { + Aggregate.Boolean b => ConvertToNumeric(b.TotalFalse, underlyingType), + _ => null, + }, + + // PercentageTrue - Boolean + "PercentageTrue" => aggregation switch + { + Aggregate.Boolean b => ConvertToNumeric(b.PercentageTrue, underlyingType), + _ => null, + }, + + // PercentageFalse - Boolean + "PercentageFalse" => aggregation switch + { + Aggregate.Boolean b => ConvertToNumeric(b.PercentageFalse, underlyingType), + _ => null, + }, + + // TopOccurrence - Text (returns first occurrence value) + "TopOccurrence" => aggregation switch + { + Aggregate.Text t when underlyingType == typeof(string) => t + .TopOccurrences.FirstOrDefault() + ?.Value, + _ => null, + }, + + // TopOccurrences - Text (returns list) + "TopOccurrences" => aggregation switch + { + Aggregate.Text t when targetType == typeof(List>) => + t.TopOccurrences, + Aggregate.Text t + when targetType == typeof(IReadOnlyList>) => + t.TopOccurrences, + Aggregate.Text t + when targetType == typeof(IList>) => + t.TopOccurrences, + Aggregate.Text t + when targetType == typeof(IEnumerable>) => + t.TopOccurrences, + _ => null, + }, + + _ => null, + }; + } + + /// + /// Converts a numeric value to the target type. + /// + private static object? ConvertToNumeric(long? value, Type targetType) + { + if (!value.HasValue) + return null; + + return targetType switch + { + _ when targetType == typeof(long) => value.Value, + _ when targetType == typeof(int) => (int)value.Value, + _ when targetType == typeof(double) => (double)value.Value, + _ when targetType == typeof(float) => (float)value.Value, + _ when targetType == typeof(decimal) => (decimal)value.Value, + _ => null, + }; + } + + /// + /// Converts a numeric value to the target type. + /// + private static object? ConvertToNumeric(double? value, Type targetType) + { + if (!value.HasValue) + return null; + + return targetType switch + { + _ when targetType == typeof(double) => value.Value, + _ when targetType == typeof(float) => (float)value.Value, + _ when targetType == typeof(decimal) => (decimal)value.Value, + _ when targetType == typeof(long) => (long)value.Value, + _ when targetType == typeof(int) => (int)value.Value, + _ => null, + }; + } + + /// + /// Converts a long value to the target type. + /// + private static object? ConvertToNumeric(long value, Type targetType) + { + return targetType switch + { + _ when targetType == typeof(long) => value, + _ when targetType == typeof(int) => (int)value, + _ when targetType == typeof(double) => (double)value, + _ when targetType == typeof(float) => (float)value, + _ when targetType == typeof(decimal) => (decimal)value, + _ => null, + }; + } + + /// + /// Converts a double value to the target type. + /// + private static object? ConvertToNumeric(double value, Type targetType) + { + return targetType switch + { + _ when targetType == typeof(double) => value, + _ when targetType == typeof(float) => (float)value, + _ when targetType == typeof(decimal) => (decimal)value, + _ when targetType == typeof(long) => (long)value, + _ when targetType == typeof(int) => (int)value, + _ => null, + }; + } +} + +/// +/// Extracts aggregate metrics from a type's properties for use with the returnMetrics parameter. +/// +public static class MetricsExtractor +{ + /// + /// Extracts aggregate metrics from a type's properties. + /// For properties with Aggregate.* types, the corresponding metric type is used with all flags enabled. + /// For properties with primitive types and recognized suffixes, only the specific metric flags are enabled. + /// + /// The type to extract metrics from. + /// An array of metrics that can be passed to the returnMetrics parameter. + /// + /// + /// public class ProductStats + /// { + /// public double? PriceMean { get; set; } + /// public long? QuantitySum { get; set; } + /// public Aggregate.Text? Category { get; set; } + /// } + /// + /// var metrics = MetricsExtractor.FromType<ProductStats>(); + /// var result = await client.Aggregate.OverAll(returnMetrics: metrics); + /// var typed = result.ToTyped<ProductStats>(); + /// + /// + public static Aggregate.Metric[] FromType() + where T : class + { + return FromType(typeof(T)); + } + + /// + /// Extracts aggregate metrics from a type's properties. + /// + /// The type to extract metrics from. + /// An array of metrics that can be passed to the returnMetrics parameter. + public static Aggregate.Metric[] FromType(Type type) + { + var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance) + .Where(p => p.CanRead); + + // Group properties by field name to combine metrics + var metricsByField = new Dictionary( + StringComparer.OrdinalIgnoreCase + ); + + foreach (var property in properties) + { + var propertyType = property.PropertyType; + var propertyName = property.Name; + + // Check if this is a full Aggregate.* type + if (IsAggregateType(propertyType)) + { + var fieldName = propertyName.Decapitalize(); + var metricType = GetMetricTypeFromAggregateType(propertyType); + if (metricType != MetricType.Unknown) + { + if (!metricsByField.TryGetValue(fieldName, out var builder)) + { + builder = new MetricBuilder(fieldName, metricType); + metricsByField[fieldName] = builder; + } + + // Check for type-specific metrics attributes + var hasAttribute = false; + var anyFlagsEnabled = false; + + if (metricType == MetricType.Text) + { + var attr = property.GetCustomAttribute(); + if (attr != null) + { + hasAttribute = true; + if (attr.Count) + { + builder.EnableFlag("Count"); + anyFlagsEnabled = true; + } + + if (attr.TopOccurrences) + { + builder.EnableFlag("TopOccurrences"); + anyFlagsEnabled = true; + } + + if (attr.MinOccurrences > 0) + builder.SetMinOccurrences(attr.MinOccurrences); + } + } + else if (metricType == MetricType.Integer) + { + var attr = property.GetCustomAttribute(); + if (attr != null) + { + hasAttribute = true; + if (attr.Count) + { + builder.EnableFlag("Count"); + anyFlagsEnabled = true; + } + + if (attr.Sum) + { + builder.EnableFlag("Sum"); + anyFlagsEnabled = true; + } + + if (attr.Mean) + { + builder.EnableFlag("Mean"); + anyFlagsEnabled = true; + } + + if (attr.Minimum) + { + builder.EnableFlag("Minimum"); + anyFlagsEnabled = true; + } + + if (attr.Maximum) + { + builder.EnableFlag("Maximum"); + anyFlagsEnabled = true; + } + + if (attr.Median) + { + builder.EnableFlag("Median"); + anyFlagsEnabled = true; + } + + if (attr.Mode) + { + builder.EnableFlag("Mode"); + anyFlagsEnabled = true; + } + } + } + else if (metricType == MetricType.Number) + { + var attr = property.GetCustomAttribute(); + if (attr != null) + { + hasAttribute = true; + if (attr.Count) + { + builder.EnableFlag("Count"); + anyFlagsEnabled = true; + } + + if (attr.Sum) + { + builder.EnableFlag("Sum"); + anyFlagsEnabled = true; + } + + if (attr.Mean) + { + builder.EnableFlag("Mean"); + anyFlagsEnabled = true; + } + + if (attr.Minimum) + { + builder.EnableFlag("Minimum"); + anyFlagsEnabled = true; + } + + if (attr.Maximum) + { + builder.EnableFlag("Maximum"); + anyFlagsEnabled = true; + } + + if (attr.Median) + { + builder.EnableFlag("Median"); + anyFlagsEnabled = true; + } + + if (attr.Mode) + { + builder.EnableFlag("Mode"); + anyFlagsEnabled = true; + } + } + } + else if (metricType == MetricType.Boolean) + { + var attr = property.GetCustomAttribute(); + if (attr != null) + { + hasAttribute = true; + if (attr.Count) + { + builder.EnableFlag("Count"); + anyFlagsEnabled = true; + } + + if (attr.TotalTrue) + { + builder.EnableFlag("TotalTrue"); + anyFlagsEnabled = true; + } + + if (attr.TotalFalse) + { + builder.EnableFlag("TotalFalse"); + anyFlagsEnabled = true; + } + + if (attr.PercentageTrue) + { + builder.EnableFlag("PercentageTrue"); + anyFlagsEnabled = true; + } + + if (attr.PercentageFalse) + { + builder.EnableFlag("PercentageFalse"); + anyFlagsEnabled = true; + } + } + } + else if (metricType == MetricType.Date) + { + var attr = property.GetCustomAttribute(); + if (attr != null) + { + hasAttribute = true; + if (attr.Count) + { + builder.EnableFlag("Count"); + anyFlagsEnabled = true; + } + + if (attr.Minimum) + { + builder.EnableFlag("Minimum"); + anyFlagsEnabled = true; + } + + if (attr.Maximum) + { + builder.EnableFlag("Maximum"); + anyFlagsEnabled = true; + } + + if (attr.Median) + { + builder.EnableFlag("Median"); + anyFlagsEnabled = true; + } + + if (attr.Mode) + { + builder.EnableFlag("Mode"); + anyFlagsEnabled = true; + } + } + } + + // If no attribute OR attribute with no flags enabled, enable all + if (!hasAttribute || !anyFlagsEnabled) + builder.EnableAll(); + } + + continue; + } + + // For primitive types, look for suffix-based mapping + var (fieldName2, suffix) = AggregatePropertyMapper.ParsePropertyNameWithSuffix( + propertyName + ); + if (suffix == null) + continue; + + var inferredType = GetMetricTypeFromSuffix(suffix, propertyType); + if (inferredType == MetricType.Unknown) + continue; + + if (!metricsByField.TryGetValue(fieldName2, out var builder2)) + { + builder2 = new MetricBuilder(fieldName2, inferredType); + metricsByField[fieldName2] = builder2; + } + + // Enable specific flag based on suffix + builder2.EnableFlag(suffix); + } + + return metricsByField.Values.Select(b => b.Build()).ToArray(); + } + + private static bool IsAggregateType(Type type) + { + return type == typeof(Aggregate.Text) + || type == typeof(Aggregate.Integer) + || type == typeof(Aggregate.Number) + || type == typeof(Aggregate.Boolean) + || type == typeof(Aggregate.Date) + || type == typeof(Aggregate.Property); + } + + private static MetricType GetMetricTypeFromAggregateType(Type type) + { + if (type == typeof(Aggregate.Text)) + return MetricType.Text; + if (type == typeof(Aggregate.Integer)) + return MetricType.Integer; + if (type == typeof(Aggregate.Number)) + return MetricType.Number; + if (type == typeof(Aggregate.Boolean)) + return MetricType.Boolean; + if (type == typeof(Aggregate.Date)) + return MetricType.Date; + return MetricType.Unknown; + } + + private static MetricType GetMetricTypeFromSuffix(string suffix, Type propertyType) + { + // Check if property is DateTime (for Date suffixes) + var underlyingType = Nullable.GetUnderlyingType(propertyType) ?? propertyType; + var isDateTime = underlyingType == typeof(DateTime); + + return suffix switch + { + // Count is available on all types, default to Integer + "Count" => MetricType.Integer, + + // Sum is only for numeric types, not dates + "Sum" => MetricType.Number, + + // Mean/Average is only for numeric types + "Mean" or "Average" => MetricType.Number, + + // Min/Max/Median/Mode can be Date or Number based on property type + "Min" or "Minimum" or "Max" or "Maximum" or "Median" or "Mode" => isDateTime + ? MetricType.Date + : MetricType.Number, + + // Boolean-specific suffixes + "TotalTrue" or "TotalFalse" or "PercentageTrue" or "PercentageFalse" => + MetricType.Boolean, + + // Text-specific suffixes + "TopOccurrence" or "TopOccurrences" => MetricType.Text, + + _ => MetricType.Unknown, + }; + } + + private enum MetricType + { + Unknown, + Text, + Integer, + Number, + Boolean, + Date, + } + + private sealed class MetricBuilder + { + private readonly string _fieldName; + private readonly MetricType _type; + private bool _count; + private bool _sum; + private bool _mean; + private bool _minimum; + private bool _maximum; + private bool _median; + private bool _mode; + private bool _totalTrue; + private bool _totalFalse; + private bool _percentageTrue; + private bool _percentageFalse; + private bool _topOccurrencesCount; + private bool _topOccurrencesValue; + private uint? _minOccurrences; + + public MetricBuilder(string fieldName, MetricType type) + { + _fieldName = fieldName; + _type = type; + } + + public void EnableAll() + { + _count = true; + _sum = true; + _mean = true; + _minimum = true; + _maximum = true; + _median = true; + _mode = true; + _totalTrue = true; + _totalFalse = true; + _percentageTrue = true; + _percentageFalse = true; + _topOccurrencesCount = true; + _topOccurrencesValue = true; + } + + public void SetMinOccurrences(uint minOccurrences) + { + _minOccurrences = minOccurrences; + } + + public void EnableFlag(string suffix) + { + switch (suffix) + { + case "Count": + _count = true; + break; + case "Sum": + _sum = true; + break; + case "Mean": + case "Average": + _mean = true; + break; + case "Min": + case "Minimum": + _minimum = true; + break; + case "Max": + case "Maximum": + _maximum = true; + break; + case "Median": + _median = true; + break; + case "Mode": + _mode = true; + break; + case "TotalTrue": + _totalTrue = true; + break; + case "TotalFalse": + _totalFalse = true; + break; + case "PercentageTrue": + _percentageTrue = true; + break; + case "PercentageFalse": + _percentageFalse = true; + break; + case "TopOccurrence": + case "TopOccurrences": + _topOccurrencesCount = true; + _topOccurrencesValue = true; + break; + } + } + + public Aggregate.Metric Build() + { + return _type switch + { + MetricType.Text => new Aggregate.Metric.Text(_fieldName) + { + Count = _count, + TopOccurrencesCount = _topOccurrencesCount, + TopOccurrencesValue = _topOccurrencesValue, + MinOccurrences = _minOccurrences, + }, + MetricType.Integer => new Aggregate.Metric.Integer(_fieldName) + { + Count = _count, + Sum = _sum, + Mean = _mean, + Minimum = _minimum, + Maximum = _maximum, + Median = _median, + Mode = _mode, + }, + MetricType.Number => new Aggregate.Metric.Number(_fieldName) + { + Count = _count, + Sum = _sum, + Mean = _mean, + Minimum = _minimum, + Maximum = _maximum, + Median = _median, + Mode = _mode, + }, + MetricType.Boolean => new Aggregate.Metric.Boolean(_fieldName) + { + Count = _count, + TotalTrue = _totalTrue, + TotalFalse = _totalFalse, + PercentageTrue = _percentageTrue, + PercentageFalse = _percentageFalse, + }, + MetricType.Date => new Aggregate.Metric.Date(_fieldName) + { + Count = _count, + Minimum = _minimum, + Maximum = _maximum, + Median = _median, + Mode = _mode, + }, + _ => throw new InvalidOperationException($"Unknown metric type: {_type}"), + }; + } + } +} diff --git a/src/Weaviate.Client/Models/Typed/TypedResultConverter.cs b/src/Weaviate.Client/Models/Typed/TypedResultConverter.cs index 6213ccde..ef6649c1 100644 --- a/src/Weaviate.Client/Models/Typed/TypedResultConverter.cs +++ b/src/Weaviate.Client/Models/Typed/TypedResultConverter.cs @@ -154,6 +154,30 @@ this IEnumerable objects #endregion + #region Aggregate Conversions + + /// + /// Converts an untyped AggregateResult to a typed AggregateResult<T>. + /// Properties are mapped to the corresponding properties of type T. + /// + public static AggregateResult ToTyped(this AggregateResult result) + where T : class, new() + { + return AggregateResult.FromUntyped(result); + } + + /// + /// Converts an untyped AggregateGroupByResult to a typed AggregateGroupByResult<T>. + /// Properties within each group are mapped to the corresponding properties of type T. + /// + public static AggregateGroupByResult ToTyped(this AggregateGroupByResult result) + where T : class, new() + { + return AggregateGroupByResult.FromUntyped(result); + } + + #endregion + #region Reverse Conversions (Typed to Untyped) /// diff --git a/src/Weaviate.Client/PublicAPI.Shipped.txt b/src/Weaviate.Client/PublicAPI.Shipped.txt index a9b6abf8..7dc5c581 100644 --- a/src/Weaviate.Client/PublicAPI.Shipped.txt +++ b/src/Weaviate.Client/PublicAPI.Shipped.txt @@ -1,5503 +1 @@ #nullable enable -Weaviate.Client.AggregateClient -Weaviate.Client.AggregateClient.Hybrid(string? query = null, float alpha = 0.7, Weaviate.Client.Models.Vectors? vectors = null, string![]? queryProperties = null, uint? objectLimit = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, Weaviate.Client.Models.Filter? filters = null, string? targetVector = null, float? maxVectorDistance = null, bool totalCount = true, System.Collections.Generic.IEnumerable? returnMetrics = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.Hybrid(string? query, Weaviate.Client.Models.Aggregate.GroupBy! groupBy, float alpha = 0.7, Weaviate.Client.Models.Vectors? vectors = null, string![]? queryProperties = null, uint? objectLimit = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, Weaviate.Client.Models.Filter? filters = null, string? targetVector = null, float? maxVectorDistance = null, bool totalCount = true, System.Collections.Generic.IEnumerable? returnMetrics = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearImage(byte[]! media, Weaviate.Client.Models.Aggregate.GroupBy? groupBy, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? metrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearImage(byte[]! media, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Collections.Generic.IEnumerable? returnMetrics = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, Weaviate.Client.Models.Aggregate.GroupBy? groupBy, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Collections.Generic.IEnumerable? returnMetrics = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearObject(System.Guid nearObject, Weaviate.Client.Models.Aggregate.GroupBy? groupBy, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearObject(System.Guid nearObject, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearText(Weaviate.Client.Models.AutoArray! query, Weaviate.Client.Models.Aggregate.GroupBy? groupBy, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearText(Weaviate.Client.Models.AutoArray! query, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearVector(Weaviate.Client.Models.NearVectorInput! vector, Weaviate.Client.Models.Aggregate.GroupBy? groupBy, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearVector(Weaviate.Client.Models.NearVectorInput! vector, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearVector(Weaviate.Client.Models.Vectors! vector, Weaviate.Client.Models.Aggregate.GroupBy? groupBy, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.NearVector(Weaviate.Client.Models.Vectors! vector, double? certainty = null, double? distance = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.TargetVectors? targetVector = null, bool totalCount = true, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.OverAll(Weaviate.Client.Models.Aggregate.GroupBy! groupBy, bool totalCount = true, Weaviate.Client.Models.Filter? filters = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AggregateClient.OverAll(bool totalCount = true, Weaviate.Client.Models.Filter? filters = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken), System.Collections.Generic.IEnumerable? returnMetrics = null) -> System.Threading.Tasks.Task! -Weaviate.Client.AliasClient -Weaviate.Client.AliasClient.Create(string! alias, string! targetCollection, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.AliasClient.Delete(string! aliasName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.AliasClient.Get(string! aliasName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.AliasClient.List(string? collectionName = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.AliasClient.Update(string! aliasName, string! targetCollection, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Auth -Weaviate.Client.Auth.ApiKeyCredentials -Weaviate.Client.Auth.ApiKeyCredentials.$() -> Weaviate.Client.Auth.ApiKeyCredentials! -Weaviate.Client.Auth.ApiKeyCredentials.ApiKeyCredentials(string! Value) -> void -Weaviate.Client.Auth.ApiKeyCredentials.Deconstruct(out string! Value) -> void -Weaviate.Client.Auth.ApiKeyCredentials.Equals(Weaviate.Client.Auth.ApiKeyCredentials? other) -> bool -Weaviate.Client.Auth.ApiKeyCredentials.Value.get -> string! -Weaviate.Client.Auth.ApiKeyCredentials.Value.init -> void -Weaviate.Client.Auth.BearerTokenCredentials -Weaviate.Client.Auth.BearerTokenCredentials.$() -> Weaviate.Client.Auth.BearerTokenCredentials! -Weaviate.Client.Auth.BearerTokenCredentials.AccessToken.get -> string! -Weaviate.Client.Auth.BearerTokenCredentials.AccessToken.init -> void -Weaviate.Client.Auth.BearerTokenCredentials.BearerTokenCredentials(string! AccessToken, int ExpiresIn = 60, string! RefreshToken = "") -> void -Weaviate.Client.Auth.BearerTokenCredentials.Deconstruct(out string! AccessToken, out int ExpiresIn, out string! RefreshToken) -> void -Weaviate.Client.Auth.BearerTokenCredentials.Equals(Weaviate.Client.Auth.BearerTokenCredentials? other) -> bool -Weaviate.Client.Auth.BearerTokenCredentials.ExpiresIn.get -> int -Weaviate.Client.Auth.BearerTokenCredentials.ExpiresIn.init -> void -Weaviate.Client.Auth.BearerTokenCredentials.RefreshToken.get -> string! -Weaviate.Client.Auth.BearerTokenCredentials.RefreshToken.init -> void -Weaviate.Client.Auth.ClientCredentialsFlow -Weaviate.Client.Auth.ClientCredentialsFlow.$() -> Weaviate.Client.Auth.ClientCredentialsFlow! -Weaviate.Client.Auth.ClientCredentialsFlow.ClientCredentialsFlow(string! ClientSecret, params string?[]! Scope) -> void -Weaviate.Client.Auth.ClientCredentialsFlow.ClientSecret.get -> string! -Weaviate.Client.Auth.ClientCredentialsFlow.ClientSecret.init -> void -Weaviate.Client.Auth.ClientCredentialsFlow.Deconstruct(out string! ClientSecret, out string?[]! Scope) -> void -Weaviate.Client.Auth.ClientCredentialsFlow.Equals(Weaviate.Client.Auth.ClientCredentialsFlow? other) -> bool -Weaviate.Client.Auth.ClientCredentialsFlow.GetScopes() -> string! -Weaviate.Client.Auth.ClientCredentialsFlow.Scope.get -> string?[]! -Weaviate.Client.Auth.ClientCredentialsFlow.Scope.init -> void -Weaviate.Client.Auth.ClientPasswordFlow -Weaviate.Client.Auth.ClientPasswordFlow.$() -> Weaviate.Client.Auth.ClientPasswordFlow! -Weaviate.Client.Auth.ClientPasswordFlow.ClientPasswordFlow(string! Username, string! Password, params string?[]! Scope) -> void -Weaviate.Client.Auth.ClientPasswordFlow.Deconstruct(out string! Username, out string! Password, out string?[]! Scope) -> void -Weaviate.Client.Auth.ClientPasswordFlow.Equals(Weaviate.Client.Auth.ClientPasswordFlow? other) -> bool -Weaviate.Client.Auth.ClientPasswordFlow.GetScopes() -> string! -Weaviate.Client.Auth.ClientPasswordFlow.Password.get -> string! -Weaviate.Client.Auth.ClientPasswordFlow.Password.init -> void -Weaviate.Client.Auth.ClientPasswordFlow.Scope.get -> string?[]! -Weaviate.Client.Auth.ClientPasswordFlow.Scope.init -> void -Weaviate.Client.Auth.ClientPasswordFlow.Username.get -> string! -Weaviate.Client.Auth.ClientPasswordFlow.Username.init -> void -Weaviate.Client.AuthenticatedHttpHandler -Weaviate.Client.AuthenticatedHttpHandler.AuthenticatedHttpHandler(Weaviate.Client.ITokenService! tokenService, int? refreshIntervalMinutes = 5) -> void -Weaviate.Client.BackupClient -Weaviate.Client.BackupClient.Cancel(Weaviate.Client.Models.BackupBackend! backend, string! id, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.BackupClient.Create(Weaviate.Client.Models.BackupCreateRequest! request, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.BackupClient.CreateSync(Weaviate.Client.Models.BackupCreateRequest! request, System.TimeSpan? timeout = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.BackupClient.GetRestoreStatus(Weaviate.Client.Models.BackupBackend! backend, string! id, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.BackupClient.GetStatus(Weaviate.Client.Models.BackupBackend! backend, string! id, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.BackupClient.List(Weaviate.Client.Models.BackupStorageProvider provider, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.BackupClient.Restore(Weaviate.Client.Models.BackupRestoreRequest! request, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.BackupClient.RestoreSync(Weaviate.Client.Models.BackupRestoreRequest! request, System.TimeSpan? timeout = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.BaseCollectionClient -Weaviate.Client.BaseCollectionClient.BaseCollectionClient(Weaviate.Client.CollectionClient! collectionClient) -> void -Weaviate.Client.BaseCollectionClient.Client.get -> Weaviate.Client.WeaviateClient! -Weaviate.Client.BaseCollectionClient.CollectionName.get -> string! -Weaviate.Client.BaseCollectionClient.ConsistencyLevel.get -> Weaviate.Client.ConsistencyLevels? -Weaviate.Client.BaseCollectionClient.Tenant.get -> string? -Weaviate.Client.Cache.SchemaCache -Weaviate.Client.Cache.SchemaCache.Clear() -> void -Weaviate.Client.Cache.SchemaCache.Contains(string! collectionName) -> bool -Weaviate.Client.Cache.SchemaCache.Count.get -> int -Weaviate.Client.Cache.SchemaCache.GetOrFetch(string! collectionName, System.Func!>! fetcher) -> System.Threading.Tasks.Task! -Weaviate.Client.Cache.SchemaCache.Invalidate(string! collectionName) -> bool -Weaviate.Client.Cache.SchemaCache.IsFresh(string! collectionName) -> bool -Weaviate.Client.Cache.SchemaCache.SchemaCache(System.TimeSpan? ttl = null) -> void -Weaviate.Client.ClientConfiguration -Weaviate.Client.ClientConfiguration.$() -> Weaviate.Client.ClientConfiguration! -Weaviate.Client.ClientConfiguration.ClientConfiguration(string! RestAddress = "localhost", string! RestPath = "v1/", string! GrpcAddress = "localhost", string! GrpcPath = "", ushort RestPort = 8080, ushort GrpcPort = 50051, bool UseSsl = false, System.Collections.Generic.Dictionary? Headers = null, Weaviate.Client.ICredentials? Credentials = null, System.TimeSpan? DefaultTimeout = null, System.TimeSpan? InitTimeout = null, System.TimeSpan? InsertTimeout = null, System.TimeSpan? QueryTimeout = null, Weaviate.Client.RetryPolicy? RetryPolicy = null, System.Net.Http.DelegatingHandler![]? CustomHandlers = null, System.Net.Http.HttpMessageHandler? HttpMessageHandler = null) -> void -Weaviate.Client.ClientConfiguration.Credentials.get -> Weaviate.Client.ICredentials? -Weaviate.Client.ClientConfiguration.Credentials.init -> void -Weaviate.Client.ClientConfiguration.CustomHandlers.get -> System.Net.Http.DelegatingHandler![]? -Weaviate.Client.ClientConfiguration.CustomHandlers.init -> void -Weaviate.Client.ClientConfiguration.Deconstruct(out string! RestAddress, out string! RestPath, out string! GrpcAddress, out string! GrpcPath, out ushort RestPort, out ushort GrpcPort, out bool UseSsl, out System.Collections.Generic.Dictionary? Headers, out Weaviate.Client.ICredentials? Credentials, out System.TimeSpan? DefaultTimeout, out System.TimeSpan? InitTimeout, out System.TimeSpan? InsertTimeout, out System.TimeSpan? QueryTimeout, out Weaviate.Client.RetryPolicy? RetryPolicy, out System.Net.Http.DelegatingHandler![]? CustomHandlers, out System.Net.Http.HttpMessageHandler? HttpMessageHandler) -> void -Weaviate.Client.ClientConfiguration.DefaultTimeout.get -> System.TimeSpan? -Weaviate.Client.ClientConfiguration.DefaultTimeout.init -> void -Weaviate.Client.ClientConfiguration.Equals(Weaviate.Client.ClientConfiguration? other) -> bool -Weaviate.Client.ClientConfiguration.GrpcAddress.get -> string! -Weaviate.Client.ClientConfiguration.GrpcAddress.init -> void -Weaviate.Client.ClientConfiguration.GrpcPath.get -> string! -Weaviate.Client.ClientConfiguration.GrpcPath.init -> void -Weaviate.Client.ClientConfiguration.GrpcPort.get -> ushort -Weaviate.Client.ClientConfiguration.GrpcPort.init -> void -Weaviate.Client.ClientConfiguration.GrpcUri.get -> System.Uri! -Weaviate.Client.ClientConfiguration.Headers.get -> System.Collections.Generic.Dictionary? -Weaviate.Client.ClientConfiguration.Headers.init -> void -Weaviate.Client.ClientConfiguration.HttpMessageHandler.get -> System.Net.Http.HttpMessageHandler? -Weaviate.Client.ClientConfiguration.HttpMessageHandler.init -> void -Weaviate.Client.ClientConfiguration.InitTimeout.get -> System.TimeSpan? -Weaviate.Client.ClientConfiguration.InitTimeout.init -> void -Weaviate.Client.ClientConfiguration.InsertTimeout.get -> System.TimeSpan? -Weaviate.Client.ClientConfiguration.InsertTimeout.init -> void -Weaviate.Client.ClientConfiguration.QueryTimeout.get -> System.TimeSpan? -Weaviate.Client.ClientConfiguration.QueryTimeout.init -> void -Weaviate.Client.ClientConfiguration.RestAddress.get -> string! -Weaviate.Client.ClientConfiguration.RestAddress.init -> void -Weaviate.Client.ClientConfiguration.RestPath.get -> string! -Weaviate.Client.ClientConfiguration.RestPath.init -> void -Weaviate.Client.ClientConfiguration.RestPort.get -> ushort -Weaviate.Client.ClientConfiguration.RestPort.init -> void -Weaviate.Client.ClientConfiguration.RestUri.get -> System.Uri! -Weaviate.Client.ClientConfiguration.RetryPolicy.get -> Weaviate.Client.RetryPolicy? -Weaviate.Client.ClientConfiguration.RetryPolicy.init -> void -Weaviate.Client.ClientConfiguration.UseSsl.get -> bool -Weaviate.Client.ClientConfiguration.UseSsl.init -> void -Weaviate.Client.ClusterClient -Weaviate.Client.ClusterClient.Nodes.get -> Weaviate.Client.NodesClient! -Weaviate.Client.ClusterClient.Replicate(Weaviate.Client.Models.ReplicateRequest! request, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.ClusterClient.ReplicateSync(Weaviate.Client.Models.ReplicateRequest! request, System.TimeSpan? timeout = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.ClusterClient.Replications.get -> Weaviate.Client.ReplicationsClient! -Weaviate.Client.CollectionClient -Weaviate.Client.CollectionClient.Aggregate.get -> Weaviate.Client.AggregateClient! -Weaviate.Client.CollectionClient.Client.get -> Weaviate.Client.WeaviateClient! -Weaviate.Client.CollectionClient.Config.get -> Weaviate.Client.CollectionConfigClient! -Weaviate.Client.CollectionClient.ConsistencyLevel.get -> Weaviate.Client.ConsistencyLevels? -Weaviate.Client.CollectionClient.Count(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionClient.Data.get -> Weaviate.Client.DataClient! -Weaviate.Client.CollectionClient.Generate.get -> Weaviate.Client.GenerateClient! -Weaviate.Client.CollectionClient.Iterator(System.Guid? after = null, uint cacheSize = 100, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IAsyncEnumerable! -Weaviate.Client.CollectionClient.Name.get -> string! -Weaviate.Client.CollectionClient.Query.get -> Weaviate.Client.QueryClient! -Weaviate.Client.CollectionClient.Tenant.get -> string? -Weaviate.Client.CollectionClient.Tenants.get -> Weaviate.Client.TenantsClient! -Weaviate.Client.CollectionClient.WeaviateVersion.get -> System.Version? -Weaviate.Client.CollectionClient.WithConsistencyLevel(Weaviate.Client.ConsistencyLevels consistencyLevel) -> Weaviate.Client.CollectionClient! -Weaviate.Client.CollectionClient.WithTenant(string! tenant) -> Weaviate.Client.CollectionClient! -Weaviate.Client.CollectionClientExtensions -Weaviate.Client.CollectionConfigClient -Weaviate.Client.CollectionConfigClient.AddProperty(Weaviate.Client.Models.Property! p) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionConfigClient.AddReference(Weaviate.Client.Models.Reference! referenceProperty) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionConfigClient.AddVector(Weaviate.Client.Models.VectorConfig! vector) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionConfigClient.Get(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionConfigClient.GetCachedConfig(Weaviate.Client.Cache.SchemaCache? schemaCache = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionConfigClient.GetShard(string! shardName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionConfigClient.GetShards(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.CollectionConfigClient.Update(System.Action! c) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionConfigClient.UpdateShardStatus(Weaviate.Client.Models.ShardStatus status, params string![]! shardNames) -> System.Threading.Tasks.Task!>! -Weaviate.Client.CollectionsClient -Weaviate.Client.CollectionsClient.CollectionsClient(Weaviate.Client.CollectionsClient! original) -> void -Weaviate.Client.CollectionsClient.Create(Weaviate.Client.Models.CollectionCreateParams! collection, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionsClient.Create(System.IO.Stream! json, bool validate = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.CollectionsClient.Create(System.Text.Json.JsonDocument! json, bool validate = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.CollectionsClient.Create(Weaviate.Client.Models.CollectionCreateParams! collection, bool validateType = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.CollectionsClient.Create(string! json, bool validate = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.CollectionsClient.CreateFromJson(System.IO.Stream! json, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionsClient.CreateFromJson(System.Text.Json.JsonDocument! json, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionsClient.CreateFromJson(string! json, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionsClient.Delete(string! collectionName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionsClient.DeleteAll(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionsClient.Exists(string! collectionName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionsClient.Export(string! collectionName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.CollectionsClient.List(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IAsyncEnumerable! -Weaviate.Client.CollectionsClient.Use(string! name) -> Weaviate.Client.CollectionClient! -Weaviate.Client.CollectionsClient.Use(string! name) -> Weaviate.Client.Typed.TypedCollectionClient! -Weaviate.Client.CollectionsClient.Use(string! name, bool validateType) -> System.Threading.Tasks.Task!>! -Weaviate.Client.CollectionsClient.this[string! name].get -> Weaviate.Client.CollectionClient! -Weaviate.Client.Configure -Weaviate.Client.Connect -Weaviate.Client.ConsistencyLevels -Weaviate.Client.ConsistencyLevels.All = 3 -> Weaviate.Client.ConsistencyLevels -Weaviate.Client.ConsistencyLevels.One = 1 -> Weaviate.Client.ConsistencyLevels -Weaviate.Client.ConsistencyLevels.Quorum = 2 -> Weaviate.Client.ConsistencyLevels -Weaviate.Client.ConsistencyLevels.Unspecified = 0 -> Weaviate.Client.ConsistencyLevels -Weaviate.Client.DataClient -Weaviate.Client.DataClient.DeleteByID(System.Guid uuid, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.DeleteMany(Weaviate.Client.Models.Filter! where, bool dryRun = false, bool verbose = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.Insert(object! properties, System.Guid? uuid = null, Weaviate.Client.Models.Vectors? vectors = null, Weaviate.Client.Models.AutoArray? references = null, bool validate = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.InsertMany(System.Collections.Generic.IEnumerable! requests, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.InsertMany(System.Collections.Generic.IEnumerable! requestBatches, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.InsertMany(System.Collections.IEnumerable! properties, bool validate = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.ReferenceAdd(System.Guid from, string! fromProperty, System.Guid to, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.ReferenceAdd(Weaviate.Client.Models.DataReference! reference, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.ReferenceAddMany(Weaviate.Client.Models.DataReference![]! references, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.ReferenceDelete(System.Guid from, string! fromProperty, System.Guid to, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.ReferenceReplace(System.Guid from, string! fromProperty, System.Guid[]! to, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.Replace(System.Guid uuid, object! properties, Weaviate.Client.Models.Vectors? vectors = null, System.Collections.Generic.IEnumerable? references = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.Update(System.Guid uuid, object! properties, Weaviate.Client.Models.Vectors? vectors = null, System.Collections.Generic.IEnumerable? references = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DataClient.VectorsToDto(Weaviate.Client.Models.Vectors? vectors) -> System.Collections.Generic.IDictionary? -Weaviate.Client.DefaultTokenServiceFactory -Weaviate.Client.DefaultTokenServiceFactory.CreateAsync(Weaviate.Client.ClientConfiguration! configuration) -> System.Threading.Tasks.Task! -Weaviate.Client.DefaultTokenServiceFactory.CreateSync(Weaviate.Client.ClientConfiguration! configuration) -> Weaviate.Client.ITokenService? -Weaviate.Client.DefaultTokenServiceFactory.DefaultTokenServiceFactory() -> void -Weaviate.Client.DependencyInjection.IWeaviateClientFactory -Weaviate.Client.DependencyInjection.IWeaviateClientFactory.GetClient(string! name) -> Weaviate.Client.WeaviateClient! -Weaviate.Client.DependencyInjection.IWeaviateClientFactory.GetClientAsync(string! name, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.DependencyInjection.WeaviateOptions -Weaviate.Client.DependencyInjection.WeaviateOptions.Credentials.get -> Weaviate.Client.ICredentials? -Weaviate.Client.DependencyInjection.WeaviateOptions.Credentials.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.DefaultTimeout.get -> System.TimeSpan? -Weaviate.Client.DependencyInjection.WeaviateOptions.DefaultTimeout.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.GrpcEndpoint.get -> string! -Weaviate.Client.DependencyInjection.WeaviateOptions.GrpcEndpoint.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.GrpcPath.get -> string! -Weaviate.Client.DependencyInjection.WeaviateOptions.GrpcPath.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.GrpcPort.get -> ushort -Weaviate.Client.DependencyInjection.WeaviateOptions.GrpcPort.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.Headers.get -> System.Collections.Generic.Dictionary? -Weaviate.Client.DependencyInjection.WeaviateOptions.Headers.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.InitTimeout.get -> System.TimeSpan? -Weaviate.Client.DependencyInjection.WeaviateOptions.InitTimeout.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.InsertTimeout.get -> System.TimeSpan? -Weaviate.Client.DependencyInjection.WeaviateOptions.InsertTimeout.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.QueryTimeout.get -> System.TimeSpan? -Weaviate.Client.DependencyInjection.WeaviateOptions.QueryTimeout.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.RestEndpoint.get -> string! -Weaviate.Client.DependencyInjection.WeaviateOptions.RestEndpoint.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.RestPath.get -> string! -Weaviate.Client.DependencyInjection.WeaviateOptions.RestPath.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.RestPort.get -> ushort -Weaviate.Client.DependencyInjection.WeaviateOptions.RestPort.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.RetryPolicy.get -> Weaviate.Client.RetryPolicy? -Weaviate.Client.DependencyInjection.WeaviateOptions.RetryPolicy.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.UseSsl.get -> bool -Weaviate.Client.DependencyInjection.WeaviateOptions.UseSsl.set -> void -Weaviate.Client.DependencyInjection.WeaviateOptions.WeaviateOptions() -> void -Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions -Weaviate.Client.Generate -Weaviate.Client.GenerateClient -Weaviate.Client.GenerateClient.BM25(string! query, Weaviate.Client.Models.GroupByRequest! groupBy, string![]? searchFields = null, Weaviate.Client.Models.Filter? filters = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, System.Guid? after = null, Weaviate.Client.ConsistencyLevels? consistencyLevel = null, Weaviate.Client.Models.AutoArray? returnProperties = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.BM25(string! query, string![]? searchFields = null, Weaviate.Client.Models.Filter? filters = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, System.Guid? after = null, Weaviate.Client.ConsistencyLevels? consistencyLevel = null, Weaviate.Client.Models.AutoArray? returnProperties = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.FetchObjectByID(System.Guid id, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.FetchObjects(System.Guid? after = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.FetchObjects(Weaviate.Client.Models.GroupByRequest! groupBy, System.Guid? after = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.FetchObjectsByIDs(System.Collections.Generic.HashSet! ids, uint? limit = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.GenerateClient(Weaviate.Client.CollectionClient! collectionClient) -> void -Weaviate.Client.GenerateClient.Hybrid(string? query, Weaviate.Client.Models.GroupByRequest! groupBy, float? alpha = null, Weaviate.Client.Models.IHybridVectorInput? vectors = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.Hybrid(string? query, Weaviate.Client.Models.GroupByRequest! groupBy, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.Hybrid(string? query, Weaviate.Client.Models.IHybridVectorInput! vectors, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.Hybrid(string? query, Weaviate.Client.Models.Vectors! vectors, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.Hybrid(string? query, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearImage(byte[]! nearImage, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearImage(byte[]! nearImage, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearObject(System.Guid nearObject, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearObject(System.Guid nearObject, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearText(Weaviate.Client.Models.AutoArray! text, Weaviate.Client.Models.GroupByRequest! groupBy, float? certainty = null, float? distance = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearText(Weaviate.Client.Models.AutoArray! text, float? certainty = null, float? distance = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearVector(Weaviate.Client.Models.NearVectorInput! vector, Weaviate.Client.Models.Filter? filters = null, float? certainty = null, float? distance = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearVector(Weaviate.Client.Models.NearVectorInput! vector, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.Filter? filters = null, float? distance = null, float? certainty = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearVector(Weaviate.Client.Models.Vectors! vector, Weaviate.Client.Models.Filter? filters = null, float? certainty = null, float? distance = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerateClient.NearVector(Weaviate.Client.Models.Vectors! vector, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.Filter? filters = null, float? distance = null, float? certainty = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GenerativeConfigFactory -Weaviate.Client.GenerativeConfigFactory.AWSBedrock(string! region, string! model, int? maxTokens = null, string![]? stopSequences = null, double? temperature = null, double? topP = null, double? topK = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.AWSSagemaker(string! region, string! endpoint, string? targetModel = null, string? targetVariant = null, int? maxTokens = null, string![]? stopSequences = null, double? temperature = null, double? topP = null, double? topK = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.Anthropic(string? baseURL = null, int? maxTokens = null, string? model = null, string![]? stopSequences = null, double? temperature = null, int? topK = null, double? topP = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.Anyscale(string? baseURL = null, string? model = null, double? temperature = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.AzureOpenAI(string! resourceName, string! deploymentId, string? model = null, string? baseURL = null, int? frequencyPenalty = null, int? maxTokens = null, int? presencePenalty = null, double? temperature = null, double? topP = null, string? apiVersion = null, string? reasoningEffort = null, string? verbosity = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.Cohere(int? k = null, string? model = null, string? baseURL = null, int? maxTokens = null, string![]? stopSequences = null, double? temperature = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.ContextualAI(string? model = null, double? temperature = null, double? topP = null, long? maxNewTokens = null, string? systemPrompt = null, bool? avoidCommentary = null, string![]? knowledge = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.Custom(string! type, object? config = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.Databricks(string! endpoint, int? maxTokens = null, double? temperature = null, int? topK = null, double? topP = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.FriendliAI(string? baseURL = null, int? maxTokens = null, string? model = null, double? temperature = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.GoogleGemini(int? maxOutputTokens = null, string? model = null, double? temperature = null, int? topK = null, double? topP = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.GoogleVertex(string? apiEndpoint = null, int? maxOutputTokens = null, string? model = null, string? projectId = null, string? endpointId = null, string? region = null, double? temperature = null, int? topK = null, double? topP = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.Mistral(string? baseURL = null, int? maxTokens = null, string? model = null, double? temperature = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.Nvidia(string? baseURL = null, int? maxTokens = null, string? model = null, double? temperature = null, double? topP = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.Ollama(string? apiEndpoint = null, string? model = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.OpenAI(string? model = null, string? baseURL = null, int? frequencyPenalty = null, int? maxTokens = null, int? presencePenalty = null, double? temperature = null, double? topP = null, string? apiVersion = null, string? reasoningEffort = null, string? verbosity = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeConfigFactory.XAI(string? baseURL = null, int? maxTokens = null, string? model = null, double? temperature = null, double? topP = null) -> Weaviate.Client.Models.IGenerativeConfig! -Weaviate.Client.GenerativeProviderFactory -Weaviate.Client.GenerativeProviderFactory.AWSBedrock(string? model = null, double? temperature = null, string? region = null, string? endpoint = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null, long? maxTokens = null) -> Weaviate.Client.Models.Generative.Providers.AWSBedrock! -Weaviate.Client.GenerativeProviderFactory.AWSSagemaker(double? temperature = null, string? region = null, string? endpoint = null, string? targetModel = null, string? targetVariant = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null, long? maxTokens = null) -> Weaviate.Client.Models.Generative.Providers.AWSSagemaker! -Weaviate.Client.GenerativeProviderFactory.Anthropic(string? baseUrl = null, long? maxTokens = null, string? model = null, double? temperature = null, long? topK = null, double? topP = null, System.Collections.Generic.List? stopSequences = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null) -> Weaviate.Client.Models.Generative.Providers.Anthropic! -Weaviate.Client.GenerativeProviderFactory.Anyscale(string? baseUrl = null, string? model = null, double? temperature = null) -> Weaviate.Client.Models.Generative.Providers.Anyscale! -Weaviate.Client.GenerativeProviderFactory.AzureOpenAI(double? frequencyPenalty = null, long? maxTokens = null, string? model = null, long? n = null, double? presencePenalty = null, System.Collections.Generic.List? stop = null, double? temperature = null, double? topP = null, string? baseUrl = null, string? apiVersion = null, string? resourceName = null, string? deploymentId = null, bool? isAzure = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null, Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel? reasoningEffort = null, Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel? verbosity = null) -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI! -Weaviate.Client.GenerativeProviderFactory.Cohere(string? baseUrl = null, double? frequencyPenalty = null, long? maxTokens = null, string? model = null, long? k = null, double? p = null, double? presencePenalty = null, System.Collections.Generic.List? stopSequences = null, double? temperature = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null) -> Weaviate.Client.Models.Generative.Providers.Cohere! -Weaviate.Client.GenerativeProviderFactory.ContextualAI(string? model = null, double? temperature = null, double? topP = null, long? maxNewTokens = null, string? systemPrompt = null, bool? avoidCommentary = null, string![]? knowledge = null) -> Weaviate.Client.Models.Generative.Providers.ContextualAI! -Weaviate.Client.GenerativeProviderFactory.Databricks(string? endpoint = null, string? model = null, double? frequencyPenalty = null, bool? logProbs = null, long? topLogProbs = null, long? maxTokens = null, long? n = null, double? presencePenalty = null, System.Collections.Generic.List? stop = null, double? temperature = null, double? topP = null) -> Weaviate.Client.Models.Generative.Providers.Databricks! -Weaviate.Client.GenerativeProviderFactory.Dummy() -> Weaviate.Client.Models.Generative.Providers.Dummy! -Weaviate.Client.GenerativeProviderFactory.FriendliAI(string? baseUrl = null, string? model = null, long? maxTokens = null, double? temperature = null, long? n = null, double? topP = null) -> Weaviate.Client.Models.Generative.Providers.FriendliAI! -Weaviate.Client.GenerativeProviderFactory.GoogleGemini(double? frequencyPenalty = null, long? maxTokens = null, string? model = null, double? presencePenalty = null, double? temperature = null, long? topK = null, double? topP = null, System.Collections.Generic.List? stopSequences = null, string? apiEndpoint = null, string? projectId = null, string? endpointId = null, string? region = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null) -> Weaviate.Client.Models.Generative.Providers.GoogleGemini! -Weaviate.Client.GenerativeProviderFactory.GoogleVertex(double? frequencyPenalty = null, long? maxTokens = null, string? model = null, double? presencePenalty = null, double? temperature = null, long? topK = null, double? topP = null, System.Collections.Generic.List? stopSequences = null, string? apiEndpoint = null, string? projectId = null, string? endpointId = null, string? region = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null) -> Weaviate.Client.Models.Generative.Providers.GoogleVertex! -Weaviate.Client.GenerativeProviderFactory.Mistral(string? baseUrl = null, long? maxTokens = null, string? model = null, double? temperature = null, double? topP = null) -> Weaviate.Client.Models.Generative.Providers.Mistral! -Weaviate.Client.GenerativeProviderFactory.Nvidia(string? baseUrl = null, string? model = null, double? temperature = null, double? topP = null, long? maxTokens = null) -> Weaviate.Client.Models.Generative.Providers.Nvidia! -Weaviate.Client.GenerativeProviderFactory.Ollama(string? apiEndpoint = null, string? model = null, double? temperature = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null) -> Weaviate.Client.Models.Generative.Providers.Ollama! -Weaviate.Client.GenerativeProviderFactory.OpenAI(double? frequencyPenalty = null, long? maxTokens = null, string? model = null, long? n = null, double? presencePenalty = null, System.Collections.Generic.List? stop = null, double? temperature = null, double? topP = null, string? baseUrl = null, string? apiVersion = null, string? resourceName = null, string? deploymentId = null, bool? isAzure = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null, Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel? reasoningEffort = null, Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel? verbosity = null) -> Weaviate.Client.Models.Generative.Providers.OpenAI! -Weaviate.Client.GenerativeProviderFactory.XAI(string? baseUrl = null, string? model = null, double? temperature = null, double? topP = null, long? maxTokens = null, System.Collections.Generic.List? images = null, System.Collections.Generic.List? imageProperties = null) -> Weaviate.Client.Models.Generative.Providers.XAI! -Weaviate.Client.GroupsClient -Weaviate.Client.GroupsClient.Oidc.get -> Weaviate.Client.GroupsOidcClient! -Weaviate.Client.GroupsOidcClient -Weaviate.Client.GroupsOidcClient.AssignRoles(string! groupId, System.Collections.Generic.IEnumerable! roles, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.GroupsOidcClient.GetKnownGroupNames(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.GroupsOidcClient.GetRoles(string! groupId, bool? includeFullRoles = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.GroupsOidcClient.RevokeRoles(string! groupId, System.Collections.Generic.IEnumerable! roles, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.ICredentials -Weaviate.Client.ITokenService -Weaviate.Client.ITokenService.GetAccessTokenAsync() -> System.Threading.Tasks.Task! -Weaviate.Client.ITokenService.IsAuthenticated() -> bool -Weaviate.Client.ITokenService.RefreshTokenAsync() -> System.Threading.Tasks.Task! -Weaviate.Client.ITokenServiceFactory -Weaviate.Client.ITokenServiceFactory.CreateAsync(Weaviate.Client.ClientConfiguration! configuration) -> System.Threading.Tasks.Task! -Weaviate.Client.ITokenServiceFactory.CreateSync(Weaviate.Client.ClientConfiguration! configuration) -> Weaviate.Client.ITokenService? -Weaviate.Client.Models.Aggregate -Weaviate.Client.Models.Aggregate.Boolean -Weaviate.Client.Models.Aggregate.Boolean.Boolean() -> void -Weaviate.Client.Models.Aggregate.Boolean.Boolean(Weaviate.Client.Models.Aggregate.Boolean! original) -> void -Weaviate.Client.Models.Aggregate.Boolean.PercentageFalse.get -> double -Weaviate.Client.Models.Aggregate.Boolean.PercentageTrue.get -> double -Weaviate.Client.Models.Aggregate.Boolean.TotalFalse.get -> long -Weaviate.Client.Models.Aggregate.Boolean.TotalTrue.get -> long -Weaviate.Client.Models.Aggregate.Date -Weaviate.Client.Models.Aggregate.Date.Date() -> void -Weaviate.Client.Models.Aggregate.Date.Date(Weaviate.Client.Models.Aggregate.Date! original) -> void -Weaviate.Client.Models.Aggregate.Date.Maximum.get -> System.DateTime? -Weaviate.Client.Models.Aggregate.Date.Median.get -> System.DateTime? -Weaviate.Client.Models.Aggregate.Date.Minimum.get -> System.DateTime? -Weaviate.Client.Models.Aggregate.Date.Mode.get -> System.DateTime? -Weaviate.Client.Models.Aggregate.GroupBy -Weaviate.Client.Models.Aggregate.GroupBy.Deconstruct(out string! Property, out uint? Limit) -> void -Weaviate.Client.Models.Aggregate.GroupBy.GroupBy(Weaviate.Client.Models.Aggregate.GroupBy! original) -> void -Weaviate.Client.Models.Aggregate.GroupBy.GroupBy(string! Property, uint? Limit = null) -> void -Weaviate.Client.Models.Aggregate.GroupBy.Limit.get -> uint? -Weaviate.Client.Models.Aggregate.GroupBy.Limit.init -> void -Weaviate.Client.Models.Aggregate.GroupBy.Property.get -> string! -Weaviate.Client.Models.Aggregate.GroupBy.Property.init -> void -Weaviate.Client.Models.Aggregate.Integer -Weaviate.Client.Models.Aggregate.Integer.Integer() -> void -Weaviate.Client.Models.Aggregate.Integer.Integer(Weaviate.Client.Models.Aggregate.Integer! original) -> void -Weaviate.Client.Models.Aggregate.Metric -Weaviate.Client.Models.Aggregate.Metric.Boolean -Weaviate.Client.Models.Aggregate.Metric.Boolean.Boolean(Weaviate.Client.Models.Aggregate.Metric.Boolean! original) -> void -Weaviate.Client.Models.Aggregate.Metric.Boolean.Boolean(string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Boolean.Deconstruct(out string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Boolean.PercentageFalse.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Boolean.PercentageFalse.init -> void -Weaviate.Client.Models.Aggregate.Metric.Boolean.PercentageTrue.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Boolean.PercentageTrue.init -> void -Weaviate.Client.Models.Aggregate.Metric.Boolean.TotalFalse.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Boolean.TotalFalse.init -> void -Weaviate.Client.Models.Aggregate.Metric.Boolean.TotalTrue.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Boolean.TotalTrue.init -> void -Weaviate.Client.Models.Aggregate.Metric.Count.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Count.init -> void -Weaviate.Client.Models.Aggregate.Metric.Date -Weaviate.Client.Models.Aggregate.Metric.Date.Date(Weaviate.Client.Models.Aggregate.Metric.Date! original) -> void -Weaviate.Client.Models.Aggregate.Metric.Date.Date(string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Date.Deconstruct(out string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Date.Maximum.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Date.Maximum.init -> void -Weaviate.Client.Models.Aggregate.Metric.Date.Median.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Date.Median.init -> void -Weaviate.Client.Models.Aggregate.Metric.Date.Minimum.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Date.Minimum.init -> void -Weaviate.Client.Models.Aggregate.Metric.Date.Mode.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Date.Mode.init -> void -Weaviate.Client.Models.Aggregate.Metric.Deconstruct(out string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Integer -Weaviate.Client.Models.Aggregate.Metric.Integer.Deconstruct(out string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Integer.Integer(Weaviate.Client.Models.Aggregate.Metric.Integer! original) -> void -Weaviate.Client.Models.Aggregate.Metric.Integer.Integer(string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Integer.Maximum.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Integer.Maximum.init -> void -Weaviate.Client.Models.Aggregate.Metric.Integer.Mean.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Integer.Mean.init -> void -Weaviate.Client.Models.Aggregate.Metric.Integer.Median.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Integer.Median.init -> void -Weaviate.Client.Models.Aggregate.Metric.Integer.Minimum.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Integer.Minimum.init -> void -Weaviate.Client.Models.Aggregate.Metric.Integer.Mode.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Integer.Mode.init -> void -Weaviate.Client.Models.Aggregate.Metric.Integer.Sum.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Integer.Sum.init -> void -Weaviate.Client.Models.Aggregate.Metric.Metric(Weaviate.Client.Models.Aggregate.Metric! original) -> void -Weaviate.Client.Models.Aggregate.Metric.Metric(string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Name.get -> string! -Weaviate.Client.Models.Aggregate.Metric.Name.init -> void -Weaviate.Client.Models.Aggregate.Metric.Number -Weaviate.Client.Models.Aggregate.Metric.Number.Deconstruct(out string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Number.Maximum.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Number.Maximum.init -> void -Weaviate.Client.Models.Aggregate.Metric.Number.Mean.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Number.Mean.init -> void -Weaviate.Client.Models.Aggregate.Metric.Number.Median.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Number.Median.init -> void -Weaviate.Client.Models.Aggregate.Metric.Number.Minimum.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Number.Minimum.init -> void -Weaviate.Client.Models.Aggregate.Metric.Number.Mode.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Number.Mode.init -> void -Weaviate.Client.Models.Aggregate.Metric.Number.Number(Weaviate.Client.Models.Aggregate.Metric.Number! original) -> void -Weaviate.Client.Models.Aggregate.Metric.Number.Number(string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Number.Sum.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Number.Sum.init -> void -Weaviate.Client.Models.Aggregate.Metric.Text -Weaviate.Client.Models.Aggregate.Metric.Text.Deconstruct(out string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Text.MinOccurrences.get -> uint? -Weaviate.Client.Models.Aggregate.Metric.Text.MinOccurrences.init -> void -Weaviate.Client.Models.Aggregate.Metric.Text.Text(Weaviate.Client.Models.Aggregate.Metric.Text! original) -> void -Weaviate.Client.Models.Aggregate.Metric.Text.Text(string! Name) -> void -Weaviate.Client.Models.Aggregate.Metric.Text.TopOccurrencesCount.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Text.TopOccurrencesCount.init -> void -Weaviate.Client.Models.Aggregate.Metric.Text.TopOccurrencesValue.get -> bool -Weaviate.Client.Models.Aggregate.Metric.Text.TopOccurrencesValue.init -> void -Weaviate.Client.Models.Aggregate.Number -Weaviate.Client.Models.Aggregate.Number.Number() -> void -Weaviate.Client.Models.Aggregate.Number.Number(Weaviate.Client.Models.Aggregate.Number! original) -> void -Weaviate.Client.Models.Aggregate.Numeric -Weaviate.Client.Models.Aggregate.Numeric.Maximum.get -> T? -Weaviate.Client.Models.Aggregate.Numeric.Mean.get -> double? -Weaviate.Client.Models.Aggregate.Numeric.Median.get -> double? -Weaviate.Client.Models.Aggregate.Numeric.Minimum.get -> T? -Weaviate.Client.Models.Aggregate.Numeric.Mode.get -> T? -Weaviate.Client.Models.Aggregate.Numeric.Numeric() -> void -Weaviate.Client.Models.Aggregate.Numeric.Numeric(Weaviate.Client.Models.Aggregate.Numeric! original) -> void -Weaviate.Client.Models.Aggregate.Numeric.Sum.get -> T? -Weaviate.Client.Models.Aggregate.Property -Weaviate.Client.Models.Aggregate.Property.Count.get -> long? -Weaviate.Client.Models.Aggregate.Property.Property() -> void -Weaviate.Client.Models.Aggregate.Property.Property(Weaviate.Client.Models.Aggregate.Property! original) -> void -Weaviate.Client.Models.Aggregate.Text -Weaviate.Client.Models.Aggregate.Text.Text() -> void -Weaviate.Client.Models.Aggregate.Text.Text(Weaviate.Client.Models.Aggregate.Text! original) -> void -Weaviate.Client.Models.Aggregate.Text.TopOccurrences.get -> System.Collections.Generic.List!>! -Weaviate.Client.Models.Aggregate.TopOccurrence -Weaviate.Client.Models.Aggregate.TopOccurrence.TopOccurrence() -> void -Weaviate.Client.Models.Aggregate.TopOccurrence.TopOccurrence(Weaviate.Client.Models.Aggregate.TopOccurrence! original) -> void -Weaviate.Client.Models.Aggregate.TopOccurrence.Value.get -> T? -Weaviate.Client.Models.AggregateGroupByResult -Weaviate.Client.Models.AggregateGroupByResult.AggregateGroupByResult() -> void -Weaviate.Client.Models.AggregateGroupByResult.AggregateGroupByResult(Weaviate.Client.Models.AggregateGroupByResult! original) -> void -Weaviate.Client.Models.AggregateGroupByResult.Group -Weaviate.Client.Models.AggregateGroupByResult.Group.By -Weaviate.Client.Models.AggregateGroupByResult.Group.By.By(Weaviate.Client.Models.AggregateGroupByResult.Group.By! original) -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.By.By(string! Property, object! Value, System.Type! Type) -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.By.Deconstruct(out string! Property, out object! Value, out System.Type! Type) -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.By.Property.get -> string! -Weaviate.Client.Models.AggregateGroupByResult.Group.By.Property.init -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.By.Type.get -> System.Type! -Weaviate.Client.Models.AggregateGroupByResult.Group.By.Type.init -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.By.Value.get -> object! -Weaviate.Client.Models.AggregateGroupByResult.Group.By.Value.init -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.Group() -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.Group(Weaviate.Client.Models.AggregateGroupByResult.Group! original) -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.GroupedBy.get -> Weaviate.Client.Models.AggregateGroupByResult.Group.By! -Weaviate.Client.Models.AggregateGroupByResult.Group.GroupedBy.init -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.Properties.get -> System.Collections.Generic.IReadOnlyDictionary! -Weaviate.Client.Models.AggregateGroupByResult.Group.Properties.init -> void -Weaviate.Client.Models.AggregateGroupByResult.Group.TotalCount.get -> long -Weaviate.Client.Models.AggregateGroupByResult.Group.TotalCount.init -> void -Weaviate.Client.Models.AggregateGroupByResult.Groups.get -> System.Collections.Generic.List! -Weaviate.Client.Models.AggregateGroupByResult.Groups.init -> void -Weaviate.Client.Models.AggregateResult -Weaviate.Client.Models.AggregateResult.AggregateResult() -> void -Weaviate.Client.Models.AggregateResult.AggregateResult(Weaviate.Client.Models.AggregateResult! original) -> void -Weaviate.Client.Models.AggregateResult.Properties.get -> System.Collections.Generic.IDictionary! -Weaviate.Client.Models.AggregateResult.Properties.init -> void -Weaviate.Client.Models.AggregateResult.TotalCount.get -> long -Weaviate.Client.Models.AggregateResult.TotalCount.init -> void -Weaviate.Client.Models.Alias -Weaviate.Client.Models.Alias.Alias(Weaviate.Client.Models.Alias! original) -> void -Weaviate.Client.Models.Alias.Alias(string! Name, string! TargetCollection) -> void -Weaviate.Client.Models.Alias.Deconstruct(out string! Name, out string! TargetCollection) -> void -Weaviate.Client.Models.Alias.Name.get -> string! -Weaviate.Client.Models.Alias.Name.init -> void -Weaviate.Client.Models.Alias.TargetCollection.get -> string! -Weaviate.Client.Models.Alias.TargetCollection.init -> void -Weaviate.Client.Models.AliasesResource -Weaviate.Client.Models.AliasesResource.Alias.get -> string? -Weaviate.Client.Models.AliasesResource.Alias.init -> void -Weaviate.Client.Models.AliasesResource.AliasesResource(Weaviate.Client.Models.AliasesResource! original) -> void -Weaviate.Client.Models.AliasesResource.AliasesResource(string? Collection = "*", string? Alias = "*") -> void -Weaviate.Client.Models.AliasesResource.Collection.get -> string? -Weaviate.Client.Models.AliasesResource.Collection.init -> void -Weaviate.Client.Models.AliasesResource.Deconstruct(out string? Collection, out string? Alias) -> void -Weaviate.Client.Models.AndNestedFilter -Weaviate.Client.Models.AndNestedFilter.AndNestedFilter(Weaviate.Client.Models.AndNestedFilter! original) -> void -Weaviate.Client.Models.AndNestedFilter.AndNestedFilter(params Weaviate.Client.Models.Filter![]! filters) -> void -Weaviate.Client.Models.AndNestedFilter.Deconstruct(out Weaviate.Client.Models.Filter![]! filters) -> void -Weaviate.Client.Models.AndNestedFilter.filters.get -> Weaviate.Client.Models.Filter![]! -Weaviate.Client.Models.AndNestedFilter.filters.init -> void -Weaviate.Client.Models.AutoArray -Weaviate.Client.Models.AutoArray.Add(T item) -> void -Weaviate.Client.Models.AutoArray.Add(params T[]! items) -> void -Weaviate.Client.Models.AutoArray.GetEnumerator() -> System.Collections.Generic.IEnumerator! -Weaviate.Client.Models.AutoArrayBuilder -Weaviate.Client.Models.BM25Config -Weaviate.Client.Models.BM25Config.B.get -> double -Weaviate.Client.Models.BM25Config.B.set -> void -Weaviate.Client.Models.BM25Config.BM25Config() -> void -Weaviate.Client.Models.BM25Config.BM25Config(Weaviate.Client.Models.BM25Config! original) -> void -Weaviate.Client.Models.BM25Config.K1.get -> double -Weaviate.Client.Models.BM25Config.K1.set -> void -Weaviate.Client.Models.BM25Operator -Weaviate.Client.Models.BM25Operator.And -Weaviate.Client.Models.BM25Operator.And.And() -> void -Weaviate.Client.Models.BM25Operator.And.And(Weaviate.Client.Models.BM25Operator.And! original) -> void -Weaviate.Client.Models.BM25Operator.BM25Operator(Weaviate.Client.Models.BM25Operator! original) -> void -Weaviate.Client.Models.BM25Operator.BM25Operator(string! Operator) -> void -Weaviate.Client.Models.BM25Operator.Deconstruct(out string! Operator) -> void -Weaviate.Client.Models.BM25Operator.Operator.get -> string! -Weaviate.Client.Models.BM25Operator.Operator.init -> void -Weaviate.Client.Models.BM25Operator.Or -Weaviate.Client.Models.BM25Operator.Or.Deconstruct(out int MinimumMatch) -> void -Weaviate.Client.Models.BM25Operator.Or.MinimumMatch.get -> int -Weaviate.Client.Models.BM25Operator.Or.MinimumMatch.init -> void -Weaviate.Client.Models.BM25Operator.Or.Or(Weaviate.Client.Models.BM25Operator.Or! original) -> void -Weaviate.Client.Models.BM25Operator.Or.Or(int MinimumMatch) -> void -Weaviate.Client.Models.Backup -Weaviate.Client.Models.Backup.Backend.get -> Weaviate.Client.Models.BackupBackend! -Weaviate.Client.Models.Backup.Backend.init -> void -Weaviate.Client.Models.Backup.Backup(Weaviate.Client.Models.Backup! original) -> void -Weaviate.Client.Models.Backup.Backup(string! Id, Weaviate.Client.Models.BackupBackend! Backend, string! StatusRaw, string![]? Classes, System.DateTimeOffset? StartedAt, System.DateTimeOffset? CompletedAt, string? Error) -> void -Weaviate.Client.Models.Backup.Classes.get -> string![]? -Weaviate.Client.Models.Backup.Classes.init -> void -Weaviate.Client.Models.Backup.CompletedAt.get -> System.DateTimeOffset? -Weaviate.Client.Models.Backup.CompletedAt.init -> void -Weaviate.Client.Models.Backup.Deconstruct(out string! Id, out Weaviate.Client.Models.BackupBackend! Backend, out string! StatusRaw, out string![]? Classes, out System.DateTimeOffset? StartedAt, out System.DateTimeOffset? CompletedAt, out string? Error) -> void -Weaviate.Client.Models.Backup.Error.get -> string? -Weaviate.Client.Models.Backup.Error.init -> void -Weaviate.Client.Models.Backup.Id.get -> string! -Weaviate.Client.Models.Backup.Id.init -> void -Weaviate.Client.Models.Backup.StartedAt.get -> System.DateTimeOffset? -Weaviate.Client.Models.Backup.StartedAt.init -> void -Weaviate.Client.Models.Backup.Status.get -> Weaviate.Client.Models.BackupStatus -Weaviate.Client.Models.Backup.StatusRaw.get -> string! -Weaviate.Client.Models.Backup.StatusRaw.init -> void -Weaviate.Client.Models.BackupBackend -Weaviate.Client.Models.BackupBackend.BackupBackend() -> void -Weaviate.Client.Models.BackupBackend.BackupBackend(Weaviate.Client.Models.BackupBackend! original) -> void -Weaviate.Client.Models.BackupClientConfig -Weaviate.Client.Models.BackupClientConfig.BackupClientConfig() -> void -Weaviate.Client.Models.BackupClientConfig.BackupClientConfig(Weaviate.Client.Models.BackupClientConfig! original) -> void -Weaviate.Client.Models.BackupClientConfig.PollInterval.get -> System.TimeSpan -Weaviate.Client.Models.BackupClientConfig.PollInterval.init -> void -Weaviate.Client.Models.BackupClientConfig.Timeout.get -> System.TimeSpan -Weaviate.Client.Models.BackupClientConfig.Timeout.init -> void -Weaviate.Client.Models.BackupCompressionLevel -Weaviate.Client.Models.BackupCompressionLevel.BestCompression = 2 -> Weaviate.Client.Models.BackupCompressionLevel -Weaviate.Client.Models.BackupCompressionLevel.BestSpeed = 1 -> Weaviate.Client.Models.BackupCompressionLevel -Weaviate.Client.Models.BackupCompressionLevel.DefaultCompression = 0 -> Weaviate.Client.Models.BackupCompressionLevel -Weaviate.Client.Models.BackupCompressionLevel.NoCompression = 6 -> Weaviate.Client.Models.BackupCompressionLevel -Weaviate.Client.Models.BackupCompressionLevel.ZstdBestCompression = 5 -> Weaviate.Client.Models.BackupCompressionLevel -Weaviate.Client.Models.BackupCompressionLevel.ZstdBestSpeed = 4 -> Weaviate.Client.Models.BackupCompressionLevel -Weaviate.Client.Models.BackupCompressionLevel.ZstdDefaultCompression = 3 -> Weaviate.Client.Models.BackupCompressionLevel -Weaviate.Client.Models.BackupCreateOperation -Weaviate.Client.Models.BackupCreateRequest -Weaviate.Client.Models.BackupCreateRequest.Backend.get -> Weaviate.Client.Models.BackupBackend! -Weaviate.Client.Models.BackupCreateRequest.Backend.init -> void -Weaviate.Client.Models.BackupCreateRequest.BackupCreateRequest(Weaviate.Client.Models.BackupCreateRequest! original) -> void -Weaviate.Client.Models.BackupCreateRequest.BackupCreateRequest(string! Id, Weaviate.Client.Models.BackupBackend! Backend, Weaviate.Client.Models.AutoArray? IncludeCollections = null, Weaviate.Client.Models.AutoArray? ExcludeCollections = null, int? CPUPercentage = null, Weaviate.Client.Models.BackupCompressionLevel? CompressionLevel = null) -> void -Weaviate.Client.Models.BackupCreateRequest.CPUPercentage.get -> int? -Weaviate.Client.Models.BackupCreateRequest.CPUPercentage.init -> void -Weaviate.Client.Models.BackupCreateRequest.CompressionLevel.get -> Weaviate.Client.Models.BackupCompressionLevel? -Weaviate.Client.Models.BackupCreateRequest.CompressionLevel.init -> void -Weaviate.Client.Models.BackupCreateRequest.Deconstruct(out string! Id, out Weaviate.Client.Models.BackupBackend! Backend, out Weaviate.Client.Models.AutoArray? IncludeCollections, out Weaviate.Client.Models.AutoArray? ExcludeCollections, out int? CPUPercentage, out Weaviate.Client.Models.BackupCompressionLevel? CompressionLevel) -> void -Weaviate.Client.Models.BackupCreateRequest.ExcludeCollections.get -> Weaviate.Client.Models.AutoArray? -Weaviate.Client.Models.BackupCreateRequest.ExcludeCollections.init -> void -Weaviate.Client.Models.BackupCreateRequest.Id.get -> string! -Weaviate.Client.Models.BackupCreateRequest.Id.init -> void -Weaviate.Client.Models.BackupCreateRequest.IncludeCollections.get -> Weaviate.Client.Models.AutoArray? -Weaviate.Client.Models.BackupCreateRequest.IncludeCollections.init -> void -Weaviate.Client.Models.BackupOperationBase -Weaviate.Client.Models.BackupOperationBase.BackupOperationBase(Weaviate.Client.Models.Backup! initial, System.Func!>! statusFetcher, System.Func! operationCancel) -> void -Weaviate.Client.Models.BackupOperationBase.Cancel(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Models.BackupOperationBase.Current.get -> Weaviate.Client.Models.Backup! -Weaviate.Client.Models.BackupOperationBase.Dispose() -> void -Weaviate.Client.Models.BackupOperationBase.DisposeAsync() -> System.Threading.Tasks.ValueTask -Weaviate.Client.Models.BackupOperationBase.IsCanceled.get -> bool -Weaviate.Client.Models.BackupOperationBase.IsCompleted.get -> bool -Weaviate.Client.Models.BackupOperationBase.IsSuccessful.get -> bool -Weaviate.Client.Models.BackupOperationBase.WaitForCompletion(System.TimeSpan? timeout = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Models.BackupRestoreOperation -Weaviate.Client.Models.BackupRestoreRequest -Weaviate.Client.Models.BackupRestoreRequest.Backend.get -> Weaviate.Client.Models.BackupBackend! -Weaviate.Client.Models.BackupRestoreRequest.Backend.init -> void -Weaviate.Client.Models.BackupRestoreRequest.BackupRestoreRequest(Weaviate.Client.Models.BackupRestoreRequest! original) -> void -Weaviate.Client.Models.BackupRestoreRequest.BackupRestoreRequest(string! Id, Weaviate.Client.Models.BackupBackend! Backend, Weaviate.Client.Models.AutoArray? IncludeCollections = null, Weaviate.Client.Models.AutoArray? ExcludeCollections = null, System.Collections.Generic.IDictionary? NodeMapping = null, int? CPUPercentage = null, Weaviate.Client.Models.RolesRestoreOption? RolesOptions = null, Weaviate.Client.Models.UserRestoreOption? UsersOptions = null, bool? OverwriteAlias = null) -> void -Weaviate.Client.Models.BackupRestoreRequest.CPUPercentage.get -> int? -Weaviate.Client.Models.BackupRestoreRequest.CPUPercentage.init -> void -Weaviate.Client.Models.BackupRestoreRequest.Deconstruct(out string! Id, out Weaviate.Client.Models.BackupBackend! Backend, out Weaviate.Client.Models.AutoArray? IncludeCollections, out Weaviate.Client.Models.AutoArray? ExcludeCollections, out System.Collections.Generic.IDictionary? NodeMapping, out int? CPUPercentage, out Weaviate.Client.Models.RolesRestoreOption? RolesOptions, out Weaviate.Client.Models.UserRestoreOption? UsersOptions, out bool? OverwriteAlias) -> void -Weaviate.Client.Models.BackupRestoreRequest.ExcludeCollections.get -> Weaviate.Client.Models.AutoArray? -Weaviate.Client.Models.BackupRestoreRequest.ExcludeCollections.init -> void -Weaviate.Client.Models.BackupRestoreRequest.Id.get -> string! -Weaviate.Client.Models.BackupRestoreRequest.Id.init -> void -Weaviate.Client.Models.BackupRestoreRequest.IncludeCollections.get -> Weaviate.Client.Models.AutoArray? -Weaviate.Client.Models.BackupRestoreRequest.IncludeCollections.init -> void -Weaviate.Client.Models.BackupRestoreRequest.NodeMapping.get -> System.Collections.Generic.IDictionary? -Weaviate.Client.Models.BackupRestoreRequest.NodeMapping.init -> void -Weaviate.Client.Models.BackupRestoreRequest.OverwriteAlias.get -> bool? -Weaviate.Client.Models.BackupRestoreRequest.OverwriteAlias.init -> void -Weaviate.Client.Models.BackupRestoreRequest.RolesOptions.get -> Weaviate.Client.Models.RolesRestoreOption? -Weaviate.Client.Models.BackupRestoreRequest.RolesOptions.init -> void -Weaviate.Client.Models.BackupRestoreRequest.UsersOptions.get -> Weaviate.Client.Models.UserRestoreOption? -Weaviate.Client.Models.BackupRestoreRequest.UsersOptions.init -> void -Weaviate.Client.Models.BackupStatus -Weaviate.Client.Models.BackupStatus.Canceled = 6 -> Weaviate.Client.Models.BackupStatus -Weaviate.Client.Models.BackupStatus.Failed = 5 -> Weaviate.Client.Models.BackupStatus -Weaviate.Client.Models.BackupStatus.Started = 1 -> Weaviate.Client.Models.BackupStatus -Weaviate.Client.Models.BackupStatus.Success = 4 -> Weaviate.Client.Models.BackupStatus -Weaviate.Client.Models.BackupStatus.Transferred = 3 -> Weaviate.Client.Models.BackupStatus -Weaviate.Client.Models.BackupStatus.Transferring = 2 -> Weaviate.Client.Models.BackupStatus -Weaviate.Client.Models.BackupStatus.Unknown = 0 -> Weaviate.Client.Models.BackupStatus -Weaviate.Client.Models.BackupStatusExtensions -Weaviate.Client.Models.BackupStorageProvider -Weaviate.Client.Models.BackupStorageProvider.Azure = 4 -> Weaviate.Client.Models.BackupStorageProvider -Weaviate.Client.Models.BackupStorageProvider.Filesystem = 1 -> Weaviate.Client.Models.BackupStorageProvider -Weaviate.Client.Models.BackupStorageProvider.GCS = 3 -> Weaviate.Client.Models.BackupStorageProvider -Weaviate.Client.Models.BackupStorageProvider.None = 0 -> Weaviate.Client.Models.BackupStorageProvider -Weaviate.Client.Models.BackupStorageProvider.S3 = 2 -> Weaviate.Client.Models.BackupStorageProvider -Weaviate.Client.Models.BackupsResource -Weaviate.Client.Models.BackupsResource.BackupsResource(Weaviate.Client.Models.BackupsResource! original) -> void -Weaviate.Client.Models.BackupsResource.BackupsResource(string? Collection) -> void -Weaviate.Client.Models.BackupsResource.Collection.get -> string? -Weaviate.Client.Models.BackupsResource.Collection.init -> void -Weaviate.Client.Models.BackupsResource.Deconstruct(out string? Collection) -> void -Weaviate.Client.Models.BatchInsertRequest -Weaviate.Client.Models.BatchInsertRequest.BatchInsertRequest(Weaviate.Client.Models.BatchInsertRequest! original) -> void -Weaviate.Client.Models.BatchInsertRequest.BatchInsertRequest(object! Data, System.Guid? ID = null, Weaviate.Client.Models.Vectors? Vectors = null, System.Collections.Generic.IEnumerable? References = null) -> void -Weaviate.Client.Models.BatchInsertRequest.Data.get -> object! -Weaviate.Client.Models.BatchInsertRequest.Data.init -> void -Weaviate.Client.Models.BatchInsertRequest.Deconstruct(out object! Data, out System.Guid? ID, out Weaviate.Client.Models.Vectors? Vectors, out System.Collections.Generic.IEnumerable? References) -> void -Weaviate.Client.Models.BatchInsertRequest.ID.get -> System.Guid? -Weaviate.Client.Models.BatchInsertRequest.ID.init -> void -Weaviate.Client.Models.BatchInsertRequest.References.get -> System.Collections.Generic.IEnumerable? -Weaviate.Client.Models.BatchInsertRequest.References.init -> void -Weaviate.Client.Models.BatchInsertRequest.Vectors.get -> Weaviate.Client.Models.Vectors? -Weaviate.Client.Models.BatchInsertRequest.Vectors.init -> void -Weaviate.Client.Models.BatchInsertResponse -Weaviate.Client.Models.BatchInsertResponse.BatchInsertResponse(Weaviate.Client.Models.BatchInsertResponse! original) -> void -Weaviate.Client.Models.BatchInsertResponse.Count.get -> int -Weaviate.Client.Models.BatchInsertResponse.Errors.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.BatchInsertResponse.GetEnumerator() -> System.Collections.Generic.IEnumerator! -Weaviate.Client.Models.BatchInsertResponse.HasErrors.get -> bool -Weaviate.Client.Models.BatchInsertResponse.Objects.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.BatchInsertResponseEntry -Weaviate.Client.Models.BatchInsertResponseEntry.BatchInsertResponseEntry(Weaviate.Client.Models.BatchInsertResponseEntry! original) -> void -Weaviate.Client.Models.BatchInsertResponseEntry.BatchInsertResponseEntry(int Index, System.Guid? ID = null, Weaviate.Client.WeaviateException? Error = null) -> void -Weaviate.Client.Models.BatchInsertResponseEntry.Deconstruct(out int Index, out System.Guid? ID, out Weaviate.Client.WeaviateException? Error) -> void -Weaviate.Client.Models.BatchInsertResponseEntry.Error.get -> Weaviate.Client.WeaviateException? -Weaviate.Client.Models.BatchInsertResponseEntry.Error.init -> void -Weaviate.Client.Models.BatchInsertResponseEntry.ID.get -> System.Guid? -Weaviate.Client.Models.BatchInsertResponseEntry.ID.init -> void -Weaviate.Client.Models.BatchInsertResponseEntry.Index.get -> int -Weaviate.Client.Models.BatchInsertResponseEntry.Index.init -> void -Weaviate.Client.Models.BatchReferenceReturn -Weaviate.Client.Models.BatchReferenceReturn.BatchReferenceReturn(Weaviate.Client.Models.BatchReferenceReturn! original) -> void -Weaviate.Client.Models.BatchReferenceReturn.BatchReferenceReturn(float elapsedSeconds, System.Collections.Generic.Dictionary! errors) -> void -Weaviate.Client.Models.BatchReferenceReturn.ElapsedSeconds.get -> float -Weaviate.Client.Models.BatchReferenceReturn.ElapsedSeconds.init -> void -Weaviate.Client.Models.BatchReferenceReturn.Errors.get -> System.Collections.Generic.Dictionary! -Weaviate.Client.Models.BatchReferenceReturn.Errors.init -> void -Weaviate.Client.Models.BatchReferenceReturn.HasErrors.get -> bool -Weaviate.Client.Models.BatchReferenceReturn.HasErrors.init -> void -Weaviate.Client.Models.Bm25ConfigUpdate -Weaviate.Client.Models.Bm25ConfigUpdate.B.get -> float? -Weaviate.Client.Models.Bm25ConfigUpdate.B.set -> void -Weaviate.Client.Models.Bm25ConfigUpdate.Bm25ConfigUpdate(Weaviate.Client.Models.BM25Config! WrappedBm25) -> void -Weaviate.Client.Models.Bm25ConfigUpdate.Bm25ConfigUpdate(Weaviate.Client.Models.Bm25ConfigUpdate! original) -> void -Weaviate.Client.Models.Bm25ConfigUpdate.Deconstruct(out Weaviate.Client.Models.BM25Config! WrappedBm25) -> void -Weaviate.Client.Models.Bm25ConfigUpdate.K1.get -> float? -Weaviate.Client.Models.Bm25ConfigUpdate.K1.set -> void -Weaviate.Client.Models.Bm25ConfigUpdate.WrappedBm25.get -> Weaviate.Client.Models.BM25Config! -Weaviate.Client.Models.Bm25ConfigUpdate.WrappedBm25.init -> void -Weaviate.Client.Models.ClusterNode -Weaviate.Client.Models.ClusterNode.ClusterNode() -> void -Weaviate.Client.Models.ClusterNode.ClusterNode(Weaviate.Client.Models.ClusterNode! original) -> void -Weaviate.Client.Models.ClusterNode.GitHash.get -> string! -Weaviate.Client.Models.ClusterNode.GitHash.init -> void -Weaviate.Client.Models.ClusterNode.Name.get -> string! -Weaviate.Client.Models.ClusterNode.Name.init -> void -Weaviate.Client.Models.ClusterNode.Status.get -> Weaviate.Client.Models.NodeStatus -Weaviate.Client.Models.ClusterNode.StatusRaw.get -> string! -Weaviate.Client.Models.ClusterNode.StatusRaw.init -> void -Weaviate.Client.Models.ClusterNode.Version.get -> string! -Weaviate.Client.Models.ClusterNode.Version.init -> void -Weaviate.Client.Models.ClusterNodeVerbose -Weaviate.Client.Models.ClusterNodeVerbose.ClusterNodeVerbose() -> void -Weaviate.Client.Models.ClusterNodeVerbose.ClusterNodeVerbose(Weaviate.Client.Models.ClusterNodeVerbose! original) -> void -Weaviate.Client.Models.ClusterNodeVerbose.NodeStats -Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.NodeStats() -> void -Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.NodeStats(Weaviate.Client.Models.ClusterNodeVerbose.NodeStats! original) -> void -Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.ObjectCount.get -> int -Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.ObjectCount.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.ShardCount.get -> int -Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.ShardCount.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Collection.get -> string! -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Collection.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Compressed.get -> bool -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Compressed.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Loaded.get -> bool? -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Loaded.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Name.get -> string! -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Name.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Node.get -> string! -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Node.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard.ObjectCount.get -> int -Weaviate.Client.Models.ClusterNodeVerbose.Shard.ObjectCount.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Shard() -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard.Shard(Weaviate.Client.Models.ClusterNodeVerbose.Shard! original) -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard.VectorIndexingStatus.get -> Weaviate.Client.Models.VectorIndexingStatus -Weaviate.Client.Models.ClusterNodeVerbose.Shard.VectorIndexingStatus.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shard.VectorQueueLength.get -> int -Weaviate.Client.Models.ClusterNodeVerbose.Shard.VectorQueueLength.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Shards.get -> Weaviate.Client.Models.ClusterNodeVerbose.Shard![]! -Weaviate.Client.Models.ClusterNodeVerbose.Shards.init -> void -Weaviate.Client.Models.ClusterNodeVerbose.Stats.get -> Weaviate.Client.Models.ClusterNodeVerbose.NodeStats! -Weaviate.Client.Models.ClusterNodeVerbose.Stats.init -> void -Weaviate.Client.Models.CollectionConfig -Weaviate.Client.Models.CollectionConfig.CollectionConfig(Weaviate.Client.Models.CollectionConfig! original) -> void -Weaviate.Client.Models.CollectionConfig.ModuleConfig.get -> Weaviate.Client.Models.ModuleConfigList? -Weaviate.Client.Models.CollectionConfig.ModuleConfig.set -> void -Weaviate.Client.Models.CollectionConfig.VectorIndexConfig.get -> object? -Weaviate.Client.Models.CollectionConfig.VectorIndexType.get -> string! -Weaviate.Client.Models.CollectionConfig.Vectorizer.get -> string! -Weaviate.Client.Models.CollectionConfigCommon -Weaviate.Client.Models.CollectionConfigCommon.CollectionConfigCommon() -> void -Weaviate.Client.Models.CollectionConfigCommon.CollectionConfigCommon(Weaviate.Client.Models.CollectionConfigCommon! original) -> void -Weaviate.Client.Models.CollectionConfigCommon.Description.get -> string! -Weaviate.Client.Models.CollectionConfigCommon.Description.set -> void -Weaviate.Client.Models.CollectionConfigCommon.GenerativeConfig.get -> Weaviate.Client.Models.IGenerativeConfig? -Weaviate.Client.Models.CollectionConfigCommon.GenerativeConfig.set -> void -Weaviate.Client.Models.CollectionConfigCommon.InvertedIndexConfig.get -> Weaviate.Client.Models.InvertedIndexConfig? -Weaviate.Client.Models.CollectionConfigCommon.InvertedIndexConfig.set -> void -Weaviate.Client.Models.CollectionConfigCommon.MultiTenancyConfig.get -> Weaviate.Client.Models.MultiTenancyConfig? -Weaviate.Client.Models.CollectionConfigCommon.MultiTenancyConfig.set -> void -Weaviate.Client.Models.CollectionConfigCommon.Name.get -> string! -Weaviate.Client.Models.CollectionConfigCommon.Name.set -> void -Weaviate.Client.Models.CollectionConfigCommon.Properties.get -> Weaviate.Client.Models.Property![]! -Weaviate.Client.Models.CollectionConfigCommon.Properties.set -> void -Weaviate.Client.Models.CollectionConfigCommon.References.get -> Weaviate.Client.Models.Reference![]! -Weaviate.Client.Models.CollectionConfigCommon.References.set -> void -Weaviate.Client.Models.CollectionConfigCommon.ReplicationConfig.get -> Weaviate.Client.Models.ReplicationConfig? -Weaviate.Client.Models.CollectionConfigCommon.ReplicationConfig.set -> void -Weaviate.Client.Models.CollectionConfigCommon.RerankerConfig.get -> Weaviate.Client.Models.IRerankerConfig? -Weaviate.Client.Models.CollectionConfigCommon.RerankerConfig.set -> void -Weaviate.Client.Models.CollectionConfigCommon.ShardingConfig.get -> Weaviate.Client.Models.ShardingConfig? -Weaviate.Client.Models.CollectionConfigCommon.ShardingConfig.set -> void -Weaviate.Client.Models.CollectionConfigCommon.VectorConfig.get -> Weaviate.Client.Models.VectorConfigList! -Weaviate.Client.Models.CollectionConfigCommon.VectorConfig.set -> void -Weaviate.Client.Models.CollectionConfigExport -Weaviate.Client.Models.CollectionConfigExport.CollectionConfigExport() -> void -Weaviate.Client.Models.CollectionConfigExport.CollectionConfigExport(Weaviate.Client.Models.CollectionConfigExport! original) -> void -Weaviate.Client.Models.CollectionConfigExport.ToCollectionConfigCreateParams() -> Weaviate.Client.Models.CollectionCreateParams! -Weaviate.Client.Models.CollectionCreateParams -Weaviate.Client.Models.CollectionCreateParams.CollectionCreateParams() -> void -Weaviate.Client.Models.CollectionCreateParams.CollectionCreateParams(Weaviate.Client.Models.CollectionCreateParams! original) -> void -Weaviate.Client.Models.CollectionUpdate -Weaviate.Client.Models.CollectionUpdate.CollectionUpdate(Weaviate.Client.Models.CollectionConfig! WrappedCollection) -> void -Weaviate.Client.Models.CollectionUpdate.CollectionUpdate(Weaviate.Client.Models.CollectionUpdate! original) -> void -Weaviate.Client.Models.CollectionUpdate.Deconstruct(out Weaviate.Client.Models.CollectionConfig! WrappedCollection) -> void -Weaviate.Client.Models.CollectionUpdate.Description.get -> string! -Weaviate.Client.Models.CollectionUpdate.Description.set -> void -Weaviate.Client.Models.CollectionUpdate.GenerativeConfig.get -> Weaviate.Client.Models.IGenerativeConfig? -Weaviate.Client.Models.CollectionUpdate.GenerativeConfig.set -> void -Weaviate.Client.Models.CollectionUpdate.InvertedIndexConfig.get -> Weaviate.Client.Models.InvertedIndexConfigUpdate! -Weaviate.Client.Models.CollectionUpdate.MultiTenancyConfig.get -> Weaviate.Client.Models.MultiTenancyConfigUpdate! -Weaviate.Client.Models.CollectionUpdate.Name.get -> string! -Weaviate.Client.Models.CollectionUpdate.Properties.get -> System.Collections.ObjectModel.ReadOnlyDictionary! -Weaviate.Client.Models.CollectionUpdate.References.get -> System.Collections.ObjectModel.ReadOnlyCollection! -Weaviate.Client.Models.CollectionUpdate.ReplicationConfig -> Weaviate.Client.Models.ReplicationConfigUpdate! -Weaviate.Client.Models.CollectionUpdate.RerankerConfig.get -> Weaviate.Client.Models.IRerankerConfig? -Weaviate.Client.Models.CollectionUpdate.RerankerConfig.set -> void -Weaviate.Client.Models.CollectionUpdate.ShardingConfig.get -> Weaviate.Client.Models.ShardingConfig? -Weaviate.Client.Models.CollectionUpdate.VectorConfig.get -> System.Collections.ObjectModel.ReadOnlyDictionary! -Weaviate.Client.Models.CollectionUpdate.WrappedCollection.get -> Weaviate.Client.Models.CollectionConfig! -Weaviate.Client.Models.CollectionUpdate.WrappedCollection.init -> void -Weaviate.Client.Models.CollectionsResource -Weaviate.Client.Models.CollectionsResource.Collection.get -> string? -Weaviate.Client.Models.CollectionsResource.Collection.init -> void -Weaviate.Client.Models.CollectionsResource.CollectionsResource(Weaviate.Client.Models.CollectionsResource! original) -> void -Weaviate.Client.Models.CollectionsResource.CollectionsResource(string? Collection) -> void -Weaviate.Client.Models.CollectionsResource.Deconstruct(out string? Collection) -> void -Weaviate.Client.Models.CurrentUserInfo -Weaviate.Client.Models.CurrentUserInfo.CurrentUserInfo(Weaviate.Client.Models.CurrentUserInfo! original) -> void -Weaviate.Client.Models.CurrentUserInfo.CurrentUserInfo(string! Username, System.Collections.Generic.IEnumerable! Roles, System.Collections.Generic.IEnumerable? Groups) -> void -Weaviate.Client.Models.CurrentUserInfo.Deconstruct(out string! Username, out System.Collections.Generic.IEnumerable! Roles, out System.Collections.Generic.IEnumerable? Groups) -> void -Weaviate.Client.Models.CurrentUserInfo.Groups.get -> System.Collections.Generic.IEnumerable? -Weaviate.Client.Models.CurrentUserInfo.Groups.init -> void -Weaviate.Client.Models.CurrentUserInfo.Roles.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.CurrentUserInfo.Roles.init -> void -Weaviate.Client.Models.CurrentUserInfo.Username.get -> string! -Weaviate.Client.Models.CurrentUserInfo.Username.init -> void -Weaviate.Client.Models.DataReference -Weaviate.Client.Models.DataReference.DataReference(System.Guid From, string! FromProperty, System.Collections.Generic.IEnumerable! To) -> void -Weaviate.Client.Models.DataReference.DataReference(System.Guid from, string! fromProperty, params System.Guid[]! to) -> void -Weaviate.Client.Models.DataReference.DataReference(Weaviate.Client.Models.DataReference! original) -> void -Weaviate.Client.Models.DataReference.Deconstruct(out System.Guid From, out string! FromProperty, out System.Collections.Generic.IEnumerable! To) -> void -Weaviate.Client.Models.DataReference.From.get -> System.Guid -Weaviate.Client.Models.DataReference.From.init -> void -Weaviate.Client.Models.DataReference.FromProperty.get -> string! -Weaviate.Client.Models.DataReference.FromProperty.init -> void -Weaviate.Client.Models.DataReference.To.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.DataReference.To.init -> void -Weaviate.Client.Models.DataResource -Weaviate.Client.Models.DataResource.Collection.get -> string? -Weaviate.Client.Models.DataResource.Collection.init -> void -Weaviate.Client.Models.DataResource.DataResource(Weaviate.Client.Models.DataResource! original) -> void -Weaviate.Client.Models.DataResource.DataResource(string? Collection = "*", string? Tenant = "*") -> void -Weaviate.Client.Models.DataResource.Deconstruct(out string? Collection, out string? Tenant) -> void -Weaviate.Client.Models.DataResource.Tenant.get -> string? -Weaviate.Client.Models.DataResource.Tenant.init -> void -Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.Blob = 14 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.Bool = 5 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.BoolArray = 6 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.Date = 9 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.DateArray = 10 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.GeoCoordinate = 13 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.Int = 3 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.IntArray = 4 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.Number = 7 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.NumberArray = 8 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.Object = 16 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.ObjectArray = 17 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.PhoneNumber = 15 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.Text = 1 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.TextArray = 2 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.Unknown = 0 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.Uuid = 11 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DataType.UuidArray = 12 -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.DatabaseUser -Weaviate.Client.Models.DatabaseUser.Active.get -> bool -Weaviate.Client.Models.DatabaseUser.Active.init -> void -Weaviate.Client.Models.DatabaseUser.ApiKeyFirstLetters.get -> string? -Weaviate.Client.Models.DatabaseUser.ApiKeyFirstLetters.init -> void -Weaviate.Client.Models.DatabaseUser.CreatedAt.get -> System.DateTimeOffset? -Weaviate.Client.Models.DatabaseUser.CreatedAt.init -> void -Weaviate.Client.Models.DatabaseUser.DatabaseUser(Weaviate.Client.Models.DatabaseUser! original) -> void -Weaviate.Client.Models.DatabaseUser.DatabaseUser(string! UserId, bool Active, Weaviate.Client.Models.DatabaseUserType DbUserType, System.DateTimeOffset? CreatedAt, System.DateTimeOffset? LastUsedAt, string? ApiKeyFirstLetters, System.Collections.Generic.IEnumerable! Roles) -> void -Weaviate.Client.Models.DatabaseUser.DbUserType.get -> Weaviate.Client.Models.DatabaseUserType -Weaviate.Client.Models.DatabaseUser.DbUserType.init -> void -Weaviate.Client.Models.DatabaseUser.Deconstruct(out string! UserId, out bool Active, out Weaviate.Client.Models.DatabaseUserType DbUserType, out System.DateTimeOffset? CreatedAt, out System.DateTimeOffset? LastUsedAt, out string? ApiKeyFirstLetters, out System.Collections.Generic.IEnumerable! Roles) -> void -Weaviate.Client.Models.DatabaseUser.LastUsedAt.get -> System.DateTimeOffset? -Weaviate.Client.Models.DatabaseUser.LastUsedAt.init -> void -Weaviate.Client.Models.DatabaseUser.Roles.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.DatabaseUser.Roles.init -> void -Weaviate.Client.Models.DatabaseUser.UserId.get -> string! -Weaviate.Client.Models.DatabaseUser.UserId.init -> void -Weaviate.Client.Models.DatabaseUserType -Weaviate.Client.Models.DatabaseUserType.DbEnvUser = 1 -> Weaviate.Client.Models.DatabaseUserType -Weaviate.Client.Models.DatabaseUserType.DbUser = 0 -> Weaviate.Client.Models.DatabaseUserType -Weaviate.Client.Models.DeleteManyObjectResult -Weaviate.Client.Models.DeleteManyObjectResult.DeleteManyObjectResult() -> void -Weaviate.Client.Models.DeleteManyObjectResult.Error.get -> string? -Weaviate.Client.Models.DeleteManyObjectResult.Error.set -> void -Weaviate.Client.Models.DeleteManyObjectResult.Successful.get -> bool -Weaviate.Client.Models.DeleteManyObjectResult.Successful.set -> void -Weaviate.Client.Models.DeleteManyObjectResult.Uuid.get -> System.Guid -Weaviate.Client.Models.DeleteManyObjectResult.Uuid.set -> void -Weaviate.Client.Models.DeleteManyResult -Weaviate.Client.Models.DeleteManyResult.DeleteManyResult() -> void -Weaviate.Client.Models.DeleteManyResult.Failed.get -> long -Weaviate.Client.Models.DeleteManyResult.Failed.set -> void -Weaviate.Client.Models.DeleteManyResult.Matches.get -> long -Weaviate.Client.Models.DeleteManyResult.Matches.set -> void -Weaviate.Client.Models.DeleteManyResult.Objects.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.DeleteManyResult.Objects.set -> void -Weaviate.Client.Models.DeleteManyResult.Successful.get -> long -Weaviate.Client.Models.DeleteManyResult.Successful.set -> void -Weaviate.Client.Models.DeletionStrategy -Weaviate.Client.Models.DeletionStrategy.DeleteOnConflict = 1 -> Weaviate.Client.Models.DeletionStrategy -Weaviate.Client.Models.DeletionStrategy.NoAutomatedResolution = 0 -> Weaviate.Client.Models.DeletionStrategy -Weaviate.Client.Models.DeletionStrategy.TimeBasedResolution = 2 -> Weaviate.Client.Models.DeletionStrategy -Weaviate.Client.Models.FilesystemBackend -Weaviate.Client.Models.FilesystemBackend.FilesystemBackend(Weaviate.Client.Models.FilesystemBackend! original) -> void -Weaviate.Client.Models.FilesystemBackend.FilesystemBackend(string? path = null) -> void -Weaviate.Client.Models.Filter -Weaviate.Client.Models.Filter.Filter() -> void -Weaviate.Client.Models.Filter.Filter(Weaviate.Client.Models.Filter! original) -> void -Weaviate.Client.Models.Filter -Weaviate.Client.Models.Filter.PropertyFilter -Weaviate.Client.Models.Filter.PropertyFilter.ContainsAll(System.Collections.Generic.IEnumerable! values) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.ContainsAny(System.Collections.Generic.IEnumerable! values) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.Equal(TResult value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.GreaterThan(TResult value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.GreaterThanEqual(TResult value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.IsNull(bool value = true) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.LessThan(TResult value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.LessThanEqual(TResult value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.Like(TResult value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.NotEqual(TResult value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.Filter.PropertyFilter.WithinGeoRange(Weaviate.Client.Models.GeoCoordinateConstraint! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.FlexibleConverter -Weaviate.Client.Models.FlexibleConverter.FlexibleConverter() -> void -Weaviate.Client.Models.FlexibleStringConverter -Weaviate.Client.Models.FlexibleStringConverter.FlexibleStringConverter() -> void -Weaviate.Client.Models.Generative.Providers -Weaviate.Client.Models.Generative.Providers.AWSBedrock -Weaviate.Client.Models.Generative.Providers.AWSBedrock.AWSBedrock() -> void -Weaviate.Client.Models.Generative.Providers.AWSBedrock.AWSBedrock(Weaviate.Client.Models.Generative.Providers.AWSBedrock! original) -> void -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Endpoint.get -> string? -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Endpoint.set -> void -Weaviate.Client.Models.Generative.Providers.AWSBedrock.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.AWSBedrock.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Images.set -> void -Weaviate.Client.Models.Generative.Providers.AWSBedrock.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.AWSBedrock.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Model.set -> void -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Region.get -> string? -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Region.set -> void -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.AWSBedrock.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.AWSSagemaker() -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.AWSSagemaker(Weaviate.Client.Models.Generative.Providers.AWSSagemaker! original) -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Endpoint.get -> string? -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Endpoint.set -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Images.set -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Region.get -> string? -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Region.set -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.TargetModel.get -> string? -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.TargetModel.set -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.TargetVariant.get -> string? -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.TargetVariant.set -> void -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.Anthropic -Weaviate.Client.Models.Generative.Providers.Anthropic.Anthropic() -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.Anthropic(Weaviate.Client.Models.Generative.Providers.Anthropic! original) -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.BaseUrl.get -> string? -Weaviate.Client.Models.Generative.Providers.Anthropic.BaseUrl.set -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.Anthropic.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.Anthropic.Images.set -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.Anthropic.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.Anthropic.Model.set -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.StopSequences.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.Anthropic.StopSequences.set -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.Anthropic.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.TopK.get -> long? -Weaviate.Client.Models.Generative.Providers.Anthropic.TopK.set -> void -Weaviate.Client.Models.Generative.Providers.Anthropic.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.Anthropic.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.Anyscale -Weaviate.Client.Models.Generative.Providers.Anyscale.Anyscale() -> void -Weaviate.Client.Models.Generative.Providers.Anyscale.Anyscale(Weaviate.Client.Models.Generative.Providers.Anyscale! original) -> void -Weaviate.Client.Models.Generative.Providers.Anyscale.BaseUrl.get -> string? -Weaviate.Client.Models.Generative.Providers.Anyscale.BaseUrl.set -> void -Weaviate.Client.Models.Generative.Providers.Anyscale.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.Anyscale.Model.set -> void -Weaviate.Client.Models.Generative.Providers.Anyscale.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.Anyscale.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ApiVersion.get -> string? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ApiVersion.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.AzureOpenAI() -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.AzureOpenAI(Weaviate.Client.Models.Generative.Providers.AzureOpenAI! original) -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.BaseUrl.get -> string? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.BaseUrl.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.DeploymentId.get -> string? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.DeploymentId.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.FrequencyPenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.FrequencyPenalty.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Images.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.IsAzure.get -> bool? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.IsAzure.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Model.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.N.get -> long? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.N.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.PresencePenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.PresencePenalty.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffort.get -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffort.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel.High = 4 -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel.Low = 2 -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel.Medium = 3 -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel.Minimal = 1 -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel.Unspecified = 0 -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ResourceName.get -> string? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ResourceName.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Stop.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Stop.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Verbosity.get -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel? -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Verbosity.set -> void -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel.High = 3 -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel.Low = 1 -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel.Medium = 2 -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel.Unspecified = 0 -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.Cohere -Weaviate.Client.Models.Generative.Providers.Cohere.BaseUrl.get -> string? -Weaviate.Client.Models.Generative.Providers.Cohere.BaseUrl.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.Cohere() -> void -Weaviate.Client.Models.Generative.Providers.Cohere.Cohere(Weaviate.Client.Models.Generative.Providers.Cohere! original) -> void -Weaviate.Client.Models.Generative.Providers.Cohere.FrequencyPenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.Cohere.FrequencyPenalty.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.Cohere.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.Cohere.Images.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.K.get -> long? -Weaviate.Client.Models.Generative.Providers.Cohere.K.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.Cohere.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.Cohere.Model.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.P.get -> double? -Weaviate.Client.Models.Generative.Providers.Cohere.P.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.PresencePenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.Cohere.PresencePenalty.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.StopSequences.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.Cohere.StopSequences.set -> void -Weaviate.Client.Models.Generative.Providers.Cohere.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.Cohere.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.ContextualAI -Weaviate.Client.Models.Generative.Providers.ContextualAI.AvoidCommentary.get -> bool? -Weaviate.Client.Models.Generative.Providers.ContextualAI.AvoidCommentary.set -> void -Weaviate.Client.Models.Generative.Providers.ContextualAI.ContextualAI() -> void -Weaviate.Client.Models.Generative.Providers.ContextualAI.ContextualAI(Weaviate.Client.Models.Generative.Providers.ContextualAI! original) -> void -Weaviate.Client.Models.Generative.Providers.ContextualAI.Knowledge.get -> string![]? -Weaviate.Client.Models.Generative.Providers.ContextualAI.Knowledge.set -> void -Weaviate.Client.Models.Generative.Providers.ContextualAI.MaxNewTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.ContextualAI.MaxNewTokens.set -> void -Weaviate.Client.Models.Generative.Providers.ContextualAI.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.ContextualAI.Model.set -> void -Weaviate.Client.Models.Generative.Providers.ContextualAI.SystemPrompt.get -> string? -Weaviate.Client.Models.Generative.Providers.ContextualAI.SystemPrompt.set -> void -Weaviate.Client.Models.Generative.Providers.ContextualAI.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.ContextualAI.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.ContextualAI.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.ContextualAI.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks -Weaviate.Client.Models.Generative.Providers.Databricks.Databricks() -> void -Weaviate.Client.Models.Generative.Providers.Databricks.Databricks(Weaviate.Client.Models.Generative.Providers.Databricks! original) -> void -Weaviate.Client.Models.Generative.Providers.Databricks.Endpoint.get -> string? -Weaviate.Client.Models.Generative.Providers.Databricks.Endpoint.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.FrequencyPenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.Databricks.FrequencyPenalty.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.LogProbs.get -> bool? -Weaviate.Client.Models.Generative.Providers.Databricks.LogProbs.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.Databricks.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.Databricks.Model.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.N.get -> long? -Weaviate.Client.Models.Generative.Providers.Databricks.N.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.PresencePenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.Databricks.PresencePenalty.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.Stop.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.Databricks.Stop.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.Databricks.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.TopLogProbs.get -> long? -Weaviate.Client.Models.Generative.Providers.Databricks.TopLogProbs.set -> void -Weaviate.Client.Models.Generative.Providers.Databricks.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.Databricks.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.Dummy -Weaviate.Client.Models.Generative.Providers.Dummy.Dummy() -> void -Weaviate.Client.Models.Generative.Providers.Dummy.Dummy(Weaviate.Client.Models.Generative.Providers.Dummy! original) -> void -Weaviate.Client.Models.Generative.Providers.FriendliAI -Weaviate.Client.Models.Generative.Providers.FriendliAI.BaseUrl.get -> string? -Weaviate.Client.Models.Generative.Providers.FriendliAI.BaseUrl.set -> void -Weaviate.Client.Models.Generative.Providers.FriendliAI.FriendliAI() -> void -Weaviate.Client.Models.Generative.Providers.FriendliAI.FriendliAI(Weaviate.Client.Models.Generative.Providers.FriendliAI! original) -> void -Weaviate.Client.Models.Generative.Providers.FriendliAI.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.FriendliAI.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.FriendliAI.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.FriendliAI.Model.set -> void -Weaviate.Client.Models.Generative.Providers.FriendliAI.N.get -> long? -Weaviate.Client.Models.Generative.Providers.FriendliAI.N.set -> void -Weaviate.Client.Models.Generative.Providers.FriendliAI.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.FriendliAI.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.FriendliAI.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.FriendliAI.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini -Weaviate.Client.Models.Generative.Providers.GoogleGemini.ApiEndpoint.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.ApiEndpoint.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.EndpointId.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.EndpointId.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.FrequencyPenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.FrequencyPenalty.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.GoogleGemini() -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.GoogleGemini(Weaviate.Client.Models.Generative.Providers.GoogleGemini! original) -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.Images.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.Model.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.PresencePenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.PresencePenalty.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.ProjectId.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.ProjectId.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.Region.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.Region.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.StopSequences.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.StopSequences.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.TopK.get -> long? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.TopK.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleGemini.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.GoogleGemini.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex -Weaviate.Client.Models.Generative.Providers.GoogleVertex.ApiEndpoint.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.ApiEndpoint.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.EndpointId.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.EndpointId.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.FrequencyPenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.FrequencyPenalty.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.GoogleVertex() -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.GoogleVertex(Weaviate.Client.Models.Generative.Providers.GoogleVertex! original) -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.Images.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.Model.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.PresencePenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.PresencePenalty.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.ProjectId.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.ProjectId.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.Region.get -> string? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.Region.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.StopSequences.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.StopSequences.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.TopK.get -> long? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.TopK.set -> void -Weaviate.Client.Models.Generative.Providers.GoogleVertex.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.GoogleVertex.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.Mistral -Weaviate.Client.Models.Generative.Providers.Mistral.BaseUrl.get -> string? -Weaviate.Client.Models.Generative.Providers.Mistral.BaseUrl.set -> void -Weaviate.Client.Models.Generative.Providers.Mistral.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.Mistral.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.Mistral.Mistral() -> void -Weaviate.Client.Models.Generative.Providers.Mistral.Mistral(Weaviate.Client.Models.Generative.Providers.Mistral! original) -> void -Weaviate.Client.Models.Generative.Providers.Mistral.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.Mistral.Model.set -> void -Weaviate.Client.Models.Generative.Providers.Mistral.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.Mistral.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.Mistral.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.Mistral.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.Nvidia -Weaviate.Client.Models.Generative.Providers.Nvidia.BaseUrl.get -> string? -Weaviate.Client.Models.Generative.Providers.Nvidia.BaseUrl.set -> void -Weaviate.Client.Models.Generative.Providers.Nvidia.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.Nvidia.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.Nvidia.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.Nvidia.Model.set -> void -Weaviate.Client.Models.Generative.Providers.Nvidia.Nvidia() -> void -Weaviate.Client.Models.Generative.Providers.Nvidia.Nvidia(Weaviate.Client.Models.Generative.Providers.Nvidia! original) -> void -Weaviate.Client.Models.Generative.Providers.Nvidia.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.Nvidia.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.Nvidia.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.Nvidia.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.Ollama -Weaviate.Client.Models.Generative.Providers.Ollama.ApiEndpoint.get -> string? -Weaviate.Client.Models.Generative.Providers.Ollama.ApiEndpoint.set -> void -Weaviate.Client.Models.Generative.Providers.Ollama.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.Ollama.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.Ollama.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.Ollama.Images.set -> void -Weaviate.Client.Models.Generative.Providers.Ollama.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.Ollama.Model.set -> void -Weaviate.Client.Models.Generative.Providers.Ollama.Ollama() -> void -Weaviate.Client.Models.Generative.Providers.Ollama.Ollama(Weaviate.Client.Models.Generative.Providers.Ollama! original) -> void -Weaviate.Client.Models.Generative.Providers.Ollama.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.Ollama.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI -Weaviate.Client.Models.Generative.Providers.OpenAI.ApiVersion.get -> string? -Weaviate.Client.Models.Generative.Providers.OpenAI.ApiVersion.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.BaseUrl.get -> string? -Weaviate.Client.Models.Generative.Providers.OpenAI.BaseUrl.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.DeploymentId.get -> string? -Weaviate.Client.Models.Generative.Providers.OpenAI.DeploymentId.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.FrequencyPenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.OpenAI.FrequencyPenalty.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.OpenAI.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.OpenAI.Images.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.IsAzure.get -> bool? -Weaviate.Client.Models.Generative.Providers.OpenAI.IsAzure.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.OpenAI.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.OpenAI.Model.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.N.get -> long? -Weaviate.Client.Models.Generative.Providers.OpenAI.N.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.OpenAI() -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.OpenAI(Weaviate.Client.Models.Generative.Providers.OpenAI! original) -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.PresencePenalty.get -> double? -Weaviate.Client.Models.Generative.Providers.OpenAI.PresencePenalty.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffort.get -> Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel? -Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffort.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel.High = 4 -> Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel.Low = 2 -> Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel.Medium = 3 -> Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel.Minimal = 1 -> Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel.Unspecified = 0 -> Weaviate.Client.Models.Generative.Providers.OpenAI.ReasoningEffortLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.ResourceName.get -> string? -Weaviate.Client.Models.Generative.Providers.OpenAI.ResourceName.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.Stop.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.OpenAI.Stop.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.OpenAI.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.OpenAI.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.Verbosity.get -> Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel? -Weaviate.Client.Models.Generative.Providers.OpenAI.Verbosity.set -> void -Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel.High = 3 -> Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel.Low = 1 -> Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel.Medium = 2 -> Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel.Unspecified = 0 -> Weaviate.Client.Models.Generative.Providers.OpenAI.VerbosityLevel -Weaviate.Client.Models.Generative.Providers.XAI -Weaviate.Client.Models.Generative.Providers.XAI.BaseUrl.get -> string? -Weaviate.Client.Models.Generative.Providers.XAI.BaseUrl.set -> void -Weaviate.Client.Models.Generative.Providers.XAI.ImageProperties.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.XAI.ImageProperties.set -> void -Weaviate.Client.Models.Generative.Providers.XAI.Images.get -> System.Collections.Generic.List? -Weaviate.Client.Models.Generative.Providers.XAI.Images.set -> void -Weaviate.Client.Models.Generative.Providers.XAI.MaxTokens.get -> long? -Weaviate.Client.Models.Generative.Providers.XAI.MaxTokens.set -> void -Weaviate.Client.Models.Generative.Providers.XAI.Model.get -> string? -Weaviate.Client.Models.Generative.Providers.XAI.Model.set -> void -Weaviate.Client.Models.Generative.Providers.XAI.Temperature.get -> double? -Weaviate.Client.Models.Generative.Providers.XAI.Temperature.set -> void -Weaviate.Client.Models.Generative.Providers.XAI.TopP.get -> double? -Weaviate.Client.Models.Generative.Providers.XAI.TopP.set -> void -Weaviate.Client.Models.Generative.Providers.XAI.XAI() -> void -Weaviate.Client.Models.Generative.Providers.XAI.XAI(Weaviate.Client.Models.Generative.Providers.XAI! original) -> void -Weaviate.Client.Models.GenerativeConfig -Weaviate.Client.Models.GenerativeConfig.AWS -Weaviate.Client.Models.GenerativeConfig.AWS.AWS(Weaviate.Client.Models.GenerativeConfig.AWS! original) -> void -Weaviate.Client.Models.GenerativeConfig.AWS.Endpoint.get -> string? -Weaviate.Client.Models.GenerativeConfig.AWS.Endpoint.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.MaxTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.AWS.MaxTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.AWS.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.Region.get -> string! -Weaviate.Client.Models.GenerativeConfig.AWS.Region.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.Service.get -> string! -Weaviate.Client.Models.GenerativeConfig.AWS.Service.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.StopSequences.get -> string![]? -Weaviate.Client.Models.GenerativeConfig.AWS.StopSequences.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.TargetModel.get -> string? -Weaviate.Client.Models.GenerativeConfig.AWS.TargetModel.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.TargetVariant.get -> string? -Weaviate.Client.Models.GenerativeConfig.AWS.TargetVariant.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.AWS.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.TopK.get -> double? -Weaviate.Client.Models.GenerativeConfig.AWS.TopK.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.TopP.get -> double? -Weaviate.Client.Models.GenerativeConfig.AWS.TopP.set -> void -Weaviate.Client.Models.GenerativeConfig.AWS.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.Anthropic -Weaviate.Client.Models.GenerativeConfig.Anthropic.Anthropic(Weaviate.Client.Models.GenerativeConfig.Anthropic! original) -> void -Weaviate.Client.Models.GenerativeConfig.Anthropic.BaseURL.get -> string? -Weaviate.Client.Models.GenerativeConfig.Anthropic.BaseURL.set -> void -Weaviate.Client.Models.GenerativeConfig.Anthropic.MaxTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.Anthropic.MaxTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.Anthropic.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.Anthropic.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.Anthropic.StopSequences.get -> string![]? -Weaviate.Client.Models.GenerativeConfig.Anthropic.StopSequences.set -> void -Weaviate.Client.Models.GenerativeConfig.Anthropic.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.Anthropic.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.Anthropic.TopK.get -> int? -Weaviate.Client.Models.GenerativeConfig.Anthropic.TopK.set -> void -Weaviate.Client.Models.GenerativeConfig.Anthropic.TopP.get -> double? -Weaviate.Client.Models.GenerativeConfig.Anthropic.TopP.set -> void -Weaviate.Client.Models.GenerativeConfig.Anthropic.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.Anyscale -Weaviate.Client.Models.GenerativeConfig.Anyscale.Anyscale(Weaviate.Client.Models.GenerativeConfig.Anyscale! original) -> void -Weaviate.Client.Models.GenerativeConfig.Anyscale.BaseURL.get -> string? -Weaviate.Client.Models.GenerativeConfig.Anyscale.BaseURL.set -> void -Weaviate.Client.Models.GenerativeConfig.Anyscale.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.Anyscale.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.Anyscale.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.Anyscale.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.Anyscale.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.AzureOpenAI -Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.AzureOpenAI(Weaviate.Client.Models.GenerativeConfig.AzureOpenAI! original) -> void -Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.DeploymentId.get -> string! -Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.DeploymentId.set -> void -Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.ResourceName.get -> string! -Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.ResourceName.set -> void -Weaviate.Client.Models.GenerativeConfig.Cohere -Weaviate.Client.Models.GenerativeConfig.Cohere.BaseURL.get -> string? -Weaviate.Client.Models.GenerativeConfig.Cohere.BaseURL.set -> void -Weaviate.Client.Models.GenerativeConfig.Cohere.Cohere(Weaviate.Client.Models.GenerativeConfig.Cohere! original) -> void -Weaviate.Client.Models.GenerativeConfig.Cohere.K.get -> int? -Weaviate.Client.Models.GenerativeConfig.Cohere.K.set -> void -Weaviate.Client.Models.GenerativeConfig.Cohere.MaxTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.Cohere.MaxTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.Cohere.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.Cohere.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.Cohere.StopSequences.get -> string![]? -Weaviate.Client.Models.GenerativeConfig.Cohere.StopSequences.set -> void -Weaviate.Client.Models.GenerativeConfig.Cohere.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.Cohere.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.Cohere.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.ContextualAI -Weaviate.Client.Models.GenerativeConfig.ContextualAI.AvoidCommentary.get -> bool? -Weaviate.Client.Models.GenerativeConfig.ContextualAI.AvoidCommentary.set -> void -Weaviate.Client.Models.GenerativeConfig.ContextualAI.ContextualAI(Weaviate.Client.Models.GenerativeConfig.ContextualAI! original) -> void -Weaviate.Client.Models.GenerativeConfig.ContextualAI.Knowledge.get -> string![]? -Weaviate.Client.Models.GenerativeConfig.ContextualAI.Knowledge.set -> void -Weaviate.Client.Models.GenerativeConfig.ContextualAI.MaxNewTokens.get -> long? -Weaviate.Client.Models.GenerativeConfig.ContextualAI.MaxNewTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.ContextualAI.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.ContextualAI.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.ContextualAI.SystemPrompt.get -> string? -Weaviate.Client.Models.GenerativeConfig.ContextualAI.SystemPrompt.set -> void -Weaviate.Client.Models.GenerativeConfig.ContextualAI.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.ContextualAI.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.ContextualAI.TopP.get -> double? -Weaviate.Client.Models.GenerativeConfig.ContextualAI.TopP.set -> void -Weaviate.Client.Models.GenerativeConfig.ContextualAI.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.Custom -Weaviate.Client.Models.GenerativeConfig.Custom.Config.get -> object! -Weaviate.Client.Models.GenerativeConfig.Custom.Config.set -> void -Weaviate.Client.Models.GenerativeConfig.Custom.Custom(Weaviate.Client.Models.GenerativeConfig.Custom! original) -> void -Weaviate.Client.Models.GenerativeConfig.Custom.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.Custom.Type.set -> void -Weaviate.Client.Models.GenerativeConfig.Databricks -Weaviate.Client.Models.GenerativeConfig.Databricks.Databricks(Weaviate.Client.Models.GenerativeConfig.Databricks! original) -> void -Weaviate.Client.Models.GenerativeConfig.Databricks.Endpoint.get -> string! -Weaviate.Client.Models.GenerativeConfig.Databricks.Endpoint.set -> void -Weaviate.Client.Models.GenerativeConfig.Databricks.MaxTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.Databricks.MaxTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.Databricks.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.Databricks.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.Databricks.TopK.get -> int? -Weaviate.Client.Models.GenerativeConfig.Databricks.TopK.set -> void -Weaviate.Client.Models.GenerativeConfig.Databricks.TopP.get -> double? -Weaviate.Client.Models.GenerativeConfig.Databricks.TopP.set -> void -Weaviate.Client.Models.GenerativeConfig.Databricks.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.FriendliAI -Weaviate.Client.Models.GenerativeConfig.FriendliAI.BaseURL.get -> string? -Weaviate.Client.Models.GenerativeConfig.FriendliAI.BaseURL.set -> void -Weaviate.Client.Models.GenerativeConfig.FriendliAI.FriendliAI(Weaviate.Client.Models.GenerativeConfig.FriendliAI! original) -> void -Weaviate.Client.Models.GenerativeConfig.FriendliAI.MaxTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.FriendliAI.MaxTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.FriendliAI.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.FriendliAI.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.FriendliAI.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.FriendliAI.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.FriendliAI.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.GoogleGemini -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.GoogleGemini(Weaviate.Client.Models.GenerativeConfig.GoogleGemini! original) -> void -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.MaxOutputTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.MaxOutputTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.TopK.get -> int? -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.TopK.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.TopP.get -> double? -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.TopP.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleGemini.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.GoogleVertex -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.ApiEndpoint.get -> string? -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.ApiEndpoint.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.EndpointId.get -> string? -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.EndpointId.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.GoogleVertex(Weaviate.Client.Models.GenerativeConfig.GoogleVertex! original) -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.MaxOutputTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.MaxOutputTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.ProjectId.get -> string? -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.ProjectId.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.Region.get -> string? -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.Region.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.TopK.get -> int? -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.TopK.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.TopP.get -> double? -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.TopP.set -> void -Weaviate.Client.Models.GenerativeConfig.GoogleVertex.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.Mistral -Weaviate.Client.Models.GenerativeConfig.Mistral.BaseURL.get -> string? -Weaviate.Client.Models.GenerativeConfig.Mistral.BaseURL.set -> void -Weaviate.Client.Models.GenerativeConfig.Mistral.MaxTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.Mistral.MaxTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.Mistral.Mistral(Weaviate.Client.Models.GenerativeConfig.Mistral! original) -> void -Weaviate.Client.Models.GenerativeConfig.Mistral.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.Mistral.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.Mistral.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.Mistral.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.Mistral.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.Nvidia -Weaviate.Client.Models.GenerativeConfig.Nvidia.BaseURL.get -> string? -Weaviate.Client.Models.GenerativeConfig.Nvidia.BaseURL.set -> void -Weaviate.Client.Models.GenerativeConfig.Nvidia.MaxTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.Nvidia.MaxTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.Nvidia.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.Nvidia.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.Nvidia.Nvidia(Weaviate.Client.Models.GenerativeConfig.Nvidia! original) -> void -Weaviate.Client.Models.GenerativeConfig.Nvidia.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.Nvidia.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.Nvidia.TopP.get -> double? -Weaviate.Client.Models.GenerativeConfig.Nvidia.TopP.set -> void -Weaviate.Client.Models.GenerativeConfig.Nvidia.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.Ollama -Weaviate.Client.Models.GenerativeConfig.Ollama.ApiEndpoint.get -> string? -Weaviate.Client.Models.GenerativeConfig.Ollama.ApiEndpoint.set -> void -Weaviate.Client.Models.GenerativeConfig.Ollama.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.Ollama.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.Ollama.Ollama(Weaviate.Client.Models.GenerativeConfig.Ollama! original) -> void -Weaviate.Client.Models.GenerativeConfig.Ollama.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.OpenAI -Weaviate.Client.Models.GenerativeConfig.OpenAI.OpenAI(Weaviate.Client.Models.GenerativeConfig.OpenAI! original) -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.ApiVersion.get -> string? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.ApiVersion.set -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.BaseURL.get -> string? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.BaseURL.set -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.FrequencyPenalty.get -> int? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.FrequencyPenalty.set -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.MaxTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.MaxTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.OpenAIBase(Weaviate.Client.Models.GenerativeConfig.OpenAIBase! original) -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.PresencePenalty.get -> int? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.PresencePenalty.set -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.ReasoningEffort.get -> string? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.ReasoningEffort.set -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.TopP.get -> double? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.TopP.set -> void -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.Verbosity.get -> string? -Weaviate.Client.Models.GenerativeConfig.OpenAIBase.Verbosity.set -> void -Weaviate.Client.Models.GenerativeConfig.XAI -Weaviate.Client.Models.GenerativeConfig.XAI.BaseURL.get -> string? -Weaviate.Client.Models.GenerativeConfig.XAI.BaseURL.set -> void -Weaviate.Client.Models.GenerativeConfig.XAI.MaxTokens.get -> int? -Weaviate.Client.Models.GenerativeConfig.XAI.MaxTokens.set -> void -Weaviate.Client.Models.GenerativeConfig.XAI.Model.get -> string? -Weaviate.Client.Models.GenerativeConfig.XAI.Model.set -> void -Weaviate.Client.Models.GenerativeConfig.XAI.Temperature.get -> double? -Weaviate.Client.Models.GenerativeConfig.XAI.Temperature.set -> void -Weaviate.Client.Models.GenerativeConfig.XAI.TopP.get -> double? -Weaviate.Client.Models.GenerativeConfig.XAI.TopP.set -> void -Weaviate.Client.Models.GenerativeConfig.XAI.Type.get -> string! -Weaviate.Client.Models.GenerativeConfig.XAI.XAI(Weaviate.Client.Models.GenerativeConfig.XAI! original) -> void -Weaviate.Client.Models.GenerativeDebug -Weaviate.Client.Models.GenerativeDebug.Deconstruct(out string? FullPrompt) -> void -Weaviate.Client.Models.GenerativeDebug.FullPrompt.get -> string? -Weaviate.Client.Models.GenerativeDebug.FullPrompt.init -> void -Weaviate.Client.Models.GenerativeDebug.GenerativeDebug(Weaviate.Client.Models.GenerativeDebug! original) -> void -Weaviate.Client.Models.GenerativeDebug.GenerativeDebug(string? FullPrompt = null) -> void -Weaviate.Client.Models.GenerativeGroupByObject -Weaviate.Client.Models.GenerativeGroupByObject.BelongsToGroup.get -> string! -Weaviate.Client.Models.GenerativeGroupByObject.BelongsToGroup.init -> void -Weaviate.Client.Models.GenerativeGroupByObject.GenerativeGroupByObject() -> void -Weaviate.Client.Models.GenerativeGroupByObject.GenerativeGroupByObject(Weaviate.Client.Models.GenerativeGroupByObject! original) -> void -Weaviate.Client.Models.GenerativeGroupByResult -Weaviate.Client.Models.GenerativeGroupByResult.Deconstruct(out System.Collections.Generic.IList! Objects, out System.Collections.Generic.IDictionary! Groups, out Weaviate.Client.Models.GenerativeResult! Generative) -> void -Weaviate.Client.Models.GenerativeGroupByResult.Generative.get -> Weaviate.Client.Models.GenerativeResult! -Weaviate.Client.Models.GenerativeGroupByResult.Generative.init -> void -Weaviate.Client.Models.GenerativeGroupByResult.GenerativeGroupByResult(System.Collections.Generic.IList! Objects, System.Collections.Generic.IDictionary! Groups, Weaviate.Client.Models.GenerativeResult! Generative) -> void -Weaviate.Client.Models.GenerativeGroupByResult.GenerativeGroupByResult(Weaviate.Client.Models.GenerativeGroupByResult! original) -> void -Weaviate.Client.Models.GenerativePrompt -Weaviate.Client.Models.GenerativePrompt.Debug.get -> bool -Weaviate.Client.Models.GenerativePrompt.Debug.set -> void -Weaviate.Client.Models.GenerativePrompt.GenerativePrompt() -> void -Weaviate.Client.Models.GenerativePrompt.GenerativePrompt(Weaviate.Client.Models.GenerativePrompt! original) -> void -Weaviate.Client.Models.GenerativePrompt.Provider.get -> Weaviate.Client.Models.GenerativeProvider? -Weaviate.Client.Models.GenerativeProvider -Weaviate.Client.Models.GenerativeProvider.GenerativeProvider(Weaviate.Client.Models.GenerativeProvider! original) -> void -Weaviate.Client.Models.GenerativeProvider.GenerativeProvider(string! name) -> void -Weaviate.Client.Models.GenerativeProvider.Name.get -> string! -Weaviate.Client.Models.GenerativeProvider.ReturnMetadata.get -> bool -Weaviate.Client.Models.GenerativeProvider.ReturnMetadata.set -> void -Weaviate.Client.Models.GenerativeReply -Weaviate.Client.Models.GenerativeReply.Deconstruct(out string! Text) -> void -Weaviate.Client.Models.GenerativeReply.GenerativeReply(Weaviate.Client.Models.GenerativeReply! original) -> void -Weaviate.Client.Models.GenerativeReply.GenerativeReply(string! Text) -> void -Weaviate.Client.Models.GenerativeReply.Text.get -> string! -Weaviate.Client.Models.GenerativeReply.Text.init -> void -Weaviate.Client.Models.GenerativeResult -Weaviate.Client.Models.GenerativeResult.Add(string! item) -> void -Weaviate.Client.Models.GenerativeResult.Clear() -> void -Weaviate.Client.Models.GenerativeResult.Contains(string! item) -> bool -Weaviate.Client.Models.GenerativeResult.CopyTo(string![]! array, int arrayIndex) -> void -Weaviate.Client.Models.GenerativeResult.Count.get -> int -Weaviate.Client.Models.GenerativeResult.Deconstruct(out System.Collections.Generic.IList! Values) -> void -Weaviate.Client.Models.GenerativeResult.GenerativeResult(System.Collections.Generic.IList! Values) -> void -Weaviate.Client.Models.GenerativeResult.GenerativeResult(Weaviate.Client.Models.GenerativeResult! original) -> void -Weaviate.Client.Models.GenerativeResult.GetEnumerator() -> System.Collections.Generic.IEnumerator! -Weaviate.Client.Models.GenerativeResult.IndexOf(string! item) -> int -Weaviate.Client.Models.GenerativeResult.Insert(int index, string! item) -> void -Weaviate.Client.Models.GenerativeResult.IsReadOnly.get -> bool -Weaviate.Client.Models.GenerativeResult.Remove(string! item) -> bool -Weaviate.Client.Models.GenerativeResult.RemoveAt(int index) -> void -Weaviate.Client.Models.GenerativeResult.Values.get -> System.Collections.Generic.IList! -Weaviate.Client.Models.GenerativeResult.Values.init -> void -Weaviate.Client.Models.GenerativeResult.this[int index].get -> string! -Weaviate.Client.Models.GenerativeResult.this[int index].set -> void -Weaviate.Client.Models.GenerativeWeaviateGroup -Weaviate.Client.Models.GenerativeWeaviateGroup.Generative.get -> Weaviate.Client.Models.GenerativeResult? -Weaviate.Client.Models.GenerativeWeaviateGroup.Generative.set -> void -Weaviate.Client.Models.GenerativeWeaviateGroup.GenerativeWeaviateGroup() -> void -Weaviate.Client.Models.GenerativeWeaviateGroup.GenerativeWeaviateGroup(Weaviate.Client.Models.GenerativeWeaviateGroup! original) -> void -Weaviate.Client.Models.GenerativeWeaviateObject -Weaviate.Client.Models.GenerativeWeaviateObject.Generative.get -> Weaviate.Client.Models.GenerativeResult? -Weaviate.Client.Models.GenerativeWeaviateObject.Generative.set -> void -Weaviate.Client.Models.GenerativeWeaviateObject.GenerativeWeaviateObject() -> void -Weaviate.Client.Models.GenerativeWeaviateObject.GenerativeWeaviateObject(Weaviate.Client.Models.GenerativeWeaviateObject! original) -> void -Weaviate.Client.Models.GenerativeWeaviateResult -Weaviate.Client.Models.GenerativeWeaviateResult.Generative.get -> Weaviate.Client.Models.GenerativeResult! -Weaviate.Client.Models.GenerativeWeaviateResult.Generative.init -> void -Weaviate.Client.Models.GenerativeWeaviateResult.GenerativeWeaviateResult() -> void -Weaviate.Client.Models.GenerativeWeaviateResult.GenerativeWeaviateResult(Weaviate.Client.Models.GenerativeWeaviateResult! original) -> void -Weaviate.Client.Models.GeoCoordinate -Weaviate.Client.Models.GeoCoordinate.Deconstruct(out float Latitude, out float Longitude) -> void -Weaviate.Client.Models.GeoCoordinate.GeoCoordinate(Weaviate.Client.Models.GeoCoordinate! original) -> void -Weaviate.Client.Models.GeoCoordinate.GeoCoordinate(float Latitude, float Longitude) -> void -Weaviate.Client.Models.GeoCoordinate.Latitude.get -> float -Weaviate.Client.Models.GeoCoordinate.Latitude.init -> void -Weaviate.Client.Models.GeoCoordinate.Longitude.get -> float -Weaviate.Client.Models.GeoCoordinate.Longitude.init -> void -Weaviate.Client.Models.GeoCoordinateConstraint -Weaviate.Client.Models.GeoCoordinateConstraint.Deconstruct(out float Latitude, out float Longitude, out float Distance) -> void -Weaviate.Client.Models.GeoCoordinateConstraint.Distance.get -> float -Weaviate.Client.Models.GeoCoordinateConstraint.Distance.init -> void -Weaviate.Client.Models.GeoCoordinateConstraint.GeoCoordinateConstraint(Weaviate.Client.Models.GeoCoordinateConstraint! original) -> void -Weaviate.Client.Models.GeoCoordinateConstraint.GeoCoordinateConstraint(float Latitude, float Longitude, float Distance) -> void -Weaviate.Client.Models.GeoCoordinateConstraint.Latitude.get -> float -Weaviate.Client.Models.GeoCoordinateConstraint.Latitude.init -> void -Weaviate.Client.Models.GeoCoordinateConstraint.Longitude.get -> float -Weaviate.Client.Models.GeoCoordinateConstraint.Longitude.init -> void -Weaviate.Client.Models.GroupByObject -Weaviate.Client.Models.GroupByObject.BelongsToGroup.get -> string! -Weaviate.Client.Models.GroupByObject.BelongsToGroup.init -> void -Weaviate.Client.Models.GroupByObject.GroupByObject(Weaviate.Client.Models.GroupByObject! original) -> void -Weaviate.Client.Models.GroupByRequest -Weaviate.Client.Models.GroupByRequest.Deconstruct(out string! PropertyName) -> void -Weaviate.Client.Models.GroupByRequest.GroupByRequest(Weaviate.Client.Models.GroupByRequest! original) -> void -Weaviate.Client.Models.GroupByRequest.GroupByRequest(string! PropertyName) -> void -Weaviate.Client.Models.GroupByRequest.NumberOfGroups.get -> uint -Weaviate.Client.Models.GroupByRequest.NumberOfGroups.set -> void -Weaviate.Client.Models.GroupByRequest.ObjectsPerGroup.get -> uint -Weaviate.Client.Models.GroupByRequest.ObjectsPerGroup.set -> void -Weaviate.Client.Models.GroupByRequest.PropertyName.get -> string! -Weaviate.Client.Models.GroupByRequest.PropertyName.init -> void -Weaviate.Client.Models.GroupByResult -Weaviate.Client.Models.GroupByResult.Deconstruct(out System.Collections.Generic.IList! Objects, out System.Collections.Generic.IDictionary! Groups) -> void -Weaviate.Client.Models.GroupByResult.GroupByResult(System.Collections.Generic.IList! Objects, System.Collections.Generic.IDictionary! Groups) -> void -Weaviate.Client.Models.GroupByResult.GroupByResult(Weaviate.Client.Models.GroupByResult! original) -> void -Weaviate.Client.Models.GroupByResult -Weaviate.Client.Models.GroupByResult.Deconstruct(out System.Collections.Generic.IList! Objects, out System.Collections.Generic.IDictionary! Groups) -> void -Weaviate.Client.Models.GroupByResult.GroupByResult(System.Collections.Generic.IList! Objects, System.Collections.Generic.IDictionary! Groups) -> void -Weaviate.Client.Models.GroupByResult.GroupByResult(Weaviate.Client.Models.GroupByResult! original) -> void -Weaviate.Client.Models.GroupByResult.Groups.get -> System.Collections.Generic.IDictionary! -Weaviate.Client.Models.GroupByResult.Groups.init -> void -Weaviate.Client.Models.GroupByResult.Objects.get -> System.Collections.Generic.IList! -Weaviate.Client.Models.GroupByResult.Objects.init -> void -Weaviate.Client.Models.GroupRoleAssignment -Weaviate.Client.Models.GroupRoleAssignment.Deconstruct(out string! GroupId, out Weaviate.Client.Models.RbacGroupType GroupType) -> void -Weaviate.Client.Models.GroupRoleAssignment.GroupId.get -> string! -Weaviate.Client.Models.GroupRoleAssignment.GroupId.init -> void -Weaviate.Client.Models.GroupRoleAssignment.GroupRoleAssignment(Weaviate.Client.Models.GroupRoleAssignment! original) -> void -Weaviate.Client.Models.GroupRoleAssignment.GroupRoleAssignment(string! GroupId, Weaviate.Client.Models.RbacGroupType GroupType) -> void -Weaviate.Client.Models.GroupRoleAssignment.GroupType.get -> Weaviate.Client.Models.RbacGroupType -Weaviate.Client.Models.GroupRoleAssignment.GroupType.init -> void -Weaviate.Client.Models.GroupedTask -Weaviate.Client.Models.GroupedTask.Deconstruct(out string! Task, out string![]! Properties) -> void -Weaviate.Client.Models.GroupedTask.GroupedTask(Weaviate.Client.Models.GroupedTask! original) -> void -Weaviate.Client.Models.GroupedTask.GroupedTask(string! Task, params string![]! Properties) -> void -Weaviate.Client.Models.GroupedTask.Properties.get -> string![]! -Weaviate.Client.Models.GroupedTask.Properties.init -> void -Weaviate.Client.Models.GroupedTask.Task.get -> string! -Weaviate.Client.Models.GroupedTask.Task.init -> void -Weaviate.Client.Models.GroupsResource -Weaviate.Client.Models.GroupsResource.Deconstruct(out string? Group, out Weaviate.Client.Models.RbacGroupType? GroupType) -> void -Weaviate.Client.Models.GroupsResource.Group.get -> string? -Weaviate.Client.Models.GroupsResource.Group.init -> void -Weaviate.Client.Models.GroupsResource.GroupType.get -> Weaviate.Client.Models.RbacGroupType? -Weaviate.Client.Models.GroupsResource.GroupType.init -> void -Weaviate.Client.Models.GroupsResource.GroupsResource(Weaviate.Client.Models.GroupsResource! original) -> void -Weaviate.Client.Models.GroupsResource.GroupsResource(string? Group = "*", Weaviate.Client.Models.RbacGroupType? GroupType = Weaviate.Client.Models.RbacGroupType.Oidc) -> void -Weaviate.Client.Models.HybridFusion -Weaviate.Client.Models.HybridFusion.Ranked = 0 -> Weaviate.Client.Models.HybridFusion -Weaviate.Client.Models.HybridFusion.RelativeScore = 1 -> Weaviate.Client.Models.HybridFusion -Weaviate.Client.Models.HybridNearText -Weaviate.Client.Models.HybridNearText.Certainty.get -> float? -Weaviate.Client.Models.HybridNearText.Certainty.init -> void -Weaviate.Client.Models.HybridNearText.Deconstruct(out string! Query, out float? Certainty, out float? Distance, out Weaviate.Client.Models.Move? MoveTo, out Weaviate.Client.Models.Move? MoveAway) -> void -Weaviate.Client.Models.HybridNearText.Distance.get -> float? -Weaviate.Client.Models.HybridNearText.Distance.init -> void -Weaviate.Client.Models.HybridNearText.HybridNearText(Weaviate.Client.Models.HybridNearText! original) -> void -Weaviate.Client.Models.HybridNearText.HybridNearText(string! Query, float? Certainty = null, float? Distance = null, Weaviate.Client.Models.Move? MoveTo = null, Weaviate.Client.Models.Move? MoveAway = null) -> void -Weaviate.Client.Models.HybridNearText.MoveAway.get -> Weaviate.Client.Models.Move? -Weaviate.Client.Models.HybridNearText.MoveAway.init -> void -Weaviate.Client.Models.HybridNearText.MoveTo.get -> Weaviate.Client.Models.Move? -Weaviate.Client.Models.HybridNearText.MoveTo.init -> void -Weaviate.Client.Models.HybridNearText.Query.get -> string! -Weaviate.Client.Models.HybridNearText.Query.init -> void -Weaviate.Client.Models.HybridNearVector -Weaviate.Client.Models.HybridNearVector.Certainty.get -> float? -Weaviate.Client.Models.HybridNearVector.Certainty.init -> void -Weaviate.Client.Models.HybridNearVector.Deconstruct(out Weaviate.Client.Models.NearVectorInput! Vector, out float? Certainty, out float? Distance, out Weaviate.Client.Models.TargetVectors? targetVector) -> void -Weaviate.Client.Models.HybridNearVector.Distance.get -> float? -Weaviate.Client.Models.HybridNearVector.Distance.init -> void -Weaviate.Client.Models.HybridNearVector.HybridNearVector(Weaviate.Client.Models.HybridNearVector! original) -> void -Weaviate.Client.Models.HybridNearVector.HybridNearVector(Weaviate.Client.Models.NearVectorInput! Vector, float? Certainty = null, float? Distance = null, Weaviate.Client.Models.TargetVectors? targetVector = null) -> void -Weaviate.Client.Models.HybridNearVector.Vector.get -> Weaviate.Client.Models.NearVectorInput! -Weaviate.Client.Models.HybridNearVector.Vector.init -> void -Weaviate.Client.Models.HybridNearVector.targetVector.get -> Weaviate.Client.Models.TargetVectors? -Weaviate.Client.Models.HybridNearVector.targetVector.init -> void -Weaviate.Client.Models.IFilterCompare -Weaviate.Client.Models.IFilterCompare.IsGreaterThan(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.IFilterCompare.IsGreaterThanEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.IFilterCompare.IsLessThan(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.IFilterCompare.IsLessThanEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.IFilterContains -Weaviate.Client.Models.IFilterContainsAll -Weaviate.Client.Models.IFilterContainsAll.ContainsAll(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.IFilterContainsAny -Weaviate.Client.Models.IFilterContainsAny.ContainsAny(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.IFilterContainsNone -Weaviate.Client.Models.IFilterContainsNone.ContainsNone(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.IFilterEquality -Weaviate.Client.Models.IFilterEquality.IsEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.IFilterEquality.IsNotEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.IGenerativeConfig -Weaviate.Client.Models.IGenerativeConfig.Type.get -> string! -Weaviate.Client.Models.IHybridVectorInput -Weaviate.Client.Models.INearVectorInput -Weaviate.Client.Models.IRerankerConfig -Weaviate.Client.Models.IRerankerConfig.Type.get -> string! -Weaviate.Client.Models.InvertedIndexConfig -Weaviate.Client.Models.InvertedIndexConfig.Bm25.get -> Weaviate.Client.Models.BM25Config? -Weaviate.Client.Models.InvertedIndexConfig.Bm25.set -> void -Weaviate.Client.Models.InvertedIndexConfig.CleanupIntervalSeconds.get -> int -Weaviate.Client.Models.InvertedIndexConfig.CleanupIntervalSeconds.set -> void -Weaviate.Client.Models.InvertedIndexConfig.IndexNullState.get -> bool -Weaviate.Client.Models.InvertedIndexConfig.IndexNullState.set -> void -Weaviate.Client.Models.InvertedIndexConfig.IndexPropertyLength.get -> bool -Weaviate.Client.Models.InvertedIndexConfig.IndexPropertyLength.set -> void -Weaviate.Client.Models.InvertedIndexConfig.IndexTimestamps.get -> bool -Weaviate.Client.Models.InvertedIndexConfig.IndexTimestamps.set -> void -Weaviate.Client.Models.InvertedIndexConfig.InvertedIndexConfig() -> void -Weaviate.Client.Models.InvertedIndexConfig.InvertedIndexConfig(Weaviate.Client.Models.InvertedIndexConfig! original) -> void -Weaviate.Client.Models.InvertedIndexConfig.Stopwords.get -> Weaviate.Client.Models.StopwordConfig? -Weaviate.Client.Models.InvertedIndexConfig.Stopwords.set -> void -Weaviate.Client.Models.InvertedIndexConfig.UsingBlockMaxWAND.get -> bool? -Weaviate.Client.Models.InvertedIndexConfig.UsingBlockMaxWAND.set -> void -Weaviate.Client.Models.InvertedIndexConfigUpdate -Weaviate.Client.Models.InvertedIndexConfigUpdate.Bm25.get -> Weaviate.Client.Models.Bm25ConfigUpdate! -Weaviate.Client.Models.InvertedIndexConfigUpdate.CleanupIntervalSeconds.get -> int -Weaviate.Client.Models.InvertedIndexConfigUpdate.CleanupIntervalSeconds.set -> void -Weaviate.Client.Models.InvertedIndexConfigUpdate.Deconstruct(out Weaviate.Client.Models.InvertedIndexConfig! WrappedConfig) -> void -Weaviate.Client.Models.InvertedIndexConfigUpdate.InvertedIndexConfigUpdate(Weaviate.Client.Models.InvertedIndexConfig! WrappedConfig) -> void -Weaviate.Client.Models.InvertedIndexConfigUpdate.InvertedIndexConfigUpdate(Weaviate.Client.Models.InvertedIndexConfigUpdate! original) -> void -Weaviate.Client.Models.InvertedIndexConfigUpdate.Stopwords.get -> Weaviate.Client.Models.StopwordsConfigUpdate! -Weaviate.Client.Models.InvertedIndexConfigUpdate.WrappedConfig.get -> Weaviate.Client.Models.InvertedIndexConfig! -Weaviate.Client.Models.InvertedIndexConfigUpdate.WrappedConfig.init -> void -Weaviate.Client.Models.JsonConverterEmptyCollectionAsNull -Weaviate.Client.Models.JsonConverterEmptyCollectionAsNull.JsonConverterEmptyCollectionAsNull() -> void -Weaviate.Client.Models.MetaInfo -Weaviate.Client.Models.MetaInfo.GrpcMaxMessageSize.get -> ulong? -Weaviate.Client.Models.MetaInfo.GrpcMaxMessageSize.set -> void -Weaviate.Client.Models.MetaInfo.Hostname.get -> string! -Weaviate.Client.Models.MetaInfo.Hostname.set -> void -Weaviate.Client.Models.MetaInfo.MetaInfo() -> void -Weaviate.Client.Models.MetaInfo.Modules.get -> System.Collections.Generic.Dictionary! -Weaviate.Client.Models.MetaInfo.Modules.set -> void -Weaviate.Client.Models.MetaInfo.Version.get -> System.Version! -Weaviate.Client.Models.MetaInfo.Version.set -> void -Weaviate.Client.Models.Metadata -Weaviate.Client.Models.Metadata.Certainty.get -> double? -Weaviate.Client.Models.Metadata.Certainty.init -> void -Weaviate.Client.Models.Metadata.CreationTime.get -> System.DateTime? -Weaviate.Client.Models.Metadata.CreationTime.set -> void -Weaviate.Client.Models.Metadata.Distance.get -> double? -Weaviate.Client.Models.Metadata.Distance.init -> void -Weaviate.Client.Models.Metadata.ExplainScore.get -> string? -Weaviate.Client.Models.Metadata.ExplainScore.init -> void -Weaviate.Client.Models.Metadata.IsConsistent.get -> bool? -Weaviate.Client.Models.Metadata.IsConsistent.init -> void -Weaviate.Client.Models.Metadata.LastUpdateTime.get -> System.DateTime? -Weaviate.Client.Models.Metadata.LastUpdateTime.set -> void -Weaviate.Client.Models.Metadata.Metadata() -> void -Weaviate.Client.Models.Metadata.Metadata(Weaviate.Client.Models.Metadata! original) -> void -Weaviate.Client.Models.Metadata.RerankScore.get -> double? -Weaviate.Client.Models.Metadata.RerankScore.init -> void -Weaviate.Client.Models.Metadata.Score.get -> double? -Weaviate.Client.Models.Metadata.Score.init -> void -Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataOptions.All = Weaviate.Client.Models.MetadataOptions.CreationTime | Weaviate.Client.Models.MetadataOptions.LastUpdateTime | Weaviate.Client.Models.MetadataOptions.Distance | Weaviate.Client.Models.MetadataOptions.Certainty | Weaviate.Client.Models.MetadataOptions.Score | Weaviate.Client.Models.MetadataOptions.ExplainScore | Weaviate.Client.Models.MetadataOptions.IsConsistent -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataOptions.Certainty = 16 -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataOptions.CreationTime = 2 -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataOptions.Distance = 8 -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataOptions.ExplainScore = 64 -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataOptions.IsConsistent = 128 -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataOptions.LastUpdateTime = 4 -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataOptions.None = 0 -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataOptions.Score = 32 -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataQuery -Weaviate.Client.Models.MetadataQuery.Certainty.get -> bool -Weaviate.Client.Models.MetadataQuery.CreationTime.get -> bool -Weaviate.Client.Models.MetadataQuery.Disable(Weaviate.Client.Models.MetadataOptions disableOptions) -> Weaviate.Client.Models.MetadataQuery! -Weaviate.Client.Models.MetadataQuery.Distance.get -> bool -Weaviate.Client.Models.MetadataQuery.Enable(Weaviate.Client.Models.MetadataOptions enableOptions) -> Weaviate.Client.Models.MetadataQuery! -Weaviate.Client.Models.MetadataQuery.ExplainScore.get -> bool -Weaviate.Client.Models.MetadataQuery.IsConsistent.get -> bool -Weaviate.Client.Models.MetadataQuery.LastUpdateTime.get -> bool -Weaviate.Client.Models.MetadataQuery.MetadataQuery(Weaviate.Client.Models.MetadataOptions options = Weaviate.Client.Models.MetadataOptions.None) -> void -Weaviate.Client.Models.MetadataQuery.MetadataQuery(Weaviate.Client.Models.MetadataQuery! original) -> void -Weaviate.Client.Models.MetadataQuery.Options.get -> Weaviate.Client.Models.MetadataOptions -Weaviate.Client.Models.MetadataQuery.Score.get -> bool -Weaviate.Client.Models.Metrics -Weaviate.Client.Models.Metrics.Boolean(bool count = false, bool percentageFalse = false, bool percentageTrue = false, bool totalFalse = false, bool totalTrue = false) -> Weaviate.Client.Models.Aggregate.Metric! -Weaviate.Client.Models.Metrics.Date(bool count = false, bool maximum = false, bool median = false, bool minimum = false, bool mode = false) -> Weaviate.Client.Models.Aggregate.Metric! -Weaviate.Client.Models.Metrics.Integer(bool count = false, bool maximum = false, bool mean = false, bool median = false, bool minimum = false, bool mode = false, bool sum = false) -> Weaviate.Client.Models.Aggregate.Metric! -Weaviate.Client.Models.Metrics.Metrics(string! name) -> void -Weaviate.Client.Models.Metrics.Number(bool count = false, bool maximum = false, bool mean = false, bool median = false, bool minimum = false, bool mode = false, bool sum = false) -> Weaviate.Client.Models.Aggregate.Metric! -Weaviate.Client.Models.Metrics.Text(bool count = false, bool topOccurrencesCount = false, bool topOccurrencesValue = false, uint? minOccurrences = null) -> Weaviate.Client.Models.Aggregate.Metric! -Weaviate.Client.Models.ModuleConfigList -Weaviate.Client.Models.ModuleConfigList.Equals(Weaviate.Client.Models.ModuleConfigList? other) -> bool -Weaviate.Client.Models.ModuleConfigList.ModuleConfigList() -> void -Weaviate.Client.Models.Move -Weaviate.Client.Models.Move.Concepts.get -> string![]? -Weaviate.Client.Models.Move.Force.get -> float -Weaviate.Client.Models.Move.Move(Weaviate.Client.Models.Move! original) -> void -Weaviate.Client.Models.Move.Move(float force, Weaviate.Client.Models.AutoArray! objects) -> void -Weaviate.Client.Models.Move.Move(float force, Weaviate.Client.Models.AutoArray! concepts) -> void -Weaviate.Client.Models.Move.Objects.get -> System.Guid[]? -Weaviate.Client.Models.MultiTenancyConfig -Weaviate.Client.Models.MultiTenancyConfig.AutoTenantActivation.get -> bool -Weaviate.Client.Models.MultiTenancyConfig.AutoTenantActivation.set -> void -Weaviate.Client.Models.MultiTenancyConfig.AutoTenantCreation.get -> bool -Weaviate.Client.Models.MultiTenancyConfig.AutoTenantCreation.set -> void -Weaviate.Client.Models.MultiTenancyConfig.Deconstruct(out bool Enabled, out bool AutoTenantCreation, out bool AutoTenantActivation) -> void -Weaviate.Client.Models.MultiTenancyConfig.Enabled.get -> bool -Weaviate.Client.Models.MultiTenancyConfig.Enabled.set -> void -Weaviate.Client.Models.MultiTenancyConfig.MultiTenancyConfig(Weaviate.Client.Models.MultiTenancyConfig! original) -> void -Weaviate.Client.Models.MultiTenancyConfig.MultiTenancyConfig(bool Enabled = false, bool AutoTenantCreation = false, bool AutoTenantActivation = false) -> void -Weaviate.Client.Models.MultiTenancyConfigUpdate -Weaviate.Client.Models.MultiTenancyConfigUpdate.AutoTenantActivation.get -> bool -Weaviate.Client.Models.MultiTenancyConfigUpdate.AutoTenantActivation.set -> void -Weaviate.Client.Models.MultiTenancyConfigUpdate.AutoTenantCreation.get -> bool -Weaviate.Client.Models.MultiTenancyConfigUpdate.AutoTenantCreation.set -> void -Weaviate.Client.Models.MultiTenancyConfigUpdate.MultiTenancyConfigUpdate(Weaviate.Client.Models.MultiTenancyConfig! WrappedMultiTenancyConfig) -> void -Weaviate.Client.Models.NearMediaType -Weaviate.Client.Models.NearMediaType.Audio = 0 -> Weaviate.Client.Models.NearMediaType -Weaviate.Client.Models.NearMediaType.Depth = 1 -> Weaviate.Client.Models.NearMediaType -Weaviate.Client.Models.NearMediaType.IMU = 3 -> Weaviate.Client.Models.NearMediaType -Weaviate.Client.Models.NearMediaType.Image = 2 -> Weaviate.Client.Models.NearMediaType -Weaviate.Client.Models.NearMediaType.Thermal = 4 -> Weaviate.Client.Models.NearMediaType -Weaviate.Client.Models.NearMediaType.Video = 5 -> Weaviate.Client.Models.NearMediaType -Weaviate.Client.Models.NearVectorInput -Weaviate.Client.Models.NearVectorInput.Add(Weaviate.Client.Models.Vectors! vectors) -> void -Weaviate.Client.Models.NearVectorInput.Add(string! name, params Weaviate.Client.Models.Vector![]! values) -> void -Weaviate.Client.Models.NearVectorInput.NearVectorInput() -> void -Weaviate.Client.Models.NearVectorInput.NearVectorInput(Weaviate.Client.Models.NearVectorInput! original) -> void -Weaviate.Client.Models.NearVectorInput.NearVectorInput(params Weaviate.Client.Models.Vector![]! vectors) -> void -Weaviate.Client.Models.NearVectorInput.Vectors.get -> System.Collections.Generic.IReadOnlyDictionary! -Weaviate.Client.Models.NestedFilter -Weaviate.Client.Models.NestedFilter.NestedFilter(Weaviate.Client.Models.NestedFilter! original) -> void -Weaviate.Client.Models.NodeStatus -Weaviate.Client.Models.NodeStatus.Healthy = 1 -> Weaviate.Client.Models.NodeStatus -Weaviate.Client.Models.NodeStatus.Timeout = 4 -> Weaviate.Client.Models.NodeStatus -Weaviate.Client.Models.NodeStatus.Unavailable = 3 -> Weaviate.Client.Models.NodeStatus -Weaviate.Client.Models.NodeStatus.Unhealthy = 2 -> Weaviate.Client.Models.NodeStatus -Weaviate.Client.Models.NodeStatus.Unknown = 0 -> Weaviate.Client.Models.NodeStatus -Weaviate.Client.Models.NodeStatusExtensions -Weaviate.Client.Models.NodeVerbosity -Weaviate.Client.Models.NodeVerbosity.Minimal = 1 -> Weaviate.Client.Models.NodeVerbosity -Weaviate.Client.Models.NodeVerbosity.Verbose = 0 -> Weaviate.Client.Models.NodeVerbosity -Weaviate.Client.Models.NodesResource -Weaviate.Client.Models.NodesResource.Collection.get -> string? -Weaviate.Client.Models.NodesResource.Collection.init -> void -Weaviate.Client.Models.NodesResource.Deconstruct(out string? Collection, out Weaviate.Client.Models.NodeVerbosity? Verbosity) -> void -Weaviate.Client.Models.NodesResource.NodesResource(Weaviate.Client.Models.NodesResource! original) -> void -Weaviate.Client.Models.NodesResource.NodesResource(string? Collection = "*", Weaviate.Client.Models.NodeVerbosity? Verbosity = Weaviate.Client.Models.NodeVerbosity.Minimal) -> void -Weaviate.Client.Models.NodesResource.Verbosity.get -> Weaviate.Client.Models.NodeVerbosity? -Weaviate.Client.Models.NodesResource.Verbosity.init -> void -Weaviate.Client.Models.NotNestedFilter -Weaviate.Client.Models.NotNestedFilter.Deconstruct(out Weaviate.Client.Models.Filter! filter) -> void -Weaviate.Client.Models.NotNestedFilter.NotNestedFilter(Weaviate.Client.Models.Filter! filter) -> void -Weaviate.Client.Models.NotNestedFilter.NotNestedFilter(Weaviate.Client.Models.NotNestedFilter! original) -> void -Weaviate.Client.Models.NotNestedFilter.filter.get -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.NotNestedFilter.filter.init -> void -Weaviate.Client.Models.ObjectReference -Weaviate.Client.Models.ObjectReference.Deconstruct(out string! Name, out System.Collections.Generic.IEnumerable! TargetID) -> void -Weaviate.Client.Models.ObjectReference.Name.get -> string! -Weaviate.Client.Models.ObjectReference.Name.init -> void -Weaviate.Client.Models.ObjectReference.ObjectReference(Weaviate.Client.Models.ObjectReference! original) -> void -Weaviate.Client.Models.ObjectReference.ObjectReference(string! Name, System.Collections.Generic.IEnumerable! TargetID) -> void -Weaviate.Client.Models.ObjectReference.ObjectReference(string! Name, params System.Guid[]! TargetID) -> void -Weaviate.Client.Models.ObjectReference.TargetID.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.ObjectReference.TargetID.init -> void -Weaviate.Client.Models.ObjectStorageBackend -Weaviate.Client.Models.ObjectStorageBackend.Bucket.get -> string? -Weaviate.Client.Models.ObjectStorageBackend.ObjectStorageBackend(Weaviate.Client.Models.BackupStorageProvider provider, string? bucket = null, string? path = null) -> void -Weaviate.Client.Models.ObjectStorageBackend.ObjectStorageBackend(Weaviate.Client.Models.ObjectStorageBackend! original) -> void -Weaviate.Client.Models.OrNestedFilter -Weaviate.Client.Models.OrNestedFilter.Deconstruct(out Weaviate.Client.Models.Filter![]! filters) -> void -Weaviate.Client.Models.OrNestedFilter.OrNestedFilter(Weaviate.Client.Models.OrNestedFilter! original) -> void -Weaviate.Client.Models.OrNestedFilter.OrNestedFilter(params Weaviate.Client.Models.Filter![]! filters) -> void -Weaviate.Client.Models.OrNestedFilter.filters.get -> Weaviate.Client.Models.Filter![]! -Weaviate.Client.Models.OrNestedFilter.filters.init -> void -Weaviate.Client.Models.PermissionScope -Weaviate.Client.Models.PermissionScope.PermissionScope() -> void -Weaviate.Client.Models.Permissions -Weaviate.Client.Models.Permissions.Alias -Weaviate.Client.Models.Permissions.Alias.Alias(string? collection, string? alias) -> void -Weaviate.Client.Models.Permissions.Alias.Create.get -> bool -Weaviate.Client.Models.Permissions.Alias.Create.set -> void -Weaviate.Client.Models.Permissions.Alias.Delete.get -> bool -Weaviate.Client.Models.Permissions.Alias.Delete.set -> void -Weaviate.Client.Models.Permissions.Alias.Read.get -> bool -Weaviate.Client.Models.Permissions.Alias.Read.set -> void -Weaviate.Client.Models.Permissions.Alias.Resource.get -> Weaviate.Client.Models.AliasesResource! -Weaviate.Client.Models.Permissions.Alias.Update.get -> bool -Weaviate.Client.Models.Permissions.Alias.Update.set -> void -Weaviate.Client.Models.Permissions.Backups -Weaviate.Client.Models.Permissions.Backups.Backups(string? collection) -> void -Weaviate.Client.Models.Permissions.Backups.Manage.get -> bool -Weaviate.Client.Models.Permissions.Backups.Manage.set -> void -Weaviate.Client.Models.Permissions.Backups.Resource.get -> Weaviate.Client.Models.BackupsResource! -Weaviate.Client.Models.Permissions.Cluster -Weaviate.Client.Models.Permissions.Cluster.Cluster() -> void -Weaviate.Client.Models.Permissions.Cluster.Read.get -> bool -Weaviate.Client.Models.Permissions.Cluster.Read.set -> void -Weaviate.Client.Models.Permissions.Collections -Weaviate.Client.Models.Permissions.Collections.Collections(string? collection) -> void -Weaviate.Client.Models.Permissions.Collections.Create.get -> bool -Weaviate.Client.Models.Permissions.Collections.Create.set -> void -Weaviate.Client.Models.Permissions.Collections.Delete.get -> bool -Weaviate.Client.Models.Permissions.Collections.Delete.set -> void -Weaviate.Client.Models.Permissions.Collections.Read.get -> bool -Weaviate.Client.Models.Permissions.Collections.Read.set -> void -Weaviate.Client.Models.Permissions.Collections.Resource.get -> Weaviate.Client.Models.CollectionsResource! -Weaviate.Client.Models.Permissions.Collections.Update.get -> bool -Weaviate.Client.Models.Permissions.Collections.Update.set -> void -Weaviate.Client.Models.Permissions.Data -Weaviate.Client.Models.Permissions.Data.Create.get -> bool -Weaviate.Client.Models.Permissions.Data.Create.set -> void -Weaviate.Client.Models.Permissions.Data.Data(string? collection, string? tenant = "*") -> void -Weaviate.Client.Models.Permissions.Data.Delete.get -> bool -Weaviate.Client.Models.Permissions.Data.Delete.set -> void -Weaviate.Client.Models.Permissions.Data.Read.get -> bool -Weaviate.Client.Models.Permissions.Data.Read.set -> void -Weaviate.Client.Models.Permissions.Data.Resource.get -> Weaviate.Client.Models.DataResource! -Weaviate.Client.Models.Permissions.Data.Update.get -> bool -Weaviate.Client.Models.Permissions.Data.Update.set -> void -Weaviate.Client.Models.Permissions.Groups -Weaviate.Client.Models.Permissions.Groups.AssignAndRevoke.get -> bool -Weaviate.Client.Models.Permissions.Groups.AssignAndRevoke.set -> void -Weaviate.Client.Models.Permissions.Groups.Groups(string? group, Weaviate.Client.Models.RbacGroupType? groupType) -> void -Weaviate.Client.Models.Permissions.Groups.Read.get -> bool -Weaviate.Client.Models.Permissions.Groups.Read.set -> void -Weaviate.Client.Models.Permissions.Groups.Resource.get -> Weaviate.Client.Models.GroupsResource! -Weaviate.Client.Models.Permissions.Nodes -Weaviate.Client.Models.Permissions.Nodes.Nodes(string? collection, Weaviate.Client.Models.NodeVerbosity? verbosity) -> void -Weaviate.Client.Models.Permissions.Nodes.Read.get -> bool -Weaviate.Client.Models.Permissions.Nodes.Read.set -> void -Weaviate.Client.Models.Permissions.Nodes.Resource.get -> Weaviate.Client.Models.NodesResource! -Weaviate.Client.Models.Permissions.Replicate -Weaviate.Client.Models.Permissions.Replicate.Create.get -> bool -Weaviate.Client.Models.Permissions.Replicate.Create.set -> void -Weaviate.Client.Models.Permissions.Replicate.Delete.get -> bool -Weaviate.Client.Models.Permissions.Replicate.Delete.set -> void -Weaviate.Client.Models.Permissions.Replicate.Read.get -> bool -Weaviate.Client.Models.Permissions.Replicate.Read.set -> void -Weaviate.Client.Models.Permissions.Replicate.Replicate(string? collection, string? shard) -> void -Weaviate.Client.Models.Permissions.Replicate.Resource.get -> Weaviate.Client.Models.ReplicateResource! -Weaviate.Client.Models.Permissions.Replicate.Update.get -> bool -Weaviate.Client.Models.Permissions.Replicate.Update.set -> void -Weaviate.Client.Models.Permissions.Roles -Weaviate.Client.Models.Permissions.Roles.Create.get -> bool -Weaviate.Client.Models.Permissions.Roles.Create.set -> void -Weaviate.Client.Models.Permissions.Roles.Delete.get -> bool -Weaviate.Client.Models.Permissions.Roles.Delete.set -> void -Weaviate.Client.Models.Permissions.Roles.Read.get -> bool -Weaviate.Client.Models.Permissions.Roles.Read.set -> void -Weaviate.Client.Models.Permissions.Roles.Resource.get -> Weaviate.Client.Models.RolesResource! -Weaviate.Client.Models.Permissions.Roles.Roles(string? name, Weaviate.Client.Models.RolesScope? scope = null) -> void -Weaviate.Client.Models.Permissions.Roles.Update.get -> bool -Weaviate.Client.Models.Permissions.Roles.Update.set -> void -Weaviate.Client.Models.Permissions.Tenants -Weaviate.Client.Models.Permissions.Tenants.Create.get -> bool -Weaviate.Client.Models.Permissions.Tenants.Create.set -> void -Weaviate.Client.Models.Permissions.Tenants.Delete.get -> bool -Weaviate.Client.Models.Permissions.Tenants.Delete.set -> void -Weaviate.Client.Models.Permissions.Tenants.Read.get -> bool -Weaviate.Client.Models.Permissions.Tenants.Read.set -> void -Weaviate.Client.Models.Permissions.Tenants.Resource.get -> Weaviate.Client.Models.TenantsResource! -Weaviate.Client.Models.Permissions.Tenants.Tenants(string? collection, string? tenant) -> void -Weaviate.Client.Models.Permissions.Tenants.Update.get -> bool -Weaviate.Client.Models.Permissions.Tenants.Update.set -> void -Weaviate.Client.Models.Permissions.Users -Weaviate.Client.Models.Permissions.Users.AssignAndRevoke.get -> bool -Weaviate.Client.Models.Permissions.Users.AssignAndRevoke.set -> void -Weaviate.Client.Models.Permissions.Users.Create.get -> bool -Weaviate.Client.Models.Permissions.Users.Create.set -> void -Weaviate.Client.Models.Permissions.Users.Delete.get -> bool -Weaviate.Client.Models.Permissions.Users.Delete.set -> void -Weaviate.Client.Models.Permissions.Users.Read.get -> bool -Weaviate.Client.Models.Permissions.Users.Read.set -> void -Weaviate.Client.Models.Permissions.Users.Resource.get -> Weaviate.Client.Models.UsersResource! -Weaviate.Client.Models.Permissions.Users.Update.get -> bool -Weaviate.Client.Models.Permissions.Users.Update.set -> void -Weaviate.Client.Models.Permissions.Users.Users() -> void -Weaviate.Client.Models.Permissions.Users.Users(string? name) -> void -Weaviate.Client.Models.PhoneNumber -Weaviate.Client.Models.PhoneNumber.CountryCode.get -> ulong? -Weaviate.Client.Models.PhoneNumber.Deconstruct(out string! Input) -> void -Weaviate.Client.Models.PhoneNumber.DefaultCountry.get -> string? -Weaviate.Client.Models.PhoneNumber.DefaultCountry.set -> void -Weaviate.Client.Models.PhoneNumber.Input.get -> string! -Weaviate.Client.Models.PhoneNumber.Input.init -> void -Weaviate.Client.Models.PhoneNumber.InternationalFormatted.get -> string? -Weaviate.Client.Models.PhoneNumber.National.get -> ulong? -Weaviate.Client.Models.PhoneNumber.NationalFormatted.get -> string? -Weaviate.Client.Models.PhoneNumber.PhoneNumber(Weaviate.Client.Models.PhoneNumber! original) -> void -Weaviate.Client.Models.PhoneNumber.PhoneNumber(string! Input = null) -> void -Weaviate.Client.Models.PhoneNumber.Valid.get -> bool? -Weaviate.Client.Models.Property -Weaviate.Client.Models.Property.DataType.get -> Weaviate.Client.Models.DataType -Weaviate.Client.Models.Property.DataType.init -> void -Weaviate.Client.Models.Property.Description.get -> string? -Weaviate.Client.Models.Property.IndexFilterable.get -> bool? -Weaviate.Client.Models.Property.IndexFilterable.init -> void -Weaviate.Client.Models.Property.IndexInverted.get -> bool? -Weaviate.Client.Models.Property.IndexInverted.init -> void -Weaviate.Client.Models.Property.IndexRangeFilters.get -> bool? -Weaviate.Client.Models.Property.IndexRangeFilters.init -> void -Weaviate.Client.Models.Property.IndexSearchable.get -> bool? -Weaviate.Client.Models.Property.IndexSearchable.init -> void -Weaviate.Client.Models.Property.Name.get -> string! -Weaviate.Client.Models.Property.Name.set -> void -Weaviate.Client.Models.Property.NestedProperties.get -> Weaviate.Client.Models.Property![]? -Weaviate.Client.Models.Property.NestedProperties.init -> void -Weaviate.Client.Models.Property.Property() -> void -Weaviate.Client.Models.Property.Property(Weaviate.Client.Models.Property! original) -> void -Weaviate.Client.Models.Property.Property(string! name, Weaviate.Client.Models.DataType dataType) -> void -Weaviate.Client.Models.Property.PropertyTokenization.get -> Weaviate.Client.Models.PropertyTokenization? -Weaviate.Client.Models.Property.PropertyTokenization.init -> void -Weaviate.Client.Models.Property.SkipVectorization.get -> bool -Weaviate.Client.Models.Property.SkipVectorization.init -> void -Weaviate.Client.Models.Property.VectorizePropertyName.get -> bool -Weaviate.Client.Models.Property.VectorizePropertyName.init -> void -Weaviate.Client.Models.Property -Weaviate.Client.Models.PropertyFactory -Weaviate.Client.Models.PropertyFilter -Weaviate.Client.Models.PropertyFilter.ContainsAll(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.ContainsAny(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.ContainsNone(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.HasLength() -> Weaviate.Client.Models.TypedValue! -Weaviate.Client.Models.PropertyFilter.IsEqual(TResult value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.IsGreaterThan(TResult value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.IsGreaterThanEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.IsLessThan(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.IsLessThanEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.IsLike(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.IsNotEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.IsNull(bool value = true) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.IsWithinGeoRange(Weaviate.Client.Models.GeoCoordinate! coord, float radius) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.IsWithinGeoRange(Weaviate.Client.Models.GeoCoordinateConstraint! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.PropertyFilter.PropertyFilter(Weaviate.Client.Models.PropertyFilter! original) -> void -Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyTokenization.Field = 3 -> Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyTokenization.Gse = 5 -> Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyTokenization.Gse_ch = 8 -> Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyTokenization.Kagome_ja = 7 -> Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyTokenization.Kagome_kr = 6 -> Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyTokenization.Lowercase = 1 -> Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyTokenization.Trigram = 4 -> Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyTokenization.Whitespace = 2 -> Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyTokenization.Word = 0 -> Weaviate.Client.Models.PropertyTokenization -Weaviate.Client.Models.PropertyUpdate -Weaviate.Client.Models.PropertyUpdate.Deconstruct(out Weaviate.Client.Models.Property! WrappedProperty) -> void -Weaviate.Client.Models.PropertyUpdate.Description.get -> string? -Weaviate.Client.Models.PropertyUpdate.Description.set -> void -Weaviate.Client.Models.PropertyUpdate.Name.get -> string! -Weaviate.Client.Models.PropertyUpdate.PropertyUpdate(Weaviate.Client.Models.Property! WrappedProperty) -> void -Weaviate.Client.Models.PropertyUpdate.PropertyUpdate(Weaviate.Client.Models.PropertyUpdate! original) -> void -Weaviate.Client.Models.PropertyUpdate.WrappedProperty.get -> Weaviate.Client.Models.Property! -Weaviate.Client.Models.PropertyUpdate.WrappedProperty.init -> void -Weaviate.Client.Models.QueryReference -Weaviate.Client.Models.QueryReference.Fields.get -> string![]? -Weaviate.Client.Models.QueryReference.Fields.init -> void -Weaviate.Client.Models.QueryReference.LinkOn.get -> string! -Weaviate.Client.Models.QueryReference.LinkOn.init -> void -Weaviate.Client.Models.QueryReference.Metadata.get -> Weaviate.Client.Models.MetadataQuery? -Weaviate.Client.Models.QueryReference.Metadata.init -> void -Weaviate.Client.Models.QueryReference.QueryReference(Weaviate.Client.Models.QueryReference! original) -> void -Weaviate.Client.Models.QueryReference.QueryReference(string! linkOn, string![]? fields = null, Weaviate.Client.Models.MetadataQuery? metadata = null, params Weaviate.Client.Models.QueryReference![]? references) -> void -Weaviate.Client.Models.QueryReference.References.get -> System.Collections.Generic.IList? -Weaviate.Client.Models.QueryReference.References.init -> void -Weaviate.Client.Models.RbacGroupType -Weaviate.Client.Models.RbacGroupType.Oidc = 0 -> Weaviate.Client.Models.RbacGroupType -Weaviate.Client.Models.RbacUserType -Weaviate.Client.Models.RbacUserType.Database = 0 -> Weaviate.Client.Models.RbacUserType -Weaviate.Client.Models.RbacUserType.Oidc = 1 -> Weaviate.Client.Models.RbacUserType -Weaviate.Client.Models.Reference -Weaviate.Client.Models.Reference.Deconstruct(out string! Name, out string! TargetCollection, out string? Description) -> void -Weaviate.Client.Models.Reference.Description.get -> string? -Weaviate.Client.Models.Reference.Description.set -> void -Weaviate.Client.Models.Reference.Name.get -> string! -Weaviate.Client.Models.Reference.Name.init -> void -Weaviate.Client.Models.Reference.Reference(Weaviate.Client.Models.Reference! original) -> void -Weaviate.Client.Models.Reference.Reference(string! Name, string! TargetCollection, string? Description = null) -> void -Weaviate.Client.Models.Reference.TargetCollection.get -> string! -Weaviate.Client.Models.Reference.TargetCollection.init -> void -Weaviate.Client.Models.ReferenceFilter -Weaviate.Client.Models.ReferenceFilter.Count.get -> Weaviate.Client.Models.TypedValue! -Weaviate.Client.Models.ReferenceFilter.ID.get -> Weaviate.Client.Models.TypedGuid! -Weaviate.Client.Models.ReferenceFilter.Property(string! name) -> Weaviate.Client.Models.PropertyFilter! -Weaviate.Client.Models.ReferenceFilter.Reference(string! name) -> Weaviate.Client.Models.ReferenceFilter! -Weaviate.Client.Models.ReferenceFilter.ReferenceFilter(Weaviate.Client.Models.ReferenceFilter! original) -> void -Weaviate.Client.Models.ReferenceUpdate -Weaviate.Client.Models.ReferenceUpdate.Deconstruct(out Weaviate.Client.Models.Reference! WrappedReference) -> void -Weaviate.Client.Models.ReferenceUpdate.Description.get -> string? -Weaviate.Client.Models.ReferenceUpdate.Description.set -> void -Weaviate.Client.Models.ReferenceUpdate.Name.get -> string! -Weaviate.Client.Models.ReferenceUpdate.ReferenceUpdate(Weaviate.Client.Models.Reference! WrappedReference) -> void -Weaviate.Client.Models.ReferenceUpdate.ReferenceUpdate(Weaviate.Client.Models.ReferenceUpdate! original) -> void -Weaviate.Client.Models.ReferenceUpdate.WrappedReference.get -> Weaviate.Client.Models.Reference! -Weaviate.Client.Models.ReferenceUpdate.WrappedReference.init -> void -Weaviate.Client.Models.ReplicateRequest -Weaviate.Client.Models.ReplicateRequest.Collection.get -> string! -Weaviate.Client.Models.ReplicateRequest.Collection.init -> void -Weaviate.Client.Models.ReplicateRequest.Deconstruct(out string! Collection, out string! Shard, out string! SourceNode, out string! TargetNode, out Weaviate.Client.Models.ReplicationType Type) -> void -Weaviate.Client.Models.ReplicateRequest.ReplicateRequest(Weaviate.Client.Models.ReplicateRequest! original) -> void -Weaviate.Client.Models.ReplicateRequest.ReplicateRequest(string! Collection, string! Shard, string! SourceNode, string! TargetNode, Weaviate.Client.Models.ReplicationType Type = Weaviate.Client.Models.ReplicationType.Copy) -> void -Weaviate.Client.Models.ReplicateRequest.Shard.get -> string! -Weaviate.Client.Models.ReplicateRequest.Shard.init -> void -Weaviate.Client.Models.ReplicateRequest.SourceNode.get -> string! -Weaviate.Client.Models.ReplicateRequest.SourceNode.init -> void -Weaviate.Client.Models.ReplicateRequest.TargetNode.get -> string! -Weaviate.Client.Models.ReplicateRequest.TargetNode.init -> void -Weaviate.Client.Models.ReplicateRequest.Type.get -> Weaviate.Client.Models.ReplicationType -Weaviate.Client.Models.ReplicateRequest.Type.init -> void -Weaviate.Client.Models.ReplicateResource -Weaviate.Client.Models.ReplicateResource.Collection.get -> string? -Weaviate.Client.Models.ReplicateResource.Collection.init -> void -Weaviate.Client.Models.ReplicateResource.Deconstruct(out string? Collection, out string? Shard) -> void -Weaviate.Client.Models.ReplicateResource.ReplicateResource(Weaviate.Client.Models.ReplicateResource! original) -> void -Weaviate.Client.Models.ReplicateResource.ReplicateResource(string? Collection = "*", string? Shard = "*") -> void -Weaviate.Client.Models.ReplicateResource.Shard.get -> string? -Weaviate.Client.Models.ReplicateResource.Shard.init -> void -Weaviate.Client.Models.ReplicationClientConfig -Weaviate.Client.Models.ReplicationClientConfig.PollInterval.get -> System.TimeSpan -Weaviate.Client.Models.ReplicationClientConfig.PollInterval.set -> void -Weaviate.Client.Models.ReplicationClientConfig.ReplicationClientConfig() -> void -Weaviate.Client.Models.ReplicationClientConfig.Timeout.get -> System.TimeSpan -Weaviate.Client.Models.ReplicationClientConfig.Timeout.set -> void -Weaviate.Client.Models.ReplicationConfig -Weaviate.Client.Models.ReplicationConfig.AsyncEnabled.get -> bool -Weaviate.Client.Models.ReplicationConfig.AsyncEnabled.set -> void -Weaviate.Client.Models.ReplicationConfig.DeletionStrategy.get -> Weaviate.Client.Models.DeletionStrategy? -Weaviate.Client.Models.ReplicationConfig.DeletionStrategy.set -> void -Weaviate.Client.Models.ReplicationConfig.Factor.get -> int -Weaviate.Client.Models.ReplicationConfig.Factor.set -> void -Weaviate.Client.Models.ReplicationConfig.ReplicationConfig() -> void -Weaviate.Client.Models.ReplicationConfig.ReplicationConfig(Weaviate.Client.Models.ReplicationConfig! original) -> void -Weaviate.Client.Models.ReplicationConfigUpdate -Weaviate.Client.Models.ReplicationConfigUpdate.AsyncEnabled.get -> bool -Weaviate.Client.Models.ReplicationConfigUpdate.AsyncEnabled.set -> void -Weaviate.Client.Models.ReplicationConfigUpdate.DeletionStrategy.get -> Weaviate.Client.Models.DeletionStrategy? -Weaviate.Client.Models.ReplicationConfigUpdate.DeletionStrategy.set -> void -Weaviate.Client.Models.ReplicationConfigUpdate.Factor.get -> int -Weaviate.Client.Models.ReplicationConfigUpdate.Factor.set -> void -Weaviate.Client.Models.ReplicationConfigUpdate.ReplicationConfigUpdate(Weaviate.Client.Models.ReplicationConfig! WrappedReplicationConfig) -> void -Weaviate.Client.Models.ReplicationOperation -Weaviate.Client.Models.ReplicationOperation.Collection.get -> string! -Weaviate.Client.Models.ReplicationOperation.Collection.init -> void -Weaviate.Client.Models.ReplicationOperation.Deconstruct(out System.Guid Id, out string! Collection, out string! Shard, out string! SourceNode, out string! TargetNode, out Weaviate.Client.Models.ReplicationType Type, out Weaviate.Client.Models.ReplicationOperationStatus! Status, out long? WhenStartedUnixMs, out bool? Uncancelable, out bool? ScheduledForCancel, out bool? ScheduledForDelete, out System.Collections.Generic.IReadOnlyList? StatusHistory) -> void -Weaviate.Client.Models.ReplicationOperation.Id.get -> System.Guid -Weaviate.Client.Models.ReplicationOperation.Id.init -> void -Weaviate.Client.Models.ReplicationOperation.IsCancelled.get -> bool -Weaviate.Client.Models.ReplicationOperation.IsCompleted.get -> bool -Weaviate.Client.Models.ReplicationOperation.IsSuccessful.get -> bool -Weaviate.Client.Models.ReplicationOperation.ReplicationOperation(System.Guid Id, string! Collection, string! Shard, string! SourceNode, string! TargetNode, Weaviate.Client.Models.ReplicationType Type, Weaviate.Client.Models.ReplicationOperationStatus! Status, long? WhenStartedUnixMs, bool? Uncancelable, bool? ScheduledForCancel, bool? ScheduledForDelete, System.Collections.Generic.IReadOnlyList? StatusHistory) -> void -Weaviate.Client.Models.ReplicationOperation.ReplicationOperation(Weaviate.Client.Models.ReplicationOperation! original) -> void -Weaviate.Client.Models.ReplicationOperation.ScheduledForCancel.get -> bool? -Weaviate.Client.Models.ReplicationOperation.ScheduledForCancel.init -> void -Weaviate.Client.Models.ReplicationOperation.ScheduledForDelete.get -> bool? -Weaviate.Client.Models.ReplicationOperation.ScheduledForDelete.init -> void -Weaviate.Client.Models.ReplicationOperation.Shard.get -> string! -Weaviate.Client.Models.ReplicationOperation.Shard.init -> void -Weaviate.Client.Models.ReplicationOperation.SourceNode.get -> string! -Weaviate.Client.Models.ReplicationOperation.SourceNode.init -> void -Weaviate.Client.Models.ReplicationOperation.Status.get -> Weaviate.Client.Models.ReplicationOperationStatus! -Weaviate.Client.Models.ReplicationOperation.Status.init -> void -Weaviate.Client.Models.ReplicationOperation.StatusHistory.get -> System.Collections.Generic.IReadOnlyList? -Weaviate.Client.Models.ReplicationOperation.StatusHistory.init -> void -Weaviate.Client.Models.ReplicationOperation.TargetNode.get -> string! -Weaviate.Client.Models.ReplicationOperation.TargetNode.init -> void -Weaviate.Client.Models.ReplicationOperation.Type.get -> Weaviate.Client.Models.ReplicationType -Weaviate.Client.Models.ReplicationOperation.Type.init -> void -Weaviate.Client.Models.ReplicationOperation.Uncancelable.get -> bool? -Weaviate.Client.Models.ReplicationOperation.Uncancelable.init -> void -Weaviate.Client.Models.ReplicationOperation.WhenStarted.get -> System.DateTimeOffset? -Weaviate.Client.Models.ReplicationOperation.WhenStartedUnixMs.get -> long? -Weaviate.Client.Models.ReplicationOperation.WhenStartedUnixMs.init -> void -Weaviate.Client.Models.ReplicationOperationError -Weaviate.Client.Models.ReplicationOperationError.Deconstruct(out long WhenErroredUnixMs, out string! Message) -> void -Weaviate.Client.Models.ReplicationOperationError.Message.get -> string! -Weaviate.Client.Models.ReplicationOperationError.Message.init -> void -Weaviate.Client.Models.ReplicationOperationError.ReplicationOperationError(Weaviate.Client.Models.ReplicationOperationError! original) -> void -Weaviate.Client.Models.ReplicationOperationError.ReplicationOperationError(long WhenErroredUnixMs, string! Message) -> void -Weaviate.Client.Models.ReplicationOperationError.WhenErrored.get -> System.DateTimeOffset -Weaviate.Client.Models.ReplicationOperationError.WhenErroredUnixMs.get -> long -Weaviate.Client.Models.ReplicationOperationError.WhenErroredUnixMs.init -> void -Weaviate.Client.Models.ReplicationOperationState -Weaviate.Client.Models.ReplicationOperationState.Cancelled = 5 -> Weaviate.Client.Models.ReplicationOperationState -Weaviate.Client.Models.ReplicationOperationState.Dehydrating = 3 -> Weaviate.Client.Models.ReplicationOperationState -Weaviate.Client.Models.ReplicationOperationState.Finalizing = 2 -> Weaviate.Client.Models.ReplicationOperationState -Weaviate.Client.Models.ReplicationOperationState.Hydrating = 1 -> Weaviate.Client.Models.ReplicationOperationState -Weaviate.Client.Models.ReplicationOperationState.Ready = 4 -> Weaviate.Client.Models.ReplicationOperationState -Weaviate.Client.Models.ReplicationOperationState.Registered = 0 -> Weaviate.Client.Models.ReplicationOperationState -Weaviate.Client.Models.ReplicationOperationStatus -Weaviate.Client.Models.ReplicationOperationStatus.Deconstruct(out Weaviate.Client.Models.ReplicationOperationState State, out long? WhenStartedUnixMs, out System.Collections.Generic.IReadOnlyList? Errors) -> void -Weaviate.Client.Models.ReplicationOperationStatus.Errors.get -> System.Collections.Generic.IReadOnlyList? -Weaviate.Client.Models.ReplicationOperationStatus.Errors.init -> void -Weaviate.Client.Models.ReplicationOperationStatus.ReplicationOperationStatus(Weaviate.Client.Models.ReplicationOperationState State, long? WhenStartedUnixMs, System.Collections.Generic.IReadOnlyList? Errors) -> void -Weaviate.Client.Models.ReplicationOperationStatus.ReplicationOperationStatus(Weaviate.Client.Models.ReplicationOperationStatus! original) -> void -Weaviate.Client.Models.ReplicationOperationStatus.State.get -> Weaviate.Client.Models.ReplicationOperationState -Weaviate.Client.Models.ReplicationOperationStatus.State.init -> void -Weaviate.Client.Models.ReplicationOperationStatus.WhenStarted.get -> System.DateTimeOffset? -Weaviate.Client.Models.ReplicationOperationStatus.WhenStartedUnixMs.get -> long? -Weaviate.Client.Models.ReplicationOperationStatus.WhenStartedUnixMs.init -> void -Weaviate.Client.Models.ReplicationOperationTracker -Weaviate.Client.Models.ReplicationOperationTracker.Cancel(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Models.ReplicationOperationTracker.CancelSync(System.TimeSpan? timeout = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Models.ReplicationOperationTracker.Current.get -> Weaviate.Client.Models.ReplicationOperation! -Weaviate.Client.Models.ReplicationOperationTracker.Dispose() -> void -Weaviate.Client.Models.ReplicationOperationTracker.DisposeAsync() -> System.Threading.Tasks.ValueTask -Weaviate.Client.Models.ReplicationOperationTracker.IsCancelled.get -> bool -Weaviate.Client.Models.ReplicationOperationTracker.IsCompleted.get -> bool -Weaviate.Client.Models.ReplicationOperationTracker.IsSuccessful.get -> bool -Weaviate.Client.Models.ReplicationOperationTracker.RefreshStatus(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Models.ReplicationOperationTracker.WaitForCompletion(System.TimeSpan? timeout = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Models.ReplicationType -Weaviate.Client.Models.ReplicationType.Copy = 0 -> Weaviate.Client.Models.ReplicationType -Weaviate.Client.Models.ReplicationType.Move = 1 -> Weaviate.Client.Models.ReplicationType -Weaviate.Client.Models.Rerank -Weaviate.Client.Models.Rerank.Property.get -> string! -Weaviate.Client.Models.Rerank.Property.init -> void -Weaviate.Client.Models.Rerank.Query.get -> string? -Weaviate.Client.Models.Rerank.Query.init -> void -Weaviate.Client.Models.Rerank.Rerank() -> void -Weaviate.Client.Models.Rerank.Rerank(Weaviate.Client.Models.Rerank! original) -> void -Weaviate.Client.Models.Reranker -Weaviate.Client.Models.Reranker.Cohere -Weaviate.Client.Models.Reranker.Cohere.Cohere(Weaviate.Client.Models.Reranker.Cohere! original) -> void -Weaviate.Client.Models.Reranker.Cohere.Model.get -> string? -Weaviate.Client.Models.Reranker.Cohere.Model.set -> void -Weaviate.Client.Models.Reranker.Cohere.Models -Weaviate.Client.Models.Reranker.Cohere.Type.get -> string! -Weaviate.Client.Models.Reranker.ContextualAI -Weaviate.Client.Models.Reranker.ContextualAI.ContextualAI(Weaviate.Client.Models.Reranker.ContextualAI! original) -> void -Weaviate.Client.Models.Reranker.ContextualAI.Instruction.get -> string? -Weaviate.Client.Models.Reranker.ContextualAI.Instruction.set -> void -Weaviate.Client.Models.Reranker.ContextualAI.Model.get -> string? -Weaviate.Client.Models.Reranker.ContextualAI.Model.set -> void -Weaviate.Client.Models.Reranker.ContextualAI.TopN.get -> int? -Weaviate.Client.Models.Reranker.ContextualAI.TopN.set -> void -Weaviate.Client.Models.Reranker.ContextualAI.Type.get -> string! -Weaviate.Client.Models.Reranker.Custom -Weaviate.Client.Models.Reranker.Custom.Config.get -> object! -Weaviate.Client.Models.Reranker.Custom.Config.set -> void -Weaviate.Client.Models.Reranker.Custom.Custom(Weaviate.Client.Models.Reranker.Custom! original) -> void -Weaviate.Client.Models.Reranker.Custom.Type.get -> string! -Weaviate.Client.Models.Reranker.Custom.Type.init -> void -Weaviate.Client.Models.Reranker.JinaAI -Weaviate.Client.Models.Reranker.JinaAI.JinaAI(Weaviate.Client.Models.Reranker.JinaAI! original) -> void -Weaviate.Client.Models.Reranker.JinaAI.Model.get -> string? -Weaviate.Client.Models.Reranker.JinaAI.Model.set -> void -Weaviate.Client.Models.Reranker.JinaAI.Models -Weaviate.Client.Models.Reranker.JinaAI.Type.get -> string! -Weaviate.Client.Models.Reranker.None -Weaviate.Client.Models.Reranker.None.None(Weaviate.Client.Models.Reranker.None! original) -> void -Weaviate.Client.Models.Reranker.None.Type.get -> string! -Weaviate.Client.Models.Reranker.Nvidia -Weaviate.Client.Models.Reranker.Nvidia.BaseURL.get -> string? -Weaviate.Client.Models.Reranker.Nvidia.BaseURL.set -> void -Weaviate.Client.Models.Reranker.Nvidia.Model.get -> string? -Weaviate.Client.Models.Reranker.Nvidia.Model.set -> void -Weaviate.Client.Models.Reranker.Nvidia.Models -Weaviate.Client.Models.Reranker.Nvidia.Nvidia(Weaviate.Client.Models.Reranker.Nvidia! original) -> void -Weaviate.Client.Models.Reranker.Nvidia.Type.get -> string! -Weaviate.Client.Models.Reranker.Transformers -Weaviate.Client.Models.Reranker.Transformers.Transformers(Weaviate.Client.Models.Reranker.Transformers! original) -> void -Weaviate.Client.Models.Reranker.Transformers.Type.get -> string! -Weaviate.Client.Models.Reranker.VoyageAI -Weaviate.Client.Models.Reranker.VoyageAI.Model.get -> string? -Weaviate.Client.Models.Reranker.VoyageAI.Model.set -> void -Weaviate.Client.Models.Reranker.VoyageAI.Models -Weaviate.Client.Models.Reranker.VoyageAI.Type.get -> string! -Weaviate.Client.Models.Reranker.VoyageAI.VoyageAI(Weaviate.Client.Models.Reranker.VoyageAI! original) -> void -Weaviate.Client.Models.RoleInfo -Weaviate.Client.Models.RoleInfo.Deconstruct(out string! Name, out System.Collections.Generic.IEnumerable! Permissions) -> void -Weaviate.Client.Models.RoleInfo.Name.get -> string! -Weaviate.Client.Models.RoleInfo.Name.init -> void -Weaviate.Client.Models.RoleInfo.Permissions.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.RoleInfo.Permissions.init -> void -Weaviate.Client.Models.RoleInfo.RoleInfo(Weaviate.Client.Models.RoleInfo! original) -> void -Weaviate.Client.Models.RoleInfo.RoleInfo(string! Name, System.Collections.Generic.IEnumerable! Permissions) -> void -Weaviate.Client.Models.RolesResource -Weaviate.Client.Models.RolesResource.Deconstruct(out string? Role, out Weaviate.Client.Models.RolesScope? Scope) -> void -Weaviate.Client.Models.RolesResource.Role.get -> string? -Weaviate.Client.Models.RolesResource.Role.init -> void -Weaviate.Client.Models.RolesResource.RolesResource(Weaviate.Client.Models.RolesResource! original) -> void -Weaviate.Client.Models.RolesResource.RolesResource(string? Role = "*", Weaviate.Client.Models.RolesScope? Scope = Weaviate.Client.Models.RolesScope.Match) -> void -Weaviate.Client.Models.RolesResource.Scope.get -> Weaviate.Client.Models.RolesScope? -Weaviate.Client.Models.RolesResource.Scope.init -> void -Weaviate.Client.Models.RolesRestoreOption -Weaviate.Client.Models.RolesRestoreOption.All = 1 -> Weaviate.Client.Models.RolesRestoreOption -Weaviate.Client.Models.RolesRestoreOption.NoRestore = 0 -> Weaviate.Client.Models.RolesRestoreOption -Weaviate.Client.Models.RolesScope -Weaviate.Client.Models.RolesScope.All = 0 -> Weaviate.Client.Models.RolesScope -Weaviate.Client.Models.RolesScope.Match = 1 -> Weaviate.Client.Models.RolesScope -Weaviate.Client.Models.ShardInfo -Weaviate.Client.Models.ShardInfo.Name.get -> string! -Weaviate.Client.Models.ShardInfo.Name.set -> void -Weaviate.Client.Models.ShardInfo.ShardInfo() -> void -Weaviate.Client.Models.ShardInfo.ShardInfo(Weaviate.Client.Models.ShardInfo! original) -> void -Weaviate.Client.Models.ShardInfo.Status.get -> Weaviate.Client.Models.ShardStatus -Weaviate.Client.Models.ShardInfo.Status.set -> void -Weaviate.Client.Models.ShardInfo.VectorQueueSize.get -> int? -Weaviate.Client.Models.ShardInfo.VectorQueueSize.set -> void -Weaviate.Client.Models.ShardStatus -Weaviate.Client.Models.ShardStatus.Indexing = 2 -> Weaviate.Client.Models.ShardStatus -Weaviate.Client.Models.ShardStatus.ReadOnly = 1 -> Weaviate.Client.Models.ShardStatus -Weaviate.Client.Models.ShardStatus.Ready = 0 -> Weaviate.Client.Models.ShardStatus -Weaviate.Client.Models.ShardingConfig -Weaviate.Client.Models.ShardingConfig.ActualCount.get -> int -Weaviate.Client.Models.ShardingConfig.ActualCount.set -> void -Weaviate.Client.Models.ShardingConfig.ActualVirtualCount.get -> int -Weaviate.Client.Models.ShardingConfig.ActualVirtualCount.set -> void -Weaviate.Client.Models.ShardingConfig.DesiredCount.get -> int -Weaviate.Client.Models.ShardingConfig.DesiredCount.set -> void -Weaviate.Client.Models.ShardingConfig.DesiredVirtualCount.get -> int -Weaviate.Client.Models.ShardingConfig.DesiredVirtualCount.set -> void -Weaviate.Client.Models.ShardingConfig.Function.get -> Weaviate.Client.Models.ShardingConfig.Functions -Weaviate.Client.Models.ShardingConfig.Function.set -> void -Weaviate.Client.Models.ShardingConfig.Functions -Weaviate.Client.Models.ShardingConfig.Functions.Murmur3 = 1 -> Weaviate.Client.Models.ShardingConfig.Functions -Weaviate.Client.Models.ShardingConfig.Functions.None = 0 -> Weaviate.Client.Models.ShardingConfig.Functions -Weaviate.Client.Models.ShardingConfig.Key.get -> string! -Weaviate.Client.Models.ShardingConfig.Key.set -> void -Weaviate.Client.Models.ShardingConfig.ShardingConfig() -> void -Weaviate.Client.Models.ShardingConfig.ShardingConfig(Weaviate.Client.Models.ShardingConfig! original) -> void -Weaviate.Client.Models.ShardingConfig.Strategies -Weaviate.Client.Models.ShardingConfig.Strategies.Hash = 1 -> Weaviate.Client.Models.ShardingConfig.Strategies -Weaviate.Client.Models.ShardingConfig.Strategies.None = 0 -> Weaviate.Client.Models.ShardingConfig.Strategies -Weaviate.Client.Models.ShardingConfig.Strategy.get -> Weaviate.Client.Models.ShardingConfig.Strategies -Weaviate.Client.Models.ShardingConfig.Strategy.set -> void -Weaviate.Client.Models.ShardingConfig.VirtualPerPhysical.get -> int -Weaviate.Client.Models.ShardingConfig.VirtualPerPhysical.set -> void -Weaviate.Client.Models.SinglePrompt -Weaviate.Client.Models.SinglePrompt.Deconstruct(out string! Prompt) -> void -Weaviate.Client.Models.SinglePrompt.Prompt.get -> string! -Weaviate.Client.Models.SinglePrompt.Prompt.init -> void -Weaviate.Client.Models.SinglePrompt.SinglePrompt(Weaviate.Client.Models.SinglePrompt! original) -> void -Weaviate.Client.Models.SinglePrompt.SinglePrompt(string! Prompt) -> void -Weaviate.Client.Models.Sort -Weaviate.Client.Models.Sort.Ascending() -> Weaviate.Client.Models.Sort! -Weaviate.Client.Models.Sort.Descending() -> Weaviate.Client.Models.Sort! -Weaviate.Client.Models.Sort.Sort(Weaviate.Client.Models.Sort! original) -> void -Weaviate.Client.Models.SortExtensions -Weaviate.Client.Models.StopwordConfig -Weaviate.Client.Models.StopwordConfig.Additions.get -> System.Collections.Immutable.ImmutableList! -Weaviate.Client.Models.StopwordConfig.Additions.set -> void -Weaviate.Client.Models.StopwordConfig.Preset.get -> Weaviate.Client.Models.StopwordConfig.Presets -Weaviate.Client.Models.StopwordConfig.Preset.set -> void -Weaviate.Client.Models.StopwordConfig.Presets -Weaviate.Client.Models.StopwordConfig.Presets.EN = 1 -> Weaviate.Client.Models.StopwordConfig.Presets -Weaviate.Client.Models.StopwordConfig.Presets.None = 0 -> Weaviate.Client.Models.StopwordConfig.Presets -Weaviate.Client.Models.StopwordConfig.Removals.get -> System.Collections.Immutable.ImmutableList! -Weaviate.Client.Models.StopwordConfig.Removals.set -> void -Weaviate.Client.Models.StopwordConfig.StopwordConfig() -> void -Weaviate.Client.Models.StopwordConfig.StopwordConfig(Weaviate.Client.Models.StopwordConfig! original) -> void -Weaviate.Client.Models.StopwordsConfigUpdate -Weaviate.Client.Models.StopwordsConfigUpdate.Additions.get -> System.Collections.Immutable.ImmutableList! -Weaviate.Client.Models.StopwordsConfigUpdate.Additions.set -> void -Weaviate.Client.Models.StopwordsConfigUpdate.Deconstruct(out Weaviate.Client.Models.StopwordConfig! WrappedStopwords) -> void -Weaviate.Client.Models.StopwordsConfigUpdate.Preset.get -> Weaviate.Client.Models.StopwordConfig.Presets -Weaviate.Client.Models.StopwordsConfigUpdate.Preset.set -> void -Weaviate.Client.Models.StopwordsConfigUpdate.Removals.get -> System.Collections.Immutable.ImmutableList! -Weaviate.Client.Models.StopwordsConfigUpdate.Removals.set -> void -Weaviate.Client.Models.StopwordsConfigUpdate.StopwordsConfigUpdate(Weaviate.Client.Models.StopwordConfig! WrappedStopwords) -> void -Weaviate.Client.Models.StopwordsConfigUpdate.StopwordsConfigUpdate(Weaviate.Client.Models.StopwordsConfigUpdate! original) -> void -Weaviate.Client.Models.StopwordsConfigUpdate.WrappedStopwords.get -> Weaviate.Client.Models.StopwordConfig! -Weaviate.Client.Models.StopwordsConfigUpdate.WrappedStopwords.init -> void -Weaviate.Client.Models.TargetVectors -Weaviate.Client.Models.TargetVectors.Add(string! target) -> void -Weaviate.Client.Models.TargetVectors.AddRange(System.Collections.Generic.IEnumerable! targets) -> void -Weaviate.Client.Models.TargetVectors.GetEnumerator() -> System.Collections.Generic.IEnumerator! -Weaviate.Client.Models.TargetVectors.TargetVectors() -> void -Weaviate.Client.Models.TargetVectors.Targets.get -> System.Collections.Generic.List! -Weaviate.Client.Models.TargetVectors.Weights.get -> System.Collections.Generic.Dictionary!>? -Weaviate.Client.Models.Tenant -Weaviate.Client.Models.Tenant.Name.get -> string! -Weaviate.Client.Models.Tenant.Name.init -> void -Weaviate.Client.Models.Tenant.Status.get -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.Tenant.Status.init -> void -Weaviate.Client.Models.Tenant.Tenant() -> void -Weaviate.Client.Models.Tenant.Tenant(Weaviate.Client.Models.Tenant! original) -> void -Weaviate.Client.Models.Tenant.Tenant(string! name, Weaviate.Client.Models.TenantActivityStatus status) -> void -Weaviate.Client.Models.Tenant.Tenant(string! name, string! status) -> void -Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Active = 1 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Cold = 7 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Freezing = 9 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Frozen = 8 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Hot = 6 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Inactive = 2 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Offloaded = 3 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Offloading = 4 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Onloading = 5 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Unfreezing = 10 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantActivityStatus.Unspecified = 0 -> Weaviate.Client.Models.TenantActivityStatus -Weaviate.Client.Models.TenantsResource -Weaviate.Client.Models.TenantsResource.Collection.get -> string? -Weaviate.Client.Models.TenantsResource.Collection.init -> void -Weaviate.Client.Models.TenantsResource.Deconstruct(out string? Collection, out string? Tenant) -> void -Weaviate.Client.Models.TenantsResource.Tenant.get -> string? -Weaviate.Client.Models.TenantsResource.Tenant.init -> void -Weaviate.Client.Models.TenantsResource.TenantsResource(Weaviate.Client.Models.TenantsResource! original) -> void -Weaviate.Client.Models.TenantsResource.TenantsResource(string? Collection = "*", string? Tenant = "*") -> void -Weaviate.Client.Models.TimeFilter -Weaviate.Client.Models.TimeFilter.TimeFilter(Weaviate.Client.Models.TimeFilter! original) -> void -Weaviate.Client.Models.Typed.GenerativeGroupByObject -Weaviate.Client.Models.Typed.GenerativeGroupByObject.BelongsToGroup.get -> string! -Weaviate.Client.Models.Typed.GenerativeGroupByObject.BelongsToGroup.init -> void -Weaviate.Client.Models.Typed.GenerativeGroupByObject.GenerativeGroupByObject(Weaviate.Client.Models.GenerativeGroupByObject! untyped) -> void -Weaviate.Client.Models.Typed.GenerativeGroupByResult -Weaviate.Client.Models.Typed.GenerativeGroupByResult.Deconstruct(out System.Collections.Generic.IList!>! Objects, out System.Collections.Generic.IDictionary!>! Groups, out Weaviate.Client.Models.GenerativeResult! Generative) -> void -Weaviate.Client.Models.Typed.GenerativeGroupByResult.Generative.get -> Weaviate.Client.Models.GenerativeResult! -Weaviate.Client.Models.Typed.GenerativeGroupByResult.Generative.init -> void -Weaviate.Client.Models.Typed.GenerativeGroupByResult.GenerativeGroupByResult(System.Collections.Generic.IList!>! Objects, System.Collections.Generic.IDictionary!>! Groups, Weaviate.Client.Models.GenerativeResult! Generative) -> void -Weaviate.Client.Models.Typed.GenerativeWeaviateGroup -Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.Generative.get -> Weaviate.Client.Models.GenerativeResult? -Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.Generative.set -> void -Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.GenerativeWeaviateGroup() -> void -Weaviate.Client.Models.Typed.GenerativeWeaviateObject -Weaviate.Client.Models.Typed.GenerativeWeaviateObject.Generative.get -> Weaviate.Client.Models.GenerativeResult? -Weaviate.Client.Models.Typed.GenerativeWeaviateObject.Generative.set -> void -Weaviate.Client.Models.Typed.GenerativeWeaviateObject.GenerativeWeaviateObject(Weaviate.Client.Models.GenerativeWeaviateObject! untyped) -> void -Weaviate.Client.Models.Typed.GenerativeWeaviateResult -Weaviate.Client.Models.Typed.GenerativeWeaviateResult.Generative.get -> Weaviate.Client.Models.GenerativeResult! -Weaviate.Client.Models.Typed.GenerativeWeaviateResult.Generative.init -> void -Weaviate.Client.Models.Typed.GenerativeWeaviateResult.GenerativeWeaviateResult() -> void -Weaviate.Client.Models.Typed.GroupByObject -Weaviate.Client.Models.Typed.GroupByObject.BelongsToGroup.get -> string! -Weaviate.Client.Models.Typed.GroupByObject.BelongsToGroup.init -> void -Weaviate.Client.Models.Typed.GroupByObject.GroupByObject(Weaviate.Client.Models.WeaviateObject! untyped) -> void -Weaviate.Client.Models.Typed.GroupByResult -Weaviate.Client.Models.Typed.GroupByResult.Deconstruct(out System.Collections.Generic.IList!>! Objects, out System.Collections.Generic.IDictionary!>! Groups) -> void -Weaviate.Client.Models.Typed.GroupByResult.GroupByResult(System.Collections.Generic.IList!>! Objects, System.Collections.Generic.IDictionary!>! Groups) -> void -Weaviate.Client.Models.Typed.TypedResultConverter -Weaviate.Client.Models.Typed.WeaviateGroup -Weaviate.Client.Models.Typed.WeaviateGroup.MaxDistance.get -> float -Weaviate.Client.Models.Typed.WeaviateGroup.MaxDistance.init -> void -Weaviate.Client.Models.Typed.WeaviateGroup.MinDistance.get -> float -Weaviate.Client.Models.Typed.WeaviateGroup.MinDistance.init -> void -Weaviate.Client.Models.Typed.WeaviateGroup.Name.get -> string! -Weaviate.Client.Models.Typed.WeaviateGroup.Name.init -> void -Weaviate.Client.Models.Typed.WeaviateGroup.NumberOfObjects.get -> int -Weaviate.Client.Models.Typed.WeaviateGroup.Objects.get -> System.Collections.Generic.IList! -Weaviate.Client.Models.Typed.WeaviateGroup.Objects.init -> void -Weaviate.Client.Models.Typed.WeaviateGroup.WeaviateGroup() -> void -Weaviate.Client.Models.Typed.WeaviateGroup -Weaviate.Client.Models.Typed.WeaviateGroup.WeaviateGroup() -> void -Weaviate.Client.Models.Typed.WeaviateObject -Weaviate.Client.Models.Typed.WeaviateObject.Collection.get -> string? -Weaviate.Client.Models.Typed.WeaviateObject.Metadata.get -> Weaviate.Client.Models.Metadata! -Weaviate.Client.Models.Typed.WeaviateObject.Object.get -> T! -Weaviate.Client.Models.Typed.WeaviateObject.Properties.get -> System.Collections.Generic.IDictionary! -Weaviate.Client.Models.Typed.WeaviateObject.References.get -> System.Collections.Generic.IDictionary!>! -Weaviate.Client.Models.Typed.WeaviateObject.Tenant.get -> string? -Weaviate.Client.Models.Typed.WeaviateObject.ToUntyped() -> Weaviate.Client.Models.WeaviateObject! -Weaviate.Client.Models.Typed.WeaviateObject.UUID.get -> System.Guid? -Weaviate.Client.Models.Typed.WeaviateObject.Vectors.get -> Weaviate.Client.Models.Vectors! -Weaviate.Client.Models.Typed.WeaviateObject.WeaviateObject(Weaviate.Client.Models.WeaviateObject! untyped) -> void -Weaviate.Client.Models.TypedBase -Weaviate.Client.Models.TypedBase.Internal.get -> Weaviate.Client.Models.PropertyFilter! -Weaviate.Client.Models.TypedBase.InternalContainsAll(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedBase.InternalContainsAny(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedBase.InternalContainsNone(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedBase.InternalEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedBase.InternalGreaterThan(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedBase.InternalGreaterThanEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedBase.InternalLessThan(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedBase.InternalLessThanEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedBase.InternalNotEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedBase.TypedBase(Weaviate.Client.Models.PropertyFilter! parent) -> void -Weaviate.Client.Models.TypedBase.TypedBase(Weaviate.Client.Models.TypedBase! original) -> void -Weaviate.Client.Models.TypedGuid -Weaviate.Client.Models.TypedGuid.ContainsAny(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedGuid.ContainsNone(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedGuid.Deconstruct(out Weaviate.Client.Models.PropertyFilter! Parent) -> void -Weaviate.Client.Models.TypedGuid.IsEqual(System.Guid value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedGuid.IsNotEqual(System.Guid value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedGuid.Parent.get -> Weaviate.Client.Models.PropertyFilter! -Weaviate.Client.Models.TypedGuid.Parent.init -> void -Weaviate.Client.Models.TypedGuid.TypedGuid(Weaviate.Client.Models.PropertyFilter! Parent) -> void -Weaviate.Client.Models.TypedGuid.TypedGuid(Weaviate.Client.Models.TypedGuid! original) -> void -Weaviate.Client.Models.TypedValue -Weaviate.Client.Models.TypedValue.ContainsAll(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedValue.ContainsAny(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedValue.ContainsNone(System.Collections.Generic.IEnumerable! value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedValue.IsEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedValue.IsGreaterThan(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedValue.IsGreaterThanEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedValue.IsLessThan(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedValue.IsLessThanEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedValue.IsNotEqual(T value) -> Weaviate.Client.Models.Filter! -Weaviate.Client.Models.TypedValue.TypedValue(Weaviate.Client.Models.TypedValue! original) -> void -Weaviate.Client.Models.User -Weaviate.Client.Models.User.Metadata.get -> Weaviate.Client.Models.UserMetadata! -Weaviate.Client.Models.User.User(Weaviate.Client.WeaviateClient! client, Weaviate.Client.Models.UserMetadata! metadata) -> void -Weaviate.Client.Models.UserMetadata -Weaviate.Client.Models.UserMetadata.Deconstruct(out System.Guid id) -> void -Weaviate.Client.Models.UserMetadata.ID.get -> System.Guid -Weaviate.Client.Models.UserMetadata.UserMetadata(System.Guid id) -> void -Weaviate.Client.Models.UserMetadata.UserMetadata(Weaviate.Client.Models.UserMetadata! original) -> void -Weaviate.Client.Models.UserMetadata.id.get -> System.Guid -Weaviate.Client.Models.UserMetadata.id.init -> void -Weaviate.Client.Models.UserRestoreOption -Weaviate.Client.Models.UserRestoreOption.All = 1 -> Weaviate.Client.Models.UserRestoreOption -Weaviate.Client.Models.UserRestoreOption.NoRestore = 0 -> Weaviate.Client.Models.UserRestoreOption -Weaviate.Client.Models.UserRoleAssignment -Weaviate.Client.Models.UserRoleAssignment.Deconstruct(out string! UserId, out Weaviate.Client.Models.RbacUserType UserType) -> void -Weaviate.Client.Models.UserRoleAssignment.UserId.get -> string! -Weaviate.Client.Models.UserRoleAssignment.UserId.init -> void -Weaviate.Client.Models.UserRoleAssignment.UserRoleAssignment(Weaviate.Client.Models.UserRoleAssignment! original) -> void -Weaviate.Client.Models.UserRoleAssignment.UserRoleAssignment(string! UserId, Weaviate.Client.Models.RbacUserType UserType) -> void -Weaviate.Client.Models.UserRoleAssignment.UserType.get -> Weaviate.Client.Models.RbacUserType -Weaviate.Client.Models.UserRoleAssignment.UserType.init -> void -Weaviate.Client.Models.UsersResource -Weaviate.Client.Models.UsersResource.Deconstruct(out string? Users) -> void -Weaviate.Client.Models.UsersResource.Users.get -> string? -Weaviate.Client.Models.UsersResource.Users.init -> void -Weaviate.Client.Models.UsersResource.UsersResource(Weaviate.Client.Models.UsersResource! original) -> void -Weaviate.Client.Models.UsersResource.UsersResource(string? Users = "*") -> void -Weaviate.Client.Models.Vector -Weaviate.Client.Models.Vector.GetEnumerator() -> System.Collections.IEnumerator! -Weaviate.Client.Models.Vector.IsMultiVector.get -> bool -Weaviate.Client.Models.Vector.Name.get -> string! -Weaviate.Client.Models.Vector.Name.init -> void -Weaviate.Client.Models.Vector.Vector() -> void -Weaviate.Client.Models.Vector.Vector(Weaviate.Client.Models.Vector! original) -> void -Weaviate.Client.Models.Vector.this[System.Index index].get -> object! -Weaviate.Client.Models.VectorConfig -Weaviate.Client.Models.VectorConfig.Name.get -> string! -Weaviate.Client.Models.VectorConfig.VectorConfig(Weaviate.Client.Models.VectorConfig! original) -> void -Weaviate.Client.Models.VectorConfig.VectorConfig(string! name, Weaviate.Client.Models.VectorizerConfig? vectorizer = null, Weaviate.Client.Models.VectorIndexConfig? vectorIndexConfig = null) -> void -Weaviate.Client.Models.VectorConfig.VectorIndexConfig.get -> Weaviate.Client.Models.VectorIndexConfig? -Weaviate.Client.Models.VectorConfig.VectorIndexType.get -> string? -Weaviate.Client.Models.VectorConfig.Vectorizer.get -> Weaviate.Client.Models.VectorizerConfig? -Weaviate.Client.Models.VectorConfigList -Weaviate.Client.Models.VectorConfigList.Add(params Weaviate.Client.Models.VectorConfig![]! vectorConfigs) -> void -Weaviate.Client.Models.VectorConfigList.ContainsKey(string! key) -> bool -Weaviate.Client.Models.VectorConfigList.Count.get -> int -Weaviate.Client.Models.VectorConfigList.GetEnumerator() -> System.Collections.Generic.IEnumerator! -Weaviate.Client.Models.VectorConfigList.Keys.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.VectorConfigList.TryGetValue(string! key, out Weaviate.Client.Models.VectorConfig? value) -> bool -Weaviate.Client.Models.VectorConfigList.Values.get -> System.Collections.Generic.IEnumerable! -Weaviate.Client.Models.VectorConfigList.VectorConfigList(Weaviate.Client.Models.VectorConfigList! original) -> void -Weaviate.Client.Models.VectorConfigList.VectorConfigList(params Weaviate.Client.Models.VectorConfig![]! vectorConfigs) -> void -Weaviate.Client.Models.VectorConfigList.this[string! key].get -> Weaviate.Client.Models.VectorConfig! -Weaviate.Client.Models.VectorConfigUpdate -Weaviate.Client.Models.VectorConfigUpdate.Name.get -> string! -Weaviate.Client.Models.VectorConfigUpdate.Name.set -> void -Weaviate.Client.Models.VectorConfigUpdate.VectorConfigUpdate(Weaviate.Client.Models.CollectionConfig! WrappedCollection, Weaviate.Client.Models.VectorConfig! WrappedVectorConfig) -> void -Weaviate.Client.Models.VectorConfigUpdate.VectorIndexConfig.get -> Weaviate.Client.Models.VectorIndexConfigUpdate! -Weaviate.Client.Models.VectorIndex -Weaviate.Client.Models.VectorIndex.Dynamic -Weaviate.Client.Models.VectorIndex.Dynamic.Distance.get -> Weaviate.Client.Models.VectorIndexConfig.VectorDistance? -Weaviate.Client.Models.VectorIndex.Dynamic.Distance.set -> void -Weaviate.Client.Models.VectorIndex.Dynamic.Dynamic() -> void -Weaviate.Client.Models.VectorIndex.Dynamic.Equals(Weaviate.Client.Models.VectorIndex.Dynamic? other) -> bool -Weaviate.Client.Models.VectorIndex.Dynamic.Flat.get -> Weaviate.Client.Models.VectorIndex.Flat? -Weaviate.Client.Models.VectorIndex.Dynamic.Flat.set -> void -Weaviate.Client.Models.VectorIndex.Dynamic.Hnsw.get -> Weaviate.Client.Models.VectorIndex.HNSW? -Weaviate.Client.Models.VectorIndex.Dynamic.Hnsw.set -> void -Weaviate.Client.Models.VectorIndex.Dynamic.Threshold.get -> int? -Weaviate.Client.Models.VectorIndex.Dynamic.Threshold.set -> void -Weaviate.Client.Models.VectorIndex.Flat -Weaviate.Client.Models.VectorIndex.Flat.Distance.get -> Weaviate.Client.Models.VectorIndexConfig.VectorDistance? -Weaviate.Client.Models.VectorIndex.Flat.Distance.set -> void -Weaviate.Client.Models.VectorIndex.Flat.Equals(Weaviate.Client.Models.VectorIndex.Flat? other) -> bool -Weaviate.Client.Models.VectorIndex.Flat.Flat() -> void -Weaviate.Client.Models.VectorIndex.Flat.Quantizer.get -> Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat? -Weaviate.Client.Models.VectorIndex.Flat.Quantizer.set -> void -Weaviate.Client.Models.VectorIndex.Flat.VectorCacheMaxObjects.get -> long? -Weaviate.Client.Models.VectorIndex.Flat.VectorCacheMaxObjects.set -> void -Weaviate.Client.Models.VectorIndex.HNSW -Weaviate.Client.Models.VectorIndex.HNSW.CleanupIntervalSeconds.get -> int? -Weaviate.Client.Models.VectorIndex.HNSW.CleanupIntervalSeconds.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.Distance.get -> Weaviate.Client.Models.VectorIndexConfig.VectorDistance? -Weaviate.Client.Models.VectorIndex.HNSW.Distance.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.DynamicEfFactor.get -> int? -Weaviate.Client.Models.VectorIndex.HNSW.DynamicEfFactor.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.DynamicEfMax.get -> int? -Weaviate.Client.Models.VectorIndex.HNSW.DynamicEfMax.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.DynamicEfMin.get -> int? -Weaviate.Client.Models.VectorIndex.HNSW.DynamicEfMin.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.Ef.get -> int? -Weaviate.Client.Models.VectorIndex.HNSW.Ef.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.EfConstruction.get -> int? -Weaviate.Client.Models.VectorIndex.HNSW.EfConstruction.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.Equals(Weaviate.Client.Models.VectorIndex.HNSW? other) -> bool -Weaviate.Client.Models.VectorIndex.HNSW.FilterStrategy.get -> Weaviate.Client.Models.VectorIndexConfig.VectorIndexFilterStrategy? -Weaviate.Client.Models.VectorIndex.HNSW.FilterStrategy.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.FlatSearchCutoff.get -> int? -Weaviate.Client.Models.VectorIndex.HNSW.FlatSearchCutoff.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.HNSW() -> void -Weaviate.Client.Models.VectorIndex.HNSW.MaxConnections.get -> int? -Weaviate.Client.Models.VectorIndex.HNSW.MaxConnections.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.MultiVector.get -> Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig? -Weaviate.Client.Models.VectorIndex.HNSW.MultiVector.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.Quantizer.get -> Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? -Weaviate.Client.Models.VectorIndex.HNSW.Quantizer.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.Skip.get -> bool? -Weaviate.Client.Models.VectorIndex.HNSW.Skip.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.SkipDefaultQuantization.get -> bool? -Weaviate.Client.Models.VectorIndex.HNSW.SkipDefaultQuantization.set -> void -Weaviate.Client.Models.VectorIndex.HNSW.VectorCacheMaxObjects.get -> long? -Weaviate.Client.Models.VectorIndex.HNSW.VectorCacheMaxObjects.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers -Weaviate.Client.Models.VectorIndex.Quantizers.BQ -Weaviate.Client.Models.VectorIndex.Quantizers.BQ.BQ() -> void -Weaviate.Client.Models.VectorIndex.Quantizers.BQ.BQ(Weaviate.Client.Models.VectorIndex.Quantizers.BQ! original) -> void -Weaviate.Client.Models.VectorIndex.Quantizers.BQ.Cache.get -> bool -Weaviate.Client.Models.VectorIndex.Quantizers.BQ.Cache.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.BQ.RescoreLimit.get -> int -Weaviate.Client.Models.VectorIndex.Quantizers.BQ.RescoreLimit.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.DistributionType -Weaviate.Client.Models.VectorIndex.Quantizers.DistributionType.LogNormal = 0 -> Weaviate.Client.Models.VectorIndex.Quantizers.DistributionType -Weaviate.Client.Models.VectorIndex.Quantizers.DistributionType.Normal = 1 -> Weaviate.Client.Models.VectorIndex.Quantizers.DistributionType -Weaviate.Client.Models.VectorIndex.Quantizers.EncoderType -Weaviate.Client.Models.VectorIndex.Quantizers.EncoderType.Kmeans = 0 -> Weaviate.Client.Models.VectorIndex.Quantizers.EncoderType -Weaviate.Client.Models.VectorIndex.Quantizers.EncoderType.Tile = 1 -> Weaviate.Client.Models.VectorIndex.Quantizers.EncoderType -Weaviate.Client.Models.VectorIndex.Quantizers.None -Weaviate.Client.Models.VectorIndex.Quantizers.None.None() -> void -Weaviate.Client.Models.VectorIndex.Quantizers.None.None(Weaviate.Client.Models.VectorIndex.Quantizers.None! original) -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.BitCompression.get -> bool -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.BitCompression.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Centroids.get -> int -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Centroids.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Encoder.get -> Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig? -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Encoder.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.Distribution.get -> Weaviate.Client.Models.VectorIndex.Quantizers.DistributionType -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.Distribution.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.EncoderConfig() -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.EncoderConfig(Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig! original) -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.Type.get -> Weaviate.Client.Models.VectorIndex.Quantizers.EncoderType -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.Type.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.PQ() -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.PQ(Weaviate.Client.Models.VectorIndex.Quantizers.PQ! original) -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Segments.get -> int -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Segments.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.TrainingLimit.get -> int -Weaviate.Client.Models.VectorIndex.Quantizers.PQ.TrainingLimit.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.RQ -Weaviate.Client.Models.VectorIndex.Quantizers.RQ.Bits.get -> int? -Weaviate.Client.Models.VectorIndex.Quantizers.RQ.Bits.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.RQ.Cache.get -> bool -Weaviate.Client.Models.VectorIndex.Quantizers.RQ.Cache.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.RQ.RQ() -> void -Weaviate.Client.Models.VectorIndex.Quantizers.RQ.RQ(Weaviate.Client.Models.VectorIndex.Quantizers.RQ! original) -> void -Weaviate.Client.Models.VectorIndex.Quantizers.RQ.RescoreLimit.get -> int -Weaviate.Client.Models.VectorIndex.Quantizers.RQ.RescoreLimit.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.SQ -Weaviate.Client.Models.VectorIndex.Quantizers.SQ.RescoreLimit.get -> int -Weaviate.Client.Models.VectorIndex.Quantizers.SQ.RescoreLimit.set -> void -Weaviate.Client.Models.VectorIndex.Quantizers.SQ.SQ() -> void -Weaviate.Client.Models.VectorIndex.Quantizers.SQ.SQ(Weaviate.Client.Models.VectorIndex.Quantizers.SQ! original) -> void -Weaviate.Client.Models.VectorIndex.Quantizers.SQ.TrainingLimit.get -> int -Weaviate.Client.Models.VectorIndex.Quantizers.SQ.TrainingLimit.set -> void -Weaviate.Client.Models.VectorIndexConfig -Weaviate.Client.Models.VectorIndexConfig.EncodingConfig -Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.EncodingConfig() -> void -Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.EncodingConfig(Weaviate.Client.Models.VectorIndexConfig.EncodingConfig! original) -> void -Weaviate.Client.Models.VectorIndexConfig.MultiVectorAggregation -Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig -Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.Aggregation.get -> string? -Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.Aggregation.set -> void -Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.Encoding.get -> Weaviate.Client.Models.VectorIndexConfig.EncodingConfig? -Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.Encoding.set -> void -Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.MultiVectorConfig() -> void -Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.MultiVectorConfig(Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig! original) -> void -Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding -Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.DProjections.get -> double? -Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.DProjections.init -> void -Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.KSim.get -> double? -Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.KSim.init -> void -Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.MuveraEncoding() -> void -Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.MuveraEncoding(Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding! original) -> void -Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.Repetitions.get -> double? -Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.Repetitions.init -> void -Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase -Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.Enabled.get -> bool -Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.Enabled.init -> void -Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.QuantizerConfigBase() -> void -Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.QuantizerConfigBase(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase! original) -> void -Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat -Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.QuantizerConfigFlat() -> void -Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.QuantizerConfigFlat(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat! original) -> void -Weaviate.Client.Models.VectorIndexConfig.VectorDistance -Weaviate.Client.Models.VectorIndexConfig.VectorDistance.Cosine = 0 -> Weaviate.Client.Models.VectorIndexConfig.VectorDistance -Weaviate.Client.Models.VectorIndexConfig.VectorDistance.Dot = 1 -> Weaviate.Client.Models.VectorIndexConfig.VectorDistance -Weaviate.Client.Models.VectorIndexConfig.VectorDistance.Hamming = 3 -> Weaviate.Client.Models.VectorIndexConfig.VectorDistance -Weaviate.Client.Models.VectorIndexConfig.VectorDistance.L2Squared = 2 -> Weaviate.Client.Models.VectorIndexConfig.VectorDistance -Weaviate.Client.Models.VectorIndexConfig.VectorIndexConfig() -> void -Weaviate.Client.Models.VectorIndexConfig.VectorIndexConfig(Weaviate.Client.Models.VectorIndexConfig! original) -> void -Weaviate.Client.Models.VectorIndexConfig.VectorIndexFilterStrategy -Weaviate.Client.Models.VectorIndexConfig.VectorIndexFilterStrategy.Acorn = 1 -> Weaviate.Client.Models.VectorIndexConfig.VectorIndexFilterStrategy -Weaviate.Client.Models.VectorIndexConfig.VectorIndexFilterStrategy.Sweeping = 0 -> Weaviate.Client.Models.VectorIndexConfig.VectorIndexFilterStrategy -Weaviate.Client.Models.VectorIndexConfigUpdate -Weaviate.Client.Models.VectorIndexConfigUpdate.UpdateDynamic(System.Action! c) -> void -Weaviate.Client.Models.VectorIndexConfigUpdate.UpdateFlat(System.Action! c) -> void -Weaviate.Client.Models.VectorIndexConfigUpdate.UpdateHNSW(System.Action! c) -> void -Weaviate.Client.Models.VectorIndexConfigUpdate.VectorIndexConfigUpdate(Weaviate.Client.Models.VectorIndexConfig? WrappedVectorIndexConfig) -> void -Weaviate.Client.Models.VectorIndexConfigUpdateDynamic -Weaviate.Client.Models.VectorIndexConfigUpdateDynamic.Distance.get -> Weaviate.Client.Models.VectorIndexConfig.VectorDistance? -Weaviate.Client.Models.VectorIndexConfigUpdateDynamic.Distance.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateDynamic.Flat.get -> Weaviate.Client.Models.VectorIndexConfigUpdateFlat? -Weaviate.Client.Models.VectorIndexConfigUpdateDynamic.Hnsw.get -> Weaviate.Client.Models.VectorIndexConfigUpdateHNSW? -Weaviate.Client.Models.VectorIndexConfigUpdateDynamic.Threshold.get -> int? -Weaviate.Client.Models.VectorIndexConfigUpdateDynamic.Threshold.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateDynamic.VectorIndexConfigUpdateDynamic(Weaviate.Client.Models.VectorIndex.Dynamic! WrappedDynamic) -> void -Weaviate.Client.Models.VectorIndexConfigUpdateFlat -Weaviate.Client.Models.VectorIndexConfigUpdateFlat.Quantizer.get -> Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat? -Weaviate.Client.Models.VectorIndexConfigUpdateFlat.Quantizer.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateFlat.VectorCacheMaxObjects.get -> long? -Weaviate.Client.Models.VectorIndexConfigUpdateFlat.VectorCacheMaxObjects.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateFlat.VectorIndexConfigUpdateFlat(Weaviate.Client.Models.VectorIndex.Flat! WrappedFlat) -> void -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.DynamicEfFactor.get -> int? -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.DynamicEfFactor.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.DynamicEfMax.get -> int? -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.DynamicEfMax.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.DynamicEfMin.get -> int? -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.DynamicEfMin.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.Ef.get -> int? -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.Ef.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.FilterStrategy.get -> Weaviate.Client.Models.VectorIndexConfig.VectorIndexFilterStrategy? -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.FilterStrategy.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.FlatSearchCutoff.get -> int? -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.FlatSearchCutoff.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.Quantizer.get -> Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.Quantizer.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.VectorCacheMaxObjects.get -> long? -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.VectorCacheMaxObjects.set -> void -Weaviate.Client.Models.VectorIndexConfigUpdateHNSW.VectorIndexConfigUpdateHNSW(Weaviate.Client.Models.VectorIndex.HNSW! WrappedHNSW) -> void -Weaviate.Client.Models.VectorIndexingStatus -Weaviate.Client.Models.VectorIndexingStatus.Indexing = 1 -> Weaviate.Client.Models.VectorIndexingStatus -Weaviate.Client.Models.VectorIndexingStatus.ReadOnly = 0 -> Weaviate.Client.Models.VectorIndexingStatus -Weaviate.Client.Models.VectorIndexingStatus.Ready = 2 -> Weaviate.Client.Models.VectorIndexingStatus -Weaviate.Client.Models.VectorMulti -Weaviate.Client.Models.VectorMulti.Equals(Weaviate.Client.Models.VectorMulti? other) -> bool -Weaviate.Client.Models.VectorMulti.GetEnumerator() -> System.Collections.Generic.IEnumerator! -Weaviate.Client.Models.VectorMulti.Values.get -> T[,]! -Weaviate.Client.Models.VectorMulti.VectorMulti(T[,]! values) -> void -Weaviate.Client.Models.VectorMulti.this[int dimension, int index].get -> T -Weaviate.Client.Models.VectorMulti.this[int dimension].get -> T[]! -Weaviate.Client.Models.VectorQuery -Weaviate.Client.Models.VectorQuery.Add(string! vector) -> void -Weaviate.Client.Models.VectorQuery.GetEnumerator() -> System.Collections.Generic.IEnumerator! -Weaviate.Client.Models.VectorQuery.VectorQuery() -> void -Weaviate.Client.Models.VectorQuery.VectorQuery(System.Collections.Generic.IEnumerable? vectors) -> void -Weaviate.Client.Models.VectorQuery.Vectors.get -> string![]? -Weaviate.Client.Models.VectorSingle -Weaviate.Client.Models.VectorSingle.Equals(Weaviate.Client.Models.VectorSingle? other) -> bool -Weaviate.Client.Models.VectorSingle.GetEnumerator() -> System.Collections.Generic.IEnumerator! -Weaviate.Client.Models.VectorSingle.Values.get -> T[]! -Weaviate.Client.Models.VectorSingle.Values.init -> void -Weaviate.Client.Models.VectorSingle.VectorSingle(params T[]! values) -> void -Weaviate.Client.Models.VectorType -Weaviate.Client.Models.VectorType.Both = Weaviate.Client.Models.VectorType.Vector | Weaviate.Client.Models.VectorType.MultiVector -> Weaviate.Client.Models.VectorType -Weaviate.Client.Models.VectorType.MultiVector = 2 -> Weaviate.Client.Models.VectorType -Weaviate.Client.Models.VectorType.Vector = 1 -> Weaviate.Client.Models.VectorType -Weaviate.Client.Models.VectorizerConfig -Weaviate.Client.Models.VectorizerConfig.Identifier.get -> string! -Weaviate.Client.Models.VectorizerConfig.SourceProperties.get -> System.Collections.Generic.ICollection? -Weaviate.Client.Models.VectorizerConfig.SourceProperties.set -> void -Weaviate.Client.Models.VectorizerConfig.VectorizerConfig() -> void -Weaviate.Client.Models.VectorizerConfig.VectorizerConfig(Weaviate.Client.Models.VectorizerConfig! original) -> void -Weaviate.Client.Models.VectorizerConfig._sourceProperties -> System.Collections.Generic.HashSet! -Weaviate.Client.Models.Vectors -Weaviate.Client.Models.Vectors.Add(Weaviate.Client.Models.Vector! vector) -> void -Weaviate.Client.Models.Vectors.Add(T[,]! value) -> void -Weaviate.Client.Models.Vectors.Add(T[]! value) -> void -Weaviate.Client.Models.Vectors.Add(string! name, T[,]! values) -> void -Weaviate.Client.Models.Vectors.Add(string! name, params T[]! values) -> void -Weaviate.Client.Models.Vectors.Vectors() -> void -Weaviate.Client.Models.WeaviateGroup -Weaviate.Client.Models.WeaviateGroup.WeaviateGroup() -> void -Weaviate.Client.Models.WeaviateGroup.WeaviateGroup(Weaviate.Client.Models.WeaviateGroup! original) -> void -Weaviate.Client.Models.WeaviateGroup -Weaviate.Client.Models.WeaviateGroup.MaxDistance.get -> float -Weaviate.Client.Models.WeaviateGroup.MaxDistance.init -> void -Weaviate.Client.Models.WeaviateGroup.MinDistance.get -> float -Weaviate.Client.Models.WeaviateGroup.MinDistance.init -> void -Weaviate.Client.Models.WeaviateGroup.Name.get -> string! -Weaviate.Client.Models.WeaviateGroup.Name.init -> void -Weaviate.Client.Models.WeaviateGroup.NumberOfObjects.get -> int -Weaviate.Client.Models.WeaviateGroup.Objects.get -> System.Collections.Generic.IList! -Weaviate.Client.Models.WeaviateGroup.Objects.init -> void -Weaviate.Client.Models.WeaviateGroup.WeaviateGroup() -> void -Weaviate.Client.Models.WeaviateGroup.WeaviateGroup(Weaviate.Client.Models.WeaviateGroup! original) -> void -Weaviate.Client.Models.WeaviateObject -Weaviate.Client.Models.WeaviateObject.Collection.get -> string? -Weaviate.Client.Models.WeaviateObject.Collection.init -> void -Weaviate.Client.Models.WeaviateObject.Metadata.get -> Weaviate.Client.Models.Metadata! -Weaviate.Client.Models.WeaviateObject.Metadata.set -> void -Weaviate.Client.Models.WeaviateObject.Properties.get -> System.Collections.Generic.IDictionary! -Weaviate.Client.Models.WeaviateObject.Properties.set -> void -Weaviate.Client.Models.WeaviateObject.References.get -> System.Collections.Generic.IDictionary!>! -Weaviate.Client.Models.WeaviateObject.References.set -> void -Weaviate.Client.Models.WeaviateObject.Tenant.get -> string? -Weaviate.Client.Models.WeaviateObject.Tenant.set -> void -Weaviate.Client.Models.WeaviateObject.UUID.get -> System.Guid? -Weaviate.Client.Models.WeaviateObject.UUID.set -> void -Weaviate.Client.Models.WeaviateObject.Vectors.get -> Weaviate.Client.Models.Vectors! -Weaviate.Client.Models.WeaviateObject.Vectors.set -> void -Weaviate.Client.Models.WeaviateObject.WeaviateObject() -> void -Weaviate.Client.Models.WeaviateObject.WeaviateObject(Weaviate.Client.Models.WeaviateObject! original) -> void -Weaviate.Client.Models.WeaviateObjectExtensions -Weaviate.Client.Models.WeaviateResult -Weaviate.Client.Models.WeaviateResult.WeaviateResult() -> void -Weaviate.Client.Models.WeaviateResult.WeaviateResult(Weaviate.Client.Models.WeaviateResult! original) -> void -Weaviate.Client.Models.WeaviateResult -Weaviate.Client.Models.WeaviateResult.GetEnumerator() -> System.Collections.Generic.IEnumerator! -Weaviate.Client.Models.WeaviateResult.Objects.get -> System.Collections.Generic.IList! -Weaviate.Client.Models.WeaviateResult.Objects.init -> void -Weaviate.Client.Models.WeaviateResult.WeaviateResult() -> void -Weaviate.Client.Models.WeaviateResult.WeaviateResult(Weaviate.Client.Models.WeaviateResult! original) -> void -Weaviate.Client.Models.WeightedField -Weaviate.Client.Models.WeightedField.Deconstruct(out string! Name, out double Weight) -> void -Weaviate.Client.Models.WeightedField.Name.get -> string! -Weaviate.Client.Models.WeightedField.Name.init -> void -Weaviate.Client.Models.WeightedField.Weight.get -> double -Weaviate.Client.Models.WeightedField.Weight.init -> void -Weaviate.Client.Models.WeightedField.WeightedField(Weaviate.Client.Models.WeightedField! original) -> void -Weaviate.Client.Models.WeightedField.WeightedField(string! Name, double Weight) -> void -Weaviate.Client.Models.WeightedFields -Weaviate.Client.Models.WeightedFields.FieldNames.get -> string![]! -Weaviate.Client.Models.WeightedFields.WeightedFields() -> void -Weaviate.Client.Models.WeightedFields.WeightedFields(System.Collections.Generic.IEnumerable! fields) -> void -Weaviate.Client.Models.WeightedFields.WeightedFields(params Weaviate.Client.Models.WeightedField![]! fields) -> void -Weaviate.Client.Models.WeightedFields.Weights.get -> double[]! -Weaviate.Client.NodesClient -Weaviate.Client.NodesClient.List(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.NodesClient.ListVerbose(string? collection = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.OAuthConfig -Weaviate.Client.OAuthConfig.ClientId.get -> string! -Weaviate.Client.OAuthConfig.ClientId.init -> void -Weaviate.Client.OAuthConfig.ClientSecret.get -> string? -Weaviate.Client.OAuthConfig.ClientSecret.init -> void -Weaviate.Client.OAuthConfig.GrantType.get -> string! -Weaviate.Client.OAuthConfig.GrantType.init -> void -Weaviate.Client.OAuthConfig.OAuthConfig() -> void -Weaviate.Client.OAuthConfig.OAuthConfig(Weaviate.Client.OAuthConfig! original) -> void -Weaviate.Client.OAuthConfig.Password.get -> string? -Weaviate.Client.OAuthConfig.Password.init -> void -Weaviate.Client.OAuthConfig.Scope.get -> string! -Weaviate.Client.OAuthConfig.Scope.init -> void -Weaviate.Client.OAuthConfig.TokenEndpoint.get -> string! -Weaviate.Client.OAuthConfig.TokenEndpoint.init -> void -Weaviate.Client.OAuthConfig.Username.get -> string? -Weaviate.Client.OAuthConfig.Username.init -> void -Weaviate.Client.QueryClient -Weaviate.Client.QueryClient.BM25(string! query, Weaviate.Client.Models.GroupByRequest! groupBy, string![]? searchFields = null, Weaviate.Client.Models.Filter? filters = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? searchOperator = null, Weaviate.Client.Models.Rerank? rerank = null, System.Guid? after = null, Weaviate.Client.ConsistencyLevels? consistencyLevel = null, Weaviate.Client.Models.AutoArray? returnProperties = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.BM25(string! query, string![]? searchFields = null, Weaviate.Client.Models.Filter? filters = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? searchOperator = null, Weaviate.Client.Models.Rerank? rerank = null, System.Guid? after = null, Weaviate.Client.ConsistencyLevels? consistencyLevel = null, Weaviate.Client.Models.AutoArray? returnProperties = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.FetchObjectByID(System.Guid id, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.FetchObjects(System.Guid? after = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.FetchObjects(Weaviate.Client.Models.GroupByRequest! groupBy, System.Guid? after = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.FetchObjectsByIDs(System.Collections.Generic.HashSet! ids, uint? limit = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.Hybrid(string? query, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.IHybridVectorInput? vectors = null, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.Hybrid(string? query, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.Vectors! vectors, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.Hybrid(string? query, Weaviate.Client.Models.IHybridVectorInput? vectors = null, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.Hybrid(string? query, Weaviate.Client.Models.Vectors! vectors, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearImage(byte[]! nearImage, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearImage(byte[]! nearImage, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearObject(System.Guid nearObject, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearObject(System.Guid nearObject, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearText(Weaviate.Client.Models.AutoArray! text, Weaviate.Client.Models.GroupByRequest! groupBy, float? certainty = null, float? distance = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearText(Weaviate.Client.Models.AutoArray! text, float? certainty = null, float? distance = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearVector(Weaviate.Client.Models.NearVectorInput! vector, Weaviate.Client.Models.Filter? filters = null, float? certainty = null, float? distance = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearVector(Weaviate.Client.Models.NearVectorInput! vector, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.Filter? filters = null, float? distance = null, float? certainty = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearVector(Weaviate.Client.Models.Vectors! vector, Weaviate.Client.Models.Filter? filters = null, float? certainty = null, float? distance = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.NearVector(Weaviate.Client.Models.Vectors! vector, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.Filter? filters = null, float? distance = null, float? certainty = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.QueryClient.QueryClient(Weaviate.Client.CollectionClient! collectionClient) -> void -Weaviate.Client.ReplicationsClient -Weaviate.Client.ReplicationsClient.Cancel(System.Guid id, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.ReplicationsClient.Delete(System.Guid id, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.ReplicationsClient.DeleteAll(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.ReplicationsClient.Get(System.Guid id, bool includeHistory = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.ReplicationsClient.List(string? collection = null, string? shard = null, string? targetNode = null, bool includeHistory = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.ReplicationsClient.ListAll(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.RerankerConfigFactory -Weaviate.Client.RerankerConfigFactory.Cohere(string? model = null) -> Weaviate.Client.Models.IRerankerConfig! -Weaviate.Client.RerankerConfigFactory.ContextualAI(string? model = null, string? instruction = null, int? topN = null) -> Weaviate.Client.Models.IRerankerConfig! -Weaviate.Client.RerankerConfigFactory.Custom(string! type, object? config = null) -> Weaviate.Client.Models.IRerankerConfig! -Weaviate.Client.RerankerConfigFactory.JinaAI(string? model = null) -> Weaviate.Client.Models.IRerankerConfig! -Weaviate.Client.RerankerConfigFactory.None() -> Weaviate.Client.Models.IRerankerConfig! -Weaviate.Client.RerankerConfigFactory.Nvidia(string? baseURL = null, string? model = null) -> Weaviate.Client.Models.IRerankerConfig! -Weaviate.Client.RerankerConfigFactory.Transformers() -> Weaviate.Client.Models.IRerankerConfig! -Weaviate.Client.RerankerConfigFactory.VoyageAI(string? model = null) -> Weaviate.Client.Models.IRerankerConfig! -Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Alias = 0 -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Backup = Weaviate.Client.ResourceType.Object | Weaviate.Client.ResourceType.User -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Collection = 1 -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Group = Weaviate.Client.ResourceType.Collection | Weaviate.Client.ResourceType.Backup -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Object = 2 -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Property = Weaviate.Client.ResourceType.Collection | Weaviate.Client.ResourceType.Object -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Reference = 8 -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Replication = Weaviate.Client.ResourceType.Collection | Weaviate.Client.ResourceType.Tenant -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Role = Weaviate.Client.ResourceType.Collection | Weaviate.Client.ResourceType.User -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Shard = Weaviate.Client.ResourceType.Collection | Weaviate.Client.ResourceType.Reference -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Tenant = Weaviate.Client.ResourceType.Object | Weaviate.Client.ResourceType.Reference -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.Unknown = Weaviate.Client.ResourceType.User | Weaviate.Client.ResourceType.Reference -> Weaviate.Client.ResourceType -Weaviate.Client.ResourceType.User = 4 -> Weaviate.Client.ResourceType -Weaviate.Client.RetryOn -Weaviate.Client.RetryOn.NetworkError = 8 -> Weaviate.Client.RetryOn -Weaviate.Client.RetryOn.None = 0 -> Weaviate.Client.RetryOn -Weaviate.Client.RetryOn.RateLimited = 2 -> Weaviate.Client.RetryOn -Weaviate.Client.RetryOn.ServiceUnavailable = 4 -> Weaviate.Client.RetryOn -Weaviate.Client.RetryOn.Timeout = 1 -> Weaviate.Client.RetryOn -Weaviate.Client.RetryOn.TransientErrors = Weaviate.Client.RetryOn.Timeout | Weaviate.Client.RetryOn.RateLimited | Weaviate.Client.RetryOn.ServiceUnavailable | Weaviate.Client.RetryOn.NetworkError -> Weaviate.Client.RetryOn -Weaviate.Client.RetryPolicy -Weaviate.Client.RetryPolicy.BackoffMultiplier.get -> double -Weaviate.Client.RetryPolicy.BackoffMultiplier.init -> void -Weaviate.Client.RetryPolicy.CalculateDelay(int attemptNumber) -> System.TimeSpan -Weaviate.Client.RetryPolicy.InitialDelay.get -> System.TimeSpan -Weaviate.Client.RetryPolicy.InitialDelay.init -> void -Weaviate.Client.RetryPolicy.MaxDelay.get -> System.TimeSpan -Weaviate.Client.RetryPolicy.MaxDelay.init -> void -Weaviate.Client.RetryPolicy.MaxRetries.get -> int -Weaviate.Client.RetryPolicy.MaxRetries.init -> void -Weaviate.Client.RetryPolicy.RetryOn.get -> Weaviate.Client.RetryOn -Weaviate.Client.RetryPolicy.RetryOn.init -> void -Weaviate.Client.RetryPolicy.RetryPolicy() -> void -Weaviate.Client.RetryPolicy.RetryPolicy(Weaviate.Client.RetryPolicy! original) -> void -Weaviate.Client.RolesClient -Weaviate.Client.RolesClient.AddPermissions(string! id, System.Collections.Generic.IEnumerable! permissions, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.RolesClient.Create(string! name, System.Collections.Generic.IEnumerable! permissions, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.RolesClient.Delete(string! id, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.RolesClient.Get(string! id, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.RolesClient.GetGroupAssignments(string! roleId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.RolesClient.GetUserAssignments(string! roleId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.RolesClient.HasPermission(string! id, Weaviate.Client.Models.PermissionScope! permission, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.RolesClient.ListAll(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.RolesClient.RemovePermissions(string! id, System.Collections.Generic.IEnumerable! permissions, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Serialization.PropertyBag -Weaviate.Client.Serialization.PropertyBag.Add(System.Collections.Generic.KeyValuePair item) -> void -Weaviate.Client.Serialization.PropertyBag.Add(string! key, object? value) -> void -Weaviate.Client.Serialization.PropertyBag.Clear() -> void -Weaviate.Client.Serialization.PropertyBag.Contains(System.Collections.Generic.KeyValuePair item) -> bool -Weaviate.Client.Serialization.PropertyBag.ContainsKey(string! key) -> bool -Weaviate.Client.Serialization.PropertyBag.CopyTo(System.Collections.Generic.KeyValuePair[]! array, int arrayIndex) -> void -Weaviate.Client.Serialization.PropertyBag.Count.get -> int -Weaviate.Client.Serialization.PropertyBag.GetAs(string! name) -> T? -Weaviate.Client.Serialization.PropertyBag.GetBlob(string! name) -> byte[]? -Weaviate.Client.Serialization.PropertyBag.GetBool(string! name) -> bool? -Weaviate.Client.Serialization.PropertyBag.GetDateTime(string! name) -> System.DateTime? -Weaviate.Client.Serialization.PropertyBag.GetDouble(string! name) -> double? -Weaviate.Client.Serialization.PropertyBag.GetEnumerator() -> System.Collections.Generic.IEnumerator>! -Weaviate.Client.Serialization.PropertyBag.GetGeo(string! name) -> Weaviate.Client.Models.GeoCoordinate? -Weaviate.Client.Serialization.PropertyBag.GetGuid(string! name) -> System.Guid? -Weaviate.Client.Serialization.PropertyBag.GetInt(string! name) -> int? -Weaviate.Client.Serialization.PropertyBag.GetIntArray(string! name) -> int[]? -Weaviate.Client.Serialization.PropertyBag.GetLong(string! name) -> long? -Weaviate.Client.Serialization.PropertyBag.GetNested(string! name) -> Weaviate.Client.Serialization.PropertyBag? -Weaviate.Client.Serialization.PropertyBag.GetPhone(string! name) -> Weaviate.Client.Models.PhoneNumber? -Weaviate.Client.Serialization.PropertyBag.GetString(string! name) -> string? -Weaviate.Client.Serialization.PropertyBag.GetStringArray(string! name) -> string![]? -Weaviate.Client.Serialization.PropertyBag.IsReadOnly.get -> bool -Weaviate.Client.Serialization.PropertyBag.Keys.get -> System.Collections.Generic.ICollection! -Weaviate.Client.Serialization.PropertyBag.PropertyBag() -> void -Weaviate.Client.Serialization.PropertyBag.PropertyBag(System.Collections.Generic.IDictionary! properties) -> void -Weaviate.Client.Serialization.PropertyBag.Remove(System.Collections.Generic.KeyValuePair item) -> bool -Weaviate.Client.Serialization.PropertyBag.Remove(string! key) -> bool -Weaviate.Client.Serialization.PropertyBag.TryGetValue(string! key, out object? value) -> bool -Weaviate.Client.Serialization.PropertyBag.Values.get -> System.Collections.Generic.ICollection! -Weaviate.Client.Serialization.PropertyBag.this[string! key].get -> object? -Weaviate.Client.Serialization.PropertyBag.this[string! key].set -> void -Weaviate.Client.TenantsClient -Weaviate.Client.TenantsClient.Activate(Weaviate.Client.Models.Tenant![]! tenants, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.TenantsClient.Activate(string![]! tenantNames, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.TenantsClient.Create(Weaviate.Client.Models.AutoArray! tenants, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.TenantsClient.Deactivate(Weaviate.Client.Models.Tenant![]! tenants, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.TenantsClient.Deactivate(string![]! tenantNames, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.TenantsClient.Delete(Weaviate.Client.Models.AutoArray! tenantNames, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.TenantsClient.Exists(string! tenantName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.TenantsClient.Get(string! tenantName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.TenantsClient.List(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.TenantsClient.List(string![]! tenantNames, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.TenantsClient.Offload(string![]! tenantNames, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.TenantsClient.Update(Weaviate.Client.Models.AutoArray! tenants, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedCollectionClient -Weaviate.Client.Typed.TypedCollectionClient.Aggregate.get -> Weaviate.Client.AggregateClient! -Weaviate.Client.Typed.TypedCollectionClient.Config.get -> Weaviate.Client.CollectionConfigClient! -Weaviate.Client.Typed.TypedCollectionClient.ConsistencyLevel.get -> Weaviate.Client.ConsistencyLevels? -Weaviate.Client.Typed.TypedCollectionClient.Count(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedCollectionClient.Data.get -> Weaviate.Client.Typed.TypedDataClient! -Weaviate.Client.Typed.TypedCollectionClient.Generate.get -> Weaviate.Client.Typed.TypedGenerateClient! -Weaviate.Client.Typed.TypedCollectionClient.Iterator(System.Guid? after = null, uint cacheSize = 100, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IAsyncEnumerable!>! -Weaviate.Client.Typed.TypedCollectionClient.Name.get -> string! -Weaviate.Client.Typed.TypedCollectionClient.Query.get -> Weaviate.Client.Typed.TypedQueryClient! -Weaviate.Client.Typed.TypedCollectionClient.Tenant.get -> string? -Weaviate.Client.Typed.TypedCollectionClient.Tenants.get -> Weaviate.Client.TenantsClient! -Weaviate.Client.Typed.TypedCollectionClient.TypedCollectionClient(Weaviate.Client.CollectionClient! collectionClient) -> void -Weaviate.Client.Typed.TypedCollectionClient.Untyped.get -> Weaviate.Client.CollectionClient! -Weaviate.Client.Typed.TypedCollectionClient.WeaviateVersion.get -> System.Version? -Weaviate.Client.Typed.TypedCollectionClient.WithConsistencyLevel(Weaviate.Client.ConsistencyLevels consistencyLevel) -> Weaviate.Client.Typed.TypedCollectionClient! -Weaviate.Client.Typed.TypedCollectionClient.WithTenant(string! tenant) -> Weaviate.Client.Typed.TypedCollectionClient! -Weaviate.Client.Typed.TypedDataClient -Weaviate.Client.Typed.TypedDataClient.DeleteByID(System.Guid uuid, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.DeleteMany(Weaviate.Client.Models.Filter! where, bool dryRun = false, bool verbose = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.Insert(T! properties, System.Guid? uuid = null, Weaviate.Client.Models.Vectors? vectors = null, Weaviate.Client.Models.AutoArray? references = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.InsertMany(System.Collections.Generic.IEnumerable! properties, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.InsertMany(System.Collections.Generic.IEnumerable! requests, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.InsertMany(System.Collections.Generic.IEnumerable! requestBatches, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.ReferenceAdd(System.Guid from, string! fromProperty, System.Guid to, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.ReferenceAdd(Weaviate.Client.Models.DataReference! reference, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.ReferenceAddMany(Weaviate.Client.Models.DataReference![]! references, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.ReferenceDelete(System.Guid from, string! fromProperty, System.Guid to, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.ReferenceReplace(System.Guid from, string! fromProperty, System.Guid[]! to, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.Replace(System.Guid uuid, T! properties, Weaviate.Client.Models.Vectors? vectors = null, System.Collections.Generic.IEnumerable? references = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedDataClient.Update(System.Guid uuid, T! properties, Weaviate.Client.Models.Vectors? vectors = null, System.Collections.Generic.IEnumerable? references = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Typed.TypedGenerateClient -Weaviate.Client.Typed.TypedGenerateClient.BM25(string! query, Weaviate.Client.Models.GroupByRequest! groupBy, string![]? searchFields = null, Weaviate.Client.Models.Filter? filters = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.ConsistencyLevels? consistencyLevel = null, Weaviate.Client.Models.AutoArray? returnProperties = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.BM25(string! query, string![]? searchFields = null, Weaviate.Client.Models.Filter? filters = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.ConsistencyLevels? consistencyLevel = null, Weaviate.Client.Models.AutoArray? returnProperties = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.FetchObjectByID(System.Guid uuid, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task?>! -Weaviate.Client.Typed.TypedGenerateClient.FetchObjects(System.Guid? after = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task?>! -Weaviate.Client.Typed.TypedGenerateClient.FetchObjects(Weaviate.Client.Models.GroupByRequest! groupBy, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.FetchObjectsByIDs(System.Collections.Generic.HashSet! uuids, uint? limit = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.Hybrid(string? query, Weaviate.Client.Models.GroupByRequest! groupBy, float? alpha = null, Weaviate.Client.Models.IHybridVectorInput? vectors = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.Hybrid(string? query, Weaviate.Client.Models.GroupByRequest! groupBy, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.Hybrid(string? query, Weaviate.Client.Models.IHybridVectorInput! vectors, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.Hybrid(string? query, Weaviate.Client.Models.Vectors! vectors, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.Hybrid(string? query, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearImage(byte[]! nearImage, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearImage(byte[]! nearImage, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearObject(System.Guid nearObject, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearObject(System.Guid nearObject, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearText(Weaviate.Client.Models.AutoArray! text, Weaviate.Client.Models.GroupByRequest! groupBy, float? certainty = null, float? distance = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearText(Weaviate.Client.Models.AutoArray! text, float? certainty = null, float? distance = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearVector(Weaviate.Client.Models.Vectors! vector, Weaviate.Client.Models.Filter? filters = null, float? certainty = null, float? distance = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.NearVector(Weaviate.Client.Models.Vectors! vector, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.Filter? filters = null, float? distance = null, float? certainty = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.SinglePrompt? singlePrompt = null, Weaviate.Client.Models.GroupedTask? groupedTask = null, Weaviate.Client.Models.GenerativeProvider? provider = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedGenerateClient.TypedGenerateClient(Weaviate.Client.GenerateClient! generateClient) -> void -Weaviate.Client.Typed.TypedQueryClient -Weaviate.Client.Typed.TypedQueryClient.BM25(string! query, Weaviate.Client.Models.GroupByRequest! groupBy, string![]? searchFields = null, Weaviate.Client.Models.Filter? filters = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.ConsistencyLevels? consistencyLevel = null, Weaviate.Client.Models.AutoArray? returnProperties = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedQueryClient.BM25(string! query, string![]? searchFields = null, Weaviate.Client.Models.Filter? filters = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.ConsistencyLevels? consistencyLevel = null, Weaviate.Client.Models.AutoArray? returnProperties = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Collections.Generic.IList? returnReferences = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.FetchObjectByID(System.Guid uuid, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task?>! -Weaviate.Client.Typed.TypedQueryClient.FetchObjects(System.Guid? after = null, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.FetchObjects(Weaviate.Client.Models.GroupByRequest! groupBy, uint? limit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedQueryClient.FetchObjectsByIDs(System.Collections.Generic.HashSet! uuids, uint? limit = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.AutoArray? sort = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.Hybrid(string? query, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.IHybridVectorInput? vectors = null, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedQueryClient.Hybrid(string? query, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.Vectors! vectors, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedQueryClient.Hybrid(string? query, Weaviate.Client.Models.IHybridVectorInput? vectors = null, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.Hybrid(string? query, Weaviate.Client.Models.Vectors! vectors, float? alpha = null, string![]? queryProperties = null, Weaviate.Client.Models.HybridFusion? fusionType = null, float? maxVectorDistance = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.BM25Operator? bm25Operator = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.NearImage(byte[]! nearImage, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedQueryClient.NearImage(byte[]! nearImage, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedQueryClient.NearMedia(byte[]! media, Weaviate.Client.Models.NearMediaType mediaType, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.NearObject(System.Guid nearObject, Weaviate.Client.Models.GroupByRequest! groupBy, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedQueryClient.NearObject(System.Guid nearObject, double? certainty = null, double? distance = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.NearText(Weaviate.Client.Models.AutoArray! text, Weaviate.Client.Models.GroupByRequest! groupBy, float? certainty = null, float? distance = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedQueryClient.NearText(Weaviate.Client.Models.AutoArray! text, float? certainty = null, float? distance = null, Weaviate.Client.Models.Move? moveTo = null, Weaviate.Client.Models.Move? moveAway = null, uint? limit = null, uint? offset = null, uint? autoLimit = null, Weaviate.Client.Models.Filter? filters = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.NearVector(Weaviate.Client.Models.Vectors! vector, Weaviate.Client.Models.Filter? filters = null, float? certainty = null, float? distance = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>!>! -Weaviate.Client.Typed.TypedQueryClient.NearVector(Weaviate.Client.Models.Vectors! vector, Weaviate.Client.Models.GroupByRequest! groupBy, Weaviate.Client.Models.Filter? filters = null, float? distance = null, float? certainty = null, uint? autoLimit = null, uint? limit = null, uint? offset = null, Weaviate.Client.Models.TargetVectors? targetVector = null, Weaviate.Client.Models.Rerank? rerank = null, Weaviate.Client.Models.AutoArray? returnProperties = null, System.Collections.Generic.IList? returnReferences = null, Weaviate.Client.Models.MetadataQuery? returnMetadata = null, Weaviate.Client.Models.VectorQuery? includeVectors = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.Typed.TypedQueryClient.TypedQueryClient(Weaviate.Client.QueryClient! queryClient) -> void -Weaviate.Client.UsersClient -Weaviate.Client.UsersClient.Db.get -> Weaviate.Client.UsersDatabaseClient! -Weaviate.Client.UsersClient.Oidc.get -> Weaviate.Client.UsersOidcClient! -Weaviate.Client.UsersClient.OwnInfo(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersDatabaseClient -Weaviate.Client.UsersDatabaseClient.Activate(string! userId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersDatabaseClient.AssignRoles(string! userId, System.Collections.Generic.IEnumerable! roles, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersDatabaseClient.Create(string! userId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersDatabaseClient.Deactivate(string! userId, bool? revokeKey = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersDatabaseClient.Delete(string! userId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersDatabaseClient.Get(string! userId, bool? includeLastUsedTime = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersDatabaseClient.GetRoles(string! userId, bool? includeFullRoles = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.UsersDatabaseClient.List(bool? includeLastUsedTime = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.UsersDatabaseClient.RevokeRoles(string! userId, System.Collections.Generic.IEnumerable! roles, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersDatabaseClient.RotateApiKey(string! userId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersOidcClient -Weaviate.Client.UsersOidcClient.AssignRoles(string! userId, System.Collections.Generic.IEnumerable! roles, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.UsersOidcClient.GetRoles(string! userId, bool? includeFullRoles = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -Weaviate.Client.UsersOidcClient.RevokeRoles(string! userId, System.Collections.Generic.IEnumerable! roles, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.Validation.TypeValidationException -Weaviate.Client.Validation.TypeValidationException.TypeValidationException(Weaviate.Client.Validation.ValidationResult! result) -> void -Weaviate.Client.Validation.TypeValidationException.TypeValidationException(string! message, Weaviate.Client.Validation.ValidationResult! result) -> void -Weaviate.Client.Validation.TypeValidationException.ValidationResult.get -> Weaviate.Client.Validation.ValidationResult! -Weaviate.Client.Validation.TypeValidator -Weaviate.Client.Validation.TypeValidator.ValidateType(System.Type! type, Weaviate.Client.Models.CollectionConfig! schema) -> Weaviate.Client.Validation.ValidationResult! -Weaviate.Client.Validation.TypeValidator.ValidateType(Weaviate.Client.Models.CollectionConfig! schema) -> Weaviate.Client.Validation.ValidationResult! -Weaviate.Client.Validation.ValidationError -Weaviate.Client.Validation.ValidationError.ActualType.get -> string? -Weaviate.Client.Validation.ValidationError.ActualType.init -> void -Weaviate.Client.Validation.ValidationError.AdditionalInfo.get -> string? -Weaviate.Client.Validation.ValidationError.AdditionalInfo.init -> void -Weaviate.Client.Validation.ValidationError.ErrorType.get -> Weaviate.Client.Validation.ValidationErrorType -Weaviate.Client.Validation.ValidationError.ErrorType.init -> void -Weaviate.Client.Validation.ValidationError.ExpectedType.get -> string? -Weaviate.Client.Validation.ValidationError.ExpectedType.init -> void -Weaviate.Client.Validation.ValidationError.Message.get -> string! -Weaviate.Client.Validation.ValidationError.Message.init -> void -Weaviate.Client.Validation.ValidationError.PropertyName.get -> string! -Weaviate.Client.Validation.ValidationError.PropertyName.init -> void -Weaviate.Client.Validation.ValidationError.ValidationError() -> void -Weaviate.Client.Validation.ValidationErrorType -Weaviate.Client.Validation.ValidationErrorType.ArrayMismatch = 1 -> Weaviate.Client.Validation.ValidationErrorType -Weaviate.Client.Validation.ValidationErrorType.NestedObjectMismatch = 4 -> Weaviate.Client.Validation.ValidationErrorType -Weaviate.Client.Validation.ValidationErrorType.RequiredPropertyMissing = 2 -> Weaviate.Client.Validation.ValidationErrorType -Weaviate.Client.Validation.ValidationErrorType.TypeMismatch = 0 -> Weaviate.Client.Validation.ValidationErrorType -Weaviate.Client.Validation.ValidationErrorType.UnsupportedType = 3 -> Weaviate.Client.Validation.ValidationErrorType -Weaviate.Client.Validation.ValidationResult -Weaviate.Client.Validation.ValidationResult.Errors.get -> System.Collections.Generic.IReadOnlyList! -Weaviate.Client.Validation.ValidationResult.Errors.init -> void -Weaviate.Client.Validation.ValidationResult.GetDetailedMessage() -> string! -Weaviate.Client.Validation.ValidationResult.IsValid.get -> bool -Weaviate.Client.Validation.ValidationResult.ThrowIfInvalid() -> void -Weaviate.Client.Validation.ValidationResult.ValidationResult() -> void -Weaviate.Client.Validation.ValidationResult.Warnings.get -> System.Collections.Generic.IReadOnlyList! -Weaviate.Client.Validation.ValidationResult.Warnings.init -> void -Weaviate.Client.Validation.ValidationWarning -Weaviate.Client.Validation.ValidationWarning.AdditionalInfo.get -> string? -Weaviate.Client.Validation.ValidationWarning.AdditionalInfo.init -> void -Weaviate.Client.Validation.ValidationWarning.Message.get -> string! -Weaviate.Client.Validation.ValidationWarning.Message.init -> void -Weaviate.Client.Validation.ValidationWarning.PropertyName.get -> string! -Weaviate.Client.Validation.ValidationWarning.PropertyName.init -> void -Weaviate.Client.Validation.ValidationWarning.ValidationWarning() -> void -Weaviate.Client.Validation.ValidationWarning.WarningType.get -> Weaviate.Client.Validation.ValidationWarningType -Weaviate.Client.Validation.ValidationWarning.WarningType.init -> void -Weaviate.Client.Validation.ValidationWarningType -Weaviate.Client.Validation.ValidationWarningType.CompatibleTypeDifference = 2 -> Weaviate.Client.Validation.ValidationWarningType -Weaviate.Client.Validation.ValidationWarningType.ExtraProperty = 0 -> Weaviate.Client.Validation.ValidationWarningType -Weaviate.Client.Validation.ValidationWarningType.NullabilityDifference = 1 -> Weaviate.Client.Validation.ValidationWarningType -Weaviate.Client.ValidationExtensions -Weaviate.Client.VectorizerFactory -Weaviate.Client.VectorizerFactory.Img2VecNeural(string![]! imageFields) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecAWSBedrock(Weaviate.Client.Models.WeightedFields! imageFields, Weaviate.Client.Models.WeightedFields! textFields, string? region = null, string? model = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecAWSBedrock(string![]? imageFields = null, string![]? textFields = null, string? region = null, string? model = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecBind(Weaviate.Client.Models.WeightedFields! imageFields, Weaviate.Client.Models.WeightedFields! textFields, Weaviate.Client.Models.WeightedFields! audioFields, Weaviate.Client.Models.WeightedFields! depthFields, Weaviate.Client.Models.WeightedFields! imuFields, Weaviate.Client.Models.WeightedFields! thermalFields, Weaviate.Client.Models.WeightedFields! videoFields, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecBind(string![]? imageFields = null, string![]? textFields = null, string![]? audioFields = null, string![]? depthFields = null, string![]? imuFields = null, string![]? thermalFields = null, string![]? videoFields = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecClip(Weaviate.Client.Models.WeightedFields! imageFields, Weaviate.Client.Models.WeightedFields! textFields, string? inferenceUrl = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecClip(string![]? imageFields = null, string![]? textFields = null, string? inferenceUrl = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecCohere(Weaviate.Client.Models.WeightedFields! imageFields, Weaviate.Client.Models.WeightedFields! textFields, string? baseURL = null, string? model = null, int? dimensions = null, string? truncate = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecCohere(string![]? imageFields = null, string![]? textFields = null, string? baseURL = null, string? model = null, int? dimensions = null, string? truncate = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecGoogle(string! projectId, string! location, Weaviate.Client.Models.WeightedFields! imageFields, Weaviate.Client.Models.WeightedFields! textFields, Weaviate.Client.Models.WeightedFields! videoFields, int? videoIntervalSeconds = null, string? model = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecGoogle(string! projectId, string! location, string![]? imageFields = null, string![]? textFields = null, string![]? videoFields = null, int? videoIntervalSeconds = null, string? model = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecJinaAI(Weaviate.Client.Models.WeightedFields! imageFields, Weaviate.Client.Models.WeightedFields! textFields, string? model = null, string? baseURL = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecJinaAI(string![]? imageFields = null, string![]? textFields = null, string? model = null, string? baseURL = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecNvidia(string? baseURL = null, string? model = null, string![]? properties = null, bool? truncate = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecVoyageAI(Weaviate.Client.Models.WeightedFields! imageFields, Weaviate.Client.Models.WeightedFields! textFields, string? baseURL = null, string? model = null, bool? truncate = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Multi2VecVoyageAI(string![]? imageFields = null, string![]? textFields = null, string? baseURL = null, string? model = null, bool? truncate = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Ref2VecCentroid(string![]! referenceProperties, string! method = "mean") -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.SelfProvided() -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecAWSBedrock(string! region, string! model, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecAWSSagemaker(string! region, string! endpoint, string? targetModel = null, string? targetVariant = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecAzureOpenAI(string! deploymentId, string! resourceName, string? baseURL = null, int? dimensions = null, string? model = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecCohere(string? baseURL = null, string? model = null, int? dimensions = null, string? truncate = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecDatabricks(string! endpoint, string? instruction = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecGoogleGemini(string? model = null, string? titleProperty = null, int? dimensions = null, string? taskType = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecGoogleVertex(string? apiEndpoint = null, string? model = null, string? projectId = null, string? titleProperty = null, int? dimensions = null, string? taskType = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecHuggingFace(string? endpointURL = null, string? model = null, string? passageModel = null, string? queryModel = null, bool? useCache = null, bool? useGPU = null, bool? waitForModel = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecJinaAI(string? model = null, string? baseURL = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecMistral(string? baseURL = null, string? model = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecModel2Vec(string? inferenceURL = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecMorph(string? baseURL = null, string? model = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecNvidia(string? baseURL = null, string? model = null, bool? truncate = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecOllama(string? apiEndpoint = null, string? model = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecOpenAI(string? baseURL = null, int? dimensions = null, string? model = null, string? modelVersion = null, string? type = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecTransformers(string? inferenceUrl = null, string? passageInferenceUrl = null, string? queryInferenceUrl = null, string? poolingStrategy = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecVoyageAI(string? baseURL = null, string? model = null, bool? truncate = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactory.Text2VecWeaviate(string? baseURL = null, int? dimensions = null, string? model = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactoryMulti -Weaviate.Client.VectorizerFactoryMulti.Multi2MultiVecJinaAI(Weaviate.Client.Models.WeightedFields! imageFields, Weaviate.Client.Models.WeightedFields! textFields, string? baseURL = null, string? model = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactoryMulti.Multi2MultiVecJinaAI(string![]? imageFields = null, string![]? textFields = null, string? baseURL = null, string? model = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactoryMulti.SelfProvided() -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.VectorizerFactoryMulti.Text2MultiVecJinaAI(string? model = null, string? baseURL = null, int? dimensions = null, bool? vectorizeCollectionName = null) -> Weaviate.Client.Models.VectorizerConfig! -Weaviate.Client.WeaviateAuthenticationException -Weaviate.Client.WeaviateAuthenticationException.WeaviateAuthenticationException(string? message = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateAuthorizationException -Weaviate.Client.WeaviateAuthorizationException.WeaviateAuthorizationException(string? message = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateBackupConflictException -Weaviate.Client.WeaviateBackupConflictException.WeaviateBackupConflictException(System.Exception! innerException) -> void -Weaviate.Client.WeaviateBadRequestException -Weaviate.Client.WeaviateBadRequestException.WeaviateBadRequestException(string? message = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateClient -Weaviate.Client.WeaviateClient.Alias.get -> Weaviate.Client.AliasClient! -Weaviate.Client.WeaviateClient.Backup.get -> Weaviate.Client.BackupClient! -Weaviate.Client.WeaviateClient.Cluster.get -> Weaviate.Client.ClusterClient! -Weaviate.Client.WeaviateClient.Collections.get -> Weaviate.Client.CollectionsClient! -Weaviate.Client.WeaviateClient.Configuration.get -> Weaviate.Client.ClientConfiguration! -Weaviate.Client.WeaviateClient.Dispose() -> void -Weaviate.Client.WeaviateClient.GetMeta(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.WeaviateClient.Groups.get -> Weaviate.Client.GroupsClient! -Weaviate.Client.WeaviateClient.InitializeAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.WeaviateClient.IsInitialized.get -> bool -Weaviate.Client.WeaviateClient.IsLive(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.WeaviateClient.IsReady(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -Weaviate.Client.WeaviateClient.Meta.get -> Weaviate.Client.Models.MetaInfo? -Weaviate.Client.WeaviateClient.Roles.get -> Weaviate.Client.RolesClient! -Weaviate.Client.WeaviateClient.Users.get -> Weaviate.Client.UsersClient! -Weaviate.Client.WeaviateClient.WaitUntilReady(System.TimeSpan timeout, System.Threading.CancellationToken cancellationToken, System.TimeSpan? pollInterval = null) -> System.Threading.Tasks.Task! -Weaviate.Client.WeaviateClient.WeaviateClient(Microsoft.Extensions.Options.IOptions! options) -> void -Weaviate.Client.WeaviateClient.WeaviateClient(Microsoft.Extensions.Options.IOptions! options, Microsoft.Extensions.Logging.ILogger? logger) -> void -Weaviate.Client.WeaviateClient.WeaviateVersion.get -> System.Version? -Weaviate.Client.WeaviateClientBuilder -Weaviate.Client.WeaviateClientBuilder.AddHandler(System.Net.Http.DelegatingHandler! handler) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.ApplyTimeouts(System.TimeSpan? defaultTimeout = null, System.TimeSpan? initTimeout = null, System.TimeSpan? insertTimeout = null, System.TimeSpan? queryTimeout = null) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.BuildAsync() -> System.Threading.Tasks.Task! -Weaviate.Client.WeaviateClientBuilder.UseSsl(bool useSsl = true) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WeaviateClientBuilder() -> void -Weaviate.Client.WeaviateClientBuilder.WithCredentials(Weaviate.Client.ICredentials? credentials) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithDefaultTimeout(System.TimeSpan timeout) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithGrpcEndpoint(string! endpoint) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithGrpcPath(string! path) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithGrpcPort(ushort port) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithHeader(string! key, string! value) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithHeaders(System.Collections.Generic.Dictionary? headers) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithHttpMessageHandler(System.Net.Http.HttpMessageHandler? handler) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithInitTimeout(System.TimeSpan timeout) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithInsertTimeout(System.TimeSpan timeout) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithQueryTimeout(System.TimeSpan timeout) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithRestEndpoint(string! endpoint) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithRestPath(string! path) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithRestPort(ushort port) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithRetryPolicy(Weaviate.Client.RetryPolicy! policy) -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilder.WithoutRetries() -> Weaviate.Client.WeaviateClientBuilder! -Weaviate.Client.WeaviateClientBuilderExtensions -Weaviate.Client.WeaviateClientException -Weaviate.Client.WeaviateClientException.WeaviateClientException(System.Exception! innerException) -> void -Weaviate.Client.WeaviateClientException.WeaviateClientException(string! message) -> void -Weaviate.Client.WeaviateClientException.WeaviateClientException(string? message = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateCollectionLimitReachedException -Weaviate.Client.WeaviateCollectionLimitReachedException.WeaviateCollectionLimitReachedException(string? message = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateConflictException -Weaviate.Client.WeaviateConflictException.WeaviateConflictException(string! message, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateDefaults -Weaviate.Client.WeaviateException -Weaviate.Client.WeaviateException.WeaviateException(System.Exception! innerException) -> void -Weaviate.Client.WeaviateException.WeaviateException(string! message) -> void -Weaviate.Client.WeaviateException.WeaviateException(string? message, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateExtensions -Weaviate.Client.WeaviateExternalModuleProblemException -Weaviate.Client.WeaviateExternalModuleProblemException.WeaviateExternalModuleProblemException(string? message = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateFeatureNotSupportedException -Weaviate.Client.WeaviateFeatureNotSupportedException.WeaviateFeatureNotSupportedException(string? message = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateModuleNotAvailableException -Weaviate.Client.WeaviateModuleNotAvailableException.WeaviateModuleNotAvailableException(string? message = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateNotFoundException -Weaviate.Client.WeaviateNotFoundException.ResourceType.get -> Weaviate.Client.ResourceType? -Weaviate.Client.WeaviateServerException -Weaviate.Client.WeaviateServerException.WeaviateServerException(System.Exception! innerException) -> void -Weaviate.Client.WeaviateServerException.WeaviateServerException(string! message) -> void -Weaviate.Client.WeaviateServerException.WeaviateServerException(string? message = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateTimeoutException -Weaviate.Client.WeaviateTimeoutException.Operation.get -> string? -Weaviate.Client.WeaviateTimeoutException.Timeout.get -> System.TimeSpan? -Weaviate.Client.WeaviateTimeoutException.WeaviateTimeoutException(System.TimeSpan? timeout = null, string? operation = null, System.Exception? innerException = null) -> void -Weaviate.Client.WeaviateUnprocessableEntityException -Weaviate.Client.WeaviateUnprocessableEntityException.WeaviateUnprocessableEntityException(string? message = null, System.Exception? innerException = null) -> void -abstract Weaviate.Client.Models.Aggregate.Metric.$() -> Weaviate.Client.Models.Aggregate.Metric! -abstract Weaviate.Client.Models.Aggregate.Property.$() -> Weaviate.Client.Models.Aggregate.Property! -abstract Weaviate.Client.Models.BM25Operator.$() -> Weaviate.Client.Models.BM25Operator! -abstract Weaviate.Client.Models.BackupBackend.$() -> Weaviate.Client.Models.BackupBackend! -abstract Weaviate.Client.Models.BackupBackend.Path.get -> string? -abstract Weaviate.Client.Models.BackupBackend.Provider.get -> Weaviate.Client.Models.BackupStorageProvider -abstract Weaviate.Client.Models.CollectionConfigCommon.$() -> Weaviate.Client.Models.CollectionConfigCommon! -abstract Weaviate.Client.Models.GenerativeConfig.OpenAIBase.$() -> Weaviate.Client.Models.GenerativeConfig.OpenAIBase! -abstract Weaviate.Client.Models.GenerativeConfig.OpenAIBase.Type.get -> string! -abstract Weaviate.Client.Models.GenerativePrompt.$() -> Weaviate.Client.Models.GenerativePrompt! -abstract Weaviate.Client.Models.GenerativeProvider.$() -> Weaviate.Client.Models.GenerativeProvider! -abstract Weaviate.Client.Models.TypedBase.$() -> Weaviate.Client.Models.TypedBase! -abstract Weaviate.Client.Models.Vector.$() -> Weaviate.Client.Models.Vector! -abstract Weaviate.Client.Models.Vector.Count.get -> int -abstract Weaviate.Client.Models.Vector.Dimensions.get -> int -abstract Weaviate.Client.Models.Vector.ValueType.get -> System.Type! -abstract Weaviate.Client.Models.VectorIndexConfig.$() -> Weaviate.Client.Models.VectorIndexConfig! -abstract Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.$() -> Weaviate.Client.Models.VectorIndexConfig.EncodingConfig! -abstract Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.$() -> Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase! -abstract Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.Type.get -> string! -abstract Weaviate.Client.Models.VectorIndexConfig.Type.get -> string! -abstract Weaviate.Client.Models.VectorizerConfig.$() -> Weaviate.Client.Models.VectorizerConfig! -const Weaviate.Client.CollectionClient.ITERATOR_CACHE_SIZE = 100 -> uint -const Weaviate.Client.Models.GenerativeConfig.AWS.TypeValue = "generative-aws" -> string! -const Weaviate.Client.Models.GenerativeConfig.Anthropic.TypeValue = "generative-anthropic" -> string! -const Weaviate.Client.Models.GenerativeConfig.Anyscale.TypeValue = "generative-anyscale" -> string! -const Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.TypeValue = "generative-azure-openai" -> string! -const Weaviate.Client.Models.GenerativeConfig.Cohere.TypeValue = "generative-cohere" -> string! -const Weaviate.Client.Models.GenerativeConfig.ContextualAI.TypeValue = "generative-contextualai" -> string! -const Weaviate.Client.Models.GenerativeConfig.Databricks.TypeValue = "generative-databricks" -> string! -const Weaviate.Client.Models.GenerativeConfig.FriendliAI.TypeValue = "generative-friendliai" -> string! -const Weaviate.Client.Models.GenerativeConfig.GoogleGemini.TypeValue = "generative-google-gemini" -> string! -const Weaviate.Client.Models.GenerativeConfig.GoogleVertex.TypeValue = "generative-google-vertex" -> string! -const Weaviate.Client.Models.GenerativeConfig.Mistral.TypeValue = "generative-mistral" -> string! -const Weaviate.Client.Models.GenerativeConfig.Nvidia.TypeValue = "generative-nvidia" -> string! -const Weaviate.Client.Models.GenerativeConfig.Ollama.TypeValue = "generative-ollama" -> string! -const Weaviate.Client.Models.GenerativeConfig.OpenAI.TypeValue = "generative-openai" -> string! -const Weaviate.Client.Models.GenerativeConfig.XAI.TypeValue = "generative-xai" -> string! -const Weaviate.Client.Models.Reranker.Cohere.Models.RerankEnglishV2 = "rerank-english-v2.0" -> string! -const Weaviate.Client.Models.Reranker.Cohere.Models.RerankMultilingualV2 = "rerank-multilingual-v2.0" -> string! -const Weaviate.Client.Models.Reranker.Cohere.TypeValue = "reranker-cohere" -> string! -const Weaviate.Client.Models.Reranker.ContextualAI.TypeValue = "reranker-contextualai" -> string! -const Weaviate.Client.Models.Reranker.JinaAI.Models.JinaColbertV1En = "jina-colbert-v1-en" -> string! -const Weaviate.Client.Models.Reranker.JinaAI.Models.JinaRerankerV1BaseEn = "jina-reranker-v1-base-en" -> string! -const Weaviate.Client.Models.Reranker.JinaAI.Models.JinaRerankerV1TinyEn = "jina-reranker-v1-tiny-en" -> string! -const Weaviate.Client.Models.Reranker.JinaAI.Models.JinaRerankerV1TurboEn = "jina-reranker-v1-turbo-en" -> string! -const Weaviate.Client.Models.Reranker.JinaAI.Models.JinaRerankerV2BaseMultilingual = "jina-reranker-v2-base-multilingual" -> string! -const Weaviate.Client.Models.Reranker.JinaAI.TypeValue = "reranker-jinaai" -> string! -const Weaviate.Client.Models.Reranker.None.TypeValue = "none" -> string! -const Weaviate.Client.Models.Reranker.Nvidia.Models.NvidiaRerankQaMistral4B = "nvidia/rerank-qa-mistral-4b" -> string! -const Weaviate.Client.Models.Reranker.Nvidia.TypeValue = "reranker-nvidia" -> string! -const Weaviate.Client.Models.Reranker.Transformers.TypeValue = "reranker-transformers" -> string! -const Weaviate.Client.Models.Reranker.VoyageAI.Models.Rerank1 = "rerank-1" -> string! -const Weaviate.Client.Models.Reranker.VoyageAI.Models.Rerank2 = "rerank-2" -> string! -const Weaviate.Client.Models.Reranker.VoyageAI.Models.Rerank25 = "rerank-2.5" -> string! -const Weaviate.Client.Models.Reranker.VoyageAI.Models.Rerank25Lite = "rerank-2.5-lite" -> string! -const Weaviate.Client.Models.Reranker.VoyageAI.Models.Rerank2Lite = "rerank-2-lite" -> string! -const Weaviate.Client.Models.Reranker.VoyageAI.Models.RerankLite1 = "rerank-lite-1" -> string! -const Weaviate.Client.Models.Reranker.VoyageAI.TypeValue = "reranker-voyageai" -> string! -const Weaviate.Client.Models.VectorIndex.Dynamic.TypeValue = "dynamic" -> string! -const Weaviate.Client.Models.VectorIndex.Flat.TypeValue = "flat" -> string! -const Weaviate.Client.Models.VectorIndex.HNSW.TypeValue = "hnsw" -> string! -const Weaviate.Client.Models.VectorIndex.Quantizers.BQ.TypeValue = "bq" -> string! -const Weaviate.Client.Models.VectorIndex.Quantizers.None.TypeValue = "none" -> string! -const Weaviate.Client.Models.VectorIndex.Quantizers.PQ.TypeValue = "pq" -> string! -const Weaviate.Client.Models.VectorIndex.Quantizers.RQ.TypeValue = "rq" -> string! -const Weaviate.Client.Models.VectorIndex.Quantizers.SQ.TypeValue = "sq" -> string! -const Weaviate.Client.Models.VectorIndexConfig.MultiVectorAggregation.MaxSim = "maxSim" -> string! -const Weaviate.Client.WeaviateAuthenticationException.DefaultMessage = "Authentication failed. Please check your API key or authentication credentials." -> string! -const Weaviate.Client.WeaviateAuthorizationException.DefaultMessage = "Authorization failed. You do not have permission to perform this operation." -> string! -const Weaviate.Client.WeaviateBackupConflictException.DefaultMessage = "A backup or restore operation is already in progress. Only one backup or restore operation can be performed at a time." -> string! -const Weaviate.Client.WeaviateBadRequestException.DefaultMessage = "The request is invalid. Please check the request parameters and schema." -> string! -const Weaviate.Client.WeaviateCollectionLimitReachedException.DefaultMessage = "Collection limit reached. Cannot create more collections than allowed by the server configuration." -> string! -const Weaviate.Client.WeaviateExternalModuleProblemException.DefaultMessage = "An external module encountered a problem. This may be related to vectorizers, generative modules, or other external service integrations." -> string! -const Weaviate.Client.WeaviateFeatureNotSupportedException.DefaultMessage = "The requested feature is not supported by the connected Weaviate server version." -> string! -const Weaviate.Client.WeaviateModuleNotAvailableException.DefaultMessage = "Required module is not available or enabled on the Weaviate server. Please check the server's module configuration." -> string! -const Weaviate.Client.WeaviateTimeoutException.DefaultMessage = "The operation timed out." -> string! -const Weaviate.Client.WeaviateUnprocessableEntityException.DefaultMessage = "The server is unable to process the request. Please check the request content." -> string! -override Weaviate.Client.Auth.ApiKeyCredentials.Equals(object? obj) -> bool -override Weaviate.Client.Auth.ApiKeyCredentials.GetHashCode() -> int -override Weaviate.Client.Auth.ApiKeyCredentials.ToString() -> string! -override Weaviate.Client.Auth.BearerTokenCredentials.Equals(object? obj) -> bool -override Weaviate.Client.Auth.BearerTokenCredentials.GetHashCode() -> int -override Weaviate.Client.Auth.BearerTokenCredentials.ToString() -> string! -override Weaviate.Client.Auth.ClientCredentialsFlow.Equals(object? obj) -> bool -override Weaviate.Client.Auth.ClientCredentialsFlow.GetHashCode() -> int -override Weaviate.Client.Auth.ClientCredentialsFlow.ToString() -> string! -override Weaviate.Client.Auth.ClientPasswordFlow.Equals(object? obj) -> bool -override Weaviate.Client.Auth.ClientPasswordFlow.GetHashCode() -> int -override Weaviate.Client.Auth.ClientPasswordFlow.ToString() -> string! -override Weaviate.Client.AuthenticatedHttpHandler.Dispose(bool disposing) -> void -override Weaviate.Client.AuthenticatedHttpHandler.SendAsync(System.Net.Http.HttpRequestMessage! request, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! -override Weaviate.Client.ClientConfiguration.Equals(object? obj) -> bool -override Weaviate.Client.ClientConfiguration.GetHashCode() -> int -override Weaviate.Client.ClientConfiguration.ToString() -> string! -override Weaviate.Client.CollectionsClient.Equals(object? obj) -> bool -override Weaviate.Client.CollectionsClient.GetHashCode() -> int -override Weaviate.Client.CollectionsClient.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Boolean.$() -> Weaviate.Client.Models.Aggregate.Boolean! -override Weaviate.Client.Models.Aggregate.Boolean.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Boolean.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Boolean.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Boolean.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Boolean.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Date.$() -> Weaviate.Client.Models.Aggregate.Date! -override Weaviate.Client.Models.Aggregate.Date.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Date.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Date.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Date.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Date.ToString() -> string! -override Weaviate.Client.Models.Aggregate.GroupBy.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.GroupBy.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.GroupBy.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Integer.$() -> Weaviate.Client.Models.Aggregate.Integer! -override Weaviate.Client.Models.Aggregate.Integer.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Integer.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Integer.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Integer.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Integer.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Metric.Boolean.$() -> Weaviate.Client.Models.Aggregate.Metric.Boolean! -override Weaviate.Client.Models.Aggregate.Metric.Boolean.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Metric.Boolean.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Boolean.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Metric.Boolean.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Boolean.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Metric.Date.$() -> Weaviate.Client.Models.Aggregate.Metric.Date! -override Weaviate.Client.Models.Aggregate.Metric.Date.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Metric.Date.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Date.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Metric.Date.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Date.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Metric.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Metric.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Metric.Integer.$() -> Weaviate.Client.Models.Aggregate.Metric.Integer! -override Weaviate.Client.Models.Aggregate.Metric.Integer.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Metric.Integer.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Integer.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Metric.Integer.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Integer.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Metric.Number.$() -> Weaviate.Client.Models.Aggregate.Metric.Number! -override Weaviate.Client.Models.Aggregate.Metric.Number.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Metric.Number.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Number.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Metric.Number.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Number.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Metric.Text.$() -> Weaviate.Client.Models.Aggregate.Metric.Text! -override Weaviate.Client.Models.Aggregate.Metric.Text.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Metric.Text.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Text.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Metric.Text.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Metric.Text.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Metric.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Number.$() -> Weaviate.Client.Models.Aggregate.Number! -override Weaviate.Client.Models.Aggregate.Number.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Number.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Number.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Number.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Number.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Numeric.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Numeric.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Numeric.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Numeric.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Numeric.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Property.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Property.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Property.ToString() -> string! -override Weaviate.Client.Models.Aggregate.Text.$() -> Weaviate.Client.Models.Aggregate.Text! -override Weaviate.Client.Models.Aggregate.Text.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.Text.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.Text.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.Text.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.Text.ToString() -> string! -override Weaviate.Client.Models.Aggregate.TopOccurrence.$() -> Weaviate.Client.Models.Aggregate.TopOccurrence! -override Weaviate.Client.Models.Aggregate.TopOccurrence.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Aggregate.TopOccurrence.Equals(object? obj) -> bool -override Weaviate.Client.Models.Aggregate.TopOccurrence.GetHashCode() -> int -override Weaviate.Client.Models.Aggregate.TopOccurrence.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Aggregate.TopOccurrence.ToString() -> string! -override Weaviate.Client.Models.AggregateGroupByResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.AggregateGroupByResult.GetHashCode() -> int -override Weaviate.Client.Models.AggregateGroupByResult.Group.By.Equals(object? obj) -> bool -override Weaviate.Client.Models.AggregateGroupByResult.Group.By.GetHashCode() -> int -override Weaviate.Client.Models.AggregateGroupByResult.Group.By.ToString() -> string! -override Weaviate.Client.Models.AggregateGroupByResult.Group.Equals(object? obj) -> bool -override Weaviate.Client.Models.AggregateGroupByResult.Group.GetHashCode() -> int -override Weaviate.Client.Models.AggregateGroupByResult.Group.ToString() -> string! -override Weaviate.Client.Models.AggregateGroupByResult.ToString() -> string! -override Weaviate.Client.Models.AggregateResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.AggregateResult.GetHashCode() -> int -override Weaviate.Client.Models.AggregateResult.ToString() -> string! -override Weaviate.Client.Models.Alias.Equals(object? obj) -> bool -override Weaviate.Client.Models.Alias.GetHashCode() -> int -override Weaviate.Client.Models.Alias.ToString() -> string! -override Weaviate.Client.Models.AliasesResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.AliasesResource.GetHashCode() -> int -override Weaviate.Client.Models.AliasesResource.ToString() -> string! -override Weaviate.Client.Models.AndNestedFilter.$() -> Weaviate.Client.Models.AndNestedFilter! -override Weaviate.Client.Models.AndNestedFilter.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.AndNestedFilter.Equals(object? obj) -> bool -override Weaviate.Client.Models.AndNestedFilter.GetHashCode() -> int -override Weaviate.Client.Models.AndNestedFilter.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.AndNestedFilter.ToString() -> string! -override Weaviate.Client.Models.BM25Config.Equals(object? obj) -> bool -override Weaviate.Client.Models.BM25Config.GetHashCode() -> int -override Weaviate.Client.Models.BM25Config.ToString() -> string! -override Weaviate.Client.Models.BM25Operator.And.$() -> Weaviate.Client.Models.BM25Operator.And! -override Weaviate.Client.Models.BM25Operator.And.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.BM25Operator.And.Equals(object? obj) -> bool -override Weaviate.Client.Models.BM25Operator.And.GetHashCode() -> int -override Weaviate.Client.Models.BM25Operator.And.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.BM25Operator.And.ToString() -> string! -override Weaviate.Client.Models.BM25Operator.Equals(object? obj) -> bool -override Weaviate.Client.Models.BM25Operator.GetHashCode() -> int -override Weaviate.Client.Models.BM25Operator.Or.$() -> Weaviate.Client.Models.BM25Operator.Or! -override Weaviate.Client.Models.BM25Operator.Or.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.BM25Operator.Or.Equals(object? obj) -> bool -override Weaviate.Client.Models.BM25Operator.Or.GetHashCode() -> int -override Weaviate.Client.Models.BM25Operator.Or.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.BM25Operator.Or.ToString() -> string! -override Weaviate.Client.Models.BM25Operator.ToString() -> string! -override Weaviate.Client.Models.Backup.Equals(object? obj) -> bool -override Weaviate.Client.Models.Backup.GetHashCode() -> int -override Weaviate.Client.Models.Backup.ToString() -> string! -override Weaviate.Client.Models.BackupBackend.Equals(object? obj) -> bool -override Weaviate.Client.Models.BackupBackend.GetHashCode() -> int -override Weaviate.Client.Models.BackupBackend.ToString() -> string! -override Weaviate.Client.Models.BackupClientConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.BackupClientConfig.GetHashCode() -> int -override Weaviate.Client.Models.BackupClientConfig.ToString() -> string! -override Weaviate.Client.Models.BackupCreateRequest.Equals(object? obj) -> bool -override Weaviate.Client.Models.BackupCreateRequest.GetHashCode() -> int -override Weaviate.Client.Models.BackupCreateRequest.ToString() -> string! -override Weaviate.Client.Models.BackupRestoreRequest.Equals(object? obj) -> bool -override Weaviate.Client.Models.BackupRestoreRequest.GetHashCode() -> int -override Weaviate.Client.Models.BackupRestoreRequest.ToString() -> string! -override Weaviate.Client.Models.BackupsResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.BackupsResource.GetHashCode() -> int -override Weaviate.Client.Models.BackupsResource.ToString() -> string! -override Weaviate.Client.Models.BatchInsertRequest.Equals(object? obj) -> bool -override Weaviate.Client.Models.BatchInsertRequest.GetHashCode() -> int -override Weaviate.Client.Models.BatchInsertRequest.ToString() -> string! -override Weaviate.Client.Models.BatchInsertResponse.Equals(object? obj) -> bool -override Weaviate.Client.Models.BatchInsertResponse.GetHashCode() -> int -override Weaviate.Client.Models.BatchInsertResponse.ToString() -> string! -override Weaviate.Client.Models.BatchInsertResponseEntry.Equals(object? obj) -> bool -override Weaviate.Client.Models.BatchInsertResponseEntry.GetHashCode() -> int -override Weaviate.Client.Models.BatchInsertResponseEntry.ToString() -> string! -override Weaviate.Client.Models.BatchReferenceReturn.Equals(object? obj) -> bool -override Weaviate.Client.Models.BatchReferenceReturn.GetHashCode() -> int -override Weaviate.Client.Models.BatchReferenceReturn.ToString() -> string! -override Weaviate.Client.Models.Bm25ConfigUpdate.Equals(object? obj) -> bool -override Weaviate.Client.Models.Bm25ConfigUpdate.GetHashCode() -> int -override Weaviate.Client.Models.Bm25ConfigUpdate.ToString() -> string! -override Weaviate.Client.Models.ClusterNode.Equals(object? obj) -> bool -override Weaviate.Client.Models.ClusterNode.GetHashCode() -> int -override Weaviate.Client.Models.ClusterNode.ToString() -> string! -override Weaviate.Client.Models.ClusterNodeVerbose.$() -> Weaviate.Client.Models.ClusterNodeVerbose! -override Weaviate.Client.Models.ClusterNodeVerbose.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.ClusterNodeVerbose.Equals(object? obj) -> bool -override Weaviate.Client.Models.ClusterNodeVerbose.GetHashCode() -> int -override Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.Equals(object? obj) -> bool -override Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.GetHashCode() -> int -override Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.ToString() -> string! -override Weaviate.Client.Models.ClusterNodeVerbose.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.ClusterNodeVerbose.Shard.Equals(object? obj) -> bool -override Weaviate.Client.Models.ClusterNodeVerbose.Shard.GetHashCode() -> int -override Weaviate.Client.Models.ClusterNodeVerbose.Shard.ToString() -> string! -override Weaviate.Client.Models.ClusterNodeVerbose.ToString() -> string! -override Weaviate.Client.Models.CollectionConfig.$() -> Weaviate.Client.Models.CollectionConfig! -override Weaviate.Client.Models.CollectionConfig.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.CollectionConfig.Equals(Weaviate.Client.Models.CollectionConfig? other) -> bool -override Weaviate.Client.Models.CollectionConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.CollectionConfig.GetHashCode() -> int -override Weaviate.Client.Models.CollectionConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.CollectionConfig.ToString() -> string! -override Weaviate.Client.Models.CollectionConfigCommon.Equals(object? obj) -> bool -override Weaviate.Client.Models.CollectionConfigCommon.GetHashCode() -> int -override Weaviate.Client.Models.CollectionConfigCommon.ToString() -> string! -override Weaviate.Client.Models.CollectionConfigExport.$() -> Weaviate.Client.Models.CollectionConfigExport! -override Weaviate.Client.Models.CollectionConfigExport.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.CollectionConfigExport.Equals(object? obj) -> bool -override Weaviate.Client.Models.CollectionConfigExport.GetHashCode() -> int -override Weaviate.Client.Models.CollectionConfigExport.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.CollectionConfigExport.ToString() -> string! -override Weaviate.Client.Models.CollectionCreateParams.$() -> Weaviate.Client.Models.CollectionCreateParams! -override Weaviate.Client.Models.CollectionCreateParams.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.CollectionCreateParams.Equals(object? obj) -> bool -override Weaviate.Client.Models.CollectionCreateParams.GetHashCode() -> int -override Weaviate.Client.Models.CollectionCreateParams.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.CollectionCreateParams.ToString() -> string! -override Weaviate.Client.Models.CollectionUpdate.Equals(object? obj) -> bool -override Weaviate.Client.Models.CollectionUpdate.GetHashCode() -> int -override Weaviate.Client.Models.CollectionUpdate.ToString() -> string! -override Weaviate.Client.Models.CollectionsResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.CollectionsResource.GetHashCode() -> int -override Weaviate.Client.Models.CollectionsResource.ToString() -> string! -override Weaviate.Client.Models.CurrentUserInfo.Equals(object? obj) -> bool -override Weaviate.Client.Models.CurrentUserInfo.GetHashCode() -> int -override Weaviate.Client.Models.CurrentUserInfo.ToString() -> string! -override Weaviate.Client.Models.DataReference.Equals(object? obj) -> bool -override Weaviate.Client.Models.DataReference.GetHashCode() -> int -override Weaviate.Client.Models.DataReference.ToString() -> string! -override Weaviate.Client.Models.DataResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.DataResource.GetHashCode() -> int -override Weaviate.Client.Models.DataResource.ToString() -> string! -override Weaviate.Client.Models.DatabaseUser.Equals(object? obj) -> bool -override Weaviate.Client.Models.DatabaseUser.GetHashCode() -> int -override Weaviate.Client.Models.DatabaseUser.ToString() -> string! -override Weaviate.Client.Models.FilesystemBackend.$() -> Weaviate.Client.Models.FilesystemBackend! -override Weaviate.Client.Models.FilesystemBackend.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.FilesystemBackend.Equals(object? obj) -> bool -override Weaviate.Client.Models.FilesystemBackend.GetHashCode() -> int -override Weaviate.Client.Models.FilesystemBackend.Path.get -> string? -override Weaviate.Client.Models.FilesystemBackend.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.FilesystemBackend.Provider.get -> Weaviate.Client.Models.BackupStorageProvider -override Weaviate.Client.Models.FilesystemBackend.ToString() -> string! -override Weaviate.Client.Models.Filter.Equals(object? obj) -> bool -override Weaviate.Client.Models.Filter.GetHashCode() -> int -override Weaviate.Client.Models.Filter.ToString() -> string! -override Weaviate.Client.Models.FlexibleConverter.Read(ref System.Text.Json.Utf8JsonReader reader, System.Type! typeToConvert, System.Text.Json.JsonSerializerOptions! options) -> T? -override Weaviate.Client.Models.FlexibleConverter.Write(System.Text.Json.Utf8JsonWriter! writer, T? value, System.Text.Json.JsonSerializerOptions! options) -> void -override Weaviate.Client.Models.FlexibleStringConverter.Read(ref System.Text.Json.Utf8JsonReader reader, System.Type! typeToConvert, System.Text.Json.JsonSerializerOptions! options) -> string? -override Weaviate.Client.Models.FlexibleStringConverter.Write(System.Text.Json.Utf8JsonWriter! writer, string? value, System.Text.Json.JsonSerializerOptions! options) -> void -override Weaviate.Client.Models.Generative.Providers.AWSBedrock.$() -> Weaviate.Client.Models.Generative.Providers.AWSBedrock! -override Weaviate.Client.Models.Generative.Providers.AWSBedrock.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.AWSBedrock.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.AWSBedrock.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.AWSBedrock.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.AWSBedrock.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.AWSSagemaker.$() -> Weaviate.Client.Models.Generative.Providers.AWSSagemaker! -override Weaviate.Client.Models.Generative.Providers.AWSSagemaker.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.AWSSagemaker.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.AWSSagemaker.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.AWSSagemaker.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.Anthropic.$() -> Weaviate.Client.Models.Generative.Providers.Anthropic! -override Weaviate.Client.Models.Generative.Providers.Anthropic.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.Anthropic.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.Anthropic.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.Anthropic.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.Anthropic.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.Anyscale.$() -> Weaviate.Client.Models.Generative.Providers.Anyscale! -override Weaviate.Client.Models.Generative.Providers.Anyscale.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.Anyscale.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.Anyscale.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.Anyscale.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.Anyscale.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.AzureOpenAI.$() -> Weaviate.Client.Models.Generative.Providers.AzureOpenAI! -override Weaviate.Client.Models.Generative.Providers.AzureOpenAI.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.AzureOpenAI.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.AzureOpenAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.AzureOpenAI.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.Cohere.$() -> Weaviate.Client.Models.Generative.Providers.Cohere! -override Weaviate.Client.Models.Generative.Providers.Cohere.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.Cohere.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.Cohere.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.Cohere.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.Cohere.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.ContextualAI.$() -> Weaviate.Client.Models.Generative.Providers.ContextualAI! -override Weaviate.Client.Models.Generative.Providers.ContextualAI.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.ContextualAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.ContextualAI.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.ContextualAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.ContextualAI.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.Databricks.$() -> Weaviate.Client.Models.Generative.Providers.Databricks! -override Weaviate.Client.Models.Generative.Providers.Databricks.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.Databricks.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.Databricks.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.Databricks.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.Databricks.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.Dummy.$() -> Weaviate.Client.Models.Generative.Providers.Dummy! -override Weaviate.Client.Models.Generative.Providers.Dummy.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.Dummy.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.Dummy.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.Dummy.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.Dummy.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.FriendliAI.$() -> Weaviate.Client.Models.Generative.Providers.FriendliAI! -override Weaviate.Client.Models.Generative.Providers.FriendliAI.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.FriendliAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.FriendliAI.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.FriendliAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.FriendliAI.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.GoogleGemini.$() -> Weaviate.Client.Models.Generative.Providers.GoogleGemini! -override Weaviate.Client.Models.Generative.Providers.GoogleGemini.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.GoogleGemini.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.GoogleGemini.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.GoogleGemini.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.GoogleGemini.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.GoogleVertex.$() -> Weaviate.Client.Models.Generative.Providers.GoogleVertex! -override Weaviate.Client.Models.Generative.Providers.GoogleVertex.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.GoogleVertex.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.GoogleVertex.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.GoogleVertex.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.GoogleVertex.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.Mistral.$() -> Weaviate.Client.Models.Generative.Providers.Mistral! -override Weaviate.Client.Models.Generative.Providers.Mistral.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.Mistral.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.Mistral.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.Mistral.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.Mistral.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.Nvidia.$() -> Weaviate.Client.Models.Generative.Providers.Nvidia! -override Weaviate.Client.Models.Generative.Providers.Nvidia.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.Nvidia.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.Nvidia.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.Nvidia.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.Nvidia.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.Ollama.$() -> Weaviate.Client.Models.Generative.Providers.Ollama! -override Weaviate.Client.Models.Generative.Providers.Ollama.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.Ollama.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.Ollama.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.Ollama.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.Ollama.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.OpenAI.$() -> Weaviate.Client.Models.Generative.Providers.OpenAI! -override Weaviate.Client.Models.Generative.Providers.OpenAI.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.OpenAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.OpenAI.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.OpenAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.OpenAI.ToString() -> string! -override Weaviate.Client.Models.Generative.Providers.XAI.$() -> Weaviate.Client.Models.Generative.Providers.XAI! -override Weaviate.Client.Models.Generative.Providers.XAI.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Generative.Providers.XAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.Generative.Providers.XAI.GetHashCode() -> int -override Weaviate.Client.Models.Generative.Providers.XAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Generative.Providers.XAI.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.AWS.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.AWS.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.AWS.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.Anthropic.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.Anthropic.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.Anthropic.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.Anyscale.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.Anyscale.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.Anyscale.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.$() -> Weaviate.Client.Models.GenerativeConfig.AzureOpenAI! -override Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.Type.get -> string! -override Weaviate.Client.Models.GenerativeConfig.Cohere.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.Cohere.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.Cohere.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.ContextualAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.ContextualAI.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.ContextualAI.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.Custom.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.Custom.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.Custom.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.Databricks.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.Databricks.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.Databricks.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.FriendliAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.FriendliAI.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.FriendliAI.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.GoogleGemini.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.GoogleGemini.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.GoogleGemini.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.GoogleVertex.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.GoogleVertex.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.GoogleVertex.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.Mistral.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.Mistral.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.Mistral.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.Nvidia.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.Nvidia.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.Nvidia.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.Ollama.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.Ollama.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.Ollama.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.OpenAI.$() -> Weaviate.Client.Models.GenerativeConfig.OpenAI! -override Weaviate.Client.Models.GenerativeConfig.OpenAI.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GenerativeConfig.OpenAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.OpenAI.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.OpenAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GenerativeConfig.OpenAI.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.OpenAI.Type.get -> string! -override Weaviate.Client.Models.GenerativeConfig.OpenAIBase.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.OpenAIBase.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.OpenAIBase.ToString() -> string! -override Weaviate.Client.Models.GenerativeConfig.XAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeConfig.XAI.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeConfig.XAI.ToString() -> string! -override Weaviate.Client.Models.GenerativeDebug.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeDebug.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeDebug.ToString() -> string! -override Weaviate.Client.Models.GenerativeGroupByObject.$() -> Weaviate.Client.Models.GenerativeGroupByObject! -override Weaviate.Client.Models.GenerativeGroupByObject.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GenerativeGroupByObject.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeGroupByObject.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeGroupByObject.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GenerativeGroupByObject.ToString() -> string! -override Weaviate.Client.Models.GenerativeGroupByResult.$() -> Weaviate.Client.Models.GenerativeGroupByResult! -override Weaviate.Client.Models.GenerativeGroupByResult.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GenerativeGroupByResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeGroupByResult.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeGroupByResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GenerativeGroupByResult.ToString() -> string! -override Weaviate.Client.Models.GenerativePrompt.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativePrompt.GetHashCode() -> int -override Weaviate.Client.Models.GenerativePrompt.ToString() -> string! -override Weaviate.Client.Models.GenerativeProvider.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeProvider.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeProvider.ToString() -> string! -override Weaviate.Client.Models.GenerativeReply.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeReply.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeReply.ToString() -> string! -override Weaviate.Client.Models.GenerativeResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeResult.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeResult.ToString() -> string! -override Weaviate.Client.Models.GenerativeWeaviateGroup.$() -> Weaviate.Client.Models.GenerativeWeaviateGroup! -override Weaviate.Client.Models.GenerativeWeaviateGroup.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GenerativeWeaviateGroup.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeWeaviateGroup.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeWeaviateGroup.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GenerativeWeaviateGroup.ToString() -> string! -override Weaviate.Client.Models.GenerativeWeaviateObject.$() -> Weaviate.Client.Models.GenerativeWeaviateObject! -override Weaviate.Client.Models.GenerativeWeaviateObject.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GenerativeWeaviateObject.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeWeaviateObject.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeWeaviateObject.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GenerativeWeaviateObject.ToString() -> string! -override Weaviate.Client.Models.GenerativeWeaviateResult.$() -> Weaviate.Client.Models.GenerativeWeaviateResult! -override Weaviate.Client.Models.GenerativeWeaviateResult.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GenerativeWeaviateResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.GenerativeWeaviateResult.GetHashCode() -> int -override Weaviate.Client.Models.GenerativeWeaviateResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GenerativeWeaviateResult.ToString() -> string! -override Weaviate.Client.Models.GeoCoordinate.Equals(object? obj) -> bool -override Weaviate.Client.Models.GeoCoordinate.GetHashCode() -> int -override Weaviate.Client.Models.GeoCoordinate.ToString() -> string! -override Weaviate.Client.Models.GeoCoordinateConstraint.Equals(object? obj) -> bool -override Weaviate.Client.Models.GeoCoordinateConstraint.GetHashCode() -> int -override Weaviate.Client.Models.GeoCoordinateConstraint.ToString() -> string! -override Weaviate.Client.Models.GroupByObject.$() -> Weaviate.Client.Models.GroupByObject! -override Weaviate.Client.Models.GroupByObject.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GroupByObject.Equals(object? obj) -> bool -override Weaviate.Client.Models.GroupByObject.GetHashCode() -> int -override Weaviate.Client.Models.GroupByObject.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GroupByObject.ToString() -> string! -override Weaviate.Client.Models.GroupByRequest.Equals(object? obj) -> bool -override Weaviate.Client.Models.GroupByRequest.GetHashCode() -> int -override Weaviate.Client.Models.GroupByRequest.ToString() -> string! -override Weaviate.Client.Models.GroupByResult.$() -> Weaviate.Client.Models.GroupByResult! -override Weaviate.Client.Models.GroupByResult.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GroupByResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.GroupByResult.GetHashCode() -> int -override Weaviate.Client.Models.GroupByResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GroupByResult.ToString() -> string! -override Weaviate.Client.Models.GroupByResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.GroupByResult.GetHashCode() -> int -override Weaviate.Client.Models.GroupByResult.ToString() -> string! -override Weaviate.Client.Models.GroupRoleAssignment.Equals(object? obj) -> bool -override Weaviate.Client.Models.GroupRoleAssignment.GetHashCode() -> int -override Weaviate.Client.Models.GroupRoleAssignment.ToString() -> string! -override Weaviate.Client.Models.GroupedTask.$() -> Weaviate.Client.Models.GroupedTask! -override Weaviate.Client.Models.GroupedTask.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.GroupedTask.Equals(object? obj) -> bool -override Weaviate.Client.Models.GroupedTask.GetHashCode() -> int -override Weaviate.Client.Models.GroupedTask.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.GroupedTask.ToString() -> string! -override Weaviate.Client.Models.GroupsResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.GroupsResource.GetHashCode() -> int -override Weaviate.Client.Models.GroupsResource.ToString() -> string! -override Weaviate.Client.Models.HybridNearText.Equals(object? obj) -> bool -override Weaviate.Client.Models.HybridNearText.GetHashCode() -> int -override Weaviate.Client.Models.HybridNearText.ToString() -> string! -override Weaviate.Client.Models.HybridNearVector.Equals(object? obj) -> bool -override Weaviate.Client.Models.HybridNearVector.GetHashCode() -> int -override Weaviate.Client.Models.HybridNearVector.ToString() -> string! -override Weaviate.Client.Models.InvertedIndexConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.InvertedIndexConfig.GetHashCode() -> int -override Weaviate.Client.Models.InvertedIndexConfig.ToString() -> string! -override Weaviate.Client.Models.InvertedIndexConfigUpdate.Equals(object? obj) -> bool -override Weaviate.Client.Models.InvertedIndexConfigUpdate.GetHashCode() -> int -override Weaviate.Client.Models.InvertedIndexConfigUpdate.ToString() -> string! -override Weaviate.Client.Models.JsonConverterEmptyCollectionAsNull.CanConvert(System.Type! typeToConvert) -> bool -override Weaviate.Client.Models.JsonConverterEmptyCollectionAsNull.Read(ref System.Text.Json.Utf8JsonReader reader, System.Type! typeToConvert, System.Text.Json.JsonSerializerOptions! options) -> System.Collections.IEnumerable? -override Weaviate.Client.Models.JsonConverterEmptyCollectionAsNull.Write(System.Text.Json.Utf8JsonWriter! writer, System.Collections.IEnumerable! value, System.Text.Json.JsonSerializerOptions! options) -> void -override Weaviate.Client.Models.Metadata.Equals(object? obj) -> bool -override Weaviate.Client.Models.Metadata.GetHashCode() -> int -override Weaviate.Client.Models.Metadata.ToString() -> string! -override Weaviate.Client.Models.MetadataQuery.Equals(object? obj) -> bool -override Weaviate.Client.Models.MetadataQuery.GetHashCode() -> int -override Weaviate.Client.Models.MetadataQuery.ToString() -> string! -override Weaviate.Client.Models.ModuleConfigList.Equals(object? obj) -> bool -override Weaviate.Client.Models.ModuleConfigList.GetHashCode() -> int -override Weaviate.Client.Models.Move.Equals(object? obj) -> bool -override Weaviate.Client.Models.Move.GetHashCode() -> int -override Weaviate.Client.Models.Move.ToString() -> string! -override Weaviate.Client.Models.MultiTenancyConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.MultiTenancyConfig.GetHashCode() -> int -override Weaviate.Client.Models.MultiTenancyConfig.ToString() -> string! -override Weaviate.Client.Models.NearVectorInput.Equals(object? obj) -> bool -override Weaviate.Client.Models.NearVectorInput.GetHashCode() -> int -override Weaviate.Client.Models.NearVectorInput.ToString() -> string! -override Weaviate.Client.Models.NestedFilter.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.NestedFilter.Equals(object? obj) -> bool -override Weaviate.Client.Models.NestedFilter.GetHashCode() -> int -override Weaviate.Client.Models.NestedFilter.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.NestedFilter.ToString() -> string! -override Weaviate.Client.Models.NodesResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.NodesResource.GetHashCode() -> int -override Weaviate.Client.Models.NodesResource.ToString() -> string! -override Weaviate.Client.Models.NotNestedFilter.$() -> Weaviate.Client.Models.NotNestedFilter! -override Weaviate.Client.Models.NotNestedFilter.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.NotNestedFilter.Equals(object? obj) -> bool -override Weaviate.Client.Models.NotNestedFilter.GetHashCode() -> int -override Weaviate.Client.Models.NotNestedFilter.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.NotNestedFilter.ToString() -> string! -override Weaviate.Client.Models.ObjectReference.Equals(object? obj) -> bool -override Weaviate.Client.Models.ObjectReference.GetHashCode() -> int -override Weaviate.Client.Models.ObjectReference.ToString() -> string! -override Weaviate.Client.Models.ObjectStorageBackend.$() -> Weaviate.Client.Models.ObjectStorageBackend! -override Weaviate.Client.Models.ObjectStorageBackend.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.ObjectStorageBackend.Equals(object? obj) -> bool -override Weaviate.Client.Models.ObjectStorageBackend.GetHashCode() -> int -override Weaviate.Client.Models.ObjectStorageBackend.Path.get -> string? -override Weaviate.Client.Models.ObjectStorageBackend.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.ObjectStorageBackend.Provider.get -> Weaviate.Client.Models.BackupStorageProvider -override Weaviate.Client.Models.ObjectStorageBackend.ToString() -> string! -override Weaviate.Client.Models.OrNestedFilter.$() -> Weaviate.Client.Models.OrNestedFilter! -override Weaviate.Client.Models.OrNestedFilter.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.OrNestedFilter.Equals(object? obj) -> bool -override Weaviate.Client.Models.OrNestedFilter.GetHashCode() -> int -override Weaviate.Client.Models.OrNestedFilter.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.OrNestedFilter.ToString() -> string! -override Weaviate.Client.Models.PhoneNumber.Equals(object? obj) -> bool -override Weaviate.Client.Models.PhoneNumber.GetHashCode() -> int -override Weaviate.Client.Models.PhoneNumber.ToString() -> string! -override Weaviate.Client.Models.Property.Equals(object? obj) -> bool -override Weaviate.Client.Models.Property.GetHashCode() -> int -override Weaviate.Client.Models.Property.ToString() -> string! -override Weaviate.Client.Models.PropertyFilter.$() -> Weaviate.Client.Models.PropertyFilter! -override Weaviate.Client.Models.PropertyFilter.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.PropertyFilter.Equals(object? obj) -> bool -override Weaviate.Client.Models.PropertyFilter.GetHashCode() -> int -override Weaviate.Client.Models.PropertyFilter.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.PropertyFilter.ToString() -> string! -override Weaviate.Client.Models.PropertyUpdate.Equals(object? obj) -> bool -override Weaviate.Client.Models.PropertyUpdate.GetHashCode() -> int -override Weaviate.Client.Models.PropertyUpdate.ToString() -> string! -override Weaviate.Client.Models.QueryReference.Equals(object? obj) -> bool -override Weaviate.Client.Models.QueryReference.GetHashCode() -> int -override Weaviate.Client.Models.QueryReference.ToString() -> string! -override Weaviate.Client.Models.Reference.Equals(object? obj) -> bool -override Weaviate.Client.Models.Reference.GetHashCode() -> int -override Weaviate.Client.Models.Reference.ToString() -> string! -override Weaviate.Client.Models.ReferenceFilter.$() -> Weaviate.Client.Models.ReferenceFilter! -override Weaviate.Client.Models.ReferenceFilter.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.ReferenceFilter.Equals(object? obj) -> bool -override Weaviate.Client.Models.ReferenceFilter.GetHashCode() -> int -override Weaviate.Client.Models.ReferenceFilter.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.ReferenceFilter.ToString() -> string! -override Weaviate.Client.Models.ReferenceUpdate.Equals(object? obj) -> bool -override Weaviate.Client.Models.ReferenceUpdate.GetHashCode() -> int -override Weaviate.Client.Models.ReferenceUpdate.ToString() -> string! -override Weaviate.Client.Models.ReplicateRequest.Equals(object? obj) -> bool -override Weaviate.Client.Models.ReplicateRequest.GetHashCode() -> int -override Weaviate.Client.Models.ReplicateRequest.ToString() -> string! -override Weaviate.Client.Models.ReplicateResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.ReplicateResource.GetHashCode() -> int -override Weaviate.Client.Models.ReplicateResource.ToString() -> string! -override Weaviate.Client.Models.ReplicationConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.ReplicationConfig.GetHashCode() -> int -override Weaviate.Client.Models.ReplicationConfig.ToString() -> string! -override Weaviate.Client.Models.ReplicationOperation.Equals(object? obj) -> bool -override Weaviate.Client.Models.ReplicationOperation.GetHashCode() -> int -override Weaviate.Client.Models.ReplicationOperation.ToString() -> string! -override Weaviate.Client.Models.ReplicationOperationError.Equals(object? obj) -> bool -override Weaviate.Client.Models.ReplicationOperationError.GetHashCode() -> int -override Weaviate.Client.Models.ReplicationOperationError.ToString() -> string! -override Weaviate.Client.Models.ReplicationOperationStatus.Equals(object? obj) -> bool -override Weaviate.Client.Models.ReplicationOperationStatus.GetHashCode() -> int -override Weaviate.Client.Models.ReplicationOperationStatus.ToString() -> string! -override Weaviate.Client.Models.Rerank.Equals(object? obj) -> bool -override Weaviate.Client.Models.Rerank.GetHashCode() -> int -override Weaviate.Client.Models.Rerank.ToString() -> string! -override Weaviate.Client.Models.Reranker.Cohere.Equals(object? obj) -> bool -override Weaviate.Client.Models.Reranker.Cohere.GetHashCode() -> int -override Weaviate.Client.Models.Reranker.Cohere.ToString() -> string! -override Weaviate.Client.Models.Reranker.ContextualAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.Reranker.ContextualAI.GetHashCode() -> int -override Weaviate.Client.Models.Reranker.ContextualAI.ToString() -> string! -override Weaviate.Client.Models.Reranker.Custom.Equals(object? obj) -> bool -override Weaviate.Client.Models.Reranker.Custom.GetHashCode() -> int -override Weaviate.Client.Models.Reranker.Custom.ToString() -> string! -override Weaviate.Client.Models.Reranker.JinaAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.Reranker.JinaAI.GetHashCode() -> int -override Weaviate.Client.Models.Reranker.JinaAI.ToString() -> string! -override Weaviate.Client.Models.Reranker.None.Equals(object? obj) -> bool -override Weaviate.Client.Models.Reranker.None.GetHashCode() -> int -override Weaviate.Client.Models.Reranker.None.ToString() -> string! -override Weaviate.Client.Models.Reranker.Nvidia.Equals(object? obj) -> bool -override Weaviate.Client.Models.Reranker.Nvidia.GetHashCode() -> int -override Weaviate.Client.Models.Reranker.Nvidia.ToString() -> string! -override Weaviate.Client.Models.Reranker.Transformers.Equals(object? obj) -> bool -override Weaviate.Client.Models.Reranker.Transformers.GetHashCode() -> int -override Weaviate.Client.Models.Reranker.Transformers.ToString() -> string! -override Weaviate.Client.Models.Reranker.VoyageAI.Equals(object? obj) -> bool -override Weaviate.Client.Models.Reranker.VoyageAI.GetHashCode() -> int -override Weaviate.Client.Models.Reranker.VoyageAI.ToString() -> string! -override Weaviate.Client.Models.RoleInfo.Equals(object? obj) -> bool -override Weaviate.Client.Models.RoleInfo.GetHashCode() -> int -override Weaviate.Client.Models.RoleInfo.ToString() -> string! -override Weaviate.Client.Models.RolesResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.RolesResource.GetHashCode() -> int -override Weaviate.Client.Models.RolesResource.ToString() -> string! -override Weaviate.Client.Models.ShardInfo.Equals(object? obj) -> bool -override Weaviate.Client.Models.ShardInfo.GetHashCode() -> int -override Weaviate.Client.Models.ShardInfo.ToString() -> string! -override Weaviate.Client.Models.ShardingConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.ShardingConfig.GetHashCode() -> int -override Weaviate.Client.Models.ShardingConfig.ToString() -> string! -override Weaviate.Client.Models.SinglePrompt.$() -> Weaviate.Client.Models.SinglePrompt! -override Weaviate.Client.Models.SinglePrompt.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.SinglePrompt.Equals(object? obj) -> bool -override Weaviate.Client.Models.SinglePrompt.GetHashCode() -> int -override Weaviate.Client.Models.SinglePrompt.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.SinglePrompt.ToString() -> string! -override Weaviate.Client.Models.Sort.Equals(object? obj) -> bool -override Weaviate.Client.Models.Sort.GetHashCode() -> int -override Weaviate.Client.Models.Sort.ToString() -> string! -override Weaviate.Client.Models.StopwordConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.StopwordConfig.GetHashCode() -> int -override Weaviate.Client.Models.StopwordConfig.ToString() -> string! -override Weaviate.Client.Models.StopwordsConfigUpdate.Equals(object? obj) -> bool -override Weaviate.Client.Models.StopwordsConfigUpdate.GetHashCode() -> int -override Weaviate.Client.Models.StopwordsConfigUpdate.ToString() -> string! -override Weaviate.Client.Models.Tenant.Equals(object? obj) -> bool -override Weaviate.Client.Models.Tenant.GetHashCode() -> int -override Weaviate.Client.Models.Tenant.ToString() -> string! -override Weaviate.Client.Models.TenantsResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.TenantsResource.GetHashCode() -> int -override Weaviate.Client.Models.TenantsResource.ToString() -> string! -override Weaviate.Client.Models.TimeFilter.$() -> Weaviate.Client.Models.TimeFilter! -override Weaviate.Client.Models.TimeFilter.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.TimeFilter.Equals(object? obj) -> bool -override Weaviate.Client.Models.TimeFilter.GetHashCode() -> int -override Weaviate.Client.Models.TimeFilter.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.TimeFilter.ToString() -> string! -override Weaviate.Client.Models.Typed.GenerativeGroupByObject.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Typed.GenerativeGroupByObject.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.GenerativeGroupByObject.GetHashCode() -> int -override Weaviate.Client.Models.Typed.GenerativeGroupByObject.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Typed.GenerativeGroupByObject.ToString() -> string! -override Weaviate.Client.Models.Typed.GenerativeGroupByResult.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Typed.GenerativeGroupByResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.GenerativeGroupByResult.GetHashCode() -> int -override Weaviate.Client.Models.Typed.GenerativeGroupByResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Typed.GenerativeGroupByResult.ToString() -> string! -override Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.GetHashCode() -> int -override Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.ToString() -> string! -override Weaviate.Client.Models.Typed.GenerativeWeaviateObject.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Typed.GenerativeWeaviateObject.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.GenerativeWeaviateObject.GetHashCode() -> int -override Weaviate.Client.Models.Typed.GenerativeWeaviateObject.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Typed.GenerativeWeaviateObject.ToString() -> string! -override Weaviate.Client.Models.Typed.GenerativeWeaviateResult.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Typed.GenerativeWeaviateResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.GenerativeWeaviateResult.GetHashCode() -> int -override Weaviate.Client.Models.Typed.GenerativeWeaviateResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Typed.GenerativeWeaviateResult.ToString() -> string! -override Weaviate.Client.Models.Typed.GroupByObject.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Typed.GroupByObject.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.GroupByObject.GetHashCode() -> int -override Weaviate.Client.Models.Typed.GroupByObject.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Typed.GroupByObject.ToString() -> string! -override Weaviate.Client.Models.Typed.GroupByResult.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Typed.GroupByResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.GroupByResult.GetHashCode() -> int -override Weaviate.Client.Models.Typed.GroupByResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Typed.GroupByResult.ToString() -> string! -override Weaviate.Client.Models.Typed.WeaviateGroup.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.WeaviateGroup.GetHashCode() -> int -override Weaviate.Client.Models.Typed.WeaviateGroup.ToString() -> string! -override Weaviate.Client.Models.Typed.WeaviateGroup.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.Typed.WeaviateGroup.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.WeaviateGroup.GetHashCode() -> int -override Weaviate.Client.Models.Typed.WeaviateGroup.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.Typed.WeaviateGroup.ToString() -> string! -override Weaviate.Client.Models.Typed.WeaviateObject.Equals(object? obj) -> bool -override Weaviate.Client.Models.Typed.WeaviateObject.GetHashCode() -> int -override Weaviate.Client.Models.Typed.WeaviateObject.ToString() -> string! -override Weaviate.Client.Models.TypedBase.Equals(object? obj) -> bool -override Weaviate.Client.Models.TypedBase.GetHashCode() -> int -override Weaviate.Client.Models.TypedBase.ToString() -> string! -override Weaviate.Client.Models.TypedGuid.$() -> Weaviate.Client.Models.TypedGuid! -override Weaviate.Client.Models.TypedGuid.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.TypedGuid.Equals(object? obj) -> bool -override Weaviate.Client.Models.TypedGuid.GetHashCode() -> int -override Weaviate.Client.Models.TypedGuid.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.TypedGuid.ToString() -> string! -override Weaviate.Client.Models.TypedValue.$() -> Weaviate.Client.Models.TypedValue! -override Weaviate.Client.Models.TypedValue.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.TypedValue.Equals(object? obj) -> bool -override Weaviate.Client.Models.TypedValue.GetHashCode() -> int -override Weaviate.Client.Models.TypedValue.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.TypedValue.ToString() -> string! -override Weaviate.Client.Models.UserMetadata.Equals(object? obj) -> bool -override Weaviate.Client.Models.UserMetadata.GetHashCode() -> int -override Weaviate.Client.Models.UserMetadata.ToString() -> string! -override Weaviate.Client.Models.UserRoleAssignment.Equals(object? obj) -> bool -override Weaviate.Client.Models.UserRoleAssignment.GetHashCode() -> int -override Weaviate.Client.Models.UserRoleAssignment.ToString() -> string! -override Weaviate.Client.Models.UsersResource.Equals(object? obj) -> bool -override Weaviate.Client.Models.UsersResource.GetHashCode() -> int -override Weaviate.Client.Models.UsersResource.ToString() -> string! -override Weaviate.Client.Models.Vector.Equals(object? obj) -> bool -override Weaviate.Client.Models.Vector.GetHashCode() -> int -override Weaviate.Client.Models.Vector.ToString() -> string! -override Weaviate.Client.Models.VectorConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorConfig.GetHashCode() -> int -override Weaviate.Client.Models.VectorConfig.ToString() -> string! -override Weaviate.Client.Models.VectorConfigList.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorConfigList.GetHashCode() -> int -override Weaviate.Client.Models.VectorConfigList.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.Dynamic.$() -> Weaviate.Client.Models.VectorIndex.Dynamic! -override Weaviate.Client.Models.VectorIndex.Dynamic.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndex.Dynamic.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndex.Dynamic.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.Dynamic.Type.get -> string! -override Weaviate.Client.Models.VectorIndex.Flat.$() -> Weaviate.Client.Models.VectorIndex.Flat! -override Weaviate.Client.Models.VectorIndex.Flat.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndex.Flat.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndex.Flat.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.Flat.Type.get -> string! -override Weaviate.Client.Models.VectorIndex.HNSW.$() -> Weaviate.Client.Models.VectorIndex.HNSW! -override Weaviate.Client.Models.VectorIndex.HNSW.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndex.HNSW.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndex.HNSW.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.HNSW.Type.get -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.BQ.$() -> Weaviate.Client.Models.VectorIndex.Quantizers.BQ! -override Weaviate.Client.Models.VectorIndex.Quantizers.BQ.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.VectorIndex.Quantizers.BQ.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.BQ.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndex.Quantizers.BQ.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.BQ.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.BQ.Type.get -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.None.$() -> Weaviate.Client.Models.VectorIndex.Quantizers.None! -override Weaviate.Client.Models.VectorIndex.Quantizers.None.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.VectorIndex.Quantizers.None.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.None.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndex.Quantizers.None.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.None.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.None.Type.get -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.$() -> Weaviate.Client.Models.VectorIndex.Quantizers.PQ! -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Type.get -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.RQ.$() -> Weaviate.Client.Models.VectorIndex.Quantizers.RQ! -override Weaviate.Client.Models.VectorIndex.Quantizers.RQ.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.VectorIndex.Quantizers.RQ.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.RQ.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndex.Quantizers.RQ.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.RQ.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.RQ.Type.get -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.SQ.$() -> Weaviate.Client.Models.VectorIndex.Quantizers.SQ! -override Weaviate.Client.Models.VectorIndex.Quantizers.SQ.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.VectorIndex.Quantizers.SQ.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.SQ.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndex.Quantizers.SQ.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.VectorIndex.Quantizers.SQ.ToString() -> string! -override Weaviate.Client.Models.VectorIndex.Quantizers.SQ.Type.get -> string! -override Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.ToString() -> string! -override Weaviate.Client.Models.VectorIndexConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndexConfig.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.ToString() -> string! -override Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.$() -> Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding! -override Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.ToString() -> string! -override Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.ToString() -> string! -override Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.GetHashCode() -> int -override Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.ToString() -> string! -override Weaviate.Client.Models.VectorIndexConfig.ToString() -> string! -override Weaviate.Client.Models.VectorMulti.$() -> Weaviate.Client.Models.VectorMulti! -override Weaviate.Client.Models.VectorMulti.Count.get -> int -override Weaviate.Client.Models.VectorMulti.Dimensions.get -> int -override Weaviate.Client.Models.VectorMulti.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorMulti.GetHashCode() -> int -override Weaviate.Client.Models.VectorMulti.ToString() -> string! -override Weaviate.Client.Models.VectorMulti.ValueType.get -> System.Type! -override Weaviate.Client.Models.VectorSingle.$() -> Weaviate.Client.Models.VectorSingle! -override Weaviate.Client.Models.VectorSingle.Count.get -> int -override Weaviate.Client.Models.VectorSingle.Dimensions.get -> int -override Weaviate.Client.Models.VectorSingle.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorSingle.GetHashCode() -> int -override Weaviate.Client.Models.VectorSingle.ToString() -> string! -override Weaviate.Client.Models.VectorSingle.ValueType.get -> System.Type! -override Weaviate.Client.Models.VectorizerConfig.Equals(object? obj) -> bool -override Weaviate.Client.Models.VectorizerConfig.GetHashCode() -> int -override Weaviate.Client.Models.VectorizerConfig.ToString() -> string! -override Weaviate.Client.Models.WeaviateGroup.$() -> Weaviate.Client.Models.WeaviateGroup! -override Weaviate.Client.Models.WeaviateGroup.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.WeaviateGroup.Equals(object? obj) -> bool -override Weaviate.Client.Models.WeaviateGroup.GetHashCode() -> int -override Weaviate.Client.Models.WeaviateGroup.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.WeaviateGroup.ToString() -> string! -override Weaviate.Client.Models.WeaviateGroup.Equals(object? obj) -> bool -override Weaviate.Client.Models.WeaviateGroup.GetHashCode() -> int -override Weaviate.Client.Models.WeaviateGroup.ToString() -> string! -override Weaviate.Client.Models.WeaviateObject.Equals(object? obj) -> bool -override Weaviate.Client.Models.WeaviateObject.GetHashCode() -> int -override Weaviate.Client.Models.WeaviateObject.ToString() -> string! -override Weaviate.Client.Models.WeaviateResult.$() -> Weaviate.Client.Models.WeaviateResult! -override Weaviate.Client.Models.WeaviateResult.EqualityContract.get -> System.Type! -override Weaviate.Client.Models.WeaviateResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.WeaviateResult.GetHashCode() -> int -override Weaviate.Client.Models.WeaviateResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -override Weaviate.Client.Models.WeaviateResult.ToString() -> string! -override Weaviate.Client.Models.WeaviateResult.Equals(object? obj) -> bool -override Weaviate.Client.Models.WeaviateResult.GetHashCode() -> int -override Weaviate.Client.Models.WeaviateResult.ToString() -> string! -override Weaviate.Client.Models.WeightedField.Equals(object? obj) -> bool -override Weaviate.Client.Models.WeightedField.GetHashCode() -> int -override Weaviate.Client.Models.WeightedField.ToString() -> string! -override Weaviate.Client.OAuthConfig.Equals(object? obj) -> bool -override Weaviate.Client.OAuthConfig.GetHashCode() -> int -override Weaviate.Client.OAuthConfig.ToString() -> string! -override Weaviate.Client.RetryPolicy.Equals(object? obj) -> bool -override Weaviate.Client.RetryPolicy.GetHashCode() -> int -override Weaviate.Client.RetryPolicy.ToString() -> string! -override Weaviate.Client.WeaviateNotFoundException.ToString() -> string! -override abstract Weaviate.Client.Models.Aggregate.Numeric.$() -> Weaviate.Client.Models.Aggregate.Numeric! -override abstract Weaviate.Client.Models.NestedFilter.$() -> Weaviate.Client.Models.NestedFilter! -override abstract Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.$() -> Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat! -override sealed Weaviate.Client.Models.Aggregate.Boolean.Equals(Weaviate.Client.Models.Aggregate.Property? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Date.Equals(Weaviate.Client.Models.Aggregate.Property? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Integer.Equals(Weaviate.Client.Models.Aggregate.Numeric? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Metric.Boolean.Equals(Weaviate.Client.Models.Aggregate.Metric? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Metric.Date.Equals(Weaviate.Client.Models.Aggregate.Metric? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Metric.Integer.Equals(Weaviate.Client.Models.Aggregate.Metric? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Metric.Number.Equals(Weaviate.Client.Models.Aggregate.Metric? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Metric.Text.Equals(Weaviate.Client.Models.Aggregate.Metric? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Number.Equals(Weaviate.Client.Models.Aggregate.Numeric? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Numeric.Equals(Weaviate.Client.Models.Aggregate.Property? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.Text.Equals(Weaviate.Client.Models.Aggregate.Property? other) -> bool -override sealed Weaviate.Client.Models.Aggregate.TopOccurrence.Equals(Weaviate.Client.Models.Aggregate.Property? other) -> bool -override sealed Weaviate.Client.Models.AndNestedFilter.Equals(Weaviate.Client.Models.NestedFilter? other) -> bool -override sealed Weaviate.Client.Models.BM25Operator.And.Equals(Weaviate.Client.Models.BM25Operator? other) -> bool -override sealed Weaviate.Client.Models.BM25Operator.Or.Equals(Weaviate.Client.Models.BM25Operator? other) -> bool -override sealed Weaviate.Client.Models.ClusterNodeVerbose.Equals(Weaviate.Client.Models.ClusterNode? other) -> bool -override sealed Weaviate.Client.Models.CollectionConfig.Equals(Weaviate.Client.Models.CollectionConfigCommon? other) -> bool -override sealed Weaviate.Client.Models.CollectionConfigExport.Equals(Weaviate.Client.Models.CollectionConfig? other) -> bool -override sealed Weaviate.Client.Models.CollectionCreateParams.Equals(Weaviate.Client.Models.CollectionConfigCommon? other) -> bool -override sealed Weaviate.Client.Models.FilesystemBackend.Equals(Weaviate.Client.Models.BackupBackend? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.AWSBedrock.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.Anthropic.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.Anyscale.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.Cohere.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.ContextualAI.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.Databricks.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.Dummy.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.FriendliAI.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.GoogleGemini.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.GoogleVertex.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.Mistral.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.Nvidia.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.Ollama.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.OpenAI.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.Generative.Providers.XAI.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -override sealed Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.Equals(Weaviate.Client.Models.GenerativeConfig.OpenAIBase? other) -> bool -override sealed Weaviate.Client.Models.GenerativeConfig.OpenAI.Equals(Weaviate.Client.Models.GenerativeConfig.OpenAIBase? other) -> bool -override sealed Weaviate.Client.Models.GenerativeGroupByObject.Equals(Weaviate.Client.Models.GenerativeWeaviateObject? other) -> bool -override sealed Weaviate.Client.Models.GenerativeGroupByResult.Equals(Weaviate.Client.Models.GroupByResult? other) -> bool -override sealed Weaviate.Client.Models.GenerativeWeaviateGroup.Equals(Weaviate.Client.Models.WeaviateGroup? other) -> bool -override sealed Weaviate.Client.Models.GenerativeWeaviateObject.Equals(Weaviate.Client.Models.WeaviateObject? other) -> bool -override sealed Weaviate.Client.Models.GenerativeWeaviateResult.Equals(Weaviate.Client.Models.WeaviateResult? other) -> bool -override sealed Weaviate.Client.Models.GroupByObject.Equals(Weaviate.Client.Models.WeaviateObject? other) -> bool -override sealed Weaviate.Client.Models.GroupByResult.Equals(Weaviate.Client.Models.GroupByResult? other) -> bool -override sealed Weaviate.Client.Models.GroupedTask.Equals(Weaviate.Client.Models.GenerativePrompt? other) -> bool -override sealed Weaviate.Client.Models.NestedFilter.Equals(Weaviate.Client.Models.Filter? other) -> bool -override sealed Weaviate.Client.Models.NotNestedFilter.Equals(Weaviate.Client.Models.NestedFilter? other) -> bool -override sealed Weaviate.Client.Models.ObjectStorageBackend.Equals(Weaviate.Client.Models.BackupBackend? other) -> bool -override sealed Weaviate.Client.Models.OrNestedFilter.Equals(Weaviate.Client.Models.NestedFilter? other) -> bool -override sealed Weaviate.Client.Models.PropertyFilter.Equals(Weaviate.Client.Models.Filter? other) -> bool -override sealed Weaviate.Client.Models.ReferenceFilter.Equals(Weaviate.Client.Models.Filter? other) -> bool -override sealed Weaviate.Client.Models.SinglePrompt.Equals(Weaviate.Client.Models.GenerativePrompt? other) -> bool -override sealed Weaviate.Client.Models.TimeFilter.Equals(Weaviate.Client.Models.TypedValue? other) -> bool -override sealed Weaviate.Client.Models.Typed.GenerativeGroupByObject.Equals(Weaviate.Client.Models.Typed.GenerativeWeaviateObject? other) -> bool -override sealed Weaviate.Client.Models.Typed.GenerativeGroupByResult.Equals(Weaviate.Client.Models.GroupByResult!, Weaviate.Client.Models.Typed.GenerativeWeaviateGroup!>? other) -> bool -override sealed Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.Equals(Weaviate.Client.Models.Typed.WeaviateGroup!>? other) -> bool -override sealed Weaviate.Client.Models.Typed.GenerativeWeaviateObject.Equals(Weaviate.Client.Models.Typed.WeaviateObject? other) -> bool -override sealed Weaviate.Client.Models.Typed.GenerativeWeaviateResult.Equals(Weaviate.Client.Models.WeaviateResult!>? other) -> bool -override sealed Weaviate.Client.Models.Typed.GroupByObject.Equals(Weaviate.Client.Models.Typed.WeaviateObject? other) -> bool -override sealed Weaviate.Client.Models.Typed.GroupByResult.Equals(Weaviate.Client.Models.GroupByResult!, Weaviate.Client.Models.Typed.WeaviateGroup!>? other) -> bool -override sealed Weaviate.Client.Models.Typed.WeaviateGroup.Equals(Weaviate.Client.Models.Typed.WeaviateGroup!>? other) -> bool -override sealed Weaviate.Client.Models.TypedGuid.Equals(Weaviate.Client.Models.TypedBase? other) -> bool -override sealed Weaviate.Client.Models.TypedValue.Equals(Weaviate.Client.Models.TypedBase? other) -> bool -override sealed Weaviate.Client.Models.VectorIndex.Dynamic.Equals(Weaviate.Client.Models.VectorIndexConfig? other) -> bool -override sealed Weaviate.Client.Models.VectorIndex.Flat.Equals(Weaviate.Client.Models.VectorIndexConfig? other) -> bool -override sealed Weaviate.Client.Models.VectorIndex.HNSW.Equals(Weaviate.Client.Models.VectorIndexConfig? other) -> bool -override sealed Weaviate.Client.Models.VectorIndex.Quantizers.BQ.Equals(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat? other) -> bool -override sealed Weaviate.Client.Models.VectorIndex.Quantizers.None.Equals(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? other) -> bool -override sealed Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Equals(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? other) -> bool -override sealed Weaviate.Client.Models.VectorIndex.Quantizers.RQ.Equals(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat? other) -> bool -override sealed Weaviate.Client.Models.VectorIndex.Quantizers.SQ.Equals(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? other) -> bool -override sealed Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.Equals(Weaviate.Client.Models.VectorIndexConfig.EncodingConfig? other) -> bool -override sealed Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.Equals(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? other) -> bool -override sealed Weaviate.Client.Models.VectorMulti.Equals(Weaviate.Client.Models.Vector? other) -> bool -override sealed Weaviate.Client.Models.VectorSingle.Equals(Weaviate.Client.Models.Vector? other) -> bool -override sealed Weaviate.Client.Models.WeaviateGroup.Equals(Weaviate.Client.Models.WeaviateGroup? other) -> bool -override sealed Weaviate.Client.Models.WeaviateResult.Equals(Weaviate.Client.Models.WeaviateResult? other) -> bool -readonly Weaviate.Client.BaseCollectionClient._collectionClient -> Weaviate.Client.CollectionClient! -static Weaviate.Client.Auth.ApiKey(string! value) -> Weaviate.Client.Auth.ApiKeyCredentials! -static Weaviate.Client.Auth.ApiKeyCredentials.implicit operator Weaviate.Client.Auth.ApiKeyCredentials!(string! value) -> Weaviate.Client.Auth.ApiKeyCredentials! -static Weaviate.Client.Auth.ApiKeyCredentials.operator !=(Weaviate.Client.Auth.ApiKeyCredentials? left, Weaviate.Client.Auth.ApiKeyCredentials? right) -> bool -static Weaviate.Client.Auth.ApiKeyCredentials.operator ==(Weaviate.Client.Auth.ApiKeyCredentials? left, Weaviate.Client.Auth.ApiKeyCredentials? right) -> bool -static Weaviate.Client.Auth.BearerToken(string! accessToken, int expiresIn = 60, string! refreshToken = "") -> Weaviate.Client.Auth.BearerTokenCredentials! -static Weaviate.Client.Auth.BearerTokenCredentials.operator !=(Weaviate.Client.Auth.BearerTokenCredentials? left, Weaviate.Client.Auth.BearerTokenCredentials? right) -> bool -static Weaviate.Client.Auth.BearerTokenCredentials.operator ==(Weaviate.Client.Auth.BearerTokenCredentials? left, Weaviate.Client.Auth.BearerTokenCredentials? right) -> bool -static Weaviate.Client.Auth.ClientCredentials(string! clientSecret, params string?[]! scope) -> Weaviate.Client.Auth.ClientCredentialsFlow! -static Weaviate.Client.Auth.ClientCredentialsFlow.operator !=(Weaviate.Client.Auth.ClientCredentialsFlow? left, Weaviate.Client.Auth.ClientCredentialsFlow? right) -> bool -static Weaviate.Client.Auth.ClientCredentialsFlow.operator ==(Weaviate.Client.Auth.ClientCredentialsFlow? left, Weaviate.Client.Auth.ClientCredentialsFlow? right) -> bool -static Weaviate.Client.Auth.ClientPassword(string! username, string! password, params string?[]! scope) -> Weaviate.Client.Auth.ClientPasswordFlow! -static Weaviate.Client.Auth.ClientPasswordFlow.operator !=(Weaviate.Client.Auth.ClientPasswordFlow? left, Weaviate.Client.Auth.ClientPasswordFlow? right) -> bool -static Weaviate.Client.Auth.ClientPasswordFlow.operator ==(Weaviate.Client.Auth.ClientPasswordFlow? left, Weaviate.Client.Auth.ClientPasswordFlow? right) -> bool -static Weaviate.Client.BackupClient.Config.get -> Weaviate.Client.Models.BackupClientConfig! -static Weaviate.Client.BackupClient.Config.set -> void -static Weaviate.Client.Cache.SchemaCache.Default.get -> Weaviate.Client.Cache.SchemaCache! -static Weaviate.Client.ClientConfiguration.operator !=(Weaviate.Client.ClientConfiguration? left, Weaviate.Client.ClientConfiguration? right) -> bool -static Weaviate.Client.ClientConfiguration.operator ==(Weaviate.Client.ClientConfiguration? left, Weaviate.Client.ClientConfiguration? right) -> bool -static Weaviate.Client.CollectionClientExtensions.AsTyped(this Weaviate.Client.CollectionClient! collectionClient) -> Weaviate.Client.Typed.TypedCollectionClient! -static Weaviate.Client.CollectionClientExtensions.AsTyped(this Weaviate.Client.CollectionClient! collectionClient, bool validateType = false, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -static Weaviate.Client.CollectionsClient.operator !=(Weaviate.Client.CollectionsClient? left, Weaviate.Client.CollectionsClient? right) -> bool -static Weaviate.Client.CollectionsClient.operator ==(Weaviate.Client.CollectionsClient? left, Weaviate.Client.CollectionsClient? right) -> bool -static Weaviate.Client.Configure.Generative.get -> Weaviate.Client.GenerativeConfigFactory! -static Weaviate.Client.Configure.MultiVector(System.Func! vectorizer, Weaviate.Client.Models.VectorIndex.HNSW? index = null, Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? quantizer = null, Weaviate.Client.Models.VectorIndexConfig.EncodingConfig? encoding = null, params string![]! sourceProperties) -> Weaviate.Client.Models.VectorConfig! -static Weaviate.Client.Configure.MultiVector(string! name, System.Func! vectorizer, Weaviate.Client.Models.VectorIndex.HNSW? index = null, Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? quantizer = null, Weaviate.Client.Models.VectorIndexConfig.EncodingConfig? encoding = null, params string![]! sourceProperties) -> Weaviate.Client.Models.VectorConfig! -static Weaviate.Client.Configure.Reranker.get -> Weaviate.Client.RerankerConfigFactory! -static Weaviate.Client.Configure.Vector(System.Func! vectorizer, Weaviate.Client.Models.VectorIndexConfig? index = null, Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? quantizer = null, params string![]! sourceProperties) -> Weaviate.Client.Models.VectorConfig! -static Weaviate.Client.Configure.Vector(string! name, System.Func! vectorizer, Weaviate.Client.Models.VectorIndexConfig? index = null, Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? quantizer = null, params string![]! sourceProperties) -> Weaviate.Client.Models.VectorConfig! -static Weaviate.Client.Connect.Cloud(string! restEndpoint, string? apiKey = null, System.Collections.Generic.Dictionary? headers = null, System.Net.Http.HttpMessageHandler? httpMessageHandler = null, System.TimeSpan? defaultTimeout = null, System.TimeSpan? initTimeout = null, System.TimeSpan? insertTimeout = null, System.TimeSpan? queryTimeout = null) -> System.Threading.Tasks.Task! -static Weaviate.Client.Connect.FromEnvironment(string! prefix = "WEAVIATE_", System.TimeSpan? defaultTimeout = null, System.TimeSpan? initTimeout = null, System.TimeSpan? insertTimeout = null, System.TimeSpan? queryTimeout = null) -> System.Threading.Tasks.Task! -static Weaviate.Client.Connect.Local(Weaviate.Client.Auth.ApiKeyCredentials! credentials, string! hostname = "localhost", ushort restPort = 8080, ushort grpcPort = 50051, bool useSsl = false, System.Collections.Generic.Dictionary? headers = null, System.Net.Http.HttpMessageHandler? httpMessageHandler = null, System.TimeSpan? defaultTimeout = null, System.TimeSpan? initTimeout = null, System.TimeSpan? insertTimeout = null, System.TimeSpan? queryTimeout = null) -> System.Threading.Tasks.Task! -static Weaviate.Client.Connect.Local(Weaviate.Client.ICredentials? credentials = null, string! hostname = "localhost", ushort restPort = 8080, ushort grpcPort = 50051, bool useSsl = false, System.Collections.Generic.Dictionary? headers = null, System.Net.Http.HttpMessageHandler? httpMessageHandler = null, System.TimeSpan? defaultTimeout = null, System.TimeSpan? initTimeout = null, System.TimeSpan? insertTimeout = null, System.TimeSpan? queryTimeout = null) -> System.Threading.Tasks.Task! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviate(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, Microsoft.Extensions.Configuration.IConfiguration! configuration, bool eagerInitialization = true) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviate(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, System.Action! configureOptions, bool eagerInitialization = true) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviateClient(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, string! name, System.Action! configureOptions) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviateClientFactory(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviateCloud(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, string! clusterEndpoint, string? apiKey = null, System.Collections.Generic.Dictionary? headers = null, System.TimeSpan? defaultTimeout = null, System.TimeSpan? initTimeout = null, System.TimeSpan? insertTimeout = null, System.TimeSpan? queryTimeout = null, bool eagerInitialization = true) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviateCloud(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, string! name, System.Action! configureOptions) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviateCloud(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, string! name, string! clusterEndpoint, string? apiKey = null, System.Collections.Generic.Dictionary? headers = null, System.TimeSpan? defaultTimeout = null, System.TimeSpan? initTimeout = null, System.TimeSpan? insertTimeout = null, System.TimeSpan? queryTimeout = null) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviateLocal(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, string! hostname = "localhost", ushort restPort = 8080, ushort grpcPort = 50051, bool useSsl = false, Weaviate.Client.ICredentials? credentials = null, System.Collections.Generic.Dictionary? headers = null, System.TimeSpan? defaultTimeout = null, System.TimeSpan? initTimeout = null, System.TimeSpan? insertTimeout = null, System.TimeSpan? queryTimeout = null, bool eagerInitialization = true) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviateLocal(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, string! name) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviateLocal(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, string! name, System.Action! configureOptions) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.DependencyInjection.WeaviateServiceCollectionExtensions.AddWeaviateLocal(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, string! name, string! hostname = "localhost", ushort restPort = 8080, ushort grpcPort = 50051, bool useSsl = false, Weaviate.Client.ICredentials? credentials = null, System.Collections.Generic.Dictionary? headers = null, System.TimeSpan? defaultTimeout = null, System.TimeSpan? initTimeout = null, System.TimeSpan? insertTimeout = null, System.TimeSpan? queryTimeout = null) -> Microsoft.Extensions.DependencyInjection.IServiceCollection! -static Weaviate.Client.Generate.Provider.get -> Weaviate.Client.GenerativeProviderFactory! -static Weaviate.Client.Models.Aggregate.Boolean.operator !=(Weaviate.Client.Models.Aggregate.Boolean? left, Weaviate.Client.Models.Aggregate.Boolean? right) -> bool -static Weaviate.Client.Models.Aggregate.Boolean.operator ==(Weaviate.Client.Models.Aggregate.Boolean? left, Weaviate.Client.Models.Aggregate.Boolean? right) -> bool -static Weaviate.Client.Models.Aggregate.Date.operator !=(Weaviate.Client.Models.Aggregate.Date? left, Weaviate.Client.Models.Aggregate.Date? right) -> bool -static Weaviate.Client.Models.Aggregate.Date.operator ==(Weaviate.Client.Models.Aggregate.Date? left, Weaviate.Client.Models.Aggregate.Date? right) -> bool -static Weaviate.Client.Models.Aggregate.GroupBy.implicit operator Weaviate.Client.Models.Aggregate.GroupBy!(string! property) -> Weaviate.Client.Models.Aggregate.GroupBy! -static Weaviate.Client.Models.Aggregate.GroupBy.operator !=(Weaviate.Client.Models.Aggregate.GroupBy? left, Weaviate.Client.Models.Aggregate.GroupBy? right) -> bool -static Weaviate.Client.Models.Aggregate.GroupBy.operator ==(Weaviate.Client.Models.Aggregate.GroupBy? left, Weaviate.Client.Models.Aggregate.GroupBy? right) -> bool -static Weaviate.Client.Models.Aggregate.Integer.operator !=(Weaviate.Client.Models.Aggregate.Integer? left, Weaviate.Client.Models.Aggregate.Integer? right) -> bool -static Weaviate.Client.Models.Aggregate.Integer.operator ==(Weaviate.Client.Models.Aggregate.Integer? left, Weaviate.Client.Models.Aggregate.Integer? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Boolean.operator !=(Weaviate.Client.Models.Aggregate.Metric.Boolean? left, Weaviate.Client.Models.Aggregate.Metric.Boolean? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Boolean.operator ==(Weaviate.Client.Models.Aggregate.Metric.Boolean? left, Weaviate.Client.Models.Aggregate.Metric.Boolean? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Date.operator !=(Weaviate.Client.Models.Aggregate.Metric.Date? left, Weaviate.Client.Models.Aggregate.Metric.Date? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Date.operator ==(Weaviate.Client.Models.Aggregate.Metric.Date? left, Weaviate.Client.Models.Aggregate.Metric.Date? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Integer.operator !=(Weaviate.Client.Models.Aggregate.Metric.Integer? left, Weaviate.Client.Models.Aggregate.Metric.Integer? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Integer.operator ==(Weaviate.Client.Models.Aggregate.Metric.Integer? left, Weaviate.Client.Models.Aggregate.Metric.Integer? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Number.operator !=(Weaviate.Client.Models.Aggregate.Metric.Number? left, Weaviate.Client.Models.Aggregate.Metric.Number? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Number.operator ==(Weaviate.Client.Models.Aggregate.Metric.Number? left, Weaviate.Client.Models.Aggregate.Metric.Number? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Text.operator !=(Weaviate.Client.Models.Aggregate.Metric.Text? left, Weaviate.Client.Models.Aggregate.Metric.Text? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.Text.operator ==(Weaviate.Client.Models.Aggregate.Metric.Text? left, Weaviate.Client.Models.Aggregate.Metric.Text? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.operator !=(Weaviate.Client.Models.Aggregate.Metric? left, Weaviate.Client.Models.Aggregate.Metric? right) -> bool -static Weaviate.Client.Models.Aggregate.Metric.operator ==(Weaviate.Client.Models.Aggregate.Metric? left, Weaviate.Client.Models.Aggregate.Metric? right) -> bool -static Weaviate.Client.Models.Aggregate.Number.operator !=(Weaviate.Client.Models.Aggregate.Number? left, Weaviate.Client.Models.Aggregate.Number? right) -> bool -static Weaviate.Client.Models.Aggregate.Number.operator ==(Weaviate.Client.Models.Aggregate.Number? left, Weaviate.Client.Models.Aggregate.Number? right) -> bool -static Weaviate.Client.Models.Aggregate.Numeric.operator !=(Weaviate.Client.Models.Aggregate.Numeric? left, Weaviate.Client.Models.Aggregate.Numeric? right) -> bool -static Weaviate.Client.Models.Aggregate.Numeric.operator ==(Weaviate.Client.Models.Aggregate.Numeric? left, Weaviate.Client.Models.Aggregate.Numeric? right) -> bool -static Weaviate.Client.Models.Aggregate.Property.operator !=(Weaviate.Client.Models.Aggregate.Property? left, Weaviate.Client.Models.Aggregate.Property? right) -> bool -static Weaviate.Client.Models.Aggregate.Property.operator ==(Weaviate.Client.Models.Aggregate.Property? left, Weaviate.Client.Models.Aggregate.Property? right) -> bool -static Weaviate.Client.Models.Aggregate.Text.operator !=(Weaviate.Client.Models.Aggregate.Text? left, Weaviate.Client.Models.Aggregate.Text? right) -> bool -static Weaviate.Client.Models.Aggregate.Text.operator ==(Weaviate.Client.Models.Aggregate.Text? left, Weaviate.Client.Models.Aggregate.Text? right) -> bool -static Weaviate.Client.Models.Aggregate.TopOccurrence.operator !=(Weaviate.Client.Models.Aggregate.TopOccurrence? left, Weaviate.Client.Models.Aggregate.TopOccurrence? right) -> bool -static Weaviate.Client.Models.Aggregate.TopOccurrence.operator ==(Weaviate.Client.Models.Aggregate.TopOccurrence? left, Weaviate.Client.Models.Aggregate.TopOccurrence? right) -> bool -static Weaviate.Client.Models.AggregateGroupByResult.Group.By.operator !=(Weaviate.Client.Models.AggregateGroupByResult.Group.By? left, Weaviate.Client.Models.AggregateGroupByResult.Group.By? right) -> bool -static Weaviate.Client.Models.AggregateGroupByResult.Group.By.operator ==(Weaviate.Client.Models.AggregateGroupByResult.Group.By? left, Weaviate.Client.Models.AggregateGroupByResult.Group.By? right) -> bool -static Weaviate.Client.Models.AggregateGroupByResult.Group.operator !=(Weaviate.Client.Models.AggregateGroupByResult.Group? left, Weaviate.Client.Models.AggregateGroupByResult.Group? right) -> bool -static Weaviate.Client.Models.AggregateGroupByResult.Group.operator ==(Weaviate.Client.Models.AggregateGroupByResult.Group? left, Weaviate.Client.Models.AggregateGroupByResult.Group? right) -> bool -static Weaviate.Client.Models.AggregateGroupByResult.operator !=(Weaviate.Client.Models.AggregateGroupByResult? left, Weaviate.Client.Models.AggregateGroupByResult? right) -> bool -static Weaviate.Client.Models.AggregateGroupByResult.operator ==(Weaviate.Client.Models.AggregateGroupByResult? left, Weaviate.Client.Models.AggregateGroupByResult? right) -> bool -static Weaviate.Client.Models.AggregateResult.operator !=(Weaviate.Client.Models.AggregateResult? left, Weaviate.Client.Models.AggregateResult? right) -> bool -static Weaviate.Client.Models.AggregateResult.operator ==(Weaviate.Client.Models.AggregateResult? left, Weaviate.Client.Models.AggregateResult? right) -> bool -static Weaviate.Client.Models.Alias.operator !=(Weaviate.Client.Models.Alias? left, Weaviate.Client.Models.Alias? right) -> bool -static Weaviate.Client.Models.Alias.operator ==(Weaviate.Client.Models.Alias? left, Weaviate.Client.Models.Alias? right) -> bool -static Weaviate.Client.Models.AliasesResource.operator !=(Weaviate.Client.Models.AliasesResource? left, Weaviate.Client.Models.AliasesResource? right) -> bool -static Weaviate.Client.Models.AliasesResource.operator ==(Weaviate.Client.Models.AliasesResource? left, Weaviate.Client.Models.AliasesResource? right) -> bool -static Weaviate.Client.Models.AndNestedFilter.operator !=(Weaviate.Client.Models.AndNestedFilter? left, Weaviate.Client.Models.AndNestedFilter? right) -> bool -static Weaviate.Client.Models.AndNestedFilter.operator ==(Weaviate.Client.Models.AndNestedFilter? left, Weaviate.Client.Models.AndNestedFilter? right) -> bool -static Weaviate.Client.Models.AutoArray.explicit operator T[]!(Weaviate.Client.Models.AutoArray! list) -> T[]! -static Weaviate.Client.Models.AutoArray.implicit operator Weaviate.Client.Models.AutoArray!(System.Collections.Generic.List! items) -> Weaviate.Client.Models.AutoArray! -static Weaviate.Client.Models.AutoArray.implicit operator Weaviate.Client.Models.AutoArray!(T item) -> Weaviate.Client.Models.AutoArray! -static Weaviate.Client.Models.AutoArray.implicit operator Weaviate.Client.Models.AutoArray?(T[]? items) -> Weaviate.Client.Models.AutoArray? -static Weaviate.Client.Models.AutoArrayBuilder.Create(System.ReadOnlySpan items) -> Weaviate.Client.Models.AutoArray! -static Weaviate.Client.Models.BM25Config.Default.get -> Weaviate.Client.Models.BM25Config! -static Weaviate.Client.Models.BM25Config.operator !=(Weaviate.Client.Models.BM25Config? left, Weaviate.Client.Models.BM25Config? right) -> bool -static Weaviate.Client.Models.BM25Config.operator ==(Weaviate.Client.Models.BM25Config? left, Weaviate.Client.Models.BM25Config? right) -> bool -static Weaviate.Client.Models.BM25Operator.And.operator !=(Weaviate.Client.Models.BM25Operator.And? left, Weaviate.Client.Models.BM25Operator.And? right) -> bool -static Weaviate.Client.Models.BM25Operator.And.operator ==(Weaviate.Client.Models.BM25Operator.And? left, Weaviate.Client.Models.BM25Operator.And? right) -> bool -static Weaviate.Client.Models.BM25Operator.Or.operator !=(Weaviate.Client.Models.BM25Operator.Or? left, Weaviate.Client.Models.BM25Operator.Or? right) -> bool -static Weaviate.Client.Models.BM25Operator.Or.operator ==(Weaviate.Client.Models.BM25Operator.Or? left, Weaviate.Client.Models.BM25Operator.Or? right) -> bool -static Weaviate.Client.Models.BM25Operator.operator !=(Weaviate.Client.Models.BM25Operator? left, Weaviate.Client.Models.BM25Operator? right) -> bool -static Weaviate.Client.Models.BM25Operator.operator ==(Weaviate.Client.Models.BM25Operator? left, Weaviate.Client.Models.BM25Operator? right) -> bool -static Weaviate.Client.Models.Backup.operator !=(Weaviate.Client.Models.Backup? left, Weaviate.Client.Models.Backup? right) -> bool -static Weaviate.Client.Models.Backup.operator ==(Weaviate.Client.Models.Backup? left, Weaviate.Client.Models.Backup? right) -> bool -static Weaviate.Client.Models.BackupBackend.Azure(string? bucket = null, string? path = null) -> Weaviate.Client.Models.BackupBackend! -static Weaviate.Client.Models.BackupBackend.Empty() -> Weaviate.Client.Models.BackupBackend! -static Weaviate.Client.Models.BackupBackend.Filesystem(string? path = null) -> Weaviate.Client.Models.BackupBackend! -static Weaviate.Client.Models.BackupBackend.GCS(string? bucket = null, string? path = null) -> Weaviate.Client.Models.BackupBackend! -static Weaviate.Client.Models.BackupBackend.S3(string? bucket = null, string? path = null) -> Weaviate.Client.Models.BackupBackend! -static Weaviate.Client.Models.BackupBackend.operator !=(Weaviate.Client.Models.BackupBackend? left, Weaviate.Client.Models.BackupBackend? right) -> bool -static Weaviate.Client.Models.BackupBackend.operator ==(Weaviate.Client.Models.BackupBackend? left, Weaviate.Client.Models.BackupBackend? right) -> bool -static Weaviate.Client.Models.BackupClientConfig.Default.get -> Weaviate.Client.Models.BackupClientConfig! -static Weaviate.Client.Models.BackupClientConfig.operator !=(Weaviate.Client.Models.BackupClientConfig? left, Weaviate.Client.Models.BackupClientConfig? right) -> bool -static Weaviate.Client.Models.BackupClientConfig.operator ==(Weaviate.Client.Models.BackupClientConfig? left, Weaviate.Client.Models.BackupClientConfig? right) -> bool -static Weaviate.Client.Models.BackupCreateRequest.operator !=(Weaviate.Client.Models.BackupCreateRequest? left, Weaviate.Client.Models.BackupCreateRequest? right) -> bool -static Weaviate.Client.Models.BackupCreateRequest.operator ==(Weaviate.Client.Models.BackupCreateRequest? left, Weaviate.Client.Models.BackupCreateRequest? right) -> bool -static Weaviate.Client.Models.BackupRestoreRequest.operator !=(Weaviate.Client.Models.BackupRestoreRequest? left, Weaviate.Client.Models.BackupRestoreRequest? right) -> bool -static Weaviate.Client.Models.BackupRestoreRequest.operator ==(Weaviate.Client.Models.BackupRestoreRequest? left, Weaviate.Client.Models.BackupRestoreRequest? right) -> bool -static Weaviate.Client.Models.BackupStatusExtensions.ToBackupStatus(this string? status) -> Weaviate.Client.Models.BackupStatus -static Weaviate.Client.Models.BackupsResource.operator !=(Weaviate.Client.Models.BackupsResource? left, Weaviate.Client.Models.BackupsResource? right) -> bool -static Weaviate.Client.Models.BackupsResource.operator ==(Weaviate.Client.Models.BackupsResource? left, Weaviate.Client.Models.BackupsResource? right) -> bool -static Weaviate.Client.Models.BatchInsertRequest.Create(System.Collections.Generic.IEnumerable<(object! data, System.Collections.Generic.IEnumerable? references)>! requests) -> Weaviate.Client.Models.BatchInsertRequest![]! -static Weaviate.Client.Models.BatchInsertRequest.Create(System.Collections.Generic.IEnumerable<(object! data, System.Guid id)>! requests) -> Weaviate.Client.Models.BatchInsertRequest![]! -static Weaviate.Client.Models.BatchInsertRequest.Create(System.Collections.Generic.IEnumerable<(object! data, Weaviate.Client.Models.Vectors! vectors)>! requests) -> Weaviate.Client.Models.BatchInsertRequest![]! -static Weaviate.Client.Models.BatchInsertRequest.Create(System.Collections.Generic.IEnumerable! data) -> Weaviate.Client.Models.BatchInsertRequest![]! -static Weaviate.Client.Models.BatchInsertRequest.Create(object! data, System.Guid? id = null, Weaviate.Client.Models.Vectors? vectors = null, System.Collections.Generic.IEnumerable? references = null) -> Weaviate.Client.Models.BatchInsertRequest! -static Weaviate.Client.Models.BatchInsertRequest.operator !=(Weaviate.Client.Models.BatchInsertRequest? left, Weaviate.Client.Models.BatchInsertRequest? right) -> bool -static Weaviate.Client.Models.BatchInsertRequest.operator ==(Weaviate.Client.Models.BatchInsertRequest? left, Weaviate.Client.Models.BatchInsertRequest? right) -> bool -static Weaviate.Client.Models.BatchInsertResponse.operator !=(Weaviate.Client.Models.BatchInsertResponse? left, Weaviate.Client.Models.BatchInsertResponse? right) -> bool -static Weaviate.Client.Models.BatchInsertResponse.operator ==(Weaviate.Client.Models.BatchInsertResponse? left, Weaviate.Client.Models.BatchInsertResponse? right) -> bool -static Weaviate.Client.Models.BatchInsertResponseEntry.operator !=(Weaviate.Client.Models.BatchInsertResponseEntry? left, Weaviate.Client.Models.BatchInsertResponseEntry? right) -> bool -static Weaviate.Client.Models.BatchInsertResponseEntry.operator ==(Weaviate.Client.Models.BatchInsertResponseEntry? left, Weaviate.Client.Models.BatchInsertResponseEntry? right) -> bool -static Weaviate.Client.Models.BatchReferenceReturn.operator !=(Weaviate.Client.Models.BatchReferenceReturn? left, Weaviate.Client.Models.BatchReferenceReturn? right) -> bool -static Weaviate.Client.Models.BatchReferenceReturn.operator +(Weaviate.Client.Models.BatchReferenceReturn! left, Weaviate.Client.Models.BatchReferenceReturn! right) -> Weaviate.Client.Models.BatchReferenceReturn! -static Weaviate.Client.Models.BatchReferenceReturn.operator ==(Weaviate.Client.Models.BatchReferenceReturn? left, Weaviate.Client.Models.BatchReferenceReturn? right) -> bool -static Weaviate.Client.Models.Bm25ConfigUpdate.operator !=(Weaviate.Client.Models.Bm25ConfigUpdate? left, Weaviate.Client.Models.Bm25ConfigUpdate? right) -> bool -static Weaviate.Client.Models.Bm25ConfigUpdate.operator ==(Weaviate.Client.Models.Bm25ConfigUpdate? left, Weaviate.Client.Models.Bm25ConfigUpdate? right) -> bool -static Weaviate.Client.Models.ClusterNode.operator !=(Weaviate.Client.Models.ClusterNode? left, Weaviate.Client.Models.ClusterNode? right) -> bool -static Weaviate.Client.Models.ClusterNode.operator ==(Weaviate.Client.Models.ClusterNode? left, Weaviate.Client.Models.ClusterNode? right) -> bool -static Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.operator !=(Weaviate.Client.Models.ClusterNodeVerbose.NodeStats? left, Weaviate.Client.Models.ClusterNodeVerbose.NodeStats? right) -> bool -static Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.operator ==(Weaviate.Client.Models.ClusterNodeVerbose.NodeStats? left, Weaviate.Client.Models.ClusterNodeVerbose.NodeStats? right) -> bool -static Weaviate.Client.Models.ClusterNodeVerbose.Shard.operator !=(Weaviate.Client.Models.ClusterNodeVerbose.Shard? left, Weaviate.Client.Models.ClusterNodeVerbose.Shard? right) -> bool -static Weaviate.Client.Models.ClusterNodeVerbose.Shard.operator ==(Weaviate.Client.Models.ClusterNodeVerbose.Shard? left, Weaviate.Client.Models.ClusterNodeVerbose.Shard? right) -> bool -static Weaviate.Client.Models.ClusterNodeVerbose.operator !=(Weaviate.Client.Models.ClusterNodeVerbose? left, Weaviate.Client.Models.ClusterNodeVerbose? right) -> bool -static Weaviate.Client.Models.ClusterNodeVerbose.operator ==(Weaviate.Client.Models.ClusterNodeVerbose? left, Weaviate.Client.Models.ClusterNodeVerbose? right) -> bool -static Weaviate.Client.Models.CollectionConfig.operator !=(Weaviate.Client.Models.CollectionConfig? left, Weaviate.Client.Models.CollectionConfig? right) -> bool -static Weaviate.Client.Models.CollectionConfig.operator ==(Weaviate.Client.Models.CollectionConfig? left, Weaviate.Client.Models.CollectionConfig? right) -> bool -static Weaviate.Client.Models.CollectionConfigCommon.operator !=(Weaviate.Client.Models.CollectionConfigCommon? left, Weaviate.Client.Models.CollectionConfigCommon? right) -> bool -static Weaviate.Client.Models.CollectionConfigCommon.operator ==(Weaviate.Client.Models.CollectionConfigCommon? left, Weaviate.Client.Models.CollectionConfigCommon? right) -> bool -static Weaviate.Client.Models.CollectionConfigExport.operator !=(Weaviate.Client.Models.CollectionConfigExport? left, Weaviate.Client.Models.CollectionConfigExport? right) -> bool -static Weaviate.Client.Models.CollectionConfigExport.operator ==(Weaviate.Client.Models.CollectionConfigExport? left, Weaviate.Client.Models.CollectionConfigExport? right) -> bool -static Weaviate.Client.Models.CollectionCreateParams.operator !=(Weaviate.Client.Models.CollectionCreateParams? left, Weaviate.Client.Models.CollectionCreateParams? right) -> bool -static Weaviate.Client.Models.CollectionCreateParams.operator ==(Weaviate.Client.Models.CollectionCreateParams? left, Weaviate.Client.Models.CollectionCreateParams? right) -> bool -static Weaviate.Client.Models.CollectionUpdate.operator !=(Weaviate.Client.Models.CollectionUpdate? left, Weaviate.Client.Models.CollectionUpdate? right) -> bool -static Weaviate.Client.Models.CollectionUpdate.operator ==(Weaviate.Client.Models.CollectionUpdate? left, Weaviate.Client.Models.CollectionUpdate? right) -> bool -static Weaviate.Client.Models.CollectionsResource.operator !=(Weaviate.Client.Models.CollectionsResource? left, Weaviate.Client.Models.CollectionsResource? right) -> bool -static Weaviate.Client.Models.CollectionsResource.operator ==(Weaviate.Client.Models.CollectionsResource? left, Weaviate.Client.Models.CollectionsResource? right) -> bool -static Weaviate.Client.Models.CurrentUserInfo.operator !=(Weaviate.Client.Models.CurrentUserInfo? left, Weaviate.Client.Models.CurrentUserInfo? right) -> bool -static Weaviate.Client.Models.CurrentUserInfo.operator ==(Weaviate.Client.Models.CurrentUserInfo? left, Weaviate.Client.Models.CurrentUserInfo? right) -> bool -static Weaviate.Client.Models.DataReference.operator !=(Weaviate.Client.Models.DataReference? left, Weaviate.Client.Models.DataReference? right) -> bool -static Weaviate.Client.Models.DataReference.operator ==(Weaviate.Client.Models.DataReference? left, Weaviate.Client.Models.DataReference? right) -> bool -static Weaviate.Client.Models.DataResource.operator !=(Weaviate.Client.Models.DataResource? left, Weaviate.Client.Models.DataResource? right) -> bool -static Weaviate.Client.Models.DataResource.operator ==(Weaviate.Client.Models.DataResource? left, Weaviate.Client.Models.DataResource? right) -> bool -static Weaviate.Client.Models.DatabaseUser.operator !=(Weaviate.Client.Models.DatabaseUser? left, Weaviate.Client.Models.DatabaseUser? right) -> bool -static Weaviate.Client.Models.DatabaseUser.operator ==(Weaviate.Client.Models.DatabaseUser? left, Weaviate.Client.Models.DatabaseUser? right) -> bool -static Weaviate.Client.Models.FilesystemBackend.operator !=(Weaviate.Client.Models.FilesystemBackend? left, Weaviate.Client.Models.FilesystemBackend? right) -> bool -static Weaviate.Client.Models.FilesystemBackend.operator ==(Weaviate.Client.Models.FilesystemBackend? left, Weaviate.Client.Models.FilesystemBackend? right) -> bool -static Weaviate.Client.Models.Filter.AllOf(params Weaviate.Client.Models.Filter![]! filters) -> Weaviate.Client.Models.Filter! -static Weaviate.Client.Models.Filter.AnyOf(params Weaviate.Client.Models.Filter![]! filters) -> Weaviate.Client.Models.Filter! -static Weaviate.Client.Models.Filter.CreationTime.get -> Weaviate.Client.Models.TypedValue! -static Weaviate.Client.Models.Filter.ID.get -> Weaviate.Client.Models.TypedGuid! -static Weaviate.Client.Models.Filter.Not(Weaviate.Client.Models.Filter! filter) -> Weaviate.Client.Models.Filter! -static Weaviate.Client.Models.Filter.Property(string! name) -> Weaviate.Client.Models.PropertyFilter! -static Weaviate.Client.Models.Filter.Reference(string! name) -> Weaviate.Client.Models.ReferenceFilter! -static Weaviate.Client.Models.Filter.UpdateTime.get -> Weaviate.Client.Models.TypedValue! -static Weaviate.Client.Models.Filter.operator !=(Weaviate.Client.Models.Filter? left, Weaviate.Client.Models.Filter? right) -> bool -static Weaviate.Client.Models.Filter.operator &(Weaviate.Client.Models.Filter! left, Weaviate.Client.Models.Filter! right) -> Weaviate.Client.Models.Filter! -static Weaviate.Client.Models.Filter.operator ==(Weaviate.Client.Models.Filter? left, Weaviate.Client.Models.Filter? right) -> bool -static Weaviate.Client.Models.Filter.operator |(Weaviate.Client.Models.Filter! left, Weaviate.Client.Models.Filter! right) -> Weaviate.Client.Models.Filter! -static Weaviate.Client.Models.Filter.Property(System.Linq.Expressions.Expression!>! selector) -> Weaviate.Client.Models.Filter.PropertyFilter! -static Weaviate.Client.Models.Generative.Providers.AWSBedrock.operator !=(Weaviate.Client.Models.Generative.Providers.AWSBedrock? left, Weaviate.Client.Models.Generative.Providers.AWSBedrock? right) -> bool -static Weaviate.Client.Models.Generative.Providers.AWSBedrock.operator ==(Weaviate.Client.Models.Generative.Providers.AWSBedrock? left, Weaviate.Client.Models.Generative.Providers.AWSBedrock? right) -> bool -static Weaviate.Client.Models.Generative.Providers.AWSSagemaker.operator !=(Weaviate.Client.Models.Generative.Providers.AWSSagemaker? left, Weaviate.Client.Models.Generative.Providers.AWSSagemaker? right) -> bool -static Weaviate.Client.Models.Generative.Providers.AWSSagemaker.operator ==(Weaviate.Client.Models.Generative.Providers.AWSSagemaker? left, Weaviate.Client.Models.Generative.Providers.AWSSagemaker? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Anthropic.operator !=(Weaviate.Client.Models.Generative.Providers.Anthropic? left, Weaviate.Client.Models.Generative.Providers.Anthropic? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Anthropic.operator ==(Weaviate.Client.Models.Generative.Providers.Anthropic? left, Weaviate.Client.Models.Generative.Providers.Anthropic? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Anyscale.operator !=(Weaviate.Client.Models.Generative.Providers.Anyscale? left, Weaviate.Client.Models.Generative.Providers.Anyscale? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Anyscale.operator ==(Weaviate.Client.Models.Generative.Providers.Anyscale? left, Weaviate.Client.Models.Generative.Providers.Anyscale? right) -> bool -static Weaviate.Client.Models.Generative.Providers.AzureOpenAI.operator !=(Weaviate.Client.Models.Generative.Providers.AzureOpenAI? left, Weaviate.Client.Models.Generative.Providers.AzureOpenAI? right) -> bool -static Weaviate.Client.Models.Generative.Providers.AzureOpenAI.operator ==(Weaviate.Client.Models.Generative.Providers.AzureOpenAI? left, Weaviate.Client.Models.Generative.Providers.AzureOpenAI? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Cohere.operator !=(Weaviate.Client.Models.Generative.Providers.Cohere? left, Weaviate.Client.Models.Generative.Providers.Cohere? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Cohere.operator ==(Weaviate.Client.Models.Generative.Providers.Cohere? left, Weaviate.Client.Models.Generative.Providers.Cohere? right) -> bool -static Weaviate.Client.Models.Generative.Providers.ContextualAI.operator !=(Weaviate.Client.Models.Generative.Providers.ContextualAI? left, Weaviate.Client.Models.Generative.Providers.ContextualAI? right) -> bool -static Weaviate.Client.Models.Generative.Providers.ContextualAI.operator ==(Weaviate.Client.Models.Generative.Providers.ContextualAI? left, Weaviate.Client.Models.Generative.Providers.ContextualAI? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Databricks.operator !=(Weaviate.Client.Models.Generative.Providers.Databricks? left, Weaviate.Client.Models.Generative.Providers.Databricks? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Databricks.operator ==(Weaviate.Client.Models.Generative.Providers.Databricks? left, Weaviate.Client.Models.Generative.Providers.Databricks? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Dummy.operator !=(Weaviate.Client.Models.Generative.Providers.Dummy? left, Weaviate.Client.Models.Generative.Providers.Dummy? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Dummy.operator ==(Weaviate.Client.Models.Generative.Providers.Dummy? left, Weaviate.Client.Models.Generative.Providers.Dummy? right) -> bool -static Weaviate.Client.Models.Generative.Providers.FriendliAI.operator !=(Weaviate.Client.Models.Generative.Providers.FriendliAI? left, Weaviate.Client.Models.Generative.Providers.FriendliAI? right) -> bool -static Weaviate.Client.Models.Generative.Providers.FriendliAI.operator ==(Weaviate.Client.Models.Generative.Providers.FriendliAI? left, Weaviate.Client.Models.Generative.Providers.FriendliAI? right) -> bool -static Weaviate.Client.Models.Generative.Providers.GoogleGemini.operator !=(Weaviate.Client.Models.Generative.Providers.GoogleGemini? left, Weaviate.Client.Models.Generative.Providers.GoogleGemini? right) -> bool -static Weaviate.Client.Models.Generative.Providers.GoogleGemini.operator ==(Weaviate.Client.Models.Generative.Providers.GoogleGemini? left, Weaviate.Client.Models.Generative.Providers.GoogleGemini? right) -> bool -static Weaviate.Client.Models.Generative.Providers.GoogleVertex.operator !=(Weaviate.Client.Models.Generative.Providers.GoogleVertex? left, Weaviate.Client.Models.Generative.Providers.GoogleVertex? right) -> bool -static Weaviate.Client.Models.Generative.Providers.GoogleVertex.operator ==(Weaviate.Client.Models.Generative.Providers.GoogleVertex? left, Weaviate.Client.Models.Generative.Providers.GoogleVertex? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Mistral.operator !=(Weaviate.Client.Models.Generative.Providers.Mistral? left, Weaviate.Client.Models.Generative.Providers.Mistral? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Mistral.operator ==(Weaviate.Client.Models.Generative.Providers.Mistral? left, Weaviate.Client.Models.Generative.Providers.Mistral? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Nvidia.operator !=(Weaviate.Client.Models.Generative.Providers.Nvidia? left, Weaviate.Client.Models.Generative.Providers.Nvidia? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Nvidia.operator ==(Weaviate.Client.Models.Generative.Providers.Nvidia? left, Weaviate.Client.Models.Generative.Providers.Nvidia? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Ollama.operator !=(Weaviate.Client.Models.Generative.Providers.Ollama? left, Weaviate.Client.Models.Generative.Providers.Ollama? right) -> bool -static Weaviate.Client.Models.Generative.Providers.Ollama.operator ==(Weaviate.Client.Models.Generative.Providers.Ollama? left, Weaviate.Client.Models.Generative.Providers.Ollama? right) -> bool -static Weaviate.Client.Models.Generative.Providers.OpenAI.operator !=(Weaviate.Client.Models.Generative.Providers.OpenAI? left, Weaviate.Client.Models.Generative.Providers.OpenAI? right) -> bool -static Weaviate.Client.Models.Generative.Providers.OpenAI.operator ==(Weaviate.Client.Models.Generative.Providers.OpenAI? left, Weaviate.Client.Models.Generative.Providers.OpenAI? right) -> bool -static Weaviate.Client.Models.Generative.Providers.XAI.operator !=(Weaviate.Client.Models.Generative.Providers.XAI? left, Weaviate.Client.Models.Generative.Providers.XAI? right) -> bool -static Weaviate.Client.Models.Generative.Providers.XAI.operator ==(Weaviate.Client.Models.Generative.Providers.XAI? left, Weaviate.Client.Models.Generative.Providers.XAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.AWS.operator !=(Weaviate.Client.Models.GenerativeConfig.AWS? left, Weaviate.Client.Models.GenerativeConfig.AWS? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.AWS.operator ==(Weaviate.Client.Models.GenerativeConfig.AWS? left, Weaviate.Client.Models.GenerativeConfig.AWS? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Anthropic.operator !=(Weaviate.Client.Models.GenerativeConfig.Anthropic? left, Weaviate.Client.Models.GenerativeConfig.Anthropic? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Anthropic.operator ==(Weaviate.Client.Models.GenerativeConfig.Anthropic? left, Weaviate.Client.Models.GenerativeConfig.Anthropic? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Anyscale.operator !=(Weaviate.Client.Models.GenerativeConfig.Anyscale? left, Weaviate.Client.Models.GenerativeConfig.Anyscale? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Anyscale.operator ==(Weaviate.Client.Models.GenerativeConfig.Anyscale? left, Weaviate.Client.Models.GenerativeConfig.Anyscale? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.operator !=(Weaviate.Client.Models.GenerativeConfig.AzureOpenAI? left, Weaviate.Client.Models.GenerativeConfig.AzureOpenAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.operator ==(Weaviate.Client.Models.GenerativeConfig.AzureOpenAI? left, Weaviate.Client.Models.GenerativeConfig.AzureOpenAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Cohere.operator !=(Weaviate.Client.Models.GenerativeConfig.Cohere? left, Weaviate.Client.Models.GenerativeConfig.Cohere? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Cohere.operator ==(Weaviate.Client.Models.GenerativeConfig.Cohere? left, Weaviate.Client.Models.GenerativeConfig.Cohere? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.ContextualAI.operator !=(Weaviate.Client.Models.GenerativeConfig.ContextualAI? left, Weaviate.Client.Models.GenerativeConfig.ContextualAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.ContextualAI.operator ==(Weaviate.Client.Models.GenerativeConfig.ContextualAI? left, Weaviate.Client.Models.GenerativeConfig.ContextualAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Custom.operator !=(Weaviate.Client.Models.GenerativeConfig.Custom? left, Weaviate.Client.Models.GenerativeConfig.Custom? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Custom.operator ==(Weaviate.Client.Models.GenerativeConfig.Custom? left, Weaviate.Client.Models.GenerativeConfig.Custom? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Databricks.operator !=(Weaviate.Client.Models.GenerativeConfig.Databricks? left, Weaviate.Client.Models.GenerativeConfig.Databricks? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Databricks.operator ==(Weaviate.Client.Models.GenerativeConfig.Databricks? left, Weaviate.Client.Models.GenerativeConfig.Databricks? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.FriendliAI.operator !=(Weaviate.Client.Models.GenerativeConfig.FriendliAI? left, Weaviate.Client.Models.GenerativeConfig.FriendliAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.FriendliAI.operator ==(Weaviate.Client.Models.GenerativeConfig.FriendliAI? left, Weaviate.Client.Models.GenerativeConfig.FriendliAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.GoogleGemini.operator !=(Weaviate.Client.Models.GenerativeConfig.GoogleGemini? left, Weaviate.Client.Models.GenerativeConfig.GoogleGemini? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.GoogleGemini.operator ==(Weaviate.Client.Models.GenerativeConfig.GoogleGemini? left, Weaviate.Client.Models.GenerativeConfig.GoogleGemini? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.GoogleVertex.operator !=(Weaviate.Client.Models.GenerativeConfig.GoogleVertex? left, Weaviate.Client.Models.GenerativeConfig.GoogleVertex? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.GoogleVertex.operator ==(Weaviate.Client.Models.GenerativeConfig.GoogleVertex? left, Weaviate.Client.Models.GenerativeConfig.GoogleVertex? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Mistral.operator !=(Weaviate.Client.Models.GenerativeConfig.Mistral? left, Weaviate.Client.Models.GenerativeConfig.Mistral? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Mistral.operator ==(Weaviate.Client.Models.GenerativeConfig.Mistral? left, Weaviate.Client.Models.GenerativeConfig.Mistral? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Nvidia.operator !=(Weaviate.Client.Models.GenerativeConfig.Nvidia? left, Weaviate.Client.Models.GenerativeConfig.Nvidia? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Nvidia.operator ==(Weaviate.Client.Models.GenerativeConfig.Nvidia? left, Weaviate.Client.Models.GenerativeConfig.Nvidia? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Ollama.operator !=(Weaviate.Client.Models.GenerativeConfig.Ollama? left, Weaviate.Client.Models.GenerativeConfig.Ollama? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.Ollama.operator ==(Weaviate.Client.Models.GenerativeConfig.Ollama? left, Weaviate.Client.Models.GenerativeConfig.Ollama? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.OpenAI.operator !=(Weaviate.Client.Models.GenerativeConfig.OpenAI? left, Weaviate.Client.Models.GenerativeConfig.OpenAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.OpenAI.operator ==(Weaviate.Client.Models.GenerativeConfig.OpenAI? left, Weaviate.Client.Models.GenerativeConfig.OpenAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.OpenAIBase.operator !=(Weaviate.Client.Models.GenerativeConfig.OpenAIBase? left, Weaviate.Client.Models.GenerativeConfig.OpenAIBase? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.OpenAIBase.operator ==(Weaviate.Client.Models.GenerativeConfig.OpenAIBase? left, Weaviate.Client.Models.GenerativeConfig.OpenAIBase? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.XAI.operator !=(Weaviate.Client.Models.GenerativeConfig.XAI? left, Weaviate.Client.Models.GenerativeConfig.XAI? right) -> bool -static Weaviate.Client.Models.GenerativeConfig.XAI.operator ==(Weaviate.Client.Models.GenerativeConfig.XAI? left, Weaviate.Client.Models.GenerativeConfig.XAI? right) -> bool -static Weaviate.Client.Models.GenerativeDebug.operator !=(Weaviate.Client.Models.GenerativeDebug? left, Weaviate.Client.Models.GenerativeDebug? right) -> bool -static Weaviate.Client.Models.GenerativeDebug.operator ==(Weaviate.Client.Models.GenerativeDebug? left, Weaviate.Client.Models.GenerativeDebug? right) -> bool -static Weaviate.Client.Models.GenerativeGroupByObject.operator !=(Weaviate.Client.Models.GenerativeGroupByObject? left, Weaviate.Client.Models.GenerativeGroupByObject? right) -> bool -static Weaviate.Client.Models.GenerativeGroupByObject.operator ==(Weaviate.Client.Models.GenerativeGroupByObject? left, Weaviate.Client.Models.GenerativeGroupByObject? right) -> bool -static Weaviate.Client.Models.GenerativeGroupByResult.Empty.get -> Weaviate.Client.Models.GenerativeGroupByResult! -static Weaviate.Client.Models.GenerativeGroupByResult.operator !=(Weaviate.Client.Models.GenerativeGroupByResult? left, Weaviate.Client.Models.GenerativeGroupByResult? right) -> bool -static Weaviate.Client.Models.GenerativeGroupByResult.operator ==(Weaviate.Client.Models.GenerativeGroupByResult? left, Weaviate.Client.Models.GenerativeGroupByResult? right) -> bool -static Weaviate.Client.Models.GenerativePrompt.operator !=(Weaviate.Client.Models.GenerativePrompt? left, Weaviate.Client.Models.GenerativePrompt? right) -> bool -static Weaviate.Client.Models.GenerativePrompt.operator ==(Weaviate.Client.Models.GenerativePrompt? left, Weaviate.Client.Models.GenerativePrompt? right) -> bool -static Weaviate.Client.Models.GenerativeProvider.operator !=(Weaviate.Client.Models.GenerativeProvider? left, Weaviate.Client.Models.GenerativeProvider? right) -> bool -static Weaviate.Client.Models.GenerativeProvider.operator ==(Weaviate.Client.Models.GenerativeProvider? left, Weaviate.Client.Models.GenerativeProvider? right) -> bool -static Weaviate.Client.Models.GenerativeReply.operator !=(Weaviate.Client.Models.GenerativeReply? left, Weaviate.Client.Models.GenerativeReply? right) -> bool -static Weaviate.Client.Models.GenerativeReply.operator ==(Weaviate.Client.Models.GenerativeReply? left, Weaviate.Client.Models.GenerativeReply? right) -> bool -static Weaviate.Client.Models.GenerativeResult.operator !=(Weaviate.Client.Models.GenerativeResult? left, Weaviate.Client.Models.GenerativeResult? right) -> bool -static Weaviate.Client.Models.GenerativeResult.operator ==(Weaviate.Client.Models.GenerativeResult? left, Weaviate.Client.Models.GenerativeResult? right) -> bool -static Weaviate.Client.Models.GenerativeWeaviateGroup.operator !=(Weaviate.Client.Models.GenerativeWeaviateGroup? left, Weaviate.Client.Models.GenerativeWeaviateGroup? right) -> bool -static Weaviate.Client.Models.GenerativeWeaviateGroup.operator ==(Weaviate.Client.Models.GenerativeWeaviateGroup? left, Weaviate.Client.Models.GenerativeWeaviateGroup? right) -> bool -static Weaviate.Client.Models.GenerativeWeaviateObject.operator !=(Weaviate.Client.Models.GenerativeWeaviateObject? left, Weaviate.Client.Models.GenerativeWeaviateObject? right) -> bool -static Weaviate.Client.Models.GenerativeWeaviateObject.operator ==(Weaviate.Client.Models.GenerativeWeaviateObject? left, Weaviate.Client.Models.GenerativeWeaviateObject? right) -> bool -static Weaviate.Client.Models.GenerativeWeaviateResult.Empty.get -> Weaviate.Client.Models.GenerativeWeaviateResult! -static Weaviate.Client.Models.GenerativeWeaviateResult.operator !=(Weaviate.Client.Models.GenerativeWeaviateResult? left, Weaviate.Client.Models.GenerativeWeaviateResult? right) -> bool -static Weaviate.Client.Models.GenerativeWeaviateResult.operator ==(Weaviate.Client.Models.GenerativeWeaviateResult? left, Weaviate.Client.Models.GenerativeWeaviateResult? right) -> bool -static Weaviate.Client.Models.GeoCoordinate.operator !=(Weaviate.Client.Models.GeoCoordinate? left, Weaviate.Client.Models.GeoCoordinate? right) -> bool -static Weaviate.Client.Models.GeoCoordinate.operator ==(Weaviate.Client.Models.GeoCoordinate? left, Weaviate.Client.Models.GeoCoordinate? right) -> bool -static Weaviate.Client.Models.GeoCoordinateConstraint.operator !=(Weaviate.Client.Models.GeoCoordinateConstraint? left, Weaviate.Client.Models.GeoCoordinateConstraint? right) -> bool -static Weaviate.Client.Models.GeoCoordinateConstraint.operator ==(Weaviate.Client.Models.GeoCoordinateConstraint? left, Weaviate.Client.Models.GeoCoordinateConstraint? right) -> bool -static Weaviate.Client.Models.GroupByObject.operator !=(Weaviate.Client.Models.GroupByObject? left, Weaviate.Client.Models.GroupByObject? right) -> bool -static Weaviate.Client.Models.GroupByObject.operator ==(Weaviate.Client.Models.GroupByObject? left, Weaviate.Client.Models.GroupByObject? right) -> bool -static Weaviate.Client.Models.GroupByRequest.operator !=(Weaviate.Client.Models.GroupByRequest? left, Weaviate.Client.Models.GroupByRequest? right) -> bool -static Weaviate.Client.Models.GroupByRequest.operator ==(Weaviate.Client.Models.GroupByRequest? left, Weaviate.Client.Models.GroupByRequest? right) -> bool -static Weaviate.Client.Models.GroupByResult.Empty.get -> Weaviate.Client.Models.GroupByResult! -static Weaviate.Client.Models.GroupByResult.operator !=(Weaviate.Client.Models.GroupByResult? left, Weaviate.Client.Models.GroupByResult? right) -> bool -static Weaviate.Client.Models.GroupByResult.operator ==(Weaviate.Client.Models.GroupByResult? left, Weaviate.Client.Models.GroupByResult? right) -> bool -static Weaviate.Client.Models.GroupByResult.operator !=(Weaviate.Client.Models.GroupByResult? left, Weaviate.Client.Models.GroupByResult? right) -> bool -static Weaviate.Client.Models.GroupByResult.operator ==(Weaviate.Client.Models.GroupByResult? left, Weaviate.Client.Models.GroupByResult? right) -> bool -static Weaviate.Client.Models.GroupRoleAssignment.operator !=(Weaviate.Client.Models.GroupRoleAssignment? left, Weaviate.Client.Models.GroupRoleAssignment? right) -> bool -static Weaviate.Client.Models.GroupRoleAssignment.operator ==(Weaviate.Client.Models.GroupRoleAssignment? left, Weaviate.Client.Models.GroupRoleAssignment? right) -> bool -static Weaviate.Client.Models.GroupedTask.implicit operator Weaviate.Client.Models.GroupedTask!(string! task) -> Weaviate.Client.Models.GroupedTask! -static Weaviate.Client.Models.GroupedTask.operator !=(Weaviate.Client.Models.GroupedTask? left, Weaviate.Client.Models.GroupedTask? right) -> bool -static Weaviate.Client.Models.GroupedTask.operator ==(Weaviate.Client.Models.GroupedTask? left, Weaviate.Client.Models.GroupedTask? right) -> bool -static Weaviate.Client.Models.GroupsResource.operator !=(Weaviate.Client.Models.GroupsResource? left, Weaviate.Client.Models.GroupsResource? right) -> bool -static Weaviate.Client.Models.GroupsResource.operator ==(Weaviate.Client.Models.GroupsResource? left, Weaviate.Client.Models.GroupsResource? right) -> bool -static Weaviate.Client.Models.HybridNearText.operator !=(Weaviate.Client.Models.HybridNearText? left, Weaviate.Client.Models.HybridNearText? right) -> bool -static Weaviate.Client.Models.HybridNearText.operator ==(Weaviate.Client.Models.HybridNearText? left, Weaviate.Client.Models.HybridNearText? right) -> bool -static Weaviate.Client.Models.HybridNearVector.operator !=(Weaviate.Client.Models.HybridNearVector? left, Weaviate.Client.Models.HybridNearVector? right) -> bool -static Weaviate.Client.Models.HybridNearVector.operator ==(Weaviate.Client.Models.HybridNearVector? left, Weaviate.Client.Models.HybridNearVector? right) -> bool -static Weaviate.Client.Models.InvertedIndexConfig.Default.get -> Weaviate.Client.Models.InvertedIndexConfig! -static Weaviate.Client.Models.InvertedIndexConfig.operator !=(Weaviate.Client.Models.InvertedIndexConfig? left, Weaviate.Client.Models.InvertedIndexConfig? right) -> bool -static Weaviate.Client.Models.InvertedIndexConfig.operator ==(Weaviate.Client.Models.InvertedIndexConfig? left, Weaviate.Client.Models.InvertedIndexConfig? right) -> bool -static Weaviate.Client.Models.InvertedIndexConfigUpdate.operator !=(Weaviate.Client.Models.InvertedIndexConfigUpdate? left, Weaviate.Client.Models.InvertedIndexConfigUpdate? right) -> bool -static Weaviate.Client.Models.InvertedIndexConfigUpdate.operator ==(Weaviate.Client.Models.InvertedIndexConfigUpdate? left, Weaviate.Client.Models.InvertedIndexConfigUpdate? right) -> bool -static Weaviate.Client.Models.MetaInfo.ParseWeaviateVersion(string! versionString) -> System.Version? -static Weaviate.Client.Models.Metadata.operator !=(Weaviate.Client.Models.Metadata? left, Weaviate.Client.Models.Metadata? right) -> bool -static Weaviate.Client.Models.Metadata.operator ==(Weaviate.Client.Models.Metadata? left, Weaviate.Client.Models.Metadata? right) -> bool -static Weaviate.Client.Models.MetadataQuery.implicit operator Weaviate.Client.Models.MetadataQuery!(Weaviate.Client.Models.MetadataOptions options) -> Weaviate.Client.Models.MetadataQuery! -static Weaviate.Client.Models.MetadataQuery.operator !=(Weaviate.Client.Models.MetadataQuery? left, Weaviate.Client.Models.MetadataQuery? right) -> bool -static Weaviate.Client.Models.MetadataQuery.operator ==(Weaviate.Client.Models.MetadataQuery? left, Weaviate.Client.Models.MetadataQuery? right) -> bool -static Weaviate.Client.Models.Metrics.ForProperty(string! propertyName) -> Weaviate.Client.Models.Metrics! -static Weaviate.Client.Models.Move.operator !=(Weaviate.Client.Models.Move? left, Weaviate.Client.Models.Move? right) -> bool -static Weaviate.Client.Models.Move.operator ==(Weaviate.Client.Models.Move? left, Weaviate.Client.Models.Move? right) -> bool -static Weaviate.Client.Models.MultiTenancyConfig.Default.get -> Weaviate.Client.Models.MultiTenancyConfig! -static Weaviate.Client.Models.MultiTenancyConfig.operator !=(Weaviate.Client.Models.MultiTenancyConfig? left, Weaviate.Client.Models.MultiTenancyConfig? right) -> bool -static Weaviate.Client.Models.MultiTenancyConfig.operator ==(Weaviate.Client.Models.MultiTenancyConfig? left, Weaviate.Client.Models.MultiTenancyConfig? right) -> bool -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(System.Collections.Generic.Dictionary!>! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(System.Collections.Generic.Dictionary!>! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(System.Collections.Generic.Dictionary!>! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(System.Collections.Generic.Dictionary!>! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(Weaviate.Client.Models.Vector! vector) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(Weaviate.Client.Models.Vector![]! vector) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.implicit operator Weaviate.Client.Models.NearVectorInput!(Weaviate.Client.Models.Vectors! vectors) -> Weaviate.Client.Models.NearVectorInput! -static Weaviate.Client.Models.NearVectorInput.operator !=(Weaviate.Client.Models.NearVectorInput? left, Weaviate.Client.Models.NearVectorInput? right) -> bool -static Weaviate.Client.Models.NearVectorInput.operator ==(Weaviate.Client.Models.NearVectorInput? left, Weaviate.Client.Models.NearVectorInput? right) -> bool -static Weaviate.Client.Models.NestedFilter.operator !=(Weaviate.Client.Models.NestedFilter? left, Weaviate.Client.Models.NestedFilter? right) -> bool -static Weaviate.Client.Models.NestedFilter.operator ==(Weaviate.Client.Models.NestedFilter? left, Weaviate.Client.Models.NestedFilter? right) -> bool -static Weaviate.Client.Models.NodeStatusExtensions.ToNodeStatus(this string? status) -> Weaviate.Client.Models.NodeStatus -static Weaviate.Client.Models.NodesResource.operator !=(Weaviate.Client.Models.NodesResource? left, Weaviate.Client.Models.NodesResource? right) -> bool -static Weaviate.Client.Models.NodesResource.operator ==(Weaviate.Client.Models.NodesResource? left, Weaviate.Client.Models.NodesResource? right) -> bool -static Weaviate.Client.Models.NotNestedFilter.operator !=(Weaviate.Client.Models.NotNestedFilter? left, Weaviate.Client.Models.NotNestedFilter? right) -> bool -static Weaviate.Client.Models.NotNestedFilter.operator ==(Weaviate.Client.Models.NotNestedFilter? left, Weaviate.Client.Models.NotNestedFilter? right) -> bool -static Weaviate.Client.Models.ObjectReference.implicit operator (string! Name, System.Guid[]! ID)(Weaviate.Client.Models.ObjectReference! value) -> (string! Name, System.Guid[]! ID) -static Weaviate.Client.Models.ObjectReference.implicit operator System.Collections.Generic.List!(Weaviate.Client.Models.ObjectReference! value) -> System.Collections.Generic.List! -static Weaviate.Client.Models.ObjectReference.implicit operator Weaviate.Client.Models.ObjectReference!((string! Name, System.Guid TargetID) value) -> Weaviate.Client.Models.ObjectReference! -static Weaviate.Client.Models.ObjectReference.implicit operator Weaviate.Client.Models.ObjectReference!((string! Name, System.Guid[]! TargetID) value) -> Weaviate.Client.Models.ObjectReference! -static Weaviate.Client.Models.ObjectReference.operator !=(Weaviate.Client.Models.ObjectReference? left, Weaviate.Client.Models.ObjectReference? right) -> bool -static Weaviate.Client.Models.ObjectReference.operator ==(Weaviate.Client.Models.ObjectReference? left, Weaviate.Client.Models.ObjectReference? right) -> bool -static Weaviate.Client.Models.ObjectStorageBackend.operator !=(Weaviate.Client.Models.ObjectStorageBackend? left, Weaviate.Client.Models.ObjectStorageBackend? right) -> bool -static Weaviate.Client.Models.ObjectStorageBackend.operator ==(Weaviate.Client.Models.ObjectStorageBackend? left, Weaviate.Client.Models.ObjectStorageBackend? right) -> bool -static Weaviate.Client.Models.OrNestedFilter.operator !=(Weaviate.Client.Models.OrNestedFilter? left, Weaviate.Client.Models.OrNestedFilter? right) -> bool -static Weaviate.Client.Models.OrNestedFilter.operator ==(Weaviate.Client.Models.OrNestedFilter? left, Weaviate.Client.Models.OrNestedFilter? right) -> bool -static Weaviate.Client.Models.PermissionScope.Empty() -> System.Collections.Generic.IEnumerable! -static Weaviate.Client.Models.PhoneNumber.FromInternational(string! number) -> Weaviate.Client.Models.PhoneNumber! -static Weaviate.Client.Models.PhoneNumber.FromNational(string! country, string! number) -> Weaviate.Client.Models.PhoneNumber! -static Weaviate.Client.Models.PhoneNumber.operator !=(Weaviate.Client.Models.PhoneNumber? left, Weaviate.Client.Models.PhoneNumber? right) -> bool -static Weaviate.Client.Models.PhoneNumber.operator ==(Weaviate.Client.Models.PhoneNumber? left, Weaviate.Client.Models.PhoneNumber? right) -> bool -static Weaviate.Client.Models.Property.Blob.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.Bool.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.BoolArray.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.Date.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.DateArray.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.FromClass(System.Type! type, int maxDepth = 1) -> Weaviate.Client.Models.Property![]! -static Weaviate.Client.Models.Property.FromClass(int maxDepth = 1) -> Weaviate.Client.Models.Property![]! -static Weaviate.Client.Models.Property.GeoCoordinate.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.Int.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.IntArray.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.Number.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.NumberArray.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.Object.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.ObjectArray.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.PhoneNumber.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.Reference(string! name, string! targetCollection, string? description = null) -> Weaviate.Client.Models.Reference! -static Weaviate.Client.Models.Property.Text.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.TextArray.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.Uuid.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.UuidArray.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.Property.operator !=(Weaviate.Client.Models.Property? left, Weaviate.Client.Models.Property? right) -> bool -static Weaviate.Client.Models.Property.operator ==(Weaviate.Client.Models.Property? left, Weaviate.Client.Models.Property? right) -> bool -static Weaviate.Client.Models.Property.New.get -> Weaviate.Client.Models.PropertyFactory! -static Weaviate.Client.Models.PropertyFilter.operator !=(Weaviate.Client.Models.PropertyFilter? left, Weaviate.Client.Models.PropertyFilter? right) -> bool -static Weaviate.Client.Models.PropertyFilter.operator ==(Weaviate.Client.Models.PropertyFilter? left, Weaviate.Client.Models.PropertyFilter? right) -> bool -static Weaviate.Client.Models.PropertyUpdate.operator !=(Weaviate.Client.Models.PropertyUpdate? left, Weaviate.Client.Models.PropertyUpdate? right) -> bool -static Weaviate.Client.Models.PropertyUpdate.operator ==(Weaviate.Client.Models.PropertyUpdate? left, Weaviate.Client.Models.PropertyUpdate? right) -> bool -static Weaviate.Client.Models.QueryReference.operator !=(Weaviate.Client.Models.QueryReference? left, Weaviate.Client.Models.QueryReference? right) -> bool -static Weaviate.Client.Models.QueryReference.operator ==(Weaviate.Client.Models.QueryReference? left, Weaviate.Client.Models.QueryReference? right) -> bool -static Weaviate.Client.Models.Reference.operator !=(Weaviate.Client.Models.Reference? left, Weaviate.Client.Models.Reference? right) -> bool -static Weaviate.Client.Models.Reference.operator ==(Weaviate.Client.Models.Reference? left, Weaviate.Client.Models.Reference? right) -> bool -static Weaviate.Client.Models.ReferenceFilter.operator !=(Weaviate.Client.Models.ReferenceFilter? left, Weaviate.Client.Models.ReferenceFilter? right) -> bool -static Weaviate.Client.Models.ReferenceFilter.operator ==(Weaviate.Client.Models.ReferenceFilter? left, Weaviate.Client.Models.ReferenceFilter? right) -> bool -static Weaviate.Client.Models.ReferenceUpdate.operator !=(Weaviate.Client.Models.ReferenceUpdate? left, Weaviate.Client.Models.ReferenceUpdate? right) -> bool -static Weaviate.Client.Models.ReferenceUpdate.operator ==(Weaviate.Client.Models.ReferenceUpdate? left, Weaviate.Client.Models.ReferenceUpdate? right) -> bool -static Weaviate.Client.Models.ReplicateRequest.operator !=(Weaviate.Client.Models.ReplicateRequest? left, Weaviate.Client.Models.ReplicateRequest? right) -> bool -static Weaviate.Client.Models.ReplicateRequest.operator ==(Weaviate.Client.Models.ReplicateRequest? left, Weaviate.Client.Models.ReplicateRequest? right) -> bool -static Weaviate.Client.Models.ReplicateResource.operator !=(Weaviate.Client.Models.ReplicateResource? left, Weaviate.Client.Models.ReplicateResource? right) -> bool -static Weaviate.Client.Models.ReplicateResource.operator ==(Weaviate.Client.Models.ReplicateResource? left, Weaviate.Client.Models.ReplicateResource? right) -> bool -static Weaviate.Client.Models.ReplicationClientConfig.Default.get -> Weaviate.Client.Models.ReplicationClientConfig! -static Weaviate.Client.Models.ReplicationConfig.Default.get -> Weaviate.Client.Models.ReplicationConfig! -static Weaviate.Client.Models.ReplicationConfig.operator !=(Weaviate.Client.Models.ReplicationConfig? left, Weaviate.Client.Models.ReplicationConfig? right) -> bool -static Weaviate.Client.Models.ReplicationConfig.operator ==(Weaviate.Client.Models.ReplicationConfig? left, Weaviate.Client.Models.ReplicationConfig? right) -> bool -static Weaviate.Client.Models.ReplicationOperation.operator !=(Weaviate.Client.Models.ReplicationOperation? left, Weaviate.Client.Models.ReplicationOperation? right) -> bool -static Weaviate.Client.Models.ReplicationOperation.operator ==(Weaviate.Client.Models.ReplicationOperation? left, Weaviate.Client.Models.ReplicationOperation? right) -> bool -static Weaviate.Client.Models.ReplicationOperationError.operator !=(Weaviate.Client.Models.ReplicationOperationError? left, Weaviate.Client.Models.ReplicationOperationError? right) -> bool -static Weaviate.Client.Models.ReplicationOperationError.operator ==(Weaviate.Client.Models.ReplicationOperationError? left, Weaviate.Client.Models.ReplicationOperationError? right) -> bool -static Weaviate.Client.Models.ReplicationOperationStatus.operator !=(Weaviate.Client.Models.ReplicationOperationStatus? left, Weaviate.Client.Models.ReplicationOperationStatus? right) -> bool -static Weaviate.Client.Models.ReplicationOperationStatus.operator ==(Weaviate.Client.Models.ReplicationOperationStatus? left, Weaviate.Client.Models.ReplicationOperationStatus? right) -> bool -static Weaviate.Client.Models.Rerank.operator !=(Weaviate.Client.Models.Rerank? left, Weaviate.Client.Models.Rerank? right) -> bool -static Weaviate.Client.Models.Rerank.operator ==(Weaviate.Client.Models.Rerank? left, Weaviate.Client.Models.Rerank? right) -> bool -static Weaviate.Client.Models.Reranker.Cohere.operator !=(Weaviate.Client.Models.Reranker.Cohere? left, Weaviate.Client.Models.Reranker.Cohere? right) -> bool -static Weaviate.Client.Models.Reranker.Cohere.operator ==(Weaviate.Client.Models.Reranker.Cohere? left, Weaviate.Client.Models.Reranker.Cohere? right) -> bool -static Weaviate.Client.Models.Reranker.ContextualAI.operator !=(Weaviate.Client.Models.Reranker.ContextualAI? left, Weaviate.Client.Models.Reranker.ContextualAI? right) -> bool -static Weaviate.Client.Models.Reranker.ContextualAI.operator ==(Weaviate.Client.Models.Reranker.ContextualAI? left, Weaviate.Client.Models.Reranker.ContextualAI? right) -> bool -static Weaviate.Client.Models.Reranker.Custom.operator !=(Weaviate.Client.Models.Reranker.Custom? left, Weaviate.Client.Models.Reranker.Custom? right) -> bool -static Weaviate.Client.Models.Reranker.Custom.operator ==(Weaviate.Client.Models.Reranker.Custom? left, Weaviate.Client.Models.Reranker.Custom? right) -> bool -static Weaviate.Client.Models.Reranker.JinaAI.operator !=(Weaviate.Client.Models.Reranker.JinaAI? left, Weaviate.Client.Models.Reranker.JinaAI? right) -> bool -static Weaviate.Client.Models.Reranker.JinaAI.operator ==(Weaviate.Client.Models.Reranker.JinaAI? left, Weaviate.Client.Models.Reranker.JinaAI? right) -> bool -static Weaviate.Client.Models.Reranker.None.operator !=(Weaviate.Client.Models.Reranker.None? left, Weaviate.Client.Models.Reranker.None? right) -> bool -static Weaviate.Client.Models.Reranker.None.operator ==(Weaviate.Client.Models.Reranker.None? left, Weaviate.Client.Models.Reranker.None? right) -> bool -static Weaviate.Client.Models.Reranker.Nvidia.operator !=(Weaviate.Client.Models.Reranker.Nvidia? left, Weaviate.Client.Models.Reranker.Nvidia? right) -> bool -static Weaviate.Client.Models.Reranker.Nvidia.operator ==(Weaviate.Client.Models.Reranker.Nvidia? left, Weaviate.Client.Models.Reranker.Nvidia? right) -> bool -static Weaviate.Client.Models.Reranker.Transformers.operator !=(Weaviate.Client.Models.Reranker.Transformers? left, Weaviate.Client.Models.Reranker.Transformers? right) -> bool -static Weaviate.Client.Models.Reranker.Transformers.operator ==(Weaviate.Client.Models.Reranker.Transformers? left, Weaviate.Client.Models.Reranker.Transformers? right) -> bool -static Weaviate.Client.Models.Reranker.VoyageAI.operator !=(Weaviate.Client.Models.Reranker.VoyageAI? left, Weaviate.Client.Models.Reranker.VoyageAI? right) -> bool -static Weaviate.Client.Models.Reranker.VoyageAI.operator ==(Weaviate.Client.Models.Reranker.VoyageAI? left, Weaviate.Client.Models.Reranker.VoyageAI? right) -> bool -static Weaviate.Client.Models.RoleInfo.operator !=(Weaviate.Client.Models.RoleInfo? left, Weaviate.Client.Models.RoleInfo? right) -> bool -static Weaviate.Client.Models.RoleInfo.operator ==(Weaviate.Client.Models.RoleInfo? left, Weaviate.Client.Models.RoleInfo? right) -> bool -static Weaviate.Client.Models.RolesResource.operator !=(Weaviate.Client.Models.RolesResource? left, Weaviate.Client.Models.RolesResource? right) -> bool -static Weaviate.Client.Models.RolesResource.operator ==(Weaviate.Client.Models.RolesResource? left, Weaviate.Client.Models.RolesResource? right) -> bool -static Weaviate.Client.Models.ShardInfo.operator !=(Weaviate.Client.Models.ShardInfo? left, Weaviate.Client.Models.ShardInfo? right) -> bool -static Weaviate.Client.Models.ShardInfo.operator ==(Weaviate.Client.Models.ShardInfo? left, Weaviate.Client.Models.ShardInfo? right) -> bool -static Weaviate.Client.Models.ShardingConfig.Default.get -> Weaviate.Client.Models.ShardingConfig! -static Weaviate.Client.Models.ShardingConfig.Zero.get -> Weaviate.Client.Models.ShardingConfig! -static Weaviate.Client.Models.ShardingConfig.operator !=(Weaviate.Client.Models.ShardingConfig? left, Weaviate.Client.Models.ShardingConfig? right) -> bool -static Weaviate.Client.Models.ShardingConfig.operator ==(Weaviate.Client.Models.ShardingConfig? left, Weaviate.Client.Models.ShardingConfig? right) -> bool -static Weaviate.Client.Models.SinglePrompt.implicit operator Weaviate.Client.Models.SinglePrompt!(string! prompt) -> Weaviate.Client.Models.SinglePrompt! -static Weaviate.Client.Models.SinglePrompt.operator !=(Weaviate.Client.Models.SinglePrompt? left, Weaviate.Client.Models.SinglePrompt? right) -> bool -static Weaviate.Client.Models.SinglePrompt.operator ==(Weaviate.Client.Models.SinglePrompt? left, Weaviate.Client.Models.SinglePrompt? right) -> bool -static Weaviate.Client.Models.Sort.ByCreationTime(bool ascending = true) -> Weaviate.Client.Models.Sort! -static Weaviate.Client.Models.Sort.ByProperty(string! name) -> Weaviate.Client.Models.Sort! -static Weaviate.Client.Models.Sort.operator !=(Weaviate.Client.Models.Sort? left, Weaviate.Client.Models.Sort? right) -> bool -static Weaviate.Client.Models.Sort.operator ==(Weaviate.Client.Models.Sort? left, Weaviate.Client.Models.Sort? right) -> bool -static Weaviate.Client.Models.SortExtensions.ByProperty(this Weaviate.Client.Models.Sort! sort, string! name) -> Weaviate.Client.Models.Sort! -static Weaviate.Client.Models.StopwordConfig.Default.get -> Weaviate.Client.Models.StopwordConfig! -static Weaviate.Client.Models.StopwordConfig.operator !=(Weaviate.Client.Models.StopwordConfig? left, Weaviate.Client.Models.StopwordConfig? right) -> bool -static Weaviate.Client.Models.StopwordConfig.operator ==(Weaviate.Client.Models.StopwordConfig? left, Weaviate.Client.Models.StopwordConfig? right) -> bool -static Weaviate.Client.Models.StopwordsConfigUpdate.operator !=(Weaviate.Client.Models.StopwordsConfigUpdate? left, Weaviate.Client.Models.StopwordsConfigUpdate? right) -> bool -static Weaviate.Client.Models.StopwordsConfigUpdate.operator ==(Weaviate.Client.Models.StopwordsConfigUpdate? left, Weaviate.Client.Models.StopwordsConfigUpdate? right) -> bool -static Weaviate.Client.Models.TargetVectors.Average(System.Collections.Generic.IEnumerable! names) -> Weaviate.Client.Models.TargetVectors! -static Weaviate.Client.Models.TargetVectors.ManualWeights(params (string! name, Weaviate.Client.Models.AutoArray! weight)[]! weights) -> Weaviate.Client.Models.TargetVectors! -static Weaviate.Client.Models.TargetVectors.Minimum(System.Collections.Generic.IEnumerable! names) -> Weaviate.Client.Models.TargetVectors! -static Weaviate.Client.Models.TargetVectors.RelativeScore(params (string! name, Weaviate.Client.Models.AutoArray! weight)[]! weights) -> Weaviate.Client.Models.TargetVectors! -static Weaviate.Client.Models.TargetVectors.Sum(System.Collections.Generic.IEnumerable! names) -> Weaviate.Client.Models.TargetVectors! -static Weaviate.Client.Models.TargetVectors.implicit operator Weaviate.Client.Models.TargetVectors!(System.Collections.Generic.List! names) -> Weaviate.Client.Models.TargetVectors! -static Weaviate.Client.Models.TargetVectors.implicit operator Weaviate.Client.Models.TargetVectors!(string![]! names) -> Weaviate.Client.Models.TargetVectors! -static Weaviate.Client.Models.Tenant.implicit operator Weaviate.Client.Models.Tenant!(string! name) -> Weaviate.Client.Models.Tenant! -static Weaviate.Client.Models.Tenant.operator !=(Weaviate.Client.Models.Tenant? left, Weaviate.Client.Models.Tenant? right) -> bool -static Weaviate.Client.Models.Tenant.operator ==(Weaviate.Client.Models.Tenant? left, Weaviate.Client.Models.Tenant? right) -> bool -static Weaviate.Client.Models.TenantsResource.operator !=(Weaviate.Client.Models.TenantsResource? left, Weaviate.Client.Models.TenantsResource? right) -> bool -static Weaviate.Client.Models.TenantsResource.operator ==(Weaviate.Client.Models.TenantsResource? left, Weaviate.Client.Models.TenantsResource? right) -> bool -static Weaviate.Client.Models.TimeFilter.operator !=(Weaviate.Client.Models.TimeFilter? left, Weaviate.Client.Models.TimeFilter? right) -> bool -static Weaviate.Client.Models.TimeFilter.operator ==(Weaviate.Client.Models.TimeFilter? left, Weaviate.Client.Models.TimeFilter? right) -> bool -static Weaviate.Client.Models.Typed.GenerativeGroupByObject.FromUntyped(Weaviate.Client.Models.GenerativeGroupByObject! obj) -> Weaviate.Client.Models.Typed.GenerativeGroupByObject! -static Weaviate.Client.Models.Typed.GenerativeGroupByResult.Empty.get -> Weaviate.Client.Models.Typed.GenerativeGroupByResult! -static Weaviate.Client.Models.Typed.GenerativeWeaviateObject.FromUntyped(Weaviate.Client.Models.GenerativeWeaviateObject! obj) -> Weaviate.Client.Models.Typed.GenerativeWeaviateObject! -static Weaviate.Client.Models.Typed.GenerativeWeaviateResult.Empty.get -> Weaviate.Client.Models.Typed.GenerativeWeaviateResult! -static Weaviate.Client.Models.Typed.GroupByObject.FromUntyped(Weaviate.Client.Models.GroupByObject! obj) -> Weaviate.Client.Models.Typed.GroupByObject! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this System.Collections.Generic.IEnumerable! objects) -> System.Collections.Generic.IEnumerable!>! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this System.Collections.Generic.IEnumerable! objects) -> System.Collections.Generic.IEnumerable!>! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.GenerativeGroupByObject! obj) -> Weaviate.Client.Models.Typed.GenerativeGroupByObject! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.GenerativeGroupByResult! result) -> Weaviate.Client.Models.Typed.GenerativeGroupByResult! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.GenerativeWeaviateGroup! group) -> Weaviate.Client.Models.Typed.GenerativeWeaviateGroup! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.GenerativeWeaviateObject! obj) -> Weaviate.Client.Models.Typed.GenerativeWeaviateObject! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.GenerativeWeaviateResult! result) -> Weaviate.Client.Models.Typed.GenerativeWeaviateResult! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.GroupByObject! obj) -> Weaviate.Client.Models.Typed.GroupByObject! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.GroupByResult! result) -> Weaviate.Client.Models.Typed.GroupByResult! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.WeaviateGroup! obj) -> Weaviate.Client.Models.Typed.WeaviateGroup! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.WeaviateObject! obj) -> Weaviate.Client.Models.Typed.WeaviateObject! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToTyped(this Weaviate.Client.Models.WeaviateResult! result) -> Weaviate.Client.Models.WeaviateResult!>! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToUntyped(this System.Collections.Generic.IEnumerable!>! objects) -> System.Collections.Generic.IEnumerable! -static Weaviate.Client.Models.Typed.TypedResultConverter.ToUntyped(this Weaviate.Client.Models.Typed.WeaviateObject! obj) -> Weaviate.Client.Models.WeaviateObject! -static Weaviate.Client.Models.Typed.WeaviateObject.FromUntyped(Weaviate.Client.Models.WeaviateObject! obj) -> Weaviate.Client.Models.Typed.WeaviateObject! -static Weaviate.Client.Models.TypedBase.implicit operator Weaviate.Client.Models.Filter!(Weaviate.Client.Models.TypedBase! filter) -> Weaviate.Client.Models.Filter! -static Weaviate.Client.Models.TypedBase.operator !=(Weaviate.Client.Models.TypedBase? left, Weaviate.Client.Models.TypedBase? right) -> bool -static Weaviate.Client.Models.TypedBase.operator ==(Weaviate.Client.Models.TypedBase? left, Weaviate.Client.Models.TypedBase? right) -> bool -static Weaviate.Client.Models.TypedGuid.operator !=(Weaviate.Client.Models.TypedGuid? left, Weaviate.Client.Models.TypedGuid? right) -> bool -static Weaviate.Client.Models.TypedGuid.operator ==(Weaviate.Client.Models.TypedGuid? left, Weaviate.Client.Models.TypedGuid? right) -> bool -static Weaviate.Client.Models.TypedValue.operator !=(Weaviate.Client.Models.TypedValue? left, Weaviate.Client.Models.TypedValue? right) -> bool -static Weaviate.Client.Models.TypedValue.operator ==(Weaviate.Client.Models.TypedValue? left, Weaviate.Client.Models.TypedValue? right) -> bool -static Weaviate.Client.Models.UserMetadata.operator !=(Weaviate.Client.Models.UserMetadata? left, Weaviate.Client.Models.UserMetadata? right) -> bool -static Weaviate.Client.Models.UserMetadata.operator ==(Weaviate.Client.Models.UserMetadata? left, Weaviate.Client.Models.UserMetadata? right) -> bool -static Weaviate.Client.Models.UserRoleAssignment.operator !=(Weaviate.Client.Models.UserRoleAssignment? left, Weaviate.Client.Models.UserRoleAssignment? right) -> bool -static Weaviate.Client.Models.UserRoleAssignment.operator ==(Weaviate.Client.Models.UserRoleAssignment? left, Weaviate.Client.Models.UserRoleAssignment? right) -> bool -static Weaviate.Client.Models.UsersResource.operator !=(Weaviate.Client.Models.UsersResource? left, Weaviate.Client.Models.UsersResource? right) -> bool -static Weaviate.Client.Models.UsersResource.operator ==(Weaviate.Client.Models.UsersResource? left, Weaviate.Client.Models.UsersResource? right) -> bool -static Weaviate.Client.Models.Vector.Create(string! name, Weaviate.Client.Models.Vector! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.Create(T[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.Create(params T[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.Create(string! name, T[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.Create(string! name, params T[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(bool[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(bool[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(byte[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(byte[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(decimal[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(decimal[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(double[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(double[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(float[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(float[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(int[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(int[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(long[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(long[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(short[,]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator Weaviate.Client.Models.Vector!(short[]! values) -> Weaviate.Client.Models.Vector! -static Weaviate.Client.Models.Vector.implicit operator bool[,]!(Weaviate.Client.Models.Vector! vector) -> bool[,]! -static Weaviate.Client.Models.Vector.implicit operator bool[]!(Weaviate.Client.Models.Vector! vector) -> bool[]! -static Weaviate.Client.Models.Vector.implicit operator byte[,]!(Weaviate.Client.Models.Vector! vector) -> byte[,]! -static Weaviate.Client.Models.Vector.implicit operator byte[]!(Weaviate.Client.Models.Vector! vector) -> byte[]! -static Weaviate.Client.Models.Vector.implicit operator decimal[,]!(Weaviate.Client.Models.Vector! vector) -> decimal[,]! -static Weaviate.Client.Models.Vector.implicit operator decimal[]!(Weaviate.Client.Models.Vector! vector) -> decimal[]! -static Weaviate.Client.Models.Vector.implicit operator double[,]!(Weaviate.Client.Models.Vector! vector) -> double[,]! -static Weaviate.Client.Models.Vector.implicit operator double[]!(Weaviate.Client.Models.Vector! vector) -> double[]! -static Weaviate.Client.Models.Vector.implicit operator float[,]!(Weaviate.Client.Models.Vector! vector) -> float[,]! -static Weaviate.Client.Models.Vector.implicit operator float[]!(Weaviate.Client.Models.Vector! vector) -> float[]! -static Weaviate.Client.Models.Vector.implicit operator int[,]!(Weaviate.Client.Models.Vector! vector) -> int[,]! -static Weaviate.Client.Models.Vector.implicit operator int[]!(Weaviate.Client.Models.Vector! vector) -> int[]! -static Weaviate.Client.Models.Vector.implicit operator long[,]!(Weaviate.Client.Models.Vector! vector) -> long[,]! -static Weaviate.Client.Models.Vector.implicit operator long[]!(Weaviate.Client.Models.Vector! vector) -> long[]! -static Weaviate.Client.Models.Vector.implicit operator short[,]!(Weaviate.Client.Models.Vector! vector) -> short[,]! -static Weaviate.Client.Models.Vector.implicit operator short[]!(Weaviate.Client.Models.Vector! vector) -> short[]! -static Weaviate.Client.Models.Vector.operator !=(Weaviate.Client.Models.Vector? left, Weaviate.Client.Models.Vector? right) -> bool -static Weaviate.Client.Models.Vector.operator ==(Weaviate.Client.Models.Vector? left, Weaviate.Client.Models.Vector? right) -> bool -static Weaviate.Client.Models.VectorConfig.operator !=(Weaviate.Client.Models.VectorConfig? left, Weaviate.Client.Models.VectorConfig? right) -> bool -static Weaviate.Client.Models.VectorConfig.operator ==(Weaviate.Client.Models.VectorConfig? left, Weaviate.Client.Models.VectorConfig? right) -> bool -static Weaviate.Client.Models.VectorConfigList.implicit operator Weaviate.Client.Models.VectorConfigList!(Weaviate.Client.Models.VectorConfig! config) -> Weaviate.Client.Models.VectorConfigList! -static Weaviate.Client.Models.VectorConfigList.implicit operator Weaviate.Client.Models.VectorConfigList!(Weaviate.Client.Models.VectorConfig![]! configs) -> Weaviate.Client.Models.VectorConfigList! -static Weaviate.Client.Models.VectorConfigList.operator !=(Weaviate.Client.Models.VectorConfigList? left, Weaviate.Client.Models.VectorConfigList? right) -> bool -static Weaviate.Client.Models.VectorConfigList.operator ==(Weaviate.Client.Models.VectorConfigList? left, Weaviate.Client.Models.VectorConfigList? right) -> bool -static Weaviate.Client.Models.VectorIndex.Dynamic.operator !=(Weaviate.Client.Models.VectorIndex.Dynamic? left, Weaviate.Client.Models.VectorIndex.Dynamic? right) -> bool -static Weaviate.Client.Models.VectorIndex.Dynamic.operator ==(Weaviate.Client.Models.VectorIndex.Dynamic? left, Weaviate.Client.Models.VectorIndex.Dynamic? right) -> bool -static Weaviate.Client.Models.VectorIndex.Flat.operator !=(Weaviate.Client.Models.VectorIndex.Flat? left, Weaviate.Client.Models.VectorIndex.Flat? right) -> bool -static Weaviate.Client.Models.VectorIndex.Flat.operator ==(Weaviate.Client.Models.VectorIndex.Flat? left, Weaviate.Client.Models.VectorIndex.Flat? right) -> bool -static Weaviate.Client.Models.VectorIndex.HNSW.operator !=(Weaviate.Client.Models.VectorIndex.HNSW? left, Weaviate.Client.Models.VectorIndex.HNSW? right) -> bool -static Weaviate.Client.Models.VectorIndex.HNSW.operator ==(Weaviate.Client.Models.VectorIndex.HNSW? left, Weaviate.Client.Models.VectorIndex.HNSW? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.BQ.operator !=(Weaviate.Client.Models.VectorIndex.Quantizers.BQ? left, Weaviate.Client.Models.VectorIndex.Quantizers.BQ? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.BQ.operator ==(Weaviate.Client.Models.VectorIndex.Quantizers.BQ? left, Weaviate.Client.Models.VectorIndex.Quantizers.BQ? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.None.operator !=(Weaviate.Client.Models.VectorIndex.Quantizers.None? left, Weaviate.Client.Models.VectorIndex.Quantizers.None? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.None.operator ==(Weaviate.Client.Models.VectorIndex.Quantizers.None? left, Weaviate.Client.Models.VectorIndex.Quantizers.None? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.operator !=(Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig? left, Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.operator ==(Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig? left, Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.PQ.operator !=(Weaviate.Client.Models.VectorIndex.Quantizers.PQ? left, Weaviate.Client.Models.VectorIndex.Quantizers.PQ? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.PQ.operator ==(Weaviate.Client.Models.VectorIndex.Quantizers.PQ? left, Weaviate.Client.Models.VectorIndex.Quantizers.PQ? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.RQ.operator !=(Weaviate.Client.Models.VectorIndex.Quantizers.RQ? left, Weaviate.Client.Models.VectorIndex.Quantizers.RQ? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.RQ.operator ==(Weaviate.Client.Models.VectorIndex.Quantizers.RQ? left, Weaviate.Client.Models.VectorIndex.Quantizers.RQ? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.SQ.operator !=(Weaviate.Client.Models.VectorIndex.Quantizers.SQ? left, Weaviate.Client.Models.VectorIndex.Quantizers.SQ? right) -> bool -static Weaviate.Client.Models.VectorIndex.Quantizers.SQ.operator ==(Weaviate.Client.Models.VectorIndex.Quantizers.SQ? left, Weaviate.Client.Models.VectorIndex.Quantizers.SQ? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.operator !=(Weaviate.Client.Models.VectorIndexConfig.EncodingConfig? left, Weaviate.Client.Models.VectorIndexConfig.EncodingConfig? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.operator ==(Weaviate.Client.Models.VectorIndexConfig.EncodingConfig? left, Weaviate.Client.Models.VectorIndexConfig.EncodingConfig? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.operator !=(Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig? left, Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.operator ==(Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig? left, Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.operator !=(Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding? left, Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.operator ==(Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding? left, Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.operator !=(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? left, Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.operator ==(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? left, Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.operator !=(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat? left, Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.operator ==(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat? left, Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.operator !=(Weaviate.Client.Models.VectorIndexConfig? left, Weaviate.Client.Models.VectorIndexConfig? right) -> bool -static Weaviate.Client.Models.VectorIndexConfig.operator ==(Weaviate.Client.Models.VectorIndexConfig? left, Weaviate.Client.Models.VectorIndexConfig? right) -> bool -static Weaviate.Client.Models.VectorMulti.operator !=(Weaviate.Client.Models.VectorMulti? left, Weaviate.Client.Models.VectorMulti? right) -> bool -static Weaviate.Client.Models.VectorMulti.operator ==(Weaviate.Client.Models.VectorMulti? left, Weaviate.Client.Models.VectorMulti? right) -> bool -static Weaviate.Client.Models.VectorQuery.implicit operator Weaviate.Client.Models.VectorQuery!(bool includeVectors) -> Weaviate.Client.Models.VectorQuery! -static Weaviate.Client.Models.VectorQuery.implicit operator Weaviate.Client.Models.VectorQuery!(string! vector) -> Weaviate.Client.Models.VectorQuery! -static Weaviate.Client.Models.VectorQuery.implicit operator Weaviate.Client.Models.VectorQuery!(string![]! vectors) -> Weaviate.Client.Models.VectorQuery! -static Weaviate.Client.Models.VectorSingle.operator !=(Weaviate.Client.Models.VectorSingle? left, Weaviate.Client.Models.VectorSingle? right) -> bool -static Weaviate.Client.Models.VectorSingle.operator ==(Weaviate.Client.Models.VectorSingle? left, Weaviate.Client.Models.VectorSingle? right) -> bool -static Weaviate.Client.Models.VectorizerConfig.operator !=(Weaviate.Client.Models.VectorizerConfig? left, Weaviate.Client.Models.VectorizerConfig? right) -> bool -static Weaviate.Client.Models.VectorizerConfig.operator ==(Weaviate.Client.Models.VectorizerConfig? left, Weaviate.Client.Models.VectorizerConfig? right) -> bool -static Weaviate.Client.Models.Vectors.Create(Weaviate.Client.Models.Vector! vector) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.Create(T[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.Create(params T[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.Create(string! name, T[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.Create(string! name, params T[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(System.Collections.Generic.Dictionary! vectors) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(Weaviate.Client.Models.Vector! vector) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(bool[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(bool[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(byte[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(byte[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(decimal[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(decimal[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(double[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(double[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(float[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(float[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(int[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(int[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(long[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(long[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(short[,]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.Vectors.implicit operator Weaviate.Client.Models.Vectors!(short[]! values) -> Weaviate.Client.Models.Vectors! -static Weaviate.Client.Models.WeaviateGroup.operator !=(Weaviate.Client.Models.WeaviateGroup? left, Weaviate.Client.Models.WeaviateGroup? right) -> bool -static Weaviate.Client.Models.WeaviateGroup.operator ==(Weaviate.Client.Models.WeaviateGroup? left, Weaviate.Client.Models.WeaviateGroup? right) -> bool -static Weaviate.Client.Models.WeaviateGroup.operator !=(Weaviate.Client.Models.WeaviateGroup? left, Weaviate.Client.Models.WeaviateGroup? right) -> bool -static Weaviate.Client.Models.WeaviateGroup.operator ==(Weaviate.Client.Models.WeaviateGroup? left, Weaviate.Client.Models.WeaviateGroup? right) -> bool -static Weaviate.Client.Models.WeaviateObject.operator !=(Weaviate.Client.Models.WeaviateObject? left, Weaviate.Client.Models.WeaviateObject? right) -> bool -static Weaviate.Client.Models.WeaviateObject.operator ==(Weaviate.Client.Models.WeaviateObject? left, Weaviate.Client.Models.WeaviateObject? right) -> bool -static Weaviate.Client.Models.WeaviateObjectExtensions.As(this Weaviate.Client.Models.WeaviateObject! obj) -> T? -static Weaviate.Client.Models.WeaviateObjectExtensions.Do(this Weaviate.Client.Models.WeaviateObject! obj, System.Action! action) -> void -static Weaviate.Client.Models.WeaviateObjectExtensions.Do(this Weaviate.Client.Models.WeaviateObject! obj, System.Action! action) -> void -static Weaviate.Client.Models.WeaviateObjectExtensions.Get(this Weaviate.Client.Models.WeaviateObject! obj, System.Func! func) -> TResult? -static Weaviate.Client.Models.WeaviateObjectExtensions.Get(this Weaviate.Client.Models.WeaviateObject! obj, System.Func! func) -> TResult? -static Weaviate.Client.Models.WeaviateResult.Empty.get -> Weaviate.Client.Models.WeaviateResult! -static Weaviate.Client.Models.WeaviateResult.operator !=(Weaviate.Client.Models.WeaviateResult? left, Weaviate.Client.Models.WeaviateResult? right) -> bool -static Weaviate.Client.Models.WeaviateResult.operator ==(Weaviate.Client.Models.WeaviateResult? left, Weaviate.Client.Models.WeaviateResult? right) -> bool -static Weaviate.Client.Models.WeaviateResult.operator !=(Weaviate.Client.Models.WeaviateResult? left, Weaviate.Client.Models.WeaviateResult? right) -> bool -static Weaviate.Client.Models.WeaviateResult.operator ==(Weaviate.Client.Models.WeaviateResult? left, Weaviate.Client.Models.WeaviateResult? right) -> bool -static Weaviate.Client.Models.WeightedField.implicit operator Weaviate.Client.Models.WeightedField!((string! Name, double Weight) tuple) -> Weaviate.Client.Models.WeightedField! -static Weaviate.Client.Models.WeightedField.operator !=(Weaviate.Client.Models.WeightedField? left, Weaviate.Client.Models.WeightedField? right) -> bool -static Weaviate.Client.Models.WeightedField.operator ==(Weaviate.Client.Models.WeightedField? left, Weaviate.Client.Models.WeightedField? right) -> bool -static Weaviate.Client.Models.WeightedFields.implicit operator string![]?(Weaviate.Client.Models.WeightedFields? weightedFields) -> string![]? -static Weaviate.Client.OAuthConfig.operator !=(Weaviate.Client.OAuthConfig? left, Weaviate.Client.OAuthConfig? right) -> bool -static Weaviate.Client.OAuthConfig.operator ==(Weaviate.Client.OAuthConfig? left, Weaviate.Client.OAuthConfig? right) -> bool -static Weaviate.Client.RetryPolicy.Default.get -> Weaviate.Client.RetryPolicy! -static Weaviate.Client.RetryPolicy.None.get -> Weaviate.Client.RetryPolicy! -static Weaviate.Client.RetryPolicy.operator !=(Weaviate.Client.RetryPolicy? left, Weaviate.Client.RetryPolicy? right) -> bool -static Weaviate.Client.RetryPolicy.operator ==(Weaviate.Client.RetryPolicy? left, Weaviate.Client.RetryPolicy? right) -> bool -static Weaviate.Client.Validation.TypeValidator.Default.get -> Weaviate.Client.Validation.TypeValidator! -static Weaviate.Client.Validation.ValidationResult.Failed(params Weaviate.Client.Validation.ValidationError![]! errors) -> Weaviate.Client.Validation.ValidationResult! -static Weaviate.Client.Validation.ValidationResult.Success() -> Weaviate.Client.Validation.ValidationResult! -static Weaviate.Client.Validation.ValidationResult.WithIssues(System.Collections.Generic.IEnumerable! errors, System.Collections.Generic.IEnumerable! warnings) -> Weaviate.Client.Validation.ValidationResult! -static Weaviate.Client.ValidationExtensions.ValidateType(this Weaviate.Client.Models.CollectionConfig? schema, Weaviate.Client.Validation.TypeValidator? typeValidator = null) -> Weaviate.Client.Validation.ValidationResult! -static Weaviate.Client.ValidationExtensions.ValidateType(this Weaviate.Client.Typed.TypedCollectionClient! client, Weaviate.Client.Validation.TypeValidator? typeValidator = null, Weaviate.Client.Cache.SchemaCache? schemaCache = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! -static Weaviate.Client.ValidationExtensions.ValidateTypeOrThrow(this Weaviate.Client.Models.CollectionConfig? schema, Weaviate.Client.Validation.TypeValidator? typeValidator = null) -> void -static Weaviate.Client.ValidationExtensions.ValidateTypeOrThrow(this Weaviate.Client.Typed.TypedCollectionClient! client, Weaviate.Client.Validation.TypeValidator? typeValidator = null, Weaviate.Client.Cache.SchemaCache? schemaCache = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!>! -static Weaviate.Client.WeaviateClient.DefaultOptions.get -> Weaviate.Client.ClientConfiguration! -static Weaviate.Client.WeaviateClientBuilder.Cloud(string! restEndpoint, string? apiKey = null, System.Collections.Generic.Dictionary? headers = null, System.Net.Http.HttpMessageHandler? httpMessageHandler = null) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateClientBuilder.Custom(string! restEndpoint = "localhost", string! restPath = "v1/", string! grpcEndpoint = "localhost", string! grpcPath = "", string! restPort = "8080", string! grpcPort = "50051", bool useSsl = false, System.Collections.Generic.Dictionary? headers = null, Weaviate.Client.ICredentials? credentials = null, System.Net.Http.HttpMessageHandler? httpMessageHandler = null) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateClientBuilder.Local(Weaviate.Client.ICredentials? credentials = null, string! hostname = "localhost", ushort restPort = 8080, ushort grpcPort = 50051, bool useSsl = false, System.Collections.Generic.Dictionary? headers = null, System.Net.Http.HttpMessageHandler? httpMessageHandler = null) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateClientBuilder.implicit operator System.Threading.Tasks.Task!(Weaviate.Client.WeaviateClientBuilder! builder) -> System.Threading.Tasks.Task! -static Weaviate.Client.WeaviateClientBuilderExtensions.WithAWS(this Weaviate.Client.WeaviateClientBuilder! builder, string! accessKey, string! secretKey) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateClientBuilderExtensions.WithCohere(this Weaviate.Client.WeaviateClientBuilder! builder, string! apiKey) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateClientBuilderExtensions.WithHuggingFace(this Weaviate.Client.WeaviateClientBuilder! builder, string! apiKey) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateClientBuilderExtensions.WithJinaAI(this Weaviate.Client.WeaviateClientBuilder! builder, string! apiKey) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateClientBuilderExtensions.WithMistral(this Weaviate.Client.WeaviateClientBuilder! builder, string! apiKey) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateClientBuilderExtensions.WithOpenAI(this Weaviate.Client.WeaviateClientBuilder! builder, string! apiKey) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateClientBuilderExtensions.WithVoyageAI(this Weaviate.Client.WeaviateClientBuilder! builder, string! apiKey) -> Weaviate.Client.WeaviateClientBuilder! -static Weaviate.Client.WeaviateDefaults.DefaultRetryPolicy.get -> Weaviate.Client.RetryPolicy! -static Weaviate.Client.WeaviateDefaults.DefaultRetryPolicy.set -> void -static Weaviate.Client.WeaviateDefaults.DefaultTimeout.get -> System.TimeSpan -static Weaviate.Client.WeaviateDefaults.DefaultTimeout.set -> void -static Weaviate.Client.WeaviateDefaults.InitTimeout.get -> System.TimeSpan -static Weaviate.Client.WeaviateDefaults.InitTimeout.set -> void -static Weaviate.Client.WeaviateDefaults.InsertTimeout.get -> System.TimeSpan -static Weaviate.Client.WeaviateDefaults.InsertTimeout.set -> void -static Weaviate.Client.WeaviateDefaults.QueryTimeout.get -> System.TimeSpan -static Weaviate.Client.WeaviateDefaults.QueryTimeout.set -> void -static readonly Weaviate.Client.Models.GenerativeResult.Empty -> Weaviate.Client.Models.GenerativeResult! -virtual Weaviate.Client.CollectionsClient.$() -> Weaviate.Client.CollectionsClient! -virtual Weaviate.Client.CollectionsClient.EqualityContract.get -> System.Type! -virtual Weaviate.Client.CollectionsClient.Equals(Weaviate.Client.CollectionsClient? other) -> bool -virtual Weaviate.Client.CollectionsClient.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Aggregate.Boolean.Equals(Weaviate.Client.Models.Aggregate.Boolean? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Date.Equals(Weaviate.Client.Models.Aggregate.Date? other) -> bool -virtual Weaviate.Client.Models.Aggregate.GroupBy.$() -> Weaviate.Client.Models.Aggregate.GroupBy! -virtual Weaviate.Client.Models.Aggregate.GroupBy.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Aggregate.GroupBy.Equals(Weaviate.Client.Models.Aggregate.GroupBy? other) -> bool -virtual Weaviate.Client.Models.Aggregate.GroupBy.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Aggregate.Integer.Equals(Weaviate.Client.Models.Aggregate.Integer? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Metric.Boolean.Equals(Weaviate.Client.Models.Aggregate.Metric.Boolean? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Metric.Date.Equals(Weaviate.Client.Models.Aggregate.Metric.Date? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Metric.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Aggregate.Metric.Equals(Weaviate.Client.Models.Aggregate.Metric? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Metric.Integer.Equals(Weaviate.Client.Models.Aggregate.Metric.Integer? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Metric.Number.Equals(Weaviate.Client.Models.Aggregate.Metric.Number? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Metric.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Aggregate.Metric.Text.Equals(Weaviate.Client.Models.Aggregate.Metric.Text? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Number.Equals(Weaviate.Client.Models.Aggregate.Number? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Numeric.Equals(Weaviate.Client.Models.Aggregate.Numeric? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Property.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Aggregate.Property.Equals(Weaviate.Client.Models.Aggregate.Property? other) -> bool -virtual Weaviate.Client.Models.Aggregate.Property.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Aggregate.Text.Equals(Weaviate.Client.Models.Aggregate.Text? other) -> bool -virtual Weaviate.Client.Models.Aggregate.TopOccurrence.Equals(Weaviate.Client.Models.Aggregate.TopOccurrence? other) -> bool -virtual Weaviate.Client.Models.AggregateGroupByResult.$() -> Weaviate.Client.Models.AggregateGroupByResult! -virtual Weaviate.Client.Models.AggregateGroupByResult.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.AggregateGroupByResult.Equals(Weaviate.Client.Models.AggregateGroupByResult? other) -> bool -virtual Weaviate.Client.Models.AggregateGroupByResult.Group.$() -> Weaviate.Client.Models.AggregateGroupByResult.Group! -virtual Weaviate.Client.Models.AggregateGroupByResult.Group.By.$() -> Weaviate.Client.Models.AggregateGroupByResult.Group.By! -virtual Weaviate.Client.Models.AggregateGroupByResult.Group.By.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.AggregateGroupByResult.Group.By.Equals(Weaviate.Client.Models.AggregateGroupByResult.Group.By? other) -> bool -virtual Weaviate.Client.Models.AggregateGroupByResult.Group.By.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.AggregateGroupByResult.Group.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.AggregateGroupByResult.Group.Equals(Weaviate.Client.Models.AggregateGroupByResult.Group? other) -> bool -virtual Weaviate.Client.Models.AggregateGroupByResult.Group.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.AggregateGroupByResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.AggregateResult.$() -> Weaviate.Client.Models.AggregateResult! -virtual Weaviate.Client.Models.AggregateResult.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.AggregateResult.Equals(Weaviate.Client.Models.AggregateResult? other) -> bool -virtual Weaviate.Client.Models.AggregateResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Alias.$() -> Weaviate.Client.Models.Alias! -virtual Weaviate.Client.Models.Alias.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Alias.Equals(Weaviate.Client.Models.Alias? other) -> bool -virtual Weaviate.Client.Models.Alias.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.AliasesResource.$() -> Weaviate.Client.Models.AliasesResource! -virtual Weaviate.Client.Models.AliasesResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.AliasesResource.Equals(Weaviate.Client.Models.AliasesResource? other) -> bool -virtual Weaviate.Client.Models.AliasesResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.AndNestedFilter.Equals(Weaviate.Client.Models.AndNestedFilter? other) -> bool -virtual Weaviate.Client.Models.BM25Config.$() -> Weaviate.Client.Models.BM25Config! -virtual Weaviate.Client.Models.BM25Config.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BM25Config.Equals(Weaviate.Client.Models.BM25Config? other) -> bool -virtual Weaviate.Client.Models.BM25Config.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BM25Operator.And.Equals(Weaviate.Client.Models.BM25Operator.And? other) -> bool -virtual Weaviate.Client.Models.BM25Operator.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BM25Operator.Equals(Weaviate.Client.Models.BM25Operator? other) -> bool -virtual Weaviate.Client.Models.BM25Operator.Or.Equals(Weaviate.Client.Models.BM25Operator.Or? other) -> bool -virtual Weaviate.Client.Models.BM25Operator.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Backup.$() -> Weaviate.Client.Models.Backup! -virtual Weaviate.Client.Models.Backup.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Backup.Equals(Weaviate.Client.Models.Backup? other) -> bool -virtual Weaviate.Client.Models.Backup.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BackupBackend.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BackupBackend.Equals(Weaviate.Client.Models.BackupBackend? other) -> bool -virtual Weaviate.Client.Models.BackupBackend.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BackupClientConfig.$() -> Weaviate.Client.Models.BackupClientConfig! -virtual Weaviate.Client.Models.BackupClientConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BackupClientConfig.Equals(Weaviate.Client.Models.BackupClientConfig? other) -> bool -virtual Weaviate.Client.Models.BackupClientConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BackupCreateRequest.$() -> Weaviate.Client.Models.BackupCreateRequest! -virtual Weaviate.Client.Models.BackupCreateRequest.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BackupCreateRequest.Equals(Weaviate.Client.Models.BackupCreateRequest? other) -> bool -virtual Weaviate.Client.Models.BackupCreateRequest.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BackupOperationBase.Dispose(bool disposing) -> void -virtual Weaviate.Client.Models.BackupRestoreRequest.$() -> Weaviate.Client.Models.BackupRestoreRequest! -virtual Weaviate.Client.Models.BackupRestoreRequest.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BackupRestoreRequest.Equals(Weaviate.Client.Models.BackupRestoreRequest? other) -> bool -virtual Weaviate.Client.Models.BackupRestoreRequest.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BackupsResource.$() -> Weaviate.Client.Models.BackupsResource! -virtual Weaviate.Client.Models.BackupsResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BackupsResource.Equals(Weaviate.Client.Models.BackupsResource? other) -> bool -virtual Weaviate.Client.Models.BackupsResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BatchInsertRequest.$() -> Weaviate.Client.Models.BatchInsertRequest! -virtual Weaviate.Client.Models.BatchInsertRequest.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BatchInsertRequest.Equals(Weaviate.Client.Models.BatchInsertRequest? other) -> bool -virtual Weaviate.Client.Models.BatchInsertRequest.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BatchInsertResponse.$() -> Weaviate.Client.Models.BatchInsertResponse! -virtual Weaviate.Client.Models.BatchInsertResponse.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BatchInsertResponse.Equals(Weaviate.Client.Models.BatchInsertResponse? other) -> bool -virtual Weaviate.Client.Models.BatchInsertResponse.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BatchInsertResponseEntry.$() -> Weaviate.Client.Models.BatchInsertResponseEntry! -virtual Weaviate.Client.Models.BatchInsertResponseEntry.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BatchInsertResponseEntry.Equals(Weaviate.Client.Models.BatchInsertResponseEntry? other) -> bool -virtual Weaviate.Client.Models.BatchInsertResponseEntry.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.BatchReferenceReturn.$() -> Weaviate.Client.Models.BatchReferenceReturn! -virtual Weaviate.Client.Models.BatchReferenceReturn.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.BatchReferenceReturn.Equals(Weaviate.Client.Models.BatchReferenceReturn? other) -> bool -virtual Weaviate.Client.Models.BatchReferenceReturn.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Bm25ConfigUpdate.$() -> Weaviate.Client.Models.Bm25ConfigUpdate! -virtual Weaviate.Client.Models.Bm25ConfigUpdate.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Bm25ConfigUpdate.Equals(Weaviate.Client.Models.Bm25ConfigUpdate? other) -> bool -virtual Weaviate.Client.Models.Bm25ConfigUpdate.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ClusterNode.$() -> Weaviate.Client.Models.ClusterNode! -virtual Weaviate.Client.Models.ClusterNode.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ClusterNode.Equals(Weaviate.Client.Models.ClusterNode? other) -> bool -virtual Weaviate.Client.Models.ClusterNode.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ClusterNodeVerbose.Equals(Weaviate.Client.Models.ClusterNodeVerbose? other) -> bool -virtual Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.$() -> Weaviate.Client.Models.ClusterNodeVerbose.NodeStats! -virtual Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.Equals(Weaviate.Client.Models.ClusterNodeVerbose.NodeStats? other) -> bool -virtual Weaviate.Client.Models.ClusterNodeVerbose.NodeStats.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ClusterNodeVerbose.Shard.$() -> Weaviate.Client.Models.ClusterNodeVerbose.Shard! -virtual Weaviate.Client.Models.ClusterNodeVerbose.Shard.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ClusterNodeVerbose.Shard.Equals(Weaviate.Client.Models.ClusterNodeVerbose.Shard? other) -> bool -virtual Weaviate.Client.Models.ClusterNodeVerbose.Shard.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.CollectionConfigCommon.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.CollectionConfigCommon.Equals(Weaviate.Client.Models.CollectionConfig? other) -> bool -virtual Weaviate.Client.Models.CollectionConfigCommon.Equals(Weaviate.Client.Models.CollectionConfigCommon? other) -> bool -virtual Weaviate.Client.Models.CollectionConfigCommon.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.CollectionConfigExport.Equals(Weaviate.Client.Models.CollectionConfigExport? other) -> bool -virtual Weaviate.Client.Models.CollectionCreateParams.Equals(Weaviate.Client.Models.CollectionCreateParams? other) -> bool -virtual Weaviate.Client.Models.CollectionUpdate.$() -> Weaviate.Client.Models.CollectionUpdate! -virtual Weaviate.Client.Models.CollectionUpdate.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.CollectionUpdate.Equals(Weaviate.Client.Models.CollectionUpdate? other) -> bool -virtual Weaviate.Client.Models.CollectionUpdate.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.CollectionsResource.$() -> Weaviate.Client.Models.CollectionsResource! -virtual Weaviate.Client.Models.CollectionsResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.CollectionsResource.Equals(Weaviate.Client.Models.CollectionsResource? other) -> bool -virtual Weaviate.Client.Models.CollectionsResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.CurrentUserInfo.$() -> Weaviate.Client.Models.CurrentUserInfo! -virtual Weaviate.Client.Models.CurrentUserInfo.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.CurrentUserInfo.Equals(Weaviate.Client.Models.CurrentUserInfo? other) -> bool -virtual Weaviate.Client.Models.CurrentUserInfo.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.DataReference.$() -> Weaviate.Client.Models.DataReference! -virtual Weaviate.Client.Models.DataReference.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.DataReference.Equals(Weaviate.Client.Models.DataReference? other) -> bool -virtual Weaviate.Client.Models.DataReference.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.DataResource.$() -> Weaviate.Client.Models.DataResource! -virtual Weaviate.Client.Models.DataResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.DataResource.Equals(Weaviate.Client.Models.DataResource? other) -> bool -virtual Weaviate.Client.Models.DataResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.DatabaseUser.$() -> Weaviate.Client.Models.DatabaseUser! -virtual Weaviate.Client.Models.DatabaseUser.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.DatabaseUser.Equals(Weaviate.Client.Models.DatabaseUser? other) -> bool -virtual Weaviate.Client.Models.DatabaseUser.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.FilesystemBackend.Equals(Weaviate.Client.Models.FilesystemBackend? other) -> bool -virtual Weaviate.Client.Models.Filter.$() -> Weaviate.Client.Models.Filter! -virtual Weaviate.Client.Models.Filter.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Filter.Equals(Weaviate.Client.Models.Filter? other) -> bool -virtual Weaviate.Client.Models.Filter.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Generative.Providers.AWSBedrock.Equals(Weaviate.Client.Models.Generative.Providers.AWSBedrock? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.AWSSagemaker.Equals(Weaviate.Client.Models.Generative.Providers.AWSSagemaker? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.Anthropic.Equals(Weaviate.Client.Models.Generative.Providers.Anthropic? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.Anyscale.Equals(Weaviate.Client.Models.Generative.Providers.Anyscale? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.AzureOpenAI.Equals(Weaviate.Client.Models.Generative.Providers.AzureOpenAI? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.Cohere.Equals(Weaviate.Client.Models.Generative.Providers.Cohere? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.ContextualAI.Equals(Weaviate.Client.Models.Generative.Providers.ContextualAI? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.Databricks.Equals(Weaviate.Client.Models.Generative.Providers.Databricks? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.Dummy.Equals(Weaviate.Client.Models.Generative.Providers.Dummy? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.FriendliAI.Equals(Weaviate.Client.Models.Generative.Providers.FriendliAI? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.GoogleGemini.Equals(Weaviate.Client.Models.Generative.Providers.GoogleGemini? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.GoogleVertex.Equals(Weaviate.Client.Models.Generative.Providers.GoogleVertex? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.Mistral.Equals(Weaviate.Client.Models.Generative.Providers.Mistral? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.Nvidia.Equals(Weaviate.Client.Models.Generative.Providers.Nvidia? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.Ollama.Equals(Weaviate.Client.Models.Generative.Providers.Ollama? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.OpenAI.Equals(Weaviate.Client.Models.Generative.Providers.OpenAI? other) -> bool -virtual Weaviate.Client.Models.Generative.Providers.XAI.Equals(Weaviate.Client.Models.Generative.Providers.XAI? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.AWS.$() -> Weaviate.Client.Models.GenerativeConfig.AWS! -virtual Weaviate.Client.Models.GenerativeConfig.AWS.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.AWS.Equals(Weaviate.Client.Models.GenerativeConfig.AWS? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.AWS.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Anthropic.$() -> Weaviate.Client.Models.GenerativeConfig.Anthropic! -virtual Weaviate.Client.Models.GenerativeConfig.Anthropic.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.Anthropic.Equals(Weaviate.Client.Models.GenerativeConfig.Anthropic? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Anthropic.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Anyscale.$() -> Weaviate.Client.Models.GenerativeConfig.Anyscale! -virtual Weaviate.Client.Models.GenerativeConfig.Anyscale.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.Anyscale.Equals(Weaviate.Client.Models.GenerativeConfig.Anyscale? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Anyscale.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.AzureOpenAI.Equals(Weaviate.Client.Models.GenerativeConfig.AzureOpenAI? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Cohere.$() -> Weaviate.Client.Models.GenerativeConfig.Cohere! -virtual Weaviate.Client.Models.GenerativeConfig.Cohere.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.Cohere.Equals(Weaviate.Client.Models.GenerativeConfig.Cohere? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Cohere.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.ContextualAI.$() -> Weaviate.Client.Models.GenerativeConfig.ContextualAI! -virtual Weaviate.Client.Models.GenerativeConfig.ContextualAI.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.ContextualAI.Equals(Weaviate.Client.Models.GenerativeConfig.ContextualAI? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.ContextualAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Custom.$() -> Weaviate.Client.Models.GenerativeConfig.Custom! -virtual Weaviate.Client.Models.GenerativeConfig.Custom.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.Custom.Equals(Weaviate.Client.Models.GenerativeConfig.Custom? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Custom.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Databricks.$() -> Weaviate.Client.Models.GenerativeConfig.Databricks! -virtual Weaviate.Client.Models.GenerativeConfig.Databricks.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.Databricks.Equals(Weaviate.Client.Models.GenerativeConfig.Databricks? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Databricks.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.FriendliAI.$() -> Weaviate.Client.Models.GenerativeConfig.FriendliAI! -virtual Weaviate.Client.Models.GenerativeConfig.FriendliAI.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.FriendliAI.Equals(Weaviate.Client.Models.GenerativeConfig.FriendliAI? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.FriendliAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.GoogleGemini.$() -> Weaviate.Client.Models.GenerativeConfig.GoogleGemini! -virtual Weaviate.Client.Models.GenerativeConfig.GoogleGemini.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.GoogleGemini.Equals(Weaviate.Client.Models.GenerativeConfig.GoogleGemini? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.GoogleGemini.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.GoogleVertex.$() -> Weaviate.Client.Models.GenerativeConfig.GoogleVertex! -virtual Weaviate.Client.Models.GenerativeConfig.GoogleVertex.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.GoogleVertex.Equals(Weaviate.Client.Models.GenerativeConfig.GoogleVertex? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.GoogleVertex.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Mistral.$() -> Weaviate.Client.Models.GenerativeConfig.Mistral! -virtual Weaviate.Client.Models.GenerativeConfig.Mistral.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.Mistral.Equals(Weaviate.Client.Models.GenerativeConfig.Mistral? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Mistral.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Nvidia.$() -> Weaviate.Client.Models.GenerativeConfig.Nvidia! -virtual Weaviate.Client.Models.GenerativeConfig.Nvidia.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.Nvidia.Equals(Weaviate.Client.Models.GenerativeConfig.Nvidia? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Nvidia.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Ollama.$() -> Weaviate.Client.Models.GenerativeConfig.Ollama! -virtual Weaviate.Client.Models.GenerativeConfig.Ollama.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.Ollama.Equals(Weaviate.Client.Models.GenerativeConfig.Ollama? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.Ollama.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.OpenAI.Equals(Weaviate.Client.Models.GenerativeConfig.OpenAI? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.OpenAIBase.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.OpenAIBase.Equals(Weaviate.Client.Models.GenerativeConfig.OpenAIBase? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.OpenAIBase.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.XAI.$() -> Weaviate.Client.Models.GenerativeConfig.XAI! -virtual Weaviate.Client.Models.GenerativeConfig.XAI.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeConfig.XAI.Equals(Weaviate.Client.Models.GenerativeConfig.XAI? other) -> bool -virtual Weaviate.Client.Models.GenerativeConfig.XAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeDebug.$() -> Weaviate.Client.Models.GenerativeDebug! -virtual Weaviate.Client.Models.GenerativeDebug.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeDebug.Equals(Weaviate.Client.Models.GenerativeDebug? other) -> bool -virtual Weaviate.Client.Models.GenerativeDebug.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeGroupByObject.Equals(Weaviate.Client.Models.GenerativeGroupByObject? other) -> bool -virtual Weaviate.Client.Models.GenerativeGroupByResult.Equals(Weaviate.Client.Models.GenerativeGroupByResult? other) -> bool -virtual Weaviate.Client.Models.GenerativePrompt.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativePrompt.Equals(Weaviate.Client.Models.GenerativePrompt? other) -> bool -virtual Weaviate.Client.Models.GenerativePrompt.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeProvider.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeProvider.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool -virtual Weaviate.Client.Models.GenerativeProvider.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeReply.$() -> Weaviate.Client.Models.GenerativeReply! -virtual Weaviate.Client.Models.GenerativeReply.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeReply.Equals(Weaviate.Client.Models.GenerativeReply? other) -> bool -virtual Weaviate.Client.Models.GenerativeReply.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeResult.$() -> Weaviate.Client.Models.GenerativeResult! -virtual Weaviate.Client.Models.GenerativeResult.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GenerativeResult.Equals(Weaviate.Client.Models.GenerativeResult? other) -> bool -virtual Weaviate.Client.Models.GenerativeResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GenerativeWeaviateGroup.Equals(Weaviate.Client.Models.GenerativeWeaviateGroup? other) -> bool -virtual Weaviate.Client.Models.GenerativeWeaviateObject.Equals(Weaviate.Client.Models.GenerativeWeaviateObject? other) -> bool -virtual Weaviate.Client.Models.GenerativeWeaviateResult.Equals(Weaviate.Client.Models.GenerativeWeaviateResult? other) -> bool -virtual Weaviate.Client.Models.GeoCoordinate.$() -> Weaviate.Client.Models.GeoCoordinate! -virtual Weaviate.Client.Models.GeoCoordinate.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GeoCoordinate.Equals(Weaviate.Client.Models.GeoCoordinate? other) -> bool -virtual Weaviate.Client.Models.GeoCoordinate.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GeoCoordinateConstraint.$() -> Weaviate.Client.Models.GeoCoordinateConstraint! -virtual Weaviate.Client.Models.GeoCoordinateConstraint.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GeoCoordinateConstraint.Equals(Weaviate.Client.Models.GeoCoordinateConstraint? other) -> bool -virtual Weaviate.Client.Models.GeoCoordinateConstraint.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GroupByObject.Equals(Weaviate.Client.Models.GroupByObject? other) -> bool -virtual Weaviate.Client.Models.GroupByRequest.$() -> Weaviate.Client.Models.GroupByRequest! -virtual Weaviate.Client.Models.GroupByRequest.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GroupByRequest.Equals(Weaviate.Client.Models.GroupByRequest? other) -> bool -virtual Weaviate.Client.Models.GroupByRequest.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GroupByResult.Equals(Weaviate.Client.Models.GroupByResult? other) -> bool -virtual Weaviate.Client.Models.GroupByResult.$() -> Weaviate.Client.Models.GroupByResult! -virtual Weaviate.Client.Models.GroupByResult.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GroupByResult.Equals(Weaviate.Client.Models.GroupByResult? other) -> bool -virtual Weaviate.Client.Models.GroupByResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GroupRoleAssignment.$() -> Weaviate.Client.Models.GroupRoleAssignment! -virtual Weaviate.Client.Models.GroupRoleAssignment.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GroupRoleAssignment.Equals(Weaviate.Client.Models.GroupRoleAssignment? other) -> bool -virtual Weaviate.Client.Models.GroupRoleAssignment.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.GroupedTask.Equals(Weaviate.Client.Models.GroupedTask? other) -> bool -virtual Weaviate.Client.Models.GroupsResource.$() -> Weaviate.Client.Models.GroupsResource! -virtual Weaviate.Client.Models.GroupsResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.GroupsResource.Equals(Weaviate.Client.Models.GroupsResource? other) -> bool -virtual Weaviate.Client.Models.GroupsResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.HybridNearText.$() -> Weaviate.Client.Models.HybridNearText! -virtual Weaviate.Client.Models.HybridNearText.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.HybridNearText.Equals(Weaviate.Client.Models.HybridNearText? other) -> bool -virtual Weaviate.Client.Models.HybridNearText.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.HybridNearVector.$() -> Weaviate.Client.Models.HybridNearVector! -virtual Weaviate.Client.Models.HybridNearVector.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.HybridNearVector.Equals(Weaviate.Client.Models.HybridNearVector? other) -> bool -virtual Weaviate.Client.Models.HybridNearVector.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.InvertedIndexConfig.$() -> Weaviate.Client.Models.InvertedIndexConfig! -virtual Weaviate.Client.Models.InvertedIndexConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.InvertedIndexConfig.Equals(Weaviate.Client.Models.InvertedIndexConfig? other) -> bool -virtual Weaviate.Client.Models.InvertedIndexConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.InvertedIndexConfigUpdate.$() -> Weaviate.Client.Models.InvertedIndexConfigUpdate! -virtual Weaviate.Client.Models.InvertedIndexConfigUpdate.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.InvertedIndexConfigUpdate.Equals(Weaviate.Client.Models.InvertedIndexConfigUpdate? other) -> bool -virtual Weaviate.Client.Models.InvertedIndexConfigUpdate.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Metadata.$() -> Weaviate.Client.Models.Metadata! -virtual Weaviate.Client.Models.Metadata.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Metadata.Equals(Weaviate.Client.Models.Metadata? other) -> bool -virtual Weaviate.Client.Models.Metadata.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.MetadataQuery.$() -> Weaviate.Client.Models.MetadataQuery! -virtual Weaviate.Client.Models.MetadataQuery.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.MetadataQuery.Equals(Weaviate.Client.Models.MetadataQuery? other) -> bool -virtual Weaviate.Client.Models.MetadataQuery.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Move.$() -> Weaviate.Client.Models.Move! -virtual Weaviate.Client.Models.Move.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Move.Equals(Weaviate.Client.Models.Move? other) -> bool -virtual Weaviate.Client.Models.Move.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.MultiTenancyConfig.$() -> Weaviate.Client.Models.MultiTenancyConfig! -virtual Weaviate.Client.Models.MultiTenancyConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.MultiTenancyConfig.Equals(Weaviate.Client.Models.MultiTenancyConfig? other) -> bool -virtual Weaviate.Client.Models.MultiTenancyConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.NearVectorInput.$() -> Weaviate.Client.Models.NearVectorInput! -virtual Weaviate.Client.Models.NearVectorInput.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.NearVectorInput.Equals(Weaviate.Client.Models.NearVectorInput? other) -> bool -virtual Weaviate.Client.Models.NearVectorInput.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.NestedFilter.Equals(Weaviate.Client.Models.NestedFilter? other) -> bool -virtual Weaviate.Client.Models.NodesResource.$() -> Weaviate.Client.Models.NodesResource! -virtual Weaviate.Client.Models.NodesResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.NodesResource.Equals(Weaviate.Client.Models.NodesResource? other) -> bool -virtual Weaviate.Client.Models.NodesResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.NotNestedFilter.Equals(Weaviate.Client.Models.NotNestedFilter? other) -> bool -virtual Weaviate.Client.Models.ObjectReference.$() -> Weaviate.Client.Models.ObjectReference! -virtual Weaviate.Client.Models.ObjectReference.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ObjectReference.Equals(Weaviate.Client.Models.ObjectReference? other) -> bool -virtual Weaviate.Client.Models.ObjectReference.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ObjectStorageBackend.Equals(Weaviate.Client.Models.ObjectStorageBackend? other) -> bool -virtual Weaviate.Client.Models.OrNestedFilter.Equals(Weaviate.Client.Models.OrNestedFilter? other) -> bool -virtual Weaviate.Client.Models.PhoneNumber.$() -> Weaviate.Client.Models.PhoneNumber! -virtual Weaviate.Client.Models.PhoneNumber.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.PhoneNumber.Equals(Weaviate.Client.Models.PhoneNumber? other) -> bool -virtual Weaviate.Client.Models.PhoneNumber.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Property.$() -> Weaviate.Client.Models.Property! -virtual Weaviate.Client.Models.Property.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Property.Equals(Weaviate.Client.Models.Property? other) -> bool -virtual Weaviate.Client.Models.Property.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.PropertyFactory.Invoke(string! name, string? description = null, bool? indexFilterable = null, bool? indexRangeFilters = null, bool? indexSearchable = null, Weaviate.Client.Models.PropertyTokenization? tokenization = null, Weaviate.Client.Models.Property![]? subProperties = null) -> Weaviate.Client.Models.Property! -virtual Weaviate.Client.Models.PropertyFilter.Equals(Weaviate.Client.Models.PropertyFilter? other) -> bool -virtual Weaviate.Client.Models.PropertyUpdate.$() -> Weaviate.Client.Models.PropertyUpdate! -virtual Weaviate.Client.Models.PropertyUpdate.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.PropertyUpdate.Equals(Weaviate.Client.Models.PropertyUpdate? other) -> bool -virtual Weaviate.Client.Models.PropertyUpdate.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.QueryReference.$() -> Weaviate.Client.Models.QueryReference! -virtual Weaviate.Client.Models.QueryReference.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.QueryReference.Equals(Weaviate.Client.Models.QueryReference? other) -> bool -virtual Weaviate.Client.Models.QueryReference.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Reference.$() -> Weaviate.Client.Models.Reference! -virtual Weaviate.Client.Models.Reference.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Reference.Equals(Weaviate.Client.Models.Reference? other) -> bool -virtual Weaviate.Client.Models.Reference.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ReferenceFilter.Equals(Weaviate.Client.Models.ReferenceFilter? other) -> bool -virtual Weaviate.Client.Models.ReferenceUpdate.$() -> Weaviate.Client.Models.ReferenceUpdate! -virtual Weaviate.Client.Models.ReferenceUpdate.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ReferenceUpdate.Equals(Weaviate.Client.Models.ReferenceUpdate? other) -> bool -virtual Weaviate.Client.Models.ReferenceUpdate.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ReplicateRequest.$() -> Weaviate.Client.Models.ReplicateRequest! -virtual Weaviate.Client.Models.ReplicateRequest.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ReplicateRequest.Equals(Weaviate.Client.Models.ReplicateRequest? other) -> bool -virtual Weaviate.Client.Models.ReplicateRequest.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ReplicateResource.$() -> Weaviate.Client.Models.ReplicateResource! -virtual Weaviate.Client.Models.ReplicateResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ReplicateResource.Equals(Weaviate.Client.Models.ReplicateResource? other) -> bool -virtual Weaviate.Client.Models.ReplicateResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ReplicationConfig.$() -> Weaviate.Client.Models.ReplicationConfig! -virtual Weaviate.Client.Models.ReplicationConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ReplicationConfig.Equals(Weaviate.Client.Models.ReplicationConfig? other) -> bool -virtual Weaviate.Client.Models.ReplicationConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ReplicationOperation.$() -> Weaviate.Client.Models.ReplicationOperation! -virtual Weaviate.Client.Models.ReplicationOperation.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ReplicationOperation.Equals(Weaviate.Client.Models.ReplicationOperation? other) -> bool -virtual Weaviate.Client.Models.ReplicationOperation.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ReplicationOperationError.$() -> Weaviate.Client.Models.ReplicationOperationError! -virtual Weaviate.Client.Models.ReplicationOperationError.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ReplicationOperationError.Equals(Weaviate.Client.Models.ReplicationOperationError? other) -> bool -virtual Weaviate.Client.Models.ReplicationOperationError.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ReplicationOperationStatus.$() -> Weaviate.Client.Models.ReplicationOperationStatus! -virtual Weaviate.Client.Models.ReplicationOperationStatus.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ReplicationOperationStatus.Equals(Weaviate.Client.Models.ReplicationOperationStatus? other) -> bool -virtual Weaviate.Client.Models.ReplicationOperationStatus.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Rerank.$() -> Weaviate.Client.Models.Rerank! -virtual Weaviate.Client.Models.Rerank.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Rerank.Equals(Weaviate.Client.Models.Rerank? other) -> bool -virtual Weaviate.Client.Models.Rerank.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Reranker.Cohere.$() -> Weaviate.Client.Models.Reranker.Cohere! -virtual Weaviate.Client.Models.Reranker.Cohere.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Reranker.Cohere.Equals(Weaviate.Client.Models.Reranker.Cohere? other) -> bool -virtual Weaviate.Client.Models.Reranker.Cohere.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Reranker.ContextualAI.$() -> Weaviate.Client.Models.Reranker.ContextualAI! -virtual Weaviate.Client.Models.Reranker.ContextualAI.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Reranker.ContextualAI.Equals(Weaviate.Client.Models.Reranker.ContextualAI? other) -> bool -virtual Weaviate.Client.Models.Reranker.ContextualAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Reranker.Custom.$() -> Weaviate.Client.Models.Reranker.Custom! -virtual Weaviate.Client.Models.Reranker.Custom.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Reranker.Custom.Equals(Weaviate.Client.Models.Reranker.Custom? other) -> bool -virtual Weaviate.Client.Models.Reranker.Custom.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Reranker.JinaAI.$() -> Weaviate.Client.Models.Reranker.JinaAI! -virtual Weaviate.Client.Models.Reranker.JinaAI.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Reranker.JinaAI.Equals(Weaviate.Client.Models.Reranker.JinaAI? other) -> bool -virtual Weaviate.Client.Models.Reranker.JinaAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Reranker.None.$() -> Weaviate.Client.Models.Reranker.None! -virtual Weaviate.Client.Models.Reranker.None.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Reranker.None.Equals(Weaviate.Client.Models.Reranker.None? other) -> bool -virtual Weaviate.Client.Models.Reranker.None.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Reranker.Nvidia.$() -> Weaviate.Client.Models.Reranker.Nvidia! -virtual Weaviate.Client.Models.Reranker.Nvidia.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Reranker.Nvidia.Equals(Weaviate.Client.Models.Reranker.Nvidia? other) -> bool -virtual Weaviate.Client.Models.Reranker.Nvidia.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Reranker.Transformers.$() -> Weaviate.Client.Models.Reranker.Transformers! -virtual Weaviate.Client.Models.Reranker.Transformers.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Reranker.Transformers.Equals(Weaviate.Client.Models.Reranker.Transformers? other) -> bool -virtual Weaviate.Client.Models.Reranker.Transformers.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Reranker.VoyageAI.$() -> Weaviate.Client.Models.Reranker.VoyageAI! -virtual Weaviate.Client.Models.Reranker.VoyageAI.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Reranker.VoyageAI.Equals(Weaviate.Client.Models.Reranker.VoyageAI? other) -> bool -virtual Weaviate.Client.Models.Reranker.VoyageAI.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.RoleInfo.$() -> Weaviate.Client.Models.RoleInfo! -virtual Weaviate.Client.Models.RoleInfo.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.RoleInfo.Equals(Weaviate.Client.Models.RoleInfo? other) -> bool -virtual Weaviate.Client.Models.RoleInfo.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.RolesResource.$() -> Weaviate.Client.Models.RolesResource! -virtual Weaviate.Client.Models.RolesResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.RolesResource.Equals(Weaviate.Client.Models.RolesResource? other) -> bool -virtual Weaviate.Client.Models.RolesResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ShardInfo.$() -> Weaviate.Client.Models.ShardInfo! -virtual Weaviate.Client.Models.ShardInfo.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ShardInfo.Equals(Weaviate.Client.Models.ShardInfo? other) -> bool -virtual Weaviate.Client.Models.ShardInfo.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.ShardingConfig.$() -> Weaviate.Client.Models.ShardingConfig! -virtual Weaviate.Client.Models.ShardingConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.ShardingConfig.Equals(Weaviate.Client.Models.ShardingConfig? other) -> bool -virtual Weaviate.Client.Models.ShardingConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.SinglePrompt.Equals(Weaviate.Client.Models.SinglePrompt? other) -> bool -virtual Weaviate.Client.Models.Sort.$() -> Weaviate.Client.Models.Sort! -virtual Weaviate.Client.Models.Sort.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Sort.Equals(Weaviate.Client.Models.Sort? other) -> bool -virtual Weaviate.Client.Models.Sort.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.StopwordConfig.$() -> Weaviate.Client.Models.StopwordConfig! -virtual Weaviate.Client.Models.StopwordConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.StopwordConfig.Equals(Weaviate.Client.Models.StopwordConfig? other) -> bool -virtual Weaviate.Client.Models.StopwordConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.StopwordsConfigUpdate.$() -> Weaviate.Client.Models.StopwordsConfigUpdate! -virtual Weaviate.Client.Models.StopwordsConfigUpdate.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.StopwordsConfigUpdate.Equals(Weaviate.Client.Models.StopwordsConfigUpdate? other) -> bool -virtual Weaviate.Client.Models.StopwordsConfigUpdate.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Tenant.$() -> Weaviate.Client.Models.Tenant! -virtual Weaviate.Client.Models.Tenant.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Tenant.Equals(Weaviate.Client.Models.Tenant? other) -> bool -virtual Weaviate.Client.Models.Tenant.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.TenantsResource.$() -> Weaviate.Client.Models.TenantsResource! -virtual Weaviate.Client.Models.TenantsResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.TenantsResource.Equals(Weaviate.Client.Models.TenantsResource? other) -> bool -virtual Weaviate.Client.Models.TenantsResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.TimeFilter.Equals(Weaviate.Client.Models.TimeFilter? other) -> bool -virtual Weaviate.Client.Models.Typed.WeaviateGroup.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Typed.WeaviateGroup.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Typed.WeaviateObject.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Typed.WeaviateObject.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.TypedBase.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.TypedBase.Equals(Weaviate.Client.Models.TypedBase? other) -> bool -virtual Weaviate.Client.Models.TypedBase.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.TypedGuid.Equals(Weaviate.Client.Models.TypedGuid? other) -> bool -virtual Weaviate.Client.Models.TypedValue.Equals(Weaviate.Client.Models.TypedValue? other) -> bool -virtual Weaviate.Client.Models.UserMetadata.$() -> Weaviate.Client.Models.UserMetadata! -virtual Weaviate.Client.Models.UserMetadata.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.UserMetadata.Equals(Weaviate.Client.Models.UserMetadata? other) -> bool -virtual Weaviate.Client.Models.UserMetadata.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.UserRoleAssignment.$() -> Weaviate.Client.Models.UserRoleAssignment! -virtual Weaviate.Client.Models.UserRoleAssignment.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.UserRoleAssignment.Equals(Weaviate.Client.Models.UserRoleAssignment? other) -> bool -virtual Weaviate.Client.Models.UserRoleAssignment.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.UsersResource.$() -> Weaviate.Client.Models.UsersResource! -virtual Weaviate.Client.Models.UsersResource.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.UsersResource.Equals(Weaviate.Client.Models.UsersResource? other) -> bool -virtual Weaviate.Client.Models.UsersResource.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.Vector.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.Vector.Equals(Weaviate.Client.Models.Vector? other) -> bool -virtual Weaviate.Client.Models.Vector.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.VectorConfig.$() -> Weaviate.Client.Models.VectorConfig! -virtual Weaviate.Client.Models.VectorConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.VectorConfig.Equals(Weaviate.Client.Models.VectorConfig? other) -> bool -virtual Weaviate.Client.Models.VectorConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.VectorConfigList.$() -> Weaviate.Client.Models.VectorConfigList! -virtual Weaviate.Client.Models.VectorConfigList.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.VectorConfigList.Equals(Weaviate.Client.Models.VectorConfigList? other) -> bool -virtual Weaviate.Client.Models.VectorConfigList.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.VectorIndex.Quantizers.BQ.Equals(Weaviate.Client.Models.VectorIndex.Quantizers.BQ? other) -> bool -virtual Weaviate.Client.Models.VectorIndex.Quantizers.None.Equals(Weaviate.Client.Models.VectorIndex.Quantizers.None? other) -> bool -virtual Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.$() -> Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig! -virtual Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.Equals(Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig? other) -> bool -virtual Weaviate.Client.Models.VectorIndex.Quantizers.PQ.EncoderConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.VectorIndex.Quantizers.PQ.Equals(Weaviate.Client.Models.VectorIndex.Quantizers.PQ? other) -> bool -virtual Weaviate.Client.Models.VectorIndex.Quantizers.RQ.Equals(Weaviate.Client.Models.VectorIndex.Quantizers.RQ? other) -> bool -virtual Weaviate.Client.Models.VectorIndex.Quantizers.SQ.Equals(Weaviate.Client.Models.VectorIndex.Quantizers.SQ? other) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.Equals(Weaviate.Client.Models.VectorIndexConfig.EncodingConfig? other) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.EncodingConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.VectorIndexConfig.Equals(Weaviate.Client.Models.VectorIndexConfig? other) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.$() -> Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig! -virtual Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.Equals(Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig? other) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.MultiVectorConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding.Equals(Weaviate.Client.Models.VectorIndexConfig.MuveraEncoding? other) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.Equals(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase? other) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigBase.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat.Equals(Weaviate.Client.Models.VectorIndexConfig.QuantizerConfigFlat? other) -> bool -virtual Weaviate.Client.Models.VectorizerConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.VectorizerConfig.Equals(Weaviate.Client.Models.VectorizerConfig? other) -> bool -virtual Weaviate.Client.Models.VectorizerConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.VectorizerConfig.ToDto() -> System.Collections.Generic.Dictionary! -virtual Weaviate.Client.Models.WeaviateGroup.Equals(Weaviate.Client.Models.WeaviateGroup? other) -> bool -virtual Weaviate.Client.Models.WeaviateGroup.$() -> Weaviate.Client.Models.WeaviateGroup! -virtual Weaviate.Client.Models.WeaviateGroup.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.WeaviateGroup.Equals(Weaviate.Client.Models.WeaviateGroup? other) -> bool -virtual Weaviate.Client.Models.WeaviateGroup.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.WeaviateObject.$() -> Weaviate.Client.Models.WeaviateObject! -virtual Weaviate.Client.Models.WeaviateObject.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.WeaviateObject.Equals(Weaviate.Client.Models.WeaviateObject? other) -> bool -virtual Weaviate.Client.Models.WeaviateObject.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.WeaviateResult.Equals(Weaviate.Client.Models.WeaviateResult? other) -> bool -virtual Weaviate.Client.Models.WeaviateResult.$() -> Weaviate.Client.Models.WeaviateResult! -virtual Weaviate.Client.Models.WeaviateResult.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.WeaviateResult.Equals(Weaviate.Client.Models.WeaviateResult? other) -> bool -virtual Weaviate.Client.Models.WeaviateResult.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.Models.WeightedField.$() -> Weaviate.Client.Models.WeightedField! -virtual Weaviate.Client.Models.WeightedField.EqualityContract.get -> System.Type! -virtual Weaviate.Client.Models.WeightedField.Equals(Weaviate.Client.Models.WeightedField? other) -> bool -virtual Weaviate.Client.Models.WeightedField.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.OAuthConfig.$() -> Weaviate.Client.OAuthConfig! -virtual Weaviate.Client.OAuthConfig.EqualityContract.get -> System.Type! -virtual Weaviate.Client.OAuthConfig.Equals(Weaviate.Client.OAuthConfig? other) -> bool -virtual Weaviate.Client.OAuthConfig.PrintMembers(System.Text.StringBuilder! builder) -> bool -virtual Weaviate.Client.RetryPolicy.$() -> Weaviate.Client.RetryPolicy! -virtual Weaviate.Client.RetryPolicy.EqualityContract.get -> System.Type! -virtual Weaviate.Client.RetryPolicy.Equals(Weaviate.Client.RetryPolicy? other) -> bool -virtual Weaviate.Client.RetryPolicy.PrintMembers(System.Text.StringBuilder! builder) -> bool -~Weaviate.Client.Models.Typed.GenerativeGroupByObject.GenerativeGroupByObject(Weaviate.Client.Models.Typed.GenerativeGroupByObject! original) -> void -~Weaviate.Client.Models.Typed.GenerativeGroupByResult.GenerativeGroupByResult(Weaviate.Client.Models.Typed.GenerativeGroupByResult! original) -> void -~Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.GenerativeWeaviateGroup(Weaviate.Client.Models.Typed.GenerativeWeaviateGroup! original) -> void -~Weaviate.Client.Models.Typed.GenerativeWeaviateObject.GenerativeWeaviateObject(Weaviate.Client.Models.Typed.GenerativeWeaviateObject! original) -> void -~Weaviate.Client.Models.Typed.GenerativeWeaviateResult.GenerativeWeaviateResult(Weaviate.Client.Models.Typed.GenerativeWeaviateResult! original) -> void -~Weaviate.Client.Models.Typed.GroupByObject.GroupByObject(Weaviate.Client.Models.Typed.GroupByObject! original) -> void -~Weaviate.Client.Models.Typed.GroupByResult.GroupByResult(Weaviate.Client.Models.Typed.GroupByResult! original) -> void -~Weaviate.Client.Models.Typed.WeaviateGroup.WeaviateGroup(Weaviate.Client.Models.Typed.WeaviateGroup! original) -> void -~Weaviate.Client.Models.Typed.WeaviateGroup.WeaviateGroup(Weaviate.Client.Models.Typed.WeaviateGroup! original) -> void -~Weaviate.Client.Models.Typed.WeaviateObject.WeaviateObject(Weaviate.Client.Models.Typed.WeaviateObject! original) -> void -~override Weaviate.Client.Models.Typed.GenerativeGroupByObject.$() -> Weaviate.Client.Models.Typed.GenerativeGroupByObject! -~override Weaviate.Client.Models.Typed.GenerativeGroupByResult.$() -> Weaviate.Client.Models.Typed.GenerativeGroupByResult! -~override Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.$() -> Weaviate.Client.Models.Typed.GenerativeWeaviateGroup! -~override Weaviate.Client.Models.Typed.GenerativeWeaviateObject.$() -> Weaviate.Client.Models.Typed.GenerativeWeaviateObject! -~override Weaviate.Client.Models.Typed.GenerativeWeaviateResult.$() -> Weaviate.Client.Models.Typed.GenerativeWeaviateResult! -~override Weaviate.Client.Models.Typed.GroupByObject.$() -> Weaviate.Client.Models.Typed.GroupByObject! -~override Weaviate.Client.Models.Typed.GroupByResult.$() -> Weaviate.Client.Models.Typed.GroupByResult! -~override Weaviate.Client.Models.Typed.WeaviateGroup.$() -> Weaviate.Client.Models.Typed.WeaviateGroup! -~static Weaviate.Client.Models.Typed.GenerativeGroupByObject.operator !=(Weaviate.Client.Models.Typed.GenerativeGroupByObject? left, Weaviate.Client.Models.Typed.GenerativeGroupByObject? right) -> bool -~static Weaviate.Client.Models.Typed.GenerativeGroupByObject.operator ==(Weaviate.Client.Models.Typed.GenerativeGroupByObject? left, Weaviate.Client.Models.Typed.GenerativeGroupByObject? right) -> bool -~static Weaviate.Client.Models.Typed.GenerativeGroupByResult.operator !=(Weaviate.Client.Models.Typed.GenerativeGroupByResult? left, Weaviate.Client.Models.Typed.GenerativeGroupByResult? right) -> bool -~static Weaviate.Client.Models.Typed.GenerativeGroupByResult.operator ==(Weaviate.Client.Models.Typed.GenerativeGroupByResult? left, Weaviate.Client.Models.Typed.GenerativeGroupByResult? right) -> bool -~static Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.operator !=(Weaviate.Client.Models.Typed.GenerativeWeaviateGroup? left, Weaviate.Client.Models.Typed.GenerativeWeaviateGroup? right) -> bool -~static Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.operator ==(Weaviate.Client.Models.Typed.GenerativeWeaviateGroup? left, Weaviate.Client.Models.Typed.GenerativeWeaviateGroup? right) -> bool -~static Weaviate.Client.Models.Typed.GenerativeWeaviateObject.operator !=(Weaviate.Client.Models.Typed.GenerativeWeaviateObject? left, Weaviate.Client.Models.Typed.GenerativeWeaviateObject? right) -> bool -~static Weaviate.Client.Models.Typed.GenerativeWeaviateObject.operator ==(Weaviate.Client.Models.Typed.GenerativeWeaviateObject? left, Weaviate.Client.Models.Typed.GenerativeWeaviateObject? right) -> bool -~static Weaviate.Client.Models.Typed.GenerativeWeaviateResult.operator !=(Weaviate.Client.Models.Typed.GenerativeWeaviateResult? left, Weaviate.Client.Models.Typed.GenerativeWeaviateResult? right) -> bool -~static Weaviate.Client.Models.Typed.GenerativeWeaviateResult.operator ==(Weaviate.Client.Models.Typed.GenerativeWeaviateResult? left, Weaviate.Client.Models.Typed.GenerativeWeaviateResult? right) -> bool -~static Weaviate.Client.Models.Typed.GroupByObject.operator !=(Weaviate.Client.Models.Typed.GroupByObject? left, Weaviate.Client.Models.Typed.GroupByObject? right) -> bool -~static Weaviate.Client.Models.Typed.GroupByObject.operator ==(Weaviate.Client.Models.Typed.GroupByObject? left, Weaviate.Client.Models.Typed.GroupByObject? right) -> bool -~static Weaviate.Client.Models.Typed.GroupByResult.operator !=(Weaviate.Client.Models.Typed.GroupByResult? left, Weaviate.Client.Models.Typed.GroupByResult? right) -> bool -~static Weaviate.Client.Models.Typed.GroupByResult.operator ==(Weaviate.Client.Models.Typed.GroupByResult? left, Weaviate.Client.Models.Typed.GroupByResult? right) -> bool -~static Weaviate.Client.Models.Typed.WeaviateGroup.operator !=(Weaviate.Client.Models.Typed.WeaviateGroup? left, Weaviate.Client.Models.Typed.WeaviateGroup? right) -> bool -~static Weaviate.Client.Models.Typed.WeaviateGroup.operator ==(Weaviate.Client.Models.Typed.WeaviateGroup? left, Weaviate.Client.Models.Typed.WeaviateGroup? right) -> bool -~static Weaviate.Client.Models.Typed.WeaviateGroup.operator !=(Weaviate.Client.Models.Typed.WeaviateGroup? left, Weaviate.Client.Models.Typed.WeaviateGroup? right) -> bool -~static Weaviate.Client.Models.Typed.WeaviateGroup.operator ==(Weaviate.Client.Models.Typed.WeaviateGroup? left, Weaviate.Client.Models.Typed.WeaviateGroup? right) -> bool -~static Weaviate.Client.Models.Typed.WeaviateObject.operator !=(Weaviate.Client.Models.Typed.WeaviateObject? left, Weaviate.Client.Models.Typed.WeaviateObject? right) -> bool -~static Weaviate.Client.Models.Typed.WeaviateObject.operator ==(Weaviate.Client.Models.Typed.WeaviateObject? left, Weaviate.Client.Models.Typed.WeaviateObject? right) -> bool -~virtual Weaviate.Client.Models.Typed.GenerativeGroupByObject.Equals(Weaviate.Client.Models.Typed.GenerativeGroupByObject? other) -> bool -~virtual Weaviate.Client.Models.Typed.GenerativeGroupByResult.Equals(Weaviate.Client.Models.Typed.GenerativeGroupByResult? other) -> bool -~virtual Weaviate.Client.Models.Typed.GenerativeWeaviateGroup.Equals(Weaviate.Client.Models.Typed.GenerativeWeaviateGroup? other) -> bool -~virtual Weaviate.Client.Models.Typed.GenerativeWeaviateObject.Equals(Weaviate.Client.Models.Typed.GenerativeWeaviateObject? other) -> bool -~virtual Weaviate.Client.Models.Typed.GenerativeWeaviateResult.Equals(Weaviate.Client.Models.Typed.GenerativeWeaviateResult? other) -> bool -~virtual Weaviate.Client.Models.Typed.GroupByObject.Equals(Weaviate.Client.Models.Typed.GroupByObject? other) -> bool -~virtual Weaviate.Client.Models.Typed.GroupByResult.Equals(Weaviate.Client.Models.Typed.GroupByResult? other) -> bool -~virtual Weaviate.Client.Models.Typed.WeaviateGroup.$() -> Weaviate.Client.Models.Typed.WeaviateGroup! -~virtual Weaviate.Client.Models.Typed.WeaviateGroup.Equals(Weaviate.Client.Models.Typed.WeaviateGroup? other) -> bool -~virtual Weaviate.Client.Models.Typed.WeaviateGroup.Equals(Weaviate.Client.Models.Typed.WeaviateGroup? other) -> bool -~virtual Weaviate.Client.Models.Typed.WeaviateObject.$() -> Weaviate.Client.Models.Typed.WeaviateObject! -~virtual Weaviate.Client.Models.Typed.WeaviateObject.Equals(Weaviate.Client.Models.Typed.WeaviateObject? other) -> bool diff --git a/src/Weaviate.Client/Typed/TypedCollectionClient.cs b/src/Weaviate.Client/Typed/TypedCollectionClient.cs index fd92c211..bfe1c00d 100644 --- a/src/Weaviate.Client/Typed/TypedCollectionClient.cs +++ b/src/Weaviate.Client/Typed/TypedCollectionClient.cs @@ -70,7 +70,8 @@ public TypedCollectionClient(CollectionClient collectionClient) public TypedGenerateClient Generate => _generateClient; /// - /// Aggregate operations. Returns untyped AggregateClient since aggregates return metrics, not objects. + /// Aggregate operations for computing statistics over the collection. + /// Use the ToTyped<T>() extension method on results to map to strongly-typed objects. /// public AggregateClient Aggregate => _collectionClient.Aggregate;