.code-samples.meilisearch.yaml

# This code-samples file is used by the Meilisearch documentation
# Every example written here will be automatically fetched by
# the documentation on build
# You can read more on https://github.com/meilisearch/documentation/tree/master/.vuepress/code-samples
---
get_one_index_1: |-
  let movies: Index = client.get_index("movies").await.unwrap();
list_all_indexes_1: |-
  let indexes: Vec<Index> = client.list_all_indexes().await.unwrap();
create_an_index_1: |-
  client.create_index("movies", Some("id")).await.unwrap();
update_an_index_1: |-
  client.index("movies").update("movie_review_id").await.unwrap();
delete_an_index_1: |-
  client.index("movies").delete().await.unwrap();
get_one_document_1: |-
  let movie: Movie = client.index("movies").get_document(String::from("25684")).await.unwrap();
get_documents_1: |-
  let documents: Vec<Movie> = client.index("movies").get_documents(None, Some(2), None).await.unwrap();
add_or_replace_documents_1: |-
  let task: TaskInfo = client.index("movies").add_or_replace(&[
    Movie {
      id: 287947,
      title: "Shazam".to_string(),
      poster: "https://image.tmdb.org/t/p/w1280/xnopI5Xtky18MPhK40cZAGAOVeV.jpg".to_string(),
      overview: "A boy is given the ability to become an adult superhero in times of need with a single magic word.".to_string(),
      release_date: "2019-03-23".to_string(),
    }
  ], None).await.unwrap();
add_or_update_documents_1: |-
  // Define the type of our documents
  #[derive(Serialize, Deserialize)]
  struct IncompleteMovie {
    id: usize,
    title: String
  }

  let task: TaskInfo = client.index("movies").add_or_update(&[
    IncompleteMovie {
      id: 287947,
      title: "Shazam ⚡️".to_string()
    }
  ], None).await.unwrap();
delete_all_documents_1: |-
  let task: TaskInfo = client.index("movies").delete_all_documents().await.unwrap();
delete_one_document_1: |-
  let task: TaskInfo = client.index("movies").delete_document(25684).await.unwrap();
delete_documents_1: |-
  let task: TaskInfo = client.index("movies").delete_documents(&[23488, 153738, 437035, 363869]).await.unwrap();
search_post_1: |-
  let results: SearchResults<Movie> = client.index("movies")
    .search()
    .with_query("American ninja")
    .execute()
    .await
    .unwrap();
get_task_by_index_1: |-
  let task: Task = client.index("movies").get_task(1).await.unwrap();
get_all_tasks_by_index_1: |-
  let tasks: TasksResults = client.index("movies").get_tasks().await.unwrap();
get_all_tasks_1: |-
  let tasks: TasksResults = client.get_tasks().await.unwrap();
get_task_1: |-
  let task: Task = client.get_task(1).await.unwrap();
get_settings_1: |-
  let settings: Settings = client.index("movies").get_settings().await.unwrap();
update_settings_1: |-
  let mut synonyms = std::collections::HashMap::new();
  synonyms.insert(String::from("wolverine"), vec!["xmen", "logan"]);
  synonyms.insert(String::from("logan"), vec!["wolverine"]);

  let settings = Settings::new()
    .with_ranking_rules([
      "words",
      "typo",
      "proximity",
      "attribute",
      "sort",
      "exactness",
      "release_date:desc",
      "rank:desc"
    ])
    .with_distinct_attribute("movie_id")
    .with_searchable_attributes([
      "title",
      "overview",
      "genres"
    ])
    .with_displayed_attributes([
      "title",
      "overview",
      "genres",
      "release_date"
    ])
    .with_stop_words([
      "the",
      "a",
      "an"
    ])
    .with_sortable_attributes([
      "title",
      "release_date"
    ])
    .with_synonyms(synonyms);

  let task: TaskInfo = client.index("movies").set_settings(&settings).await.unwrap();
reset_settings_1: |-
  let task: TaskInfo = client.index("movies").reset_settings().await.unwrap();
get_synonyms_1: |-
  let synonyms: HashMap<String, Vec<String>> = client.index("movies").get_synonyms().await.unwrap();
