1
2
3
4
5
6
7
8
client.replace_dictionary_entries(
  'stopwords',
  [{
    objectID: 'down',
    language: 'en',
    word: 'down'
  }]
)

1
2
3
4
5
6
7
client.replaceDictionaryEntries('stopwords', [
  {
    objectID: 'down',
    language: 'de',
    word: 'down',
  },
]);

1
2
3
4
5
6
7
8
client.replace_dictionary_entries(
  'stopwords',
  [{
    'objectID': 'down',
    'language': 'en',
    'word': 'down'
  }]
)

1
2
3
4
5
6
7
8
9
10
let entry = StopwordsDictionary.Entry(objectID: "down",
                                      language: .english,
                                      word: "down",
                                      state: .enabled)

client.replaceDictionaryEntries(in: StopwordsDictionary.self, with: [entry]) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
val entry = DictionaryEntry.Stopword(
    objectID = ObjectID("MyObjectID"),
    language = Language.English,
    word = "upper"
)
client.replaceDictionaryEntries(Dictionary.Stopwords, listOf(entry))
// or using extension function:
client.replaceStopwordEntries(listOf(entry))

1
2
3
4
5
6
7
8
9
10
11
12
13
Stopword stopword = new Stopword()
{
  ObjectID = objectId,
  Language = "en",
   Word = "upper",
};

// Synchronous
var replaceDictionaryResponse = DictionaryClient.ReplaceDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { stopword });

// Asynchronous
var replaceDictionaryResponse = DictionaryClient.ReplaceDictionaryEntriesAsync(algoliaDictionary, new List<DictionaryEntry>() { stopword });
replaceDictionaryResponse.Wait();

1
2
3
4
5
Stopword stopword = DictionaryEntry.stopword("MyObjectID", "en", "down", "enabled");
// Synchronous
searchClient.replaceDictionaryEntries(Dictionary.STOPWORDS, Collections.singletonList(stopword));
// Asynchronous
searchClient.replaceDictionaryEntriesAsync(Dictionary.STOPWORDS, Collections.singletonList(stopword));

1
2
3
stopwordEntry := search.NewStopword(entryID, "en", "down", "enabled")

res, err := client.ReplaceDictionaryEntries(search.Stopwords, []search.DictionaryEntry{stopwordEntry})

1
2
3
4
5
6
7
8
9
val entry = StopwordEntry(
  objectID = "MyObjectID",
  language = "en",
  word = "down",
  state = "enabled"
)
client.execute {
  replace dictionary Stopwords entries Seq(entry)
}

1
2
3
4
5
6
7
8
client.replace_dictionary_entries(
  'plurals',
  [{
    objectID: 'chevaux',
    language: 'fr',
    words: %w(cheval chevaux)
  }]
)

1
2
3
4
5
6
7
client.replaceDictionaryEntries('plurals', [
  {
    objectID: 'chevaux',
    language: 'fr',
    words: ['cheval', 'chevaux'],
  },
]);

1
2
3
4
5
6
7
8
client.replace_dictionary_entries(
  'plurals',
  [{
    'objectID': 'chevaux',
    'language': 'fr',
    'words': ['cheval', 'chevaux']
  }]
)

1
2
3
4
5
6
7
8
9
let entry = PluralsDictionary.Entry(objectID: "chevaux",
                                    language: .french,
                                    words: ["cheval", "chevaux"])

client.replaceDictionaryEntries(in: PluralsDictionary.self, with: [entry]) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
val entry = DictionaryEntry.Plural(
    objectID = ObjectID("MyObjectID"),
    language = Language.French,
    words = listOf("cheval", "chevaux")
)
client.replaceDictionaryEntries(Dictionary.Plurals, listOf(entry))
// or using extension function:
client.replacePluralEntries(listOf(entry))

1
2
3
4
5
6
7
8
9
10
11
12
13
Plural plural = new Plural()
{
  ObjectID = objectId,
  Language = "fr",
  Words = new List<String>() { "cheval", "chevaux" }
};

// Synchronous
DictionaryClient.ReplaceDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { plural });

// Asynchronous
var replaceDictionaryResponse = await DictionaryClient.ReplaceDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { plural });
replaceDictionaryResponse.Wait();

