.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
---
filtering_guide_nested_1: |-
  let searchParameters = SearchParameters(
      query: "thriller",
      filter: "rating.users >= 90"
  )
  client.index("movie_ratings").search(searchParameters) { (result: Result<Searchable<Meteorite>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
sorting_guide_sort_nested_1: |-
  let searchParameters = SearchParameters(
      query: "science fiction",
      sort: ["rating.users:asc"]
  )
  client.index("books").search(searchParameters) { (result: Result<Searchable<Meteorite>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
getting_started_faceting: |-
  client.index("movies").updateFaceting({ maxValuesPerFacet: 2 })
getting_started_pagination: |-
  client.index("movies").updatePagination({ maxTotalHits: 500 })
synonyms_guide_1: |-
  let synonyms: [String: [String]] = [
    "great": ["fantastic"],
    "fantastic": ["great"]
  ]

  client.index("movies").updateSynonyms(synonyms) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
  }
date_guide_index_1: |-
  let path = Bundle.main.url(forResource: "games", withExtension: "json")!
  let documents: Data = try Data(contentsOf: path)

  client.index("games").addDocuments(documents: documents) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
  }
date_guide_filterable_attributes_1: |-
  client.index("games").updateFilterableAttributes(["release_timestamp"]) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
  }
date_guide_filter_1: |-
  let searchParameters = SearchParameters(
    query: "",
    filter: "release_timestamp >= 1514761200 AND release_timestamp < 1672527600"
  )
  client.index("games").search(searchParameters) { (result: Result<Searchable<Game>, Swift.Error>) in
    switch result {
    case .success(let searchResult):
        print(searchResult)
    case .failure(let error):
        print(error)
    }
  }
date_guide_sortable_attributes_1: |-
  client.index("games").updateSortableAttributes(["release_timestamp"]) { (result) in
    switch result {
    case .success(let task):
      print(task)
    case .failure(let error):
      print(error)
    }
  }
date_guide_sort_1: |-
  let searchParameters = SearchParameters(
    query: "",
    sort: ["release_timestamp:desc"],
  )

  client.index("games").search(searchParameters) { (result: Result<Searchable<Game>, Swift.Error>) in
    switch result {
    case .success(let searchResult):
        print(searchResult)
    case .failure(let error):
        print(error)
    }
  }

async_guide_filter_by_date_1: |-
  client.getTasks(params: TasksQuery(afterEnqueuedAt: dateFormatter.date(from: "2020-10-11T11:49:53.000Z"))) { result in
    switch result {
    case .success(let taskResult):
      print(taskResult)
    case .failure(let error):
      print(error)
    }
  }
async_guide_multiple_filters_1: |-
  client.getTasks(params: TasksQuery(indexUids: "movies", types: ["documentAdditionOrUpdate", "documentDeletion"], statuses: ["processing"])) { result in
    switch result {
    case .success(let taskResult):
      print(taskResult)
    case .failure(let error):
      print(error)
    }
  }
async_guide_filter_by_ids_1: |-
  client.getTasks(params: TasksQuery(uids: [5, 10, 13])) { result in
    switch result {
    case .success(let taskResult):
      print(taskResult)
    case .failure(let error):
      print(error)
    }
  }
async_guide_filter_by_statuses_1: |-
  client.getTasks(params: TasksQuery(statuses: [.failed, .canceled])) { result in
    switch result {
    case .success(let taskResult):
      print(taskResult)
    case .failure(let error):
      print(error)
    }
  }
async_guide_filter_by_types_1: |-
  client.getTasks(params: TasksQuery(types: [.dumpCreation, .indexSwap])) { result in
    switch result {
    case .success(let taskResult):
      print(taskResult)
    case .failure(let error):
      print(error)
    }
  }
async_guide_filter_by_index_uids_1: |-
  client.getTasks(params: TasksQuery(indexUids: ["movies"])) { result in
    switch result {
    case .success(let taskResult):
      print(taskResult)
    case .failure(let error):
      print(error)
    }
  }
async_guide_canceled_by: |-
  client.getTasks(params: TasksQuery(canceledBy: [9, 15])) { result in
    switch result {
    case .success(let taskResult):
      print(taskResult)
    case .failure(let error):
      print(error)
    }
  }
get_dictionary_1: |-
  client.index("books").getDictionary { result in
    // handle result
  }
update_dictionary_1: |-
  client.index("books").updateDictionary(["J. R. R.", "W. E. B."]) { result in
    // handle result
  }
reset_dictionary_1: |-
  client.index("books").resetDictionary { result in
    // handle result
  }
get_separator_tokens_1: |-
  client.index("books").getSeparatorTokens { result in
    // handle result
  }
update_separator_tokens_1: |-
  client.index("books").updateSeparatorTokens(["|", "&hellip;"]) { result in
    // handle result
  }
reset_separator_tokens_1: |-
  client.index("books").resetSeparatorTokens { result in
    // handle result
  }
get_non_separator_tokens_1: |-
  client.index("books").getNonSeparatorTokens { result in
    // handle result
  }
update_non_separator_tokens_1: |-
  client.index("books").updateNonSeparatorTokens(["@", "#"]) { result in
    // handle result
  }
reset_non_separator_tokens_1: |-
  client.index("books").resetNonSeparatorTokens { result in
    // handle result
  }
search_parameter_guide_hitsperpage_1: |-
  let searchParameters = SearchParameters(query: "", hitsPerPage: 15)
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
    switch result {
    case .success(let searchResult):
        print(searchResult)
    case .failure(let error):
        print(error)
    }
  }