update_synonyms_1: |-
  let mut synonyms = std::collections::HashMap::new();
  synonyms.insert(String::from("wolverine"), vec![String::from("xmen"), String::from("logan")]);
  synonyms.insert(String::from("logan"), vec![String::from("xmen"), String::from("wolverine")]);
  synonyms.insert(String::from("wow"), vec![String::from("world of warcraft")]);

  let task: TaskInfo = client.index("movies").set_synonyms(&synonyms).await.unwrap();
reset_synonyms_1: |-
  let task: TaskInfo = client.index("movies").reset_synonyms().await.unwrap();
get_stop_words_1: |-
  let stop_words: Vec<String> = client.index("movies").get_stop_words().await.unwrap();
update_stop_words_1: |-
  let stop_words = ["of", "the", "to"];
  let task: TaskInfo = client.index("movies").set_stop_words(&stop_words).await.unwrap();
reset_stop_words_1: |-
  let task: TaskInfo = client.index("movies").reset_stop_words().await.unwrap();
get_ranking_rules_1: |-
  let ranking_rules: Vec<String> = client.index("movies").get_ranking_rules().await.unwrap();
update_ranking_rules_1: |-
  let ranking_rules = [
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness",
    "release_date:asc",
    "rank:desc",
  ];

  let task: TaskInfo = client.index("movies").set_ranking_rules(&ranking_rules).await.unwrap();
reset_ranking_rules_1: |-
  let task: TaskInfo = client.index("movies").reset_ranking_rules().await.unwrap();
get_distinct_attribute_1: |-
  let distinct_attribute: Option<String> = client.index("shoes").get_distinct_attribute().await.unwrap();
update_distinct_attribute_1: |-
  let task: TaskInfo = client.index("shoes").set_distinct_attribute("skuid").await.unwrap();
reset_distinct_attribute_1: |-
  let task: TaskInfo = client.index("shoes").reset_distinct_attribute().await.unwrap();
get_searchable_attributes_1: |-
  let searchable_attributes: Vec<String> = client.index("movies").get_searchable_attributes().await.unwrap();
update_searchable_attributes_1: |-
  let searchable_attributes = [
    "title",
    "overview",
    "genres"
  ];

  let task: TaskInfo = client.index("movies").set_searchable_attributes(&searchable_attributes).await.unwrap();
reset_searchable_attributes_1: |-
  let task: TaskInfo = client.index("movies").reset_searchable_attributes().await.unwrap();
get_filterable_attributes_1: |-
  let filterable_attributes: Vec<String> = client.index("movies").get_filterable_attributes().await.unwrap();
update_filterable_attributes_1: |-
  let filterable_attributes = [
    "genres",
    "director"
  ];

  let task: TaskInfo = client.index("movies").set_filterable_attributes(&filterable_attributes).await.unwrap();
reset_filterable_attributes_1: |-
  let task: TaskInfo = client.index("movies").reset_filterable_attributes().await.unwrap();
get_displayed_attributes_1: |-
  let displayed_attributes: Vec<String> = client.index("movies").get_displayed_attributes().await.unwrap();
update_displayed_attributes_1: |-
  let displayed_attributes = [
    "title",
    "overview",
    "genres",
    "release_date"
  ];

  let task: TaskInfo = client.index("movies").set_displayed_attributes(&displayed_attributes).await.unwrap();
reset_displayed_attributes_1: |-
  let task: TaskInfo = client.index("movies").reset_displayed_attributes().await.unwrap();
get_index_stats_1: |-
  let stats: IndexStats = client.index("movies").get_stats().await.unwrap();
get_indexes_stats_1: |-
  let stats: ClientStats = client.get_stats().await.unwrap();
get_health_1: |-
  // health() return an Err() if the server is not healthy, so this example would panic due to the unwrap
  client.health().await.unwrap();
get_version_1: |-
  let version: Version = client.get_version().await.unwrap();
distinct_attribute_guide_1: |-
  let task: TaskInfo = client.index("jackets").set_distinct_attribute("product_id").await.unwrap();
field_properties_guide_searchable_1: |-
  let searchable_attributes = [
    "title",
    "overvieww",
    "genres"
  ];

  let task: TaskInfo = client.index("movies").set_searchable_attributes(&searchable_attributes).await.unwrap();