1
2
3
4
5
Plural plural = DictionaryEntry.plural("MyObjectID", "fr", Arrays.asList("cheval", "chevaux"));
// Synchronous
client.replaceDictionaryEntries(Dictionary.PLURALS, Collections.singletonList(plural));
// Asynchronous
client.replaceDictionaryEntriesAsync(Dictionary.PLURALS, Collections.singletonList(plural));

1
2
3
pluralEntry := search.NewPlural(entryID, "fr", []string{"cheval", "chevaux"})

res, err := client.ReplaceDictionaryEntries(search.Plurals, []search.DictionaryEntry{pluralEntry})

1
2
3
4
5
6
7
8
val entry = PluralEntry(
  objectID = "MyObjectID",
  language = "fr",
  words = Seq("cheval", "chevaux")
)
client.execute {
  replace dictionary Plurals entries Seq(entry)
}

1
2
3
4
5
6
7
8
9
client.replace_dictionary_entries(
  'compounds',
  [{
    objectID: 'kopfschmerztablette',
    language: 'de',
    word: 'kopfschmerztablette',
    decomposition: %w(kopf schmerz tablette)
  }]
)

1
2
3
4
5
6
7
8
client.replaceDictionaryEntries('compounds', [
  {
    objectID: 'kopfschmerztablette',
    language: 'de',
    word: 'kopfschmerztablette',
    decomposition: ['kopf', 'schmerz', 'tablette'],
  },
]);

1
2
3
4
5
6
7
8
9
client.replace_dictionary_entries(
  'compounds',
  [{
    'objectID': 'kopfschmerztablette',
    'language': 'de',
    'word': 'kopfschmerztablette',
    'decomposition': ['kopf', 'schmerz', 'tablette]
  }]
)

1
2
3
4
5
6
7
8
9
10
let entry = CompoundsDictionary.Entry(objectID: "kopfschmerztablette",
                                      language: .german,
                                      word: "kopfschmerztablette",
                                      decomposition: ["kopf", "schmerz", "tablette"])

client.replaceDictionaryEntries(in: CompoundsDictionary.self, with: [entry]) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
val entry = DictionaryEntry.Compound(
    objectID = ObjectID("MyObjectID"),
    language = Language.Dutch,
    word = "kopfschmerztablette",
    decomposition = listOf("kopf", "schmerz", "tablette")
)
client.replaceDictionaryEntries(Dictionary.Compounds, listOf(entry))
// or using extension function:
client.replaceCompoundEntries(listOf(entry))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Compound compound = new Compound()
{
  ObjectID = objectId,
  Language = "nl",
  Word = "kopfschmerztablette",
  Decomposition = new List<String>() { "kopf", "schmerz", "tablette" }
 };

 // Synchronous
 var replaceDictionaryResponse = DictionaryClient.ReplaceDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { compound });

 // Asynchronous
 var replaceDictionaryResponse = await DictionaryClient.ReplaceDictionaryEntriesAsync(algoliaDictionary, new List<DictionaryEntry>() { compound });
 replaceDictionaryResponse.Wait();

1
2
3
4
5
Compound compound = DictionaryEntry.compound("MyObjectID", "de", "kopfschmerztablette",Arrays.asList("kopf", "schmerz", "tablette"));
// Synchronous
client.replaceDictionaryEntries(Dictionary.COMPOUNDS, Collections.singletonList(compound));
// Asynchronous
client.replaceDictionaryEntriesAsync(Dictionary.COMPOUNDS, Collections.singletonList(compound));

1
2
3
compoundEntry := search.NewCompound(entryID, "de", "kopfschmerztablette", []string{"kopf", "schmerz", "tablette"})

res, err := client.ReplaceDictionaryEntries(search.Compounds, []search.DictionaryEntry{compoundEntry})

1
2
3
4
5
6
7
8
9
val entry = CompoundEntry(
  objectID = "MyObjectID",
  language = "de",
  word = "kopfschmerztablette",
  decomposition = Seq("kopf", "schmerz", "tablette")
)
client.execute {
  replace dictionary Compounds entries Seq(entry)
}