# `Qdrant.Types`
[🔗](https://github.com/marinac-dev/qdrant/blob/v0.1.18/lib/qdrant/types.ex#L1)

Canonical shared types for Qdrant request and response values.

Large request schemas evolve with Qdrant and are intentionally represented by
`map()` in endpoint APIs rather than by incomplete closed maps.

# `batch_request`

```elixir
@type batch_request() :: %{searches: [request_body()]}
```

# `consistency`

```elixir
@type consistency() :: non_neg_integer() | :majority | :quorum | :all
```

# `dense_vector`

```elixir
@type dense_vector() :: [number()]
```

# `extended_point_id`

```elixir
@type extended_point_id() :: non_neg_integer() | String.t()
```

# `health_body`

```elixir
@type health_body() :: json_value()
```

# `hnsw_config`

```elixir
@type hnsw_config() :: %{
  optional(:m) => non_neg_integer(),
  optional(:ef_construct) => non_neg_integer(),
  optional(:full_scan_threshold) => non_neg_integer(),
  optional(:max_indexing_threads) => non_neg_integer(),
  optional(:on_disk) => boolean(),
  optional(:payload_m) => non_neg_integer()
}
```

# `json_value`

```elixir
@type json_value() :: String.t() | map() | list() | boolean() | number() | nil
```

# `match`

```elixir
@type match() :: %{
  optional(:value) => match_value(),
  optional(:text) => String.t(),
  optional(:any) => [match_value()],
  optional(:except) => [match_value()]
}
```

# `match_any`

```elixir
@type match_any() :: %{any: [match_value()]}
```

# `match_except`

```elixir
@type match_except() :: %{except: [match_value()]}
```

# `match_value`

```elixir
@type match_value() :: String.t() | number() | boolean()
```

# `multivector`

```elixir
@type multivector() :: [dense_vector()]
```

# `named_vector`

```elixir
@type named_vector() :: %{name: String.t(), vector: unnamed_vector()}
```

# `optimizers_config`

```elixir
@type optimizers_config() :: %{
  optional(:deleted_threshold) => number(),
  optional(:vacuum_min_vector_number) => non_neg_integer(),
  optional(:default_segment_number) => non_neg_integer(),
  optional(:max_segment_size) => non_neg_integer(),
  optional(:memmap_threshold) => non_neg_integer(),
  optional(:indexing_threshold) => non_neg_integer(),
  optional(:flush_interval_sec) => non_neg_integer(),
  optional(:max_optimization_threads) => pos_integer()
}
```

# `ordering`

```elixir
@type ordering() :: :weak | :medium | :strong
```

# `payload_selector`

```elixir
@type payload_selector() :: %{include: [String.t()]} | %{exclude: [String.t()]}
```

# `point`

```elixir
@type point() :: %{
  :id => extended_point_id(),
  optional(:vector) => vector(),
  optional(:payload) => map()
}
```

# `point_id_list`

```elixir
@type point_id_list() :: point_ids()
```

# `point_ids`

```elixir
@type point_ids() :: [extended_point_id()]
```

# `quantization_config`

```elixir
@type quantization_config() :: map()
```

# `request_body`

```elixir
@type request_body() :: map()
```

# `request_option`

```elixir
@type request_option() ::
  {:query, keyword() | map()}
  | {:body, term()}
  | {:response, :auto | :json | :text | :binary}
```

# `request_options`

```elixir
@type request_options() :: keyword()
```

# `result`

```elixir
@type result() :: result(term())
```

# `result`

```elixir
@type result(response) :: {:ok, response} | {:error, Qdrant.Error.t()}
```

# `score_threshold`

```elixir
@type score_threshold() :: number()
```

# `sparse_vector`

```elixir
@type sparse_vector() :: %{indices: [non_neg_integer()], values: [number()]}
```

# `unnamed_vector`

```elixir
@type unnamed_vector() :: dense_vector() | sparse_vector() | multivector()
```

# `vector`

```elixir
@type vector() :: unnamed_vector() | named_vector()
```

# `with_payload_interface`

```elixir
@type with_payload_interface() :: boolean() | [String.t()] | payload_selector()
```

---

*Consult [api-reference.md](api-reference.md) for complete listing*