field_properties_guide_displayed_1: |-
  let displayed_attributes = [
    "title",
    "overvieww",
    "genres",
    "release_date"
  ];

  let task: TaskInfo = client.index("movies").set_displayed_attributes(&displayed_attributes).await.unwrap();
filtering_guide_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("Avengers")
    .with_filter("release_date > 795484800")
    .execute()
    .await
    .unwrap();
filtering_guide_2: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("Batman")
    .with_filter(r#"release_date > 795484800 AND (director = "Tim Burton" OR director = "Christopher Nolan")"#)
    .execute()
    .await
    .unwrap();
filtering_guide_3: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("Planet of the Apes")
    .with_filter(r#"rating >= 3 AND (NOT director = "Tim Burton")"#)
    .execute()
    .await
    .unwrap();
search_parameter_guide_query_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("shifu")
    .execute()
    .await
    .unwrap();
search_parameter_guide_offset_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("shifu")
    .with_offset(1)
    .execute()
    .await
    .unwrap();
search_parameter_guide_limit_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("shifu")
    .with_limit(2)
    .execute()
    .await
    .unwrap();
search_parameter_guide_retrieve_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("shifu")
    .with_attributes_to_retrieve(Selectors::Some(&["overview", "title"]))
    .execute()
    .await
    .unwrap();
search_parameter_guide_crop_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("shifu")
    .with_attributes_to_crop(Selectors::Some(&[("overview", None)]))
    .with_crop_length(5)
    .execute()
    .await
    .unwrap();

  // Get the formatted results
  let formatted_results: Vec<&Movie> = results.hits.iter().map(|r| r.formatted_result.as_ref().unwrap()).collect();
search_parameter_guide_crop_marker_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("shifu")
    .with_attributes_to_crop(Selectors::Some(&[("overview", None)]))
    .with_crop_marker("[…]")
    .execute()
    .await
    .unwrap();

  // Get the formatted results
  let formatted_results: Vec<&Movie> = results.hits.iter().map(|r| r.formatted_result.as_ref().unwrap()).collect();
search_parameter_guide_highlight_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("winter feast")
    .with_attributes_to_highlight(Selectors::Some(&["overview"]))
    .execute()
    .await
    .unwrap();

  // Get the formatted results
  let formatted_results: Vec<&Movie> = results.hits.iter().map(|r| r.formatted_result.as_ref().unwrap()).collect();
search_parameter_guide_highlight_tag_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("winter feast")
    .with_attributes_to_highlight(Selectors::Some(&["overview"]))
    .with_highlight_pre_tag("<span class=\"highlight\">")
    .with_highlight_post_tag("</span>")
    .execute()
    .await
    .unwrap();

  // Get the formatted results
  let formatted_results: Vec<&Movie> = results.hits.iter().map(|r| r.formatted_result.as_ref().unwrap()).collect();
search_parameter_guide_matches_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("winter feast")
    .with_matches(true)
    .execute()
    .await
    .unwrap();

  // Get the matches info
  let matched_info: Vec<&HashMap<String, Vec<MatchRange>>> = results.hits.iter().map(|r| r.matches_info.as_ref().unwrap()).collect();
settings_guide_synonyms_1: |-
  let mut synonyms = HashMap::new();
  synonyms.insert(String::from("sweater"), vec![String::from("jumper")]);
  synonyms.insert(String::from("jumper"), vec![String::from("sweater")]);

  let settings = Settings::new()
    .with_synonyms(synonyms);

  let task = client.index("tops").set_settings(&settings).await.unwrap();
settings_guide_stop_words_1: |-
  let settings = Settings::new()
    .with_stop_words([
      "the",
      "a",
      "an"
    ]);

  let task = client.index("movies").set_settings(&settings).await.unwrap();
settings_guide_filterable_attributes_1: |-
  let settings = Settings::new()
    .with_filterable_attributes([
      "director",
      "genres"
    ]);

  let task: TaskInfo = client.index("movies").set_settings(&settings).await.unwrap();
settings_guide_ranking_rules_1: |-
  let settings = Settings::new()
    .with_ranking_rules([
      "words",
      "typo",
      "proximity",
      "attribute",
      "sort",
      "exactness",
      "release_date:asc",
      "rank:desc",
    ]);

  let task = client.index("movies").set_settings(&settings).await.unwrap();
settings_guide_distinct_1: |-
  let settings = Settings::new()
    .with_distinct_attribute("product_id");

  let task: TaskInfo = client.index("jackets").set_settings(&settings).await.unwrap();
settings_guide_searchable_1: |-
  let settings = Settings::new()
    .with_searchable_attributes([
      "title",
      "overview",
      "genres"
    ]);

  let task: TaskInfo = client.index("movies").set_settings(&settings).await.unwrap();
settings_guide_displayed_1: |-
  let settings = Settings::new()
    .with_displayed_attributes([
      "title",
      "overview",
      "genres",
      "release_date"
    ]);

  let task: TaskInfo = client.index("movies").set_settings(&settings).await.unwrap();
settings_guide_sortable_1: |-
  let settings = Settings::new()
    .with_sortable_attributes([
      "author",
      "price"
    ]);

  let task: TaskInfo = client.index("books").set_settings(&settings).await.unwrap();
add_movies_json_1: |-
  use meilisearch_sdk::{
    indexes::*,
    client::*,
    search::*,
    settings::*
  };
  use serde::{Serialize, Deserialize};
  use std::{io::prelude::*, fs::File};
  use futures::executor::block_on;

  fn main() { block_on(async move {
    let client = Client::new("http://localhost:7700", "masterKey");

    // reading and parsing the file
    let mut file = File::open("movies.json").unwrap();
    let mut content = String::new();
    file.read_to_string(&mut content).unwrap();
    let movies_docs: Vec<Movie> = serde_json::from_str(&content).unwrap();

    // adding documents
    client.index("movies").add_documents(&movies_docs, None).await.unwrap();
  })}
documents_guide_add_movie_1: |-
  // Define the type of our documents
  #[derive(Serialize, Deserialize)]
  struct IncompleteMovie {
    id: String,
    title: String
  }

  // Add a document to our index
  let task: TaskInfo = client.index("movies").add_documents(&[
    IncompleteMovie {
      id: "123sq178".to_string(),
      title: "Amélie Poulain".to_string(),
    }
  ], None).await.unwrap();
primary_field_guide_update_document_primary_key: |-
  client.index("books").update("title").await.unwrap();
primary_field_guide_create_index_primary_key: |-
  client.create_index("books", Some("reference_number")).await.unwrap();
primary_field_guide_add_document_primary_key: |-
  #[derive(Serialize, Deserialize)]
  struct Book {
    reference_number: String,
    title: String,
    author: String,
    genres: Vec<String>,
    price: f64
  }

  let task: TaskInfo = client.index("books").add_documents(&[
    Book {
      reference_number: "287947".to_string(),
      title: "Diary of a Wimpy Kid".to_string(),
      author: "Jeff Kinney".to_string(),
      genres: vec!["comedy".to_string(),"humor".to_string()],
      price: 5.00
    }
  ], Some("reference_number")).await.unwrap();
getting_started_add_documents_md: |-
  ```toml
    [dependencies]
    meilisearch-sdk = "0.17"
    # futures: because we want to block on futures
    futures = "0.3"
    # serde: required if you are going to use documents
    serde = { version="1.0",   features = ["derive"] }
    # serde_json: required in some parts of this guide
    serde_json = "1.0"
  ```

  Documents in the Rust library are strongly typed.

  ```rust
  #[derive(Serialize, Deserialize)]
  struct Movie {
    id: String,
    title: String,
    poster: String,
    overview: String,
    release_date: i64,
    genres: Vec<String>
  }
  ```

  You will often need this `Movie` struct in other parts of this documentation. (you will have to change it a bit sometimes)
  You can also use schemaless values, by putting a `serde_json::Value` inside your own struct like this:

  ```rust
  #[derive(Serialize, Deserialize)]
  struct Movie {
    id: String,
    #[serde(flatten)]
    value: serde_json::Value,
  }
  ```

  Then, add documents into the index:

  ```rust
  use meilisearch_sdk::{
    indexes::*,
    client::*,
    search::*,
    settings::*
  };
  use serde::{Serialize, Deserialize};
  use std::{io::prelude::*, fs::File};
  use futures::executor::block_on;

  fn main() { block_on(async move {
    let client = Client::new("http://localhost:7700", "masterKey");

    // reading and parsing the file
    let mut file = File::open("movies.json").unwrap();
    let mut content = String::new();
    file.read_to_string(&mut content).unwrap();
    let movies_docs: Vec<Movie> = serde_json::from_str(&content).unwrap();

    // adding documents
    client.index("movies").add_documents(&movies_docs, None).await.unwrap();
  })}
  ```

  [About this SDK](https://github.com/meilisearch/meilisearch-rust/)
getting_started_search_md: |-
  You can build a `Query` and execute it later:
  ```rust
  let query: Query = Query::new(&movies)
    .with_query("botman")
    .build();

  let results: SearchResults<Movie> = client.index("movies").execute_query(&query).await.unwrap();
  ```

  You can build a `Query` and execute it directly:
  ```rust
  let results: SearchResults<Movie> = Query::new(&movies)
    .with_query("botman")
    .execute()
    .await
    .unwrap();
  ```

  You can search in an index directly:
  ```rust
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("botman")
    .execute()
    .await
    .unwrap();
  ```

  [About this SDK](https://github.com/meilisearch/meilisearch-rust/)
getting_started_update_ranking_rules: |-
  let ranking_rules = [
    "exactness",
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "release_date:asc",
    "rank:desc"
  ];

  client.index("movies").set_ranking_rules(&ranking_rules).await.unwrap();
getting_started_update_searchable_attributes: |-
  let searchable_attributes = [
    "title"
  ];

  client.index("movies").set_searchable_attributes(&searchable_attributes).await.unwrap();
getting_started_update_stop_words: |-
  let stop_words = ["the"];
  client.index("movies").set_stop_words(&stop_words).await.unwrap();
getting_started_check_task_status: |-
  client.index("movies").get_task(0).await.unwrap();
getting_started_synonyms: |-
  let mut synonyms = std::collections::HashMap::new();
  synonyms.insert(String::from("winnie"), vec![String::from("piglet")]);
  synonyms.insert(String::from("piglet"), vec![String::from("winnie")]);

  client.index("movies").set_synonyms(&synonyms).await.unwrap();
getting_started_update_displayed_attributes: |-
  let displayed_attributes = [
    "title",
    "overview",
    "poster",
  ];

  client.index("movies").set_displayed_attributes(&displayed_attributes).await.unwrap();
getting_started_communicating_with_a_protected_instance: |-
  let client = Client::new("http://localhost:7700", "apiKey");
  client.index("movies").search()
getting_started_add_meteorites: |-
  use serde::{Serialize, Deserialize};
  use std::fs::File;

  #[derive(Serialize, Deserialize)]
  struct Geo {
    lat: f64,
    lon: f64
  }

  struct Meteorite {
    name: String,
    id: String,
    nametype: String,
    recclass: String,
    mass: i64,
    fall: String,
    _geo: Geo
  }

  let mut file = File::open("meteorites.json")?;
  let meteorites: Vec<Meteorite> = serde_json::from_reader(file)?;

  client.index("meteorites").add_documents(&meteorites, None).await?;
getting_started_configure_settings: |-
  let settings = Settings::new()
    .with_filterable_attributes([
      "mass",
      "_geo"
    ])
    .with_sortable_attributes([
      "mass",
      "_geo"
    ])
  let task: TaskInfo = client.index("meteorites").set_settings(&settings).await.unwrap();
getting_started_geo_radius: |-
  let results: SearchResults<Meteorite> = client.index("meteorites").search()
    .with_filter("_geoRadius(46.9480, 7.4474, 210000)")
    .execute()
    .await
    .unwrap();
getting_started_geo_point: |-
  let results: SearchResults<Meteorite> = client.index("meteorites").search()
    .with_sort(&["_geoPoint(48.8583701, 2.2922926):asc"])
    .execute()
    .await
    .unwrap();
getting_started_sorting: |-
  let results: SearchResults<Meteorite> = client.index("meteorites").search()
    .with_filter("mass < 200")
    .with_sort(&["mass:asc"])
    .execute()
    .await
    .unwrap();
getting_started_filtering: |-
  let results: SearchResults<Meteorite> = client.index("meteorites").search()
    .with_filter("mass < 200")
    .execute()
    .await
    .unwrap();
faceted_search_update_settings_1: |-
  let task: TaskInfo = client.index("movies").set_filterable_attributes(["director", "genres"]).await.unwrap();
faceted_search_filter_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("thriller")
    .with_filter("(genres = Horror AND genres = Mystery) OR director = \"Jordan Peele\"")
    .execute()
    .await
    .unwrap();
faceted_search_facets_distribution_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("Batman")
    .with_facets_distribution(Selectors::Some(&["genres"]))
    .execute()
    .await
    .unwrap();
  let genres: &HashMap<String, usize> = results.facets_distribution.unwrap().get("genres").unwrap();
faceted_search_walkthrough_filter_1: |-
  let results: SearchResults<Movie> = client.index("movies").search()
    .with_query("thriller")
    .with_filter("(genres = Horror AND genres = Mystery) OR director = \"Jordan Peele\"")
    .execute()
    .await
    .unwrap();
post_dump_1: |-
  client.create_dump().await.unwrap();
get_dump_status_1: |-
  client.get_dump_status("20201101-110357260").await.unwrap();
phrase_search_1: |-
  let results: SearchResults<Movie> = client.index("movies")
    .search()
    .with_query("\"african american\" horror")
    .execute()
    .await
    .unwrap();
sorting_guide_update_sortable_attributes_1: |-
  let sortable_attributes = [
    "author",
    "price"
  ];

  let task: TaskInfo = client.index("books").set_sortable_attributes(&sortable_attributes).await.unwrap();
sorting_guide_update_ranking_rules_1: |-
  let ranking_rules = [
    "words",
    "sort",
    "typo",
    "proximity",
    "attribute",
    "exactness"
  ];

  let task: TaskInfo = client.index("books").set_ranking_rules(&ranking_rules).await.unwrap();
sorting_guide_sort_parameter_1: |-
  let results: SearchResults<Books> = client.index("books").search()
    .with_query("science fiction")
    .with_sort(&["price:asc"])
    .execute()
    .await
    .unwrap();
sorting_guide_sort_parameter_2: |-
  let results: SearchResults<Books> = client.index("books").search()
    .with_query("butler")
    .with_sort(&["author:desc"])
    .execute()
    .await
    .unwrap();
get_sortable_attributes_1: |-
  let sortable_attributes: Vec<String> = client.index("books").get_sortable_attributes().await.unwrap();
update_sortable_attributes_1: |-
  let sortable_attributes = [
    "price",
    "author"
  ];

  let task: TaskInfo = client.index("books").set_sortable_attributes(&sortable_attributes).await.unwrap();
reset_sortable_attributes_1: |-
  let task: TaskInfo = client.index("books").reset_sortable_attributes().await.unwrap();
search_parameter_guide_sort_1: |-
  let results: SearchResults<Books> = client.index("books").search()
    .with_query("science fiction")
    .with_sort(&["price:asc"])
    .execute()
    .await
    .unwrap();
geosearch_guide_filter_settings_1: |-
  let task: TaskInfo = client.index("restaurants").set_filterable_attributes(&["_geo"]).await.unwrap();
geosearch_guide_filter_usage_1: |-
  let results: SearchResults<Restaurant> = client.index("restaurants").search()
    .with_filter("_geoRadius(45.472735, 9.184019, 2000)")
    .execute()
    .await
    .unwrap();
geosearch_guide_filter_usage_2: |-
  let results: SearchResults<Restaurant> = client.index("restaurants").search()
    .with_filter("_geoRadius(45.472735, 9.184019, 2000) AND type = pizza")
    .execute()
    .await
    .unwrap();
geosearch_guide_sort_settings_1: |-
  let task: TaskInfo = client.index("restaurants").set_sortable_attributes(&["_geo"]).await.unwrap();
geosearch_guide_sort_usage_1: |-
  let results: SearchResults<Restaurant> = client.index("restaurants").search()
    .with_sort(&["_geoPoint(48.8561446, 2.2978204):asc"])
    .execute()
    .await
    .unwrap();
geosearch_guide_sort_usage_2: |-
  let results: SearchResults<Restaurant> = client.index("restaurants").search()
    .with_sort(&["_geoPoint(48.8561446, 2.2978204):asc", "rating:desc"])
    .execute()
    .await
    .unwrap();
get_one_key_1: |-
  let key = client.get_key("d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4").await.unwrap();
get_all_keys_1: |-
  let keys = client.get_keys().await.unwrap();
create_a_key_1: |-
  let mut key_options = KeyBuilder::new("Add documents: Products API key");
  key_options.with_action(Action::DocumentsAdd)
      .with_expires_at(time::macros::datetime!(2042 - 04 - 02 00:42:42 UTC))
      .with_index("products");
  let new_key = client.create_key(key_options).await.unwrap();
update_a_key_1: |-
  let mut key = client.get_key("d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4").await.unwrap();
  key
      .with_description("Manage documents: Products/Reviews API key".to_string())
      .with_actions(vec![Action::DocumentsAdd, Action::DocumentsDelete])
      .with_indexes(vec!["products".to_string(), "reviews".to_string()])
      .with_expires_at(time::macros::datetime!(2042 - 04 - 02 00:42:42 UTC))
      .update(&client);
delete_a_key_1: |-
  let key = client.get_key("d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4").await.unwrap();
  client.delete_key(&key);
authorization_header_1:
  let client = Client::new("http://localhost:7700", "masterKey");
  let keys = client.get_keys().await.unwrap();
security_guide_search_key_1: |-
  let client = Client::new("http://localhost:7700", "apiKey");
  let result = client.index("patient_medical_records").search().execute().await.unwrap();
security_guide_update_key_1: |-
  let client = Client::new("http://localhost:7700", "masterKey");
  let mut key = client.get_key("d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4").await.unwrap();
  key.with_indexes(vec!["doctors".to_string()]).update(&client);
security_guide_create_key_1: |-
  let client = Client::new("http://localhost:7700", "masterKey");
  let mut key_options = KeyBuilder::new("Search patient records key");
  key_options.with_action(Action::Search)
      .with_expires_at(time::macros::datetime!(2023 - 01 - 01 00:00:00 UTC))
      .with_index("patient_medical_records");
  let new_key = client.create_key(key_options).await.unwrap();
security_guide_list_keys_1: |-
  let client = Client::new("http://localhost:7700", "masterKey");
  let keys = client.get_keys().await.unwrap();
security_guide_delete_key_1: |-
  let client = Client::new("http://localhost:7700", "masterKey");
  let key = client.get_key("d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4").await.unwrap();
  client.delete_key(&key);
landing_getting_started_1: |-
  let client = Client::new("http://localhost:7700", "masterKey");

  #[derive(Serialize, Deserialize)]
  struct Movie {
    id: String,
    title: String
  }

  client.index("movies").add_documents(&[
    Movie { id: "1".to_string(), title: "Carol".to_string() },
    Movie { id: "2".to_string(), title: "Wonder Woman".to_string() },
    Movie { id: "3".to_string(), title: "Life of Pi".to_string() },
    Movie { id: "4".to_string(), title: "Mad Max: Fury Road".to_string() },
    Movie { id: "5".to_string(), title: "Moana".to_string() },
    Movie { id: "6".to_string(), title: "Philadelphia".to_string() }
  ], Some("reference_number")).await.unwrap();
tenant_token_guide_generate_sdk_1: |-
  let api_key = "B5KdX2MY2jV6EXfUs6scSfmC...";
  let expires_at = time::macros::datetime!(2025 - 12 - 20 00:00:00 UTC);
  let search_rules = json!({ "patient_medical_records": { "filter": "user_id = 1" } });

  let token = client.generate_tenant_token(search_rules, api_key, expires_at).unwrap();
tenant_token_guide_search_sdk_1: |-
  let front_end_client = Client::new("http://127.0.0.1:7700", token);
  let results: SearchResults<Patient> = front_end_client.index("patient_medical_records")
    .search()
    .with_query("blood test")
    .execute()
    .await
    .unwrap();