search_parameter_guide_page_1: |-
  let searchParameters = SearchParameters(query: "", page: 15)
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
    switch result {
    case .success(let searchResult):
        print(searchResult)
    case .failure(let error):
        print(error)
    }
  }
search_parameter_guide_attributes_to_search_on_1: |-
  let searchParameters = SearchParameters(query: "adventure", attributesToSearchOn: ["overview"])
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
    switch result {
    case .success(let searchResult):
        print(searchResult)
    case .failure(let error):
        print(error)
    }
  }
search_parameter_guide_show_ranking_score_1: |-
  let searchParameters = SearchParameters(query: "dragon", showRankingScore: true)
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
    switch result {
    case .success(let searchResult):
        print(searchResult.rankingScore)
    case .failure(let error):
        print(error)
    }
  }
authorization_header_1: |-
  client = try MeiliSearch(host: "http://localhost:7700", apiKey: "masterKey")
  client.getKeys { result in
      switch result {
      case .success(let keys):
          print(keys)
      case .failure(let error):
          print(error)
      }
  }
getting_started_typo_tolerance: |-

get_all_tasks_paginating_1: |-
  client.getTasks(params: TasksQuery(limit: 2, from: 10)) { result in
    switch result {
    case .success(let taskResult):
      print(taskResult)
    case .failure(let error):
      print(error)
    }
  }
get_all_tasks_paginating_2: |-
  client.getTasks(params: TasksQuery(limit: 2, from: 8)) { result in
    switch result {
    case .success(let taskResult):
      print(taskResult)
    case .failure(let error):
      print(error)
    }
  }
get_one_index_1: |-
  client.getIndex("movies") { (result) in
      switch result {
      case .success(let index):
          print(index)
      case .failure(let error):
          print(error)
      }
  }
list_all_indexes_1: |-
  client.getIndexes { (result) in
      switch result {
      case .success(let indexes):
          print(indexes)
      case .failure(let error):
          print(error)
      }
  }
create_an_index_1: |-
  client.createIndex(uid: "movies", primaryKey: "id") { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
update_an_index_1: |-
  client.index("movies").update(primaryKey: "id") { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
delete_an_index_1: |-
  client.index("movies").delete { (result) in
      switch result {
      case .success:
          print("Index deleted")
      case .failure(let error):
          print(error)
      }
  }
get_one_document_1: |-
  client.index("movies").getDocument(25684) { (result: Result<Movie, Swift.Error>) in
      switch result {
      case .success(let movie):
          print(movie)
      case .failure(let error):
          print(error)
      }
  }
get_documents_1: |-
  client.index("movies").getDocuments(params: DocumentsQuery(limit: 2)) { (result: Result<DocumentsResults<Movie>, Swift.Error>) in
      switch result {
      case .success(let movies):
          print(movies)
      case .failure(let error):
          print(error)
      }
  }
add_or_replace_documents_1: |-
  let documentJsonString = """
  [
    {
      "reference_number": 287947,
      "title": "Shazam",
      "poster": "https://image.tmdb.org/t/p/w1280/xnopI5Xtky18MPhK40cZAGAOVeV.jpg",
      "overview": "A boy is given the ability to become an adult superhero in times of need with a single magic word.",
      "release_date": "2019-03-23"
    }
  ]
  """
  let documents: Data = documentJsonString.data(using: .utf8)!

  client.index("movies").addDocuments(documents: documents) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
add_or_update_documents_1: |-
  let documentJsonString = """
  [
    {
      "reference_number": 287947,
      "title": "Shazam ⚡️",
      "genres": "comedy"
    }
  ]
  """
  let documents: Data = documentJsonString.data(using: .utf8)!

  client.index("movies").updateDocuments(documents: documents) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
delete_all_documents_1: |-
  client.index("movies").deleteAllDocuments() { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
delete_one_document_1: |-
  client.index("movies").deleteDocument("25684") { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
delete_documents_1: |-
  client.index("movies").deleteBatchDocuments(["23488", "153738", "437035", "363869"]) {
  (result) in
        switch result {
        case .success(let task):
            print(task)
        case .failure(let error):
            print(error)
        }
    }
search_post_1: |-
  let searchParameters = SearchParameters(query: "American ninja")
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
get_task_1: |-
  client.getTask(taskUid: 1) { (result) in
        switch result {
        case .success(let task):
            print(task)
        case .failure(let error):
            print(error)
        }
    }
get_all_tasks_1: |-
  client.getTasks { (result) in
      switch result {
      case .success(let tasks):
          print(tasks)
      case .failure(let error):
          print(error)
      }
  }
delete_tasks_1: |-
  client.deleteTasks(filter: DeleteTasksQuery(uids: [1, 2])) { (result) in
      switch result {
      case .success(let taskInfo):
          print(taskInfo)
      case .failure(let error):
          print(error)
      }
  }
cancel_tasks_1: |-
  client.cancelTasks(filter: CancelTasksQuery(uids: [1, 2])) { (result) in
      switch result {
      case .success(let taskInfo):
          print(taskInfo)
      case .failure(let error):
          print(error)
      }
  }
get_one_key_1: |-
  client.getKey(keyOrUid: "6062abda-a5aa-4414-ac91-ecd7944c0f8d") { result in
      switch result {
      case .success(let key):
          print(key)
      case .failure(let error):
          print(error)
      }
  }
get_all_keys_1: |-
  client.getKeys(params: KeysQuery(limit: 3)) { result in
      switch result {
      case .success(let keys):
          print(keys)
      case .failure(let error):
          print(error)
      }
  }
create_a_key_1: |-
  let keyParams = KeyParams(
    description: "Add documents: Products API key",
    actions: ["documents.add"],
    indexes: ["products"],
    expiresAt: "2042-04-02T00:42:42Z"
  )
  client.createKey(keyParams) { result in
      switch result {
      case .success(let key):
          print(key)
      case .failure(let error):
          print(error)
      }
  }
update_a_key_1: |-
  let keyParams = KeyUpdateParams(
    description: "Manage documents: Products/Reviews API key",
    name: "Products/Reviews API key"
  )

  client.updateKey(keyOrUid: "6062abda-a5aa-4414-ac91-ecd7944c0f8d", keyParams: keyParams) { result in
    switch result {
    case .success(let key):
        print(key)
    case .failure(let error):
        print(error)
    }
  }
delete_a_key_1: |-
  client.deleteKey(keyOrUid: "6062abda-a5aa-4414-ac91-ecd7944c0f8d") { result in
      switch result {
      case .success:
          print("success")
      case .failure(let error):
          print(error)
      }
  }

security_guide_search_key_1: |-
  client = try MeiliSearch(host: "http://localhost:7700", apiKey: "apiKey")
  client.index("patient_medical_records")
    .search(SearchParameters(query: "")) { (result: Result<Searchable<Patient>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
security_guide_update_key_1: |-
  let client = try MeiliSearch(host: "http://localhost:7700", apiKey: "masterKey")
  let keyParams = KeyUpdateParams(description: "Default Search API Key")

  client.updateKey(key: "74c9c733-3368-4738-bbe5-1d18a5fecb37", keyParams: keyParams) { result in
    switch result {
    case .success(let key):
      print(key)
    case .failure(let error):
      print(error)
    }
  }
security_guide_create_key_1: |-
  let client = try MeiliSearch(host: "http://localhost:7700", apiKey: "masterKey")

  let keyParams = KeyParams(
    description: "Search patient records key",
    actions: ["search"],
    indexes: ["patient_medical_records"],
    expiresAt: "2023-01-01T00:00:00Z"
  )
  client.createKey(keyParams) { result in
    switch result {
    case .success(let key):
      print(key)
    case .failure(let error):
      print(error)
    }
  }
security_guide_list_keys_1: |-
  let client = try MeiliSearch(host: "http://localhost:7700", apiKey: "masterKey")

  client.getKeys() { result in
      switch result {
      case .success(let keys):
          print(keys)
      case .failure(let error):
          print(error)
      }
  }
security_guide_delete_key_1: |-
  let client = try MeiliSearch(host: "http://localhost:7700", apiKey: "masterKey")

  client.deleteKey(keyOrUid: "ac5cd97d-5a4b-4226-a868-2d0eb6d197ab") { result in
      switch result {
      case .success:
          print("success")
      case .failure(let error):
          print(error)
      }
  }
get_settings_1: |-
  client.index("movies").getSettings { (result) in
      switch result {
      case .success(let setting):
          print(setting)
      case .failure(let error):
          print(error)
      }
  }
update_settings_1: |-
  let settings = Setting(rankingRules: [
      "words",
      "typo",
      "proximity",
      "attribute",
      "sort",
      "exactness",
      "release_date:desc",
      "rank:desc"
  ], searchableAttributes: [
      "title",
      "overview",
      "genres"
  ], displayedAttributes: [
      "title",
      "overview",
      "genres",
      "release_date"
  ], stopWords: [
      "the",
      "a",
      "an"
  ], synonyms: [
      "wolverine": ["xmen", "logan"],
      "logan": ["wolverine"]
  ], distinctAttribute: "movie_id",
  sortableAttributes: [
      "title",
      "release_date"
  ])
  client.index("movies").updateSettings(settings) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
reset_settings_1: |-
  client.index("movies").resetSettings { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
get_synonyms_1: |-
  client.index("movies").getSynonyms { (result) in
      switch result {
      case .success(let synonyms):
          print(synonyms)
      case .failure(let error):
          print(error)
      }
  }
update_synonyms_1: |-
  let synonyms: [String: [String]] = [
      "wolverine": ["xmen", "logan"],
      "logan": ["wolverine", "xmen"],
      "wow": ["world of warcraft"]
  ]
  client.index("movies").updateSynonyms(synonyms) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
reset_synonyms_1: |-
  client.index("movies").resetSynonyms { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
get_stop_words_1: |-
  client.index("movies").getStopWords { (result) in
      switch result {
      case .success(let stopWords):
          print(stopWords)
      case .failure(let error):
          print(error)
      }
  }
update_stop_words_1: |-
  let stopWords: [String] = ["of", "the", "to"]
  client.index("movies").updateStopWords(stopWords) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
reset_stop_words_1: |-
  client.index("movies").resetStopWords { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
get_ranking_rules_1: |-
  client.index("movies").getRankingRules { (result) in
      switch result {
      case .success(let rankingRules):
          print(rankingRules)
      case .failure(let error):
          print(error)
      }
  }
update_ranking_rules_1: |-
  let rankingRules: [String] = [
      "words",
      "typo",
      "proximity",
      "attribute",
      "sort",
      "exactness",
      "release_date:asc",
      "rank:desc"
  ]
  client.index("movies").updateRankingRules(rankingRules) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
reset_ranking_rules_1: |-
  client.index("movies").resetRankingRules { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
get_distinct_attribute_1: |-
  client.index("shoes").getDistinctAttribute { (result) in
      switch result {
      case .success(let distinctAttribute):
          print(distinctAttribute)
      case .failure(let error):
          print(error)
      }
  }
update_distinct_attribute_1: |-
  client.index("shoes").updateDistinctAttribute("skuid") { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
reset_distinct_attribute_1: |-
  client.index("shoes").resetDistinctAttribute { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
get_searchable_attributes_1: |-
  client.index("movies").getSearchableAttributes { (result) in
      switch result {
      case .success(let searchableAttributes):
          print(searchableAttributes)
      case .failure(let error):
          print(error)
      }
  }
update_searchable_attributes_1: |-
  let searchableAttributes: [String] = ["title", "overview", "genres"]
  client.index("movies").updateSearchableAttributes(searchableAttributes) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
reset_searchable_attributes_1: |-
  client.index("movies").resetSearchableAttributes { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
get_displayed_attributes_1: |-
  client.index("movies").getDisplayedAttributes { (result) in
      switch result {
      case .success(let displayedAttributes):
          print(displayedAttributes)
      case .failure(let error):
          print(error)
      }
  }
update_displayed_attributes_1: |-
  let displayedAttributes: [String] = ["title", "overview", "genres", "release_date"]
  client.index("movies").updateDisplayedAttributes(displayedAttributes) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
reset_displayed_attributes_1: |-
  client.index("movies").resetDisplayedAttributes { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }

get_index_stats_1: |-
  client.index("movies").stats { (result) in
      switch result {
      case .success(let stats):
          print(stats)
      case .failure(let error):
          print(error)
      }
  }
get_indexes_stats_1: |-
  client.allStats { (result) in
      switch result {
      case .success(let stats):
          print(stats)
      case .failure(let error):
          print(error)
      }
  }
get_health_1: |-
  client.health { (result) in
      switch result {
      case .success:
          print("Healthy!")
      case .failure(let error):
          print(error)
      }
  }
get_version_1: |-
  client.version { (result) in
      switch result {
      case .success(let version):
          print(version)
      case .failure(let error):
          print(error)
      }
  }
distinct_attribute_guide_1: |-
  client.index("jackets").updateDistinctAttribute("product_id") { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
field_properties_guide_searchable_1: |-
  let searchableAttributes: [String] = [
      "title",
      "overview",
      "genres"
  ]
  client.index("movies").updateSearchableAttributes(searchableAttributes) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
field_properties_guide_displayed_1: |-
  let displayedAttributes: [String] = [
      "title",
      "overview",
      "genres",
      "release_date"
  ]
  client.index("movies").updateDisplayedAttributes(displayedAttributes) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
filtering_guide_1: |-
  let searchParameters = SearchParameters(
      query: "Avengers",
      filter: "release_date > 795484800"
  )
  client.index("movie_ratings").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
filtering_guide_2: |-
  let searchParameters = SearchParameters(
      query: "Batman",
      filter: "release_date > 795484800 AND (director = \"Tim Burton\" OR director = \"Christopher Nolan\"")
  client.index("movie_ratings").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
filtering_guide_3: |-
  let searchParameters = SearchParameters(
      query: "Planet of the Apes",
      filter: "release_date > 1577884550 AND (NOT director = \"Tim Burton\"))
  client.index("movie_ratings").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
search_parameter_guide_query_1: |-
  client.index("movies").search(SearchParameters(query: "shifu")) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
search_parameter_guide_offset_1: |-
  let searchParameters = SearchParameters(
      query: "shifu",
      offset: 1)
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
search_parameter_guide_limit_1: |-
  let searchParameters = SearchParameters(
      query: "shifu",
      limit: 2)
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
search_parameter_guide_retrieve_1: |-
  let searchParameters = SearchParameters(
      query: "shifu",
      attributesToRetrieve: ["overview", "title"])
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
search_parameter_guide_crop_1: |-
  let searchParameters = SearchParameters(
      query: "shifu",
      attributesToCrop: ["overview"],
      cropLength: 5)
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
search_parameter_guide_crop_marker_1: |-
  let searchParameters = SearchParameters(
      query: "shifu",
      attributesToCrop: ["overview"],
      cropMarker: "[…]")
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
search_parameter_guide_highlight_1: |-
  let searchParameters = SearchParameters(
      query: "winter feast",
      attributesToHighlight: ["overview"])
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
search_parameter_guide_highlight_tag_1: |-
  let searchParameters = SearchParameters(
      query: "winter feast",
      attributesToHighlight: ["overview"],
      highlightPreTag: "<span class=\"highlight\">",
      highlightPostTag: "</span>")
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
search_parameter_guide_show_matches_position_1: |-
  let searchParameters = SearchParameters(
      query: "winter feast",
      showMatchesPosition: true)
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
add_movies_json_1: |-
  let path = Bundle.main.url(forResource: "movies", withExtension: "json")!
  let documents: Data = try Data(contentsOf: path)

  client.index("movies").addDocuments(documents: documents) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
documents_guide_add_movie_1: |-
  let documentJsonString = """
  [{
      "movie_id": 123sq178,
      "title": "Amélie Poulain"
  }]
  """
  let documents: Data = documentJsonString.data(using: .utf8)!

  client.index("movies").addDocuments(documents: documents) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
primary_field_guide_create_index_primary_key: |-
  client.createIndex(uid: "books", primaryKey: "reference_number") { (result) in
    switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
primary_field_guide_update_document_primary_key: |-
  client.updateIndex(uid: "movies", primaryKey: "title") { (result) in
    switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
primary_field_guide_add_document_primary_key: |-
  let documents: Data = """
  [
    {
      "reference_number": 287947,
      "title": "Diary of a Wimpy Kid",
      "author": "Jeff Kinney",
      "genres": ["comedy", "humor"],
      "price": 5
    }
  ]
  """.data(using: .utf8)!

  client.index("books").addDocuments(documents: documents, primaryKey: "reference_number") { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
getting_started_add_documents_md: |-
  Add this to your `Package.swift`:
  ```swift
    dependencies: [
      .package(url: "https://github.com/meilisearch/meilisearch-swift.git", from: "0.16.0")
    ]
  ```

  ```swift
    let path = Bundle.main.url(forResource: "movies", withExtension: "json")!
    let documents: Data = try Data(contentsOf: path)
    let client = try MeiliSearch(host: "http://localhost:7700", apiKey: "aSampleMasterKey")

    client.index("movies").addDocuments(documents: documents) { (result) in
        switch result {
        case .success(let task):
            print(task)
        case .failure(let error):
            print(error)
        }
    }
  ```
  [About this SDK](https://www.github.com/meilisearch/meilisearch-swift)
getting_started_search_md: |-
  ```swift
    client.index("movies").search(SearchParameters(query: "botman")) { (result) in
        switch result {
        case .success(let searchResult):
            print(searchResult)
        case .failure(let error):
            print(error)
        }
    }
  ```
  [About this SDK](https://www.github.com/meilisearch/meilisearch-swift)

getting_started_update_ranking_rules: |-
  let rankingRules: [String] = [
    "exactness",
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "release_date:asc",
    "rank:desc"
  ]
  client.index("movies").updateRankingRules(rankingRules) { (result) in
    switch result {
    case .success(let task):
      print(task)
    case .failure(let error):
      print(error)
    }
  }
getting_started_update_searchable_attributes: |-
  let searchableAttributes: [String] = ["title"]
  client.index("movies").updateSearchableAttributes(searchableAttributes) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
getting_started_update_stop_words: |-
  let stopWords: [String] = ["the"]
  client.index("movies").updateStopWords(stopWords) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
getting_started_check_task_status: |-
  client.getTask(taskUid: 0) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
getting_started_synonyms: |-
  let synonyms: [String: [String]] = [
     "winnie": ["piglet"],
     "piglet": ["winnie"]
  ]
   client.index("movies").updateSynonyms(synonyms) { (result) in
       switch result {
       case .success(let task):
           print(task)
       case .failure(let error):
           print(error)
       }
   }
getting_started_update_displayed_attributes: |-
  let displayedAttributes: [String] = ["title", "overview", "poster"]
  client.index("movies").updateDisplayedAttributes(displayedAttributes) { (result) in
       switch result {
       case .success(let task):
           print(task)
       case .failure(let error):
           print(error)
       }
   }
getting_started_communicating_with_a_protected_instance: |-
  let client = try MeiliSearch(host: "http://localhost:7700", apiKey: "apiKey")

  client.index("movies").search(SearchParameters(query: "")) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
getting_started_add_meteorites: |-
  let file = "meteorites.json"
  let path = URL(fileURLWithPath: file)
  let documents: Data = try Data(contentsOf: path)

  client.index("meteorites").addDocuments(documents: documents) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
getting_started_configure_settings: |-
  let settings = Setting(
    filterableAttributes: ["mass", "_geo"],
    sortableAttributes: ["mass", "_geo"]
  )
  client.index("meteorites").updateSettings(settings) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
getting_started_geo_radius: |-
  let searchParameters = SearchParameters(
      query: "",
      filter: "_geoRadius(46.9480, 7.4474, 210000)"
  )
  client.index("meteorites").search(searchParameters) { (result: Result<Searchable<Meteorite>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
getting_started_geo_point: |-
  let searchParameters = SearchParameters(
      query: "",
      sort: ["_geoPoint(48.8583701, 2.2922926):asc"]
  )
  client.index("meteorites").search(searchParameters) { (result: Result<Searchable<Meteorite>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
getting_started_sorting: |-
  let searchParameters = SearchParameters(
    query: "",
    filter: "mass < 200",
    sort: ["mass:asc"]
  )
  client.index("meteorites").search(searchParameters) { (result: Result<Searchable<Meteorite>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
getting_started_filtering: |-
  let searchParameters = SearchParameters(
     query: "",
     filter: "mass < 200"
   )
   client.index("meteorites").search(searchParameters) { (result: Result<Searchable<Meteorite>, Swift.Error>) in
       switch result {
       case .success(let searchResult):
           print(searchResult)
       case .failure(let error):
           print(error)
       }
   }
get_filterable_attributes_1: |-
  client.index("movies").getFilterableAttributes { (result) in
      switch result {
      case .success(let attributes):
          print(attributes)
      case .failure(let error):
          print(error)
      }
  }
update_filterable_attributes_1: |-
  client.index("movies").updateFilterableAttributes(["genre", "director"]) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
reset_filterable_attributes_1: |-
  client.index("movies").resetFilterableAttributes { (result) in
      switch result {
      case .success(let attributes):
          print(attributes)
      case .failure(let error):
          print(error)
      }
  }
filtering_update_settings_1: |-
  client.index("movies").updateFilterableAttributes(["genre", "director"]) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }

faceted_search_facets_1: |-
  let searchParameters = SearchParameters(
      query: "Batman",
      facets: ["genres"])
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
faceted_search_walkthrough_filter_1: |-
  let searchParameters = SearchParameters(
      query: "thriller",
      filter: [
        [
          "genres = Horror",
          "genres = Mystery"
        ],
        "director = \"Jordan Peele\""
      ])
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
phrase_search_1: |-
  let searchParameters = SearchParameters(
      query: "\"african american\" horror")
  client.index("movies").search(searchParameters) { (result: Result<Searchable<Movie>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
sorting_guide_update_sortable_attributes_1: |-
  client.index("books").updateSortableAttributes(["price", "author"]) { (result: Result<TaskInfo, Swift.Error>) in
    switch result {
    case .success(let task):
      print(task)
    case .failure(let error):
      print(error)
    }
  }
sorting_guide_update_ranking_rules_1: |-
  let rankingRules: [String] = [
    "words",
    "sort",
    "typo",
    "proximity",
    "attribute",
    "exactness"
  ]
  client.index("books").updateRankingRules(rankingRules) { (result) in
    switch result {
    case .success(let task):
      print(task)
    case .failure(let error):
      print(error)
    }
  }
sorting_guide_sort_parameter_1: |-
  let searchParameters = SearchParameters(
    query: "science fiction",
    sort: ["price:asc"]
  )
  client.index("books").search(searchParameters) { (result: Result<Searchable<Book>, Swift.Error>) in
    switch result {
    case .success(let searchResult):
      print(searchResult)
    case .failure(let error):
      print(error)
    }
  }
sorting_guide_sort_parameter_2: |-
  let searchParameters = SearchParameters(
    query: "butler",
    sort: ["author:desc"]
  )
  client.index("books").search(searchParameters) { (result: Result<Searchable<Book>, Swift.Error>) in
    switch result {
    case .success(let searchResult):
      print(searchResult)
    case .failure(let error):
      print(error)
    }
  }
get_sortable_attributes_1: |-
  client.index("books").getSortableAttributes { (result: Result<Searchable<Book>, Swift.Error>) in
    switch result {
    case .success(let attributes):
      print(attributes)
    case .failure(let error):
      print(error)
    }
  }
update_sortable_attributes_1: |-
  client.index("books").updateSortableAttributes(["price", "author"]) { (result) in
    switch result {
    case .success(let task):
      print(task)
    case .failure(let error):
      print(error)
    }
  }
reset_sortable_attributes_1: |-
  client.index("books").resetSortableAttributes() { (result) in
    switch result {
    case .success(let attributes):
      print(attributes)
    case .failure(let error):
      print(error)
    }
  }
search_parameter_guide_sort_1: |-
  let searchParameters = SearchParameters(
    query: "science fiction",
    sort: ["price:asc"]
  )
  client.index("books").search(searchParameters) { (result: Result<Searchable<Book>, Swift.Error>) in
    switch result {
    case .success(let searchResult):
      print(searchResult)
    case .failure(let error):
      print(error)
    }
  }
post_dump_1: |-
  client.createDump { result in
      switch result {
      case .success(let dumpStatus):
          print(dumpStatus)
      case .failure(let error):
          print(error)
      }
  }
geosearch_guide_filter_settings_1: |-
  client.index("restaurants").updateFilterableAttributes(["_geo"]) { (result) in
      switch result {
      case .success(let task):
          print(task)
      case .failure(let error):
          print(error)
      }
  }
geosearch_guide_filter_usage_1: |-
  let searchParameters = SearchParameters(
      filter: "_geoRadius(45.472735, 9.184019, 2000)"
  )
  client.index("restaurants").search(searchParameters) { (result: Result<Searchable<Restaurant>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
geosearch_guide_filter_usage_2: |-
  let searchParameters = SearchParameters(
      filter: "_geoRadius(45.472735, 9.184019, 2000) AND type = pizza"
  )
  client.index("restaurants").search(searchParameters) { (result: Result<Searchable<Restaurant>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
geosearch_guide_filter_usage_3: |-
  let searchParameters = SearchParameters(
      filter: "_geoBoundingBox([45.494181, 9.214024], [45.449484, 9.179175])"
  )
  client.index("restaurants").search(searchParameters) { (result: Result<Searchable<Restaurant>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
geosearch_guide_sort_settings_1: |-
  client.index("restaurants").updateSortableAttributes(["_geo"]) { (result) in
    switch result {
    case .success(let task):
      print(task)
    case .failure(let error):
      print(error)
    }
  }
geosearch_guide_sort_usage_1: |-
  let searchParameters = SearchParameters(
      query: "",
      sort: ["_geoPoint(48.8561446, 2.2978204):asc"]
  )
  client.index("restaurants").search(searchParameters) { (result: Result<Searchable<Restaurant>, Swift.Error>) in
      switch result {
      case .success(let task):
        print(task)
      case .failure(let error):
        print(error)
      }
    }
geosearch_guide_sort_usage_2: |-
  let searchParameters = SearchParameters(
      query: "",
      sort: ["_geoPoint(48.8561446, 2.2978204):asc", "rating:desc"]
  )
  client.index("restaurants").search(searchParameters) { (result: Result<Searchable<Restaurant>, Swift.Error>) in
      switch result {
      case .success(let searchResult):
          print(searchResult)
      case .failure(let error):
          print(error)
      }
  }
landing_getting_started_1: |-
  let client = try MeiliSearch(host: "http://localhost:7700", apiKey: "masterKey")
  let documents = """
  [
    { "id": 1, "title": "Carol" },
    { "id": 2, "title": "Wonder Woman" },
    { "id": 3, "title": "Life of Pi" },
    { "id": 4, "title": "Mad Max: Fury Road" },
    { "id": 5, "title": "Moana" },
    { "id": 6, "title": "Philadelphia"}
  ]
  """.data(using: .utf8)!

  client.index("movies").addDocuments(documents: documents, primaryKey: "reference_number") { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
  }
swap_indexes_1: |-
  let task = try await self.client.swapIndexes([
    ("indexA", "indexB"),
    ("indexX", "indexY")
  ])