1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_ACTIONSMODEL_LIBTEXTCLASSIFIER3_H_
5 #define FLATBUFFERS_GENERATED_ACTIONSMODEL_LIBTEXTCLASSIFIER3_H_
6
7 #include "flatbuffers/flatbuffers.h"
8
9 // Ensure the included flatbuffers.h is the same version as when this file was
10 // generated, otherwise it may not be compatible.
11 static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
12 FLATBUFFERS_VERSION_MINOR == 0 &&
13 FLATBUFFERS_VERSION_REVISION == 7,
14 "Non-compatible flatbuffers version included");
15
16 #include "actions/actions-entity-data_generated.h"
17 #include "annotator/model_generated.h"
18 #include "utils/codepoint-range_generated.h"
19 #include "utils/flatbuffers/flatbuffers_generated.h"
20 #include "utils/grammar/rules_generated.h"
21 #include "utils/intents/intent-config_generated.h"
22 #include "utils/normalization_generated.h"
23 #include "utils/resources_generated.h"
24 #include "utils/tokenizer_generated.h"
25 #include "utils/zlib/buffer_generated.h"
26
27 namespace libtextclassifier3 {
28
29 struct PredictionMetadata;
30 struct PredictionMetadataBuilder;
31 struct PredictionMetadataT;
32
33 namespace TensorflowLiteModelSpec_ {
34
35 struct InputNameIndexEntry;
36 struct InputNameIndexEntryBuilder;
37 struct InputNameIndexEntryT;
38
39 } // namespace TensorflowLiteModelSpec_
40
41 struct TensorflowLiteModelSpec;
42 struct TensorflowLiteModelSpecBuilder;
43 struct TensorflowLiteModelSpecT;
44
45 struct ActionsTokenizerOptions;
46 struct ActionsTokenizerOptionsBuilder;
47 struct ActionsTokenizerOptionsT;
48
49 struct ActionsTokenFeatureProcessorOptions;
50 struct ActionsTokenFeatureProcessorOptionsBuilder;
51 struct ActionsTokenFeatureProcessorOptionsT;
52
53 struct NGramLinearRegressionModel;
54 struct NGramLinearRegressionModelBuilder;
55 struct NGramLinearRegressionModelT;
56
57 struct TFLiteSensitiveClassifierConfig;
58 struct TFLiteSensitiveClassifierConfigBuilder;
59 struct TFLiteSensitiveClassifierConfigT;
60
61 struct TriggeringPreconditions;
62 struct TriggeringPreconditionsBuilder;
63 struct TriggeringPreconditionsT;
64
65 struct ActionConceptToSuggestion;
66 struct ActionConceptToSuggestionBuilder;
67 struct ActionConceptToSuggestionT;
68
69 struct ActionSuggestionSpec;
70 struct ActionSuggestionSpecBuilder;
71 struct ActionSuggestionSpecT;
72
73 struct ActionTypeOptions;
74 struct ActionTypeOptionsBuilder;
75 struct ActionTypeOptionsT;
76
77 namespace AnnotationActionsSpec_ {
78
79 struct AnnotationMapping;
80 struct AnnotationMappingBuilder;
81 struct AnnotationMappingT;
82
83 } // namespace AnnotationActionsSpec_
84
85 struct AnnotationActionsSpec;
86 struct AnnotationActionsSpecBuilder;
87 struct AnnotationActionsSpecT;
88
89 struct RankingOptions;
90 struct RankingOptionsBuilder;
91 struct RankingOptionsT;
92
93 namespace RulesModel_ {
94 namespace RuleActionSpec_ {
95
96 struct RuleCapturingGroup;
97 struct RuleCapturingGroupBuilder;
98 struct RuleCapturingGroupT;
99
100 } // namespace RuleActionSpec_
101
102 struct RuleActionSpec;
103 struct RuleActionSpecBuilder;
104 struct RuleActionSpecT;
105
106 struct RegexRule;
107 struct RegexRuleBuilder;
108 struct RegexRuleT;
109
110 namespace GrammarRules_ {
111
112 struct RuleMatch;
113 struct RuleMatchBuilder;
114 struct RuleMatchT;
115
116 } // namespace GrammarRules_
117
118 struct GrammarRules;
119 struct GrammarRulesBuilder;
120 struct GrammarRulesT;
121
122 } // namespace RulesModel_
123
124 struct RulesModel;
125 struct RulesModelBuilder;
126 struct RulesModelT;
127
128 struct ActionsModel;
129 struct ActionsModelBuilder;
130 struct ActionsModelT;
131
132 enum PredictionType : int32_t {
133 PredictionType_UNSUPPORTED = 0,
134 PredictionType_NEXT_MESSAGE_PREDICTION = 1,
135 PredictionType_INTENT_TRIGGERING = 2,
136 PredictionType_ENTITY_ANNOTATION = 3,
137 PredictionType_MIN = PredictionType_UNSUPPORTED,
138 PredictionType_MAX = PredictionType_ENTITY_ANNOTATION
139 };
140
EnumValuesPredictionType()141 inline const PredictionType (&EnumValuesPredictionType())[4] {
142 static const PredictionType values[] = {
143 PredictionType_UNSUPPORTED,
144 PredictionType_NEXT_MESSAGE_PREDICTION,
145 PredictionType_INTENT_TRIGGERING,
146 PredictionType_ENTITY_ANNOTATION
147 };
148 return values;
149 }
150
EnumNamesPredictionType()151 inline const char * const *EnumNamesPredictionType() {
152 static const char * const names[5] = {
153 "UNSUPPORTED",
154 "NEXT_MESSAGE_PREDICTION",
155 "INTENT_TRIGGERING",
156 "ENTITY_ANNOTATION",
157 nullptr
158 };
159 return names;
160 }
161
EnumNamePredictionType(PredictionType e)162 inline const char *EnumNamePredictionType(PredictionType e) {
163 if (flatbuffers::IsOutRange(e, PredictionType_UNSUPPORTED, PredictionType_ENTITY_ANNOTATION)) return "";
164 const size_t index = static_cast<size_t>(e);
165 return EnumNamesPredictionType()[index];
166 }
167
168 enum RankingOptionsSortType : int32_t {
169 RankingOptionsSortType_SORT_TYPE_UNSPECIFIED = 0,
170 RankingOptionsSortType_SORT_TYPE_SCORE = 1,
171 RankingOptionsSortType_SORT_TYPE_PRIORITY_SCORE = 2,
172 RankingOptionsSortType_MIN = RankingOptionsSortType_SORT_TYPE_UNSPECIFIED,
173 RankingOptionsSortType_MAX = RankingOptionsSortType_SORT_TYPE_PRIORITY_SCORE
174 };
175
EnumValuesRankingOptionsSortType()176 inline const RankingOptionsSortType (&EnumValuesRankingOptionsSortType())[3] {
177 static const RankingOptionsSortType values[] = {
178 RankingOptionsSortType_SORT_TYPE_UNSPECIFIED,
179 RankingOptionsSortType_SORT_TYPE_SCORE,
180 RankingOptionsSortType_SORT_TYPE_PRIORITY_SCORE
181 };
182 return values;
183 }
184
EnumNamesRankingOptionsSortType()185 inline const char * const *EnumNamesRankingOptionsSortType() {
186 static const char * const names[4] = {
187 "SORT_TYPE_UNSPECIFIED",
188 "SORT_TYPE_SCORE",
189 "SORT_TYPE_PRIORITY_SCORE",
190 nullptr
191 };
192 return names;
193 }
194
EnumNameRankingOptionsSortType(RankingOptionsSortType e)195 inline const char *EnumNameRankingOptionsSortType(RankingOptionsSortType e) {
196 if (flatbuffers::IsOutRange(e, RankingOptionsSortType_SORT_TYPE_UNSPECIFIED, RankingOptionsSortType_SORT_TYPE_PRIORITY_SCORE)) return "";
197 const size_t index = static_cast<size_t>(e);
198 return EnumNamesRankingOptionsSortType()[index];
199 }
200
201 struct PredictionMetadataT : public flatbuffers::NativeTable {
202 typedef PredictionMetadata TableType;
203 libtextclassifier3::PredictionType prediction_type = libtextclassifier3::PredictionType_UNSUPPORTED;
204 std::unique_ptr<libtextclassifier3::ActionSuggestionSpecT> task_spec{};
205 int32_t output_suggestions = 0;
206 int32_t output_suggestions_scores = 0;
207 int32_t output_suggestions_spans = 0;
208 PredictionMetadataT() = default;
209 PredictionMetadataT(const PredictionMetadataT &o);
210 PredictionMetadataT(PredictionMetadataT&&) FLATBUFFERS_NOEXCEPT = default;
211 PredictionMetadataT &operator=(PredictionMetadataT o) FLATBUFFERS_NOEXCEPT;
212 };
213
214 struct PredictionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
215 typedef PredictionMetadataT NativeTableType;
216 typedef PredictionMetadataBuilder Builder;
217 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
218 VT_PREDICTION_TYPE = 4,
219 VT_TASK_SPEC = 6,
220 VT_OUTPUT_SUGGESTIONS = 8,
221 VT_OUTPUT_SUGGESTIONS_SCORES = 10,
222 VT_OUTPUT_SUGGESTIONS_SPANS = 12
223 };
prediction_typeFLATBUFFERS_FINAL_CLASS224 libtextclassifier3::PredictionType prediction_type() const {
225 return static_cast<libtextclassifier3::PredictionType>(GetField<int32_t>(VT_PREDICTION_TYPE, 0));
226 }
task_specFLATBUFFERS_FINAL_CLASS227 const libtextclassifier3::ActionSuggestionSpec *task_spec() const {
228 return GetPointer<const libtextclassifier3::ActionSuggestionSpec *>(VT_TASK_SPEC);
229 }
output_suggestionsFLATBUFFERS_FINAL_CLASS230 int32_t output_suggestions() const {
231 return GetField<int32_t>(VT_OUTPUT_SUGGESTIONS, 0);
232 }
output_suggestions_scoresFLATBUFFERS_FINAL_CLASS233 int32_t output_suggestions_scores() const {
234 return GetField<int32_t>(VT_OUTPUT_SUGGESTIONS_SCORES, 0);
235 }
output_suggestions_spansFLATBUFFERS_FINAL_CLASS236 int32_t output_suggestions_spans() const {
237 return GetField<int32_t>(VT_OUTPUT_SUGGESTIONS_SPANS, 0);
238 }
VerifyFLATBUFFERS_FINAL_CLASS239 bool Verify(flatbuffers::Verifier &verifier) const {
240 return VerifyTableStart(verifier) &&
241 VerifyField<int32_t>(verifier, VT_PREDICTION_TYPE, 4) &&
242 VerifyOffset(verifier, VT_TASK_SPEC) &&
243 verifier.VerifyTable(task_spec()) &&
244 VerifyField<int32_t>(verifier, VT_OUTPUT_SUGGESTIONS, 4) &&
245 VerifyField<int32_t>(verifier, VT_OUTPUT_SUGGESTIONS_SCORES, 4) &&
246 VerifyField<int32_t>(verifier, VT_OUTPUT_SUGGESTIONS_SPANS, 4) &&
247 verifier.EndTable();
248 }
249 PredictionMetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
250 void UnPackTo(PredictionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
251 static flatbuffers::Offset<PredictionMetadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PredictionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
252 };
253
254 struct PredictionMetadataBuilder {
255 typedef PredictionMetadata Table;
256 flatbuffers::FlatBufferBuilder &fbb_;
257 flatbuffers::uoffset_t start_;
add_prediction_typePredictionMetadataBuilder258 void add_prediction_type(libtextclassifier3::PredictionType prediction_type) {
259 fbb_.AddElement<int32_t>(PredictionMetadata::VT_PREDICTION_TYPE, static_cast<int32_t>(prediction_type), 0);
260 }
add_task_specPredictionMetadataBuilder261 void add_task_spec(flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> task_spec) {
262 fbb_.AddOffset(PredictionMetadata::VT_TASK_SPEC, task_spec);
263 }
add_output_suggestionsPredictionMetadataBuilder264 void add_output_suggestions(int32_t output_suggestions) {
265 fbb_.AddElement<int32_t>(PredictionMetadata::VT_OUTPUT_SUGGESTIONS, output_suggestions, 0);
266 }
add_output_suggestions_scoresPredictionMetadataBuilder267 void add_output_suggestions_scores(int32_t output_suggestions_scores) {
268 fbb_.AddElement<int32_t>(PredictionMetadata::VT_OUTPUT_SUGGESTIONS_SCORES, output_suggestions_scores, 0);
269 }
add_output_suggestions_spansPredictionMetadataBuilder270 void add_output_suggestions_spans(int32_t output_suggestions_spans) {
271 fbb_.AddElement<int32_t>(PredictionMetadata::VT_OUTPUT_SUGGESTIONS_SPANS, output_suggestions_spans, 0);
272 }
PredictionMetadataBuilderPredictionMetadataBuilder273 explicit PredictionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
274 : fbb_(_fbb) {
275 start_ = fbb_.StartTable();
276 }
FinishPredictionMetadataBuilder277 flatbuffers::Offset<PredictionMetadata> Finish() {
278 const auto end = fbb_.EndTable(start_);
279 auto o = flatbuffers::Offset<PredictionMetadata>(end);
280 return o;
281 }
282 };
283
284 inline flatbuffers::Offset<PredictionMetadata> CreatePredictionMetadata(
285 flatbuffers::FlatBufferBuilder &_fbb,
286 libtextclassifier3::PredictionType prediction_type = libtextclassifier3::PredictionType_UNSUPPORTED,
287 flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> task_spec = 0,
288 int32_t output_suggestions = 0,
289 int32_t output_suggestions_scores = 0,
290 int32_t output_suggestions_spans = 0) {
291 PredictionMetadataBuilder builder_(_fbb);
292 builder_.add_output_suggestions_spans(output_suggestions_spans);
293 builder_.add_output_suggestions_scores(output_suggestions_scores);
294 builder_.add_output_suggestions(output_suggestions);
295 builder_.add_task_spec(task_spec);
296 builder_.add_prediction_type(prediction_type);
297 return builder_.Finish();
298 }
299
300 flatbuffers::Offset<PredictionMetadata> CreatePredictionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const PredictionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
301
302 namespace TensorflowLiteModelSpec_ {
303
304 struct InputNameIndexEntryT : public flatbuffers::NativeTable {
305 typedef InputNameIndexEntry TableType;
306 std::string key{};
307 int32_t value = 0;
308 };
309
310 struct InputNameIndexEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
311 typedef InputNameIndexEntryT NativeTableType;
312 typedef InputNameIndexEntryBuilder Builder;
313 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
314 VT_KEY = 4,
315 VT_VALUE = 6
316 };
keyFLATBUFFERS_FINAL_CLASS317 const flatbuffers::String *key() const {
318 return GetPointer<const flatbuffers::String *>(VT_KEY);
319 }
KeyCompareLessThanFLATBUFFERS_FINAL_CLASS320 bool KeyCompareLessThan(const InputNameIndexEntry *o) const {
321 return *key() < *o->key();
322 }
KeyCompareWithValueFLATBUFFERS_FINAL_CLASS323 int KeyCompareWithValue(const char *_key) const {
324 return strcmp(key()->c_str(), _key);
325 }
valueFLATBUFFERS_FINAL_CLASS326 int32_t value() const {
327 return GetField<int32_t>(VT_VALUE, 0);
328 }
VerifyFLATBUFFERS_FINAL_CLASS329 bool Verify(flatbuffers::Verifier &verifier) const {
330 return VerifyTableStart(verifier) &&
331 VerifyOffsetRequired(verifier, VT_KEY) &&
332 verifier.VerifyString(key()) &&
333 VerifyField<int32_t>(verifier, VT_VALUE, 4) &&
334 verifier.EndTable();
335 }
336 InputNameIndexEntryT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
337 void UnPackTo(InputNameIndexEntryT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
338 static flatbuffers::Offset<InputNameIndexEntry> Pack(flatbuffers::FlatBufferBuilder &_fbb, const InputNameIndexEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
339 };
340
341 struct InputNameIndexEntryBuilder {
342 typedef InputNameIndexEntry Table;
343 flatbuffers::FlatBufferBuilder &fbb_;
344 flatbuffers::uoffset_t start_;
add_keyInputNameIndexEntryBuilder345 void add_key(flatbuffers::Offset<flatbuffers::String> key) {
346 fbb_.AddOffset(InputNameIndexEntry::VT_KEY, key);
347 }
add_valueInputNameIndexEntryBuilder348 void add_value(int32_t value) {
349 fbb_.AddElement<int32_t>(InputNameIndexEntry::VT_VALUE, value, 0);
350 }
InputNameIndexEntryBuilderInputNameIndexEntryBuilder351 explicit InputNameIndexEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
352 : fbb_(_fbb) {
353 start_ = fbb_.StartTable();
354 }
FinishInputNameIndexEntryBuilder355 flatbuffers::Offset<InputNameIndexEntry> Finish() {
356 const auto end = fbb_.EndTable(start_);
357 auto o = flatbuffers::Offset<InputNameIndexEntry>(end);
358 fbb_.Required(o, InputNameIndexEntry::VT_KEY);
359 return o;
360 }
361 };
362
363 inline flatbuffers::Offset<InputNameIndexEntry> CreateInputNameIndexEntry(
364 flatbuffers::FlatBufferBuilder &_fbb,
365 flatbuffers::Offset<flatbuffers::String> key = 0,
366 int32_t value = 0) {
367 InputNameIndexEntryBuilder builder_(_fbb);
368 builder_.add_value(value);
369 builder_.add_key(key);
370 return builder_.Finish();
371 }
372
373 inline flatbuffers::Offset<InputNameIndexEntry> CreateInputNameIndexEntryDirect(
374 flatbuffers::FlatBufferBuilder &_fbb,
375 const char *key = nullptr,
376 int32_t value = 0) {
377 auto key__ = key ? _fbb.CreateSharedString(key) : 0;
378 return libtextclassifier3::TensorflowLiteModelSpec_::CreateInputNameIndexEntry(
379 _fbb,
380 key__,
381 value);
382 }
383
384 flatbuffers::Offset<InputNameIndexEntry> CreateInputNameIndexEntry(flatbuffers::FlatBufferBuilder &_fbb, const InputNameIndexEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
385
386 } // namespace TensorflowLiteModelSpec_
387
388 struct TensorflowLiteModelSpecT : public flatbuffers::NativeTable {
389 typedef TensorflowLiteModelSpec TableType;
390 std::vector<uint8_t> tflite_model{};
391 int32_t input_user_id = 0;
392 int32_t input_context = 1;
393 int32_t input_context_length = 2;
394 int32_t input_time_diffs = 3;
395 int32_t input_num_suggestions = 4;
396 int32_t input_token_embeddings = -1;
397 int32_t input_num_tokens = -1;
398 int32_t output_replies = 0;
399 int32_t output_replies_scores = 1;
400 int32_t output_sensitive_topic_score = 3;
401 int32_t output_triggering_score = 4;
402 int32_t output_actions_scores = 5;
403 bool resize_inputs = false;
404 int32_t input_flattened_token_embeddings = -1;
405 std::vector<std::unique_ptr<libtextclassifier3::PredictionMetadataT>> prediction_metadata{};
406 std::vector<std::unique_ptr<libtextclassifier3::TensorflowLiteModelSpec_::InputNameIndexEntryT>> input_name_index{};
407 int32_t input_length_to_pad = 0;
408 TensorflowLiteModelSpecT() = default;
409 TensorflowLiteModelSpecT(const TensorflowLiteModelSpecT &o);
410 TensorflowLiteModelSpecT(TensorflowLiteModelSpecT&&) FLATBUFFERS_NOEXCEPT = default;
411 TensorflowLiteModelSpecT &operator=(TensorflowLiteModelSpecT o) FLATBUFFERS_NOEXCEPT;
412 };
413
414 struct TensorflowLiteModelSpec FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
415 typedef TensorflowLiteModelSpecT NativeTableType;
416 typedef TensorflowLiteModelSpecBuilder Builder;
417 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
418 VT_TFLITE_MODEL = 4,
419 VT_INPUT_USER_ID = 6,
420 VT_INPUT_CONTEXT = 8,
421 VT_INPUT_CONTEXT_LENGTH = 10,
422 VT_INPUT_TIME_DIFFS = 12,
423 VT_INPUT_NUM_SUGGESTIONS = 14,
424 VT_INPUT_TOKEN_EMBEDDINGS = 22,
425 VT_INPUT_NUM_TOKENS = 24,
426 VT_OUTPUT_REPLIES = 26,
427 VT_OUTPUT_REPLIES_SCORES = 28,
428 VT_OUTPUT_SENSITIVE_TOPIC_SCORE = 30,
429 VT_OUTPUT_TRIGGERING_SCORE = 32,
430 VT_OUTPUT_ACTIONS_SCORES = 34,
431 VT_RESIZE_INPUTS = 36,
432 VT_INPUT_FLATTENED_TOKEN_EMBEDDINGS = 38,
433 VT_PREDICTION_METADATA = 40,
434 VT_INPUT_NAME_INDEX = 42,
435 VT_INPUT_LENGTH_TO_PAD = 44
436 };
tflite_modelFLATBUFFERS_FINAL_CLASS437 const flatbuffers::Vector<uint8_t> *tflite_model() const {
438 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TFLITE_MODEL);
439 }
input_user_idFLATBUFFERS_FINAL_CLASS440 int32_t input_user_id() const {
441 return GetField<int32_t>(VT_INPUT_USER_ID, 0);
442 }
input_contextFLATBUFFERS_FINAL_CLASS443 int32_t input_context() const {
444 return GetField<int32_t>(VT_INPUT_CONTEXT, 1);
445 }
input_context_lengthFLATBUFFERS_FINAL_CLASS446 int32_t input_context_length() const {
447 return GetField<int32_t>(VT_INPUT_CONTEXT_LENGTH, 2);
448 }
input_time_diffsFLATBUFFERS_FINAL_CLASS449 int32_t input_time_diffs() const {
450 return GetField<int32_t>(VT_INPUT_TIME_DIFFS, 3);
451 }
input_num_suggestionsFLATBUFFERS_FINAL_CLASS452 int32_t input_num_suggestions() const {
453 return GetField<int32_t>(VT_INPUT_NUM_SUGGESTIONS, 4);
454 }
input_token_embeddingsFLATBUFFERS_FINAL_CLASS455 int32_t input_token_embeddings() const {
456 return GetField<int32_t>(VT_INPUT_TOKEN_EMBEDDINGS, -1);
457 }
input_num_tokensFLATBUFFERS_FINAL_CLASS458 int32_t input_num_tokens() const {
459 return GetField<int32_t>(VT_INPUT_NUM_TOKENS, -1);
460 }
output_repliesFLATBUFFERS_FINAL_CLASS461 int32_t output_replies() const {
462 return GetField<int32_t>(VT_OUTPUT_REPLIES, 0);
463 }
output_replies_scoresFLATBUFFERS_FINAL_CLASS464 int32_t output_replies_scores() const {
465 return GetField<int32_t>(VT_OUTPUT_REPLIES_SCORES, 1);
466 }
output_sensitive_topic_scoreFLATBUFFERS_FINAL_CLASS467 int32_t output_sensitive_topic_score() const {
468 return GetField<int32_t>(VT_OUTPUT_SENSITIVE_TOPIC_SCORE, 3);
469 }
output_triggering_scoreFLATBUFFERS_FINAL_CLASS470 int32_t output_triggering_score() const {
471 return GetField<int32_t>(VT_OUTPUT_TRIGGERING_SCORE, 4);
472 }
output_actions_scoresFLATBUFFERS_FINAL_CLASS473 int32_t output_actions_scores() const {
474 return GetField<int32_t>(VT_OUTPUT_ACTIONS_SCORES, 5);
475 }
resize_inputsFLATBUFFERS_FINAL_CLASS476 bool resize_inputs() const {
477 return GetField<uint8_t>(VT_RESIZE_INPUTS, 0) != 0;
478 }
input_flattened_token_embeddingsFLATBUFFERS_FINAL_CLASS479 int32_t input_flattened_token_embeddings() const {
480 return GetField<int32_t>(VT_INPUT_FLATTENED_TOKEN_EMBEDDINGS, -1);
481 }
prediction_metadataFLATBUFFERS_FINAL_CLASS482 const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::PredictionMetadata>> *prediction_metadata() const {
483 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::PredictionMetadata>> *>(VT_PREDICTION_METADATA);
484 }
input_name_indexFLATBUFFERS_FINAL_CLASS485 const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::TensorflowLiteModelSpec_::InputNameIndexEntry>> *input_name_index() const {
486 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::TensorflowLiteModelSpec_::InputNameIndexEntry>> *>(VT_INPUT_NAME_INDEX);
487 }
input_length_to_padFLATBUFFERS_FINAL_CLASS488 int32_t input_length_to_pad() const {
489 return GetField<int32_t>(VT_INPUT_LENGTH_TO_PAD, 0);
490 }
VerifyFLATBUFFERS_FINAL_CLASS491 bool Verify(flatbuffers::Verifier &verifier) const {
492 return VerifyTableStart(verifier) &&
493 VerifyOffset(verifier, VT_TFLITE_MODEL) &&
494 verifier.VerifyVector(tflite_model()) &&
495 VerifyField<int32_t>(verifier, VT_INPUT_USER_ID, 4) &&
496 VerifyField<int32_t>(verifier, VT_INPUT_CONTEXT, 4) &&
497 VerifyField<int32_t>(verifier, VT_INPUT_CONTEXT_LENGTH, 4) &&
498 VerifyField<int32_t>(verifier, VT_INPUT_TIME_DIFFS, 4) &&
499 VerifyField<int32_t>(verifier, VT_INPUT_NUM_SUGGESTIONS, 4) &&
500 VerifyField<int32_t>(verifier, VT_INPUT_TOKEN_EMBEDDINGS, 4) &&
501 VerifyField<int32_t>(verifier, VT_INPUT_NUM_TOKENS, 4) &&
502 VerifyField<int32_t>(verifier, VT_OUTPUT_REPLIES, 4) &&
503 VerifyField<int32_t>(verifier, VT_OUTPUT_REPLIES_SCORES, 4) &&
504 VerifyField<int32_t>(verifier, VT_OUTPUT_SENSITIVE_TOPIC_SCORE, 4) &&
505 VerifyField<int32_t>(verifier, VT_OUTPUT_TRIGGERING_SCORE, 4) &&
506 VerifyField<int32_t>(verifier, VT_OUTPUT_ACTIONS_SCORES, 4) &&
507 VerifyField<uint8_t>(verifier, VT_RESIZE_INPUTS, 1) &&
508 VerifyField<int32_t>(verifier, VT_INPUT_FLATTENED_TOKEN_EMBEDDINGS, 4) &&
509 VerifyOffset(verifier, VT_PREDICTION_METADATA) &&
510 verifier.VerifyVector(prediction_metadata()) &&
511 verifier.VerifyVectorOfTables(prediction_metadata()) &&
512 VerifyOffset(verifier, VT_INPUT_NAME_INDEX) &&
513 verifier.VerifyVector(input_name_index()) &&
514 verifier.VerifyVectorOfTables(input_name_index()) &&
515 VerifyField<int32_t>(verifier, VT_INPUT_LENGTH_TO_PAD, 4) &&
516 verifier.EndTable();
517 }
518 TensorflowLiteModelSpecT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
519 void UnPackTo(TensorflowLiteModelSpecT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
520 static flatbuffers::Offset<TensorflowLiteModelSpec> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorflowLiteModelSpecT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
521 };
522
523 struct TensorflowLiteModelSpecBuilder {
524 typedef TensorflowLiteModelSpec Table;
525 flatbuffers::FlatBufferBuilder &fbb_;
526 flatbuffers::uoffset_t start_;
add_tflite_modelTensorflowLiteModelSpecBuilder527 void add_tflite_model(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> tflite_model) {
528 fbb_.AddOffset(TensorflowLiteModelSpec::VT_TFLITE_MODEL, tflite_model);
529 }
add_input_user_idTensorflowLiteModelSpecBuilder530 void add_input_user_id(int32_t input_user_id) {
531 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_INPUT_USER_ID, input_user_id, 0);
532 }
add_input_contextTensorflowLiteModelSpecBuilder533 void add_input_context(int32_t input_context) {
534 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_INPUT_CONTEXT, input_context, 1);
535 }
add_input_context_lengthTensorflowLiteModelSpecBuilder536 void add_input_context_length(int32_t input_context_length) {
537 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_INPUT_CONTEXT_LENGTH, input_context_length, 2);
538 }
add_input_time_diffsTensorflowLiteModelSpecBuilder539 void add_input_time_diffs(int32_t input_time_diffs) {
540 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_INPUT_TIME_DIFFS, input_time_diffs, 3);
541 }
add_input_num_suggestionsTensorflowLiteModelSpecBuilder542 void add_input_num_suggestions(int32_t input_num_suggestions) {
543 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_INPUT_NUM_SUGGESTIONS, input_num_suggestions, 4);
544 }
add_input_token_embeddingsTensorflowLiteModelSpecBuilder545 void add_input_token_embeddings(int32_t input_token_embeddings) {
546 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_INPUT_TOKEN_EMBEDDINGS, input_token_embeddings, -1);
547 }
add_input_num_tokensTensorflowLiteModelSpecBuilder548 void add_input_num_tokens(int32_t input_num_tokens) {
549 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_INPUT_NUM_TOKENS, input_num_tokens, -1);
550 }
add_output_repliesTensorflowLiteModelSpecBuilder551 void add_output_replies(int32_t output_replies) {
552 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_OUTPUT_REPLIES, output_replies, 0);
553 }
add_output_replies_scoresTensorflowLiteModelSpecBuilder554 void add_output_replies_scores(int32_t output_replies_scores) {
555 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_OUTPUT_REPLIES_SCORES, output_replies_scores, 1);
556 }
add_output_sensitive_topic_scoreTensorflowLiteModelSpecBuilder557 void add_output_sensitive_topic_score(int32_t output_sensitive_topic_score) {
558 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_OUTPUT_SENSITIVE_TOPIC_SCORE, output_sensitive_topic_score, 3);
559 }
add_output_triggering_scoreTensorflowLiteModelSpecBuilder560 void add_output_triggering_score(int32_t output_triggering_score) {
561 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_OUTPUT_TRIGGERING_SCORE, output_triggering_score, 4);
562 }
add_output_actions_scoresTensorflowLiteModelSpecBuilder563 void add_output_actions_scores(int32_t output_actions_scores) {
564 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_OUTPUT_ACTIONS_SCORES, output_actions_scores, 5);
565 }
add_resize_inputsTensorflowLiteModelSpecBuilder566 void add_resize_inputs(bool resize_inputs) {
567 fbb_.AddElement<uint8_t>(TensorflowLiteModelSpec::VT_RESIZE_INPUTS, static_cast<uint8_t>(resize_inputs), 0);
568 }
add_input_flattened_token_embeddingsTensorflowLiteModelSpecBuilder569 void add_input_flattened_token_embeddings(int32_t input_flattened_token_embeddings) {
570 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_INPUT_FLATTENED_TOKEN_EMBEDDINGS, input_flattened_token_embeddings, -1);
571 }
add_prediction_metadataTensorflowLiteModelSpecBuilder572 void add_prediction_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::PredictionMetadata>>> prediction_metadata) {
573 fbb_.AddOffset(TensorflowLiteModelSpec::VT_PREDICTION_METADATA, prediction_metadata);
574 }
add_input_name_indexTensorflowLiteModelSpecBuilder575 void add_input_name_index(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::TensorflowLiteModelSpec_::InputNameIndexEntry>>> input_name_index) {
576 fbb_.AddOffset(TensorflowLiteModelSpec::VT_INPUT_NAME_INDEX, input_name_index);
577 }
add_input_length_to_padTensorflowLiteModelSpecBuilder578 void add_input_length_to_pad(int32_t input_length_to_pad) {
579 fbb_.AddElement<int32_t>(TensorflowLiteModelSpec::VT_INPUT_LENGTH_TO_PAD, input_length_to_pad, 0);
580 }
TensorflowLiteModelSpecBuilderTensorflowLiteModelSpecBuilder581 explicit TensorflowLiteModelSpecBuilder(flatbuffers::FlatBufferBuilder &_fbb)
582 : fbb_(_fbb) {
583 start_ = fbb_.StartTable();
584 }
FinishTensorflowLiteModelSpecBuilder585 flatbuffers::Offset<TensorflowLiteModelSpec> Finish() {
586 const auto end = fbb_.EndTable(start_);
587 auto o = flatbuffers::Offset<TensorflowLiteModelSpec>(end);
588 return o;
589 }
590 };
591
592 inline flatbuffers::Offset<TensorflowLiteModelSpec> CreateTensorflowLiteModelSpec(
593 flatbuffers::FlatBufferBuilder &_fbb,
594 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> tflite_model = 0,
595 int32_t input_user_id = 0,
596 int32_t input_context = 1,
597 int32_t input_context_length = 2,
598 int32_t input_time_diffs = 3,
599 int32_t input_num_suggestions = 4,
600 int32_t input_token_embeddings = -1,
601 int32_t input_num_tokens = -1,
602 int32_t output_replies = 0,
603 int32_t output_replies_scores = 1,
604 int32_t output_sensitive_topic_score = 3,
605 int32_t output_triggering_score = 4,
606 int32_t output_actions_scores = 5,
607 bool resize_inputs = false,
608 int32_t input_flattened_token_embeddings = -1,
609 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::PredictionMetadata>>> prediction_metadata = 0,
610 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::TensorflowLiteModelSpec_::InputNameIndexEntry>>> input_name_index = 0,
611 int32_t input_length_to_pad = 0) {
612 TensorflowLiteModelSpecBuilder builder_(_fbb);
613 builder_.add_input_length_to_pad(input_length_to_pad);
614 builder_.add_input_name_index(input_name_index);
615 builder_.add_prediction_metadata(prediction_metadata);
616 builder_.add_input_flattened_token_embeddings(input_flattened_token_embeddings);
617 builder_.add_output_actions_scores(output_actions_scores);
618 builder_.add_output_triggering_score(output_triggering_score);
619 builder_.add_output_sensitive_topic_score(output_sensitive_topic_score);
620 builder_.add_output_replies_scores(output_replies_scores);
621 builder_.add_output_replies(output_replies);
622 builder_.add_input_num_tokens(input_num_tokens);
623 builder_.add_input_token_embeddings(input_token_embeddings);
624 builder_.add_input_num_suggestions(input_num_suggestions);
625 builder_.add_input_time_diffs(input_time_diffs);
626 builder_.add_input_context_length(input_context_length);
627 builder_.add_input_context(input_context);
628 builder_.add_input_user_id(input_user_id);
629 builder_.add_tflite_model(tflite_model);
630 builder_.add_resize_inputs(resize_inputs);
631 return builder_.Finish();
632 }
633
634 inline flatbuffers::Offset<TensorflowLiteModelSpec> CreateTensorflowLiteModelSpecDirect(
635 flatbuffers::FlatBufferBuilder &_fbb,
636 const std::vector<uint8_t> *tflite_model = nullptr,
637 int32_t input_user_id = 0,
638 int32_t input_context = 1,
639 int32_t input_context_length = 2,
640 int32_t input_time_diffs = 3,
641 int32_t input_num_suggestions = 4,
642 int32_t input_token_embeddings = -1,
643 int32_t input_num_tokens = -1,
644 int32_t output_replies = 0,
645 int32_t output_replies_scores = 1,
646 int32_t output_sensitive_topic_score = 3,
647 int32_t output_triggering_score = 4,
648 int32_t output_actions_scores = 5,
649 bool resize_inputs = false,
650 int32_t input_flattened_token_embeddings = -1,
651 const std::vector<flatbuffers::Offset<libtextclassifier3::PredictionMetadata>> *prediction_metadata = nullptr,
652 std::vector<flatbuffers::Offset<libtextclassifier3::TensorflowLiteModelSpec_::InputNameIndexEntry>> *input_name_index = nullptr,
653 int32_t input_length_to_pad = 0) {
654 if (tflite_model) { _fbb.ForceVectorAlignment(tflite_model->size(), sizeof(uint8_t), 16); }
655 auto tflite_model__ = tflite_model ? _fbb.CreateVector<uint8_t>(*tflite_model) : 0;
656 auto prediction_metadata__ = prediction_metadata ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::PredictionMetadata>>(*prediction_metadata) : 0;
657 auto input_name_index__ = input_name_index ? _fbb.CreateVectorOfSortedTables<libtextclassifier3::TensorflowLiteModelSpec_::InputNameIndexEntry>(input_name_index) : 0;
658 return libtextclassifier3::CreateTensorflowLiteModelSpec(
659 _fbb,
660 tflite_model__,
661 input_user_id,
662 input_context,
663 input_context_length,
664 input_time_diffs,
665 input_num_suggestions,
666 input_token_embeddings,
667 input_num_tokens,
668 output_replies,
669 output_replies_scores,
670 output_sensitive_topic_score,
671 output_triggering_score,
672 output_actions_scores,
673 resize_inputs,
674 input_flattened_token_embeddings,
675 prediction_metadata__,
676 input_name_index__,
677 input_length_to_pad);
678 }
679
680 flatbuffers::Offset<TensorflowLiteModelSpec> CreateTensorflowLiteModelSpec(flatbuffers::FlatBufferBuilder &_fbb, const TensorflowLiteModelSpecT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
681
682 struct ActionsTokenizerOptionsT : public flatbuffers::NativeTable {
683 typedef ActionsTokenizerOptions TableType;
684 libtextclassifier3::TokenizationType type = libtextclassifier3::TokenizationType_INTERNAL_TOKENIZER;
685 bool icu_preserve_whitespace_tokens = false;
686 std::vector<std::unique_ptr<libtextclassifier3::TokenizationCodepointRangeT>> tokenization_codepoint_config{};
687 std::vector<std::unique_ptr<libtextclassifier3::CodepointRangeT>> internal_tokenizer_codepoint_ranges{};
688 bool tokenize_on_script_change = false;
689 ActionsTokenizerOptionsT() = default;
690 ActionsTokenizerOptionsT(const ActionsTokenizerOptionsT &o);
691 ActionsTokenizerOptionsT(ActionsTokenizerOptionsT&&) FLATBUFFERS_NOEXCEPT = default;
692 ActionsTokenizerOptionsT &operator=(ActionsTokenizerOptionsT o) FLATBUFFERS_NOEXCEPT;
693 };
694
695 struct ActionsTokenizerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
696 typedef ActionsTokenizerOptionsT NativeTableType;
697 typedef ActionsTokenizerOptionsBuilder Builder;
698 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
699 VT_TYPE = 4,
700 VT_ICU_PRESERVE_WHITESPACE_TOKENS = 6,
701 VT_TOKENIZATION_CODEPOINT_CONFIG = 8,
702 VT_INTERNAL_TOKENIZER_CODEPOINT_RANGES = 10,
703 VT_TOKENIZE_ON_SCRIPT_CHANGE = 12
704 };
typeFLATBUFFERS_FINAL_CLASS705 libtextclassifier3::TokenizationType type() const {
706 return static_cast<libtextclassifier3::TokenizationType>(GetField<int32_t>(VT_TYPE, 1));
707 }
icu_preserve_whitespace_tokensFLATBUFFERS_FINAL_CLASS708 bool icu_preserve_whitespace_tokens() const {
709 return GetField<uint8_t>(VT_ICU_PRESERVE_WHITESPACE_TOKENS, 0) != 0;
710 }
tokenization_codepoint_configFLATBUFFERS_FINAL_CLASS711 const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::TokenizationCodepointRange>> *tokenization_codepoint_config() const {
712 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::TokenizationCodepointRange>> *>(VT_TOKENIZATION_CODEPOINT_CONFIG);
713 }
internal_tokenizer_codepoint_rangesFLATBUFFERS_FINAL_CLASS714 const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::CodepointRange>> *internal_tokenizer_codepoint_ranges() const {
715 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::CodepointRange>> *>(VT_INTERNAL_TOKENIZER_CODEPOINT_RANGES);
716 }
tokenize_on_script_changeFLATBUFFERS_FINAL_CLASS717 bool tokenize_on_script_change() const {
718 return GetField<uint8_t>(VT_TOKENIZE_ON_SCRIPT_CHANGE, 0) != 0;
719 }
VerifyFLATBUFFERS_FINAL_CLASS720 bool Verify(flatbuffers::Verifier &verifier) const {
721 return VerifyTableStart(verifier) &&
722 VerifyField<int32_t>(verifier, VT_TYPE, 4) &&
723 VerifyField<uint8_t>(verifier, VT_ICU_PRESERVE_WHITESPACE_TOKENS, 1) &&
724 VerifyOffset(verifier, VT_TOKENIZATION_CODEPOINT_CONFIG) &&
725 verifier.VerifyVector(tokenization_codepoint_config()) &&
726 verifier.VerifyVectorOfTables(tokenization_codepoint_config()) &&
727 VerifyOffset(verifier, VT_INTERNAL_TOKENIZER_CODEPOINT_RANGES) &&
728 verifier.VerifyVector(internal_tokenizer_codepoint_ranges()) &&
729 verifier.VerifyVectorOfTables(internal_tokenizer_codepoint_ranges()) &&
730 VerifyField<uint8_t>(verifier, VT_TOKENIZE_ON_SCRIPT_CHANGE, 1) &&
731 verifier.EndTable();
732 }
733 ActionsTokenizerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
734 void UnPackTo(ActionsTokenizerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
735 static flatbuffers::Offset<ActionsTokenizerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ActionsTokenizerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
736 };
737
738 struct ActionsTokenizerOptionsBuilder {
739 typedef ActionsTokenizerOptions Table;
740 flatbuffers::FlatBufferBuilder &fbb_;
741 flatbuffers::uoffset_t start_;
add_typeActionsTokenizerOptionsBuilder742 void add_type(libtextclassifier3::TokenizationType type) {
743 fbb_.AddElement<int32_t>(ActionsTokenizerOptions::VT_TYPE, static_cast<int32_t>(type), 1);
744 }
add_icu_preserve_whitespace_tokensActionsTokenizerOptionsBuilder745 void add_icu_preserve_whitespace_tokens(bool icu_preserve_whitespace_tokens) {
746 fbb_.AddElement<uint8_t>(ActionsTokenizerOptions::VT_ICU_PRESERVE_WHITESPACE_TOKENS, static_cast<uint8_t>(icu_preserve_whitespace_tokens), 0);
747 }
add_tokenization_codepoint_configActionsTokenizerOptionsBuilder748 void add_tokenization_codepoint_config(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::TokenizationCodepointRange>>> tokenization_codepoint_config) {
749 fbb_.AddOffset(ActionsTokenizerOptions::VT_TOKENIZATION_CODEPOINT_CONFIG, tokenization_codepoint_config);
750 }
add_internal_tokenizer_codepoint_rangesActionsTokenizerOptionsBuilder751 void add_internal_tokenizer_codepoint_ranges(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::CodepointRange>>> internal_tokenizer_codepoint_ranges) {
752 fbb_.AddOffset(ActionsTokenizerOptions::VT_INTERNAL_TOKENIZER_CODEPOINT_RANGES, internal_tokenizer_codepoint_ranges);
753 }
add_tokenize_on_script_changeActionsTokenizerOptionsBuilder754 void add_tokenize_on_script_change(bool tokenize_on_script_change) {
755 fbb_.AddElement<uint8_t>(ActionsTokenizerOptions::VT_TOKENIZE_ON_SCRIPT_CHANGE, static_cast<uint8_t>(tokenize_on_script_change), 0);
756 }
ActionsTokenizerOptionsBuilderActionsTokenizerOptionsBuilder757 explicit ActionsTokenizerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
758 : fbb_(_fbb) {
759 start_ = fbb_.StartTable();
760 }
FinishActionsTokenizerOptionsBuilder761 flatbuffers::Offset<ActionsTokenizerOptions> Finish() {
762 const auto end = fbb_.EndTable(start_);
763 auto o = flatbuffers::Offset<ActionsTokenizerOptions>(end);
764 return o;
765 }
766 };
767
768 inline flatbuffers::Offset<ActionsTokenizerOptions> CreateActionsTokenizerOptions(
769 flatbuffers::FlatBufferBuilder &_fbb,
770 libtextclassifier3::TokenizationType type = libtextclassifier3::TokenizationType_INTERNAL_TOKENIZER,
771 bool icu_preserve_whitespace_tokens = false,
772 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::TokenizationCodepointRange>>> tokenization_codepoint_config = 0,
773 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::CodepointRange>>> internal_tokenizer_codepoint_ranges = 0,
774 bool tokenize_on_script_change = false) {
775 ActionsTokenizerOptionsBuilder builder_(_fbb);
776 builder_.add_internal_tokenizer_codepoint_ranges(internal_tokenizer_codepoint_ranges);
777 builder_.add_tokenization_codepoint_config(tokenization_codepoint_config);
778 builder_.add_type(type);
779 builder_.add_tokenize_on_script_change(tokenize_on_script_change);
780 builder_.add_icu_preserve_whitespace_tokens(icu_preserve_whitespace_tokens);
781 return builder_.Finish();
782 }
783
784 inline flatbuffers::Offset<ActionsTokenizerOptions> CreateActionsTokenizerOptionsDirect(
785 flatbuffers::FlatBufferBuilder &_fbb,
786 libtextclassifier3::TokenizationType type = libtextclassifier3::TokenizationType_INTERNAL_TOKENIZER,
787 bool icu_preserve_whitespace_tokens = false,
788 const std::vector<flatbuffers::Offset<libtextclassifier3::TokenizationCodepointRange>> *tokenization_codepoint_config = nullptr,
789 const std::vector<flatbuffers::Offset<libtextclassifier3::CodepointRange>> *internal_tokenizer_codepoint_ranges = nullptr,
790 bool tokenize_on_script_change = false) {
791 auto tokenization_codepoint_config__ = tokenization_codepoint_config ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::TokenizationCodepointRange>>(*tokenization_codepoint_config) : 0;
792 auto internal_tokenizer_codepoint_ranges__ = internal_tokenizer_codepoint_ranges ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::CodepointRange>>(*internal_tokenizer_codepoint_ranges) : 0;
793 return libtextclassifier3::CreateActionsTokenizerOptions(
794 _fbb,
795 type,
796 icu_preserve_whitespace_tokens,
797 tokenization_codepoint_config__,
798 internal_tokenizer_codepoint_ranges__,
799 tokenize_on_script_change);
800 }
801
802 flatbuffers::Offset<ActionsTokenizerOptions> CreateActionsTokenizerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ActionsTokenizerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
803
804 struct ActionsTokenFeatureProcessorOptionsT : public flatbuffers::NativeTable {
805 typedef ActionsTokenFeatureProcessorOptions TableType;
806 std::unique_ptr<libtextclassifier3::ActionsTokenizerOptionsT> tokenizer_options{};
807 std::vector<uint8_t> embedding_model{};
808 int32_t embedding_size = -1;
809 int32_t embedding_quantization_bits = 8;
810 int32_t num_buckets = -1;
811 std::vector<int32_t> chargram_orders{};
812 bool extract_case_feature = false;
813 bool unicode_aware_features = false;
814 std::vector<std::string> regexp_features{};
815 bool remap_digits = false;
816 bool lowercase_tokens = false;
817 int32_t max_token_length = 20;
818 int32_t max_num_tokens_per_message = -1;
819 int32_t min_num_tokens_per_message = -1;
820 int32_t max_num_total_tokens = -1;
821 int32_t min_num_total_tokens = -1;
822 int32_t padding_token_id = 0;
823 int32_t start_token_id = 1;
824 int32_t end_token_id = 2;
825 ActionsTokenFeatureProcessorOptionsT() = default;
826 ActionsTokenFeatureProcessorOptionsT(const ActionsTokenFeatureProcessorOptionsT &o);
827 ActionsTokenFeatureProcessorOptionsT(ActionsTokenFeatureProcessorOptionsT&&) FLATBUFFERS_NOEXCEPT = default;
828 ActionsTokenFeatureProcessorOptionsT &operator=(ActionsTokenFeatureProcessorOptionsT o) FLATBUFFERS_NOEXCEPT;
829 };
830
831 struct ActionsTokenFeatureProcessorOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
832 typedef ActionsTokenFeatureProcessorOptionsT NativeTableType;
833 typedef ActionsTokenFeatureProcessorOptionsBuilder Builder;
834 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
835 VT_TOKENIZER_OPTIONS = 4,
836 VT_EMBEDDING_MODEL = 6,
837 VT_EMBEDDING_SIZE = 8,
838 VT_EMBEDDING_QUANTIZATION_BITS = 10,
839 VT_NUM_BUCKETS = 12,
840 VT_CHARGRAM_ORDERS = 14,
841 VT_EXTRACT_CASE_FEATURE = 16,
842 VT_UNICODE_AWARE_FEATURES = 18,
843 VT_REGEXP_FEATURES = 20,
844 VT_REMAP_DIGITS = 22,
845 VT_LOWERCASE_TOKENS = 24,
846 VT_MAX_TOKEN_LENGTH = 26,
847 VT_MAX_NUM_TOKENS_PER_MESSAGE = 28,
848 VT_MIN_NUM_TOKENS_PER_MESSAGE = 30,
849 VT_MAX_NUM_TOTAL_TOKENS = 32,
850 VT_MIN_NUM_TOTAL_TOKENS = 34,
851 VT_PADDING_TOKEN_ID = 36,
852 VT_START_TOKEN_ID = 38,
853 VT_END_TOKEN_ID = 40
854 };
tokenizer_optionsFLATBUFFERS_FINAL_CLASS855 const libtextclassifier3::ActionsTokenizerOptions *tokenizer_options() const {
856 return GetPointer<const libtextclassifier3::ActionsTokenizerOptions *>(VT_TOKENIZER_OPTIONS);
857 }
embedding_modelFLATBUFFERS_FINAL_CLASS858 const flatbuffers::Vector<uint8_t> *embedding_model() const {
859 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EMBEDDING_MODEL);
860 }
embedding_sizeFLATBUFFERS_FINAL_CLASS861 int32_t embedding_size() const {
862 return GetField<int32_t>(VT_EMBEDDING_SIZE, -1);
863 }
embedding_quantization_bitsFLATBUFFERS_FINAL_CLASS864 int32_t embedding_quantization_bits() const {
865 return GetField<int32_t>(VT_EMBEDDING_QUANTIZATION_BITS, 8);
866 }
num_bucketsFLATBUFFERS_FINAL_CLASS867 int32_t num_buckets() const {
868 return GetField<int32_t>(VT_NUM_BUCKETS, -1);
869 }
chargram_ordersFLATBUFFERS_FINAL_CLASS870 const flatbuffers::Vector<int32_t> *chargram_orders() const {
871 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_CHARGRAM_ORDERS);
872 }
extract_case_featureFLATBUFFERS_FINAL_CLASS873 bool extract_case_feature() const {
874 return GetField<uint8_t>(VT_EXTRACT_CASE_FEATURE, 0) != 0;
875 }
unicode_aware_featuresFLATBUFFERS_FINAL_CLASS876 bool unicode_aware_features() const {
877 return GetField<uint8_t>(VT_UNICODE_AWARE_FEATURES, 0) != 0;
878 }
regexp_featuresFLATBUFFERS_FINAL_CLASS879 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *regexp_features() const {
880 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_REGEXP_FEATURES);
881 }
remap_digitsFLATBUFFERS_FINAL_CLASS882 bool remap_digits() const {
883 return GetField<uint8_t>(VT_REMAP_DIGITS, 0) != 0;
884 }
lowercase_tokensFLATBUFFERS_FINAL_CLASS885 bool lowercase_tokens() const {
886 return GetField<uint8_t>(VT_LOWERCASE_TOKENS, 0) != 0;
887 }
max_token_lengthFLATBUFFERS_FINAL_CLASS888 int32_t max_token_length() const {
889 return GetField<int32_t>(VT_MAX_TOKEN_LENGTH, 20);
890 }
max_num_tokens_per_messageFLATBUFFERS_FINAL_CLASS891 int32_t max_num_tokens_per_message() const {
892 return GetField<int32_t>(VT_MAX_NUM_TOKENS_PER_MESSAGE, -1);
893 }
min_num_tokens_per_messageFLATBUFFERS_FINAL_CLASS894 int32_t min_num_tokens_per_message() const {
895 return GetField<int32_t>(VT_MIN_NUM_TOKENS_PER_MESSAGE, -1);
896 }
max_num_total_tokensFLATBUFFERS_FINAL_CLASS897 int32_t max_num_total_tokens() const {
898 return GetField<int32_t>(VT_MAX_NUM_TOTAL_TOKENS, -1);
899 }
min_num_total_tokensFLATBUFFERS_FINAL_CLASS900 int32_t min_num_total_tokens() const {
901 return GetField<int32_t>(VT_MIN_NUM_TOTAL_TOKENS, -1);
902 }
padding_token_idFLATBUFFERS_FINAL_CLASS903 int32_t padding_token_id() const {
904 return GetField<int32_t>(VT_PADDING_TOKEN_ID, 0);
905 }
start_token_idFLATBUFFERS_FINAL_CLASS906 int32_t start_token_id() const {
907 return GetField<int32_t>(VT_START_TOKEN_ID, 1);
908 }
end_token_idFLATBUFFERS_FINAL_CLASS909 int32_t end_token_id() const {
910 return GetField<int32_t>(VT_END_TOKEN_ID, 2);
911 }
VerifyFLATBUFFERS_FINAL_CLASS912 bool Verify(flatbuffers::Verifier &verifier) const {
913 return VerifyTableStart(verifier) &&
914 VerifyOffset(verifier, VT_TOKENIZER_OPTIONS) &&
915 verifier.VerifyTable(tokenizer_options()) &&
916 VerifyOffset(verifier, VT_EMBEDDING_MODEL) &&
917 verifier.VerifyVector(embedding_model()) &&
918 VerifyField<int32_t>(verifier, VT_EMBEDDING_SIZE, 4) &&
919 VerifyField<int32_t>(verifier, VT_EMBEDDING_QUANTIZATION_BITS, 4) &&
920 VerifyField<int32_t>(verifier, VT_NUM_BUCKETS, 4) &&
921 VerifyOffset(verifier, VT_CHARGRAM_ORDERS) &&
922 verifier.VerifyVector(chargram_orders()) &&
923 VerifyField<uint8_t>(verifier, VT_EXTRACT_CASE_FEATURE, 1) &&
924 VerifyField<uint8_t>(verifier, VT_UNICODE_AWARE_FEATURES, 1) &&
925 VerifyOffset(verifier, VT_REGEXP_FEATURES) &&
926 verifier.VerifyVector(regexp_features()) &&
927 verifier.VerifyVectorOfStrings(regexp_features()) &&
928 VerifyField<uint8_t>(verifier, VT_REMAP_DIGITS, 1) &&
929 VerifyField<uint8_t>(verifier, VT_LOWERCASE_TOKENS, 1) &&
930 VerifyField<int32_t>(verifier, VT_MAX_TOKEN_LENGTH, 4) &&
931 VerifyField<int32_t>(verifier, VT_MAX_NUM_TOKENS_PER_MESSAGE, 4) &&
932 VerifyField<int32_t>(verifier, VT_MIN_NUM_TOKENS_PER_MESSAGE, 4) &&
933 VerifyField<int32_t>(verifier, VT_MAX_NUM_TOTAL_TOKENS, 4) &&
934 VerifyField<int32_t>(verifier, VT_MIN_NUM_TOTAL_TOKENS, 4) &&
935 VerifyField<int32_t>(verifier, VT_PADDING_TOKEN_ID, 4) &&
936 VerifyField<int32_t>(verifier, VT_START_TOKEN_ID, 4) &&
937 VerifyField<int32_t>(verifier, VT_END_TOKEN_ID, 4) &&
938 verifier.EndTable();
939 }
940 ActionsTokenFeatureProcessorOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
941 void UnPackTo(ActionsTokenFeatureProcessorOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
942 static flatbuffers::Offset<ActionsTokenFeatureProcessorOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ActionsTokenFeatureProcessorOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
943 };
944
945 struct ActionsTokenFeatureProcessorOptionsBuilder {
946 typedef ActionsTokenFeatureProcessorOptions Table;
947 flatbuffers::FlatBufferBuilder &fbb_;
948 flatbuffers::uoffset_t start_;
add_tokenizer_optionsActionsTokenFeatureProcessorOptionsBuilder949 void add_tokenizer_options(flatbuffers::Offset<libtextclassifier3::ActionsTokenizerOptions> tokenizer_options) {
950 fbb_.AddOffset(ActionsTokenFeatureProcessorOptions::VT_TOKENIZER_OPTIONS, tokenizer_options);
951 }
add_embedding_modelActionsTokenFeatureProcessorOptionsBuilder952 void add_embedding_model(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> embedding_model) {
953 fbb_.AddOffset(ActionsTokenFeatureProcessorOptions::VT_EMBEDDING_MODEL, embedding_model);
954 }
add_embedding_sizeActionsTokenFeatureProcessorOptionsBuilder955 void add_embedding_size(int32_t embedding_size) {
956 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_EMBEDDING_SIZE, embedding_size, -1);
957 }
add_embedding_quantization_bitsActionsTokenFeatureProcessorOptionsBuilder958 void add_embedding_quantization_bits(int32_t embedding_quantization_bits) {
959 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_EMBEDDING_QUANTIZATION_BITS, embedding_quantization_bits, 8);
960 }
add_num_bucketsActionsTokenFeatureProcessorOptionsBuilder961 void add_num_buckets(int32_t num_buckets) {
962 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_NUM_BUCKETS, num_buckets, -1);
963 }
add_chargram_ordersActionsTokenFeatureProcessorOptionsBuilder964 void add_chargram_orders(flatbuffers::Offset<flatbuffers::Vector<int32_t>> chargram_orders) {
965 fbb_.AddOffset(ActionsTokenFeatureProcessorOptions::VT_CHARGRAM_ORDERS, chargram_orders);
966 }
add_extract_case_featureActionsTokenFeatureProcessorOptionsBuilder967 void add_extract_case_feature(bool extract_case_feature) {
968 fbb_.AddElement<uint8_t>(ActionsTokenFeatureProcessorOptions::VT_EXTRACT_CASE_FEATURE, static_cast<uint8_t>(extract_case_feature), 0);
969 }
add_unicode_aware_featuresActionsTokenFeatureProcessorOptionsBuilder970 void add_unicode_aware_features(bool unicode_aware_features) {
971 fbb_.AddElement<uint8_t>(ActionsTokenFeatureProcessorOptions::VT_UNICODE_AWARE_FEATURES, static_cast<uint8_t>(unicode_aware_features), 0);
972 }
add_regexp_featuresActionsTokenFeatureProcessorOptionsBuilder973 void add_regexp_features(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> regexp_features) {
974 fbb_.AddOffset(ActionsTokenFeatureProcessorOptions::VT_REGEXP_FEATURES, regexp_features);
975 }
add_remap_digitsActionsTokenFeatureProcessorOptionsBuilder976 void add_remap_digits(bool remap_digits) {
977 fbb_.AddElement<uint8_t>(ActionsTokenFeatureProcessorOptions::VT_REMAP_DIGITS, static_cast<uint8_t>(remap_digits), 0);
978 }
add_lowercase_tokensActionsTokenFeatureProcessorOptionsBuilder979 void add_lowercase_tokens(bool lowercase_tokens) {
980 fbb_.AddElement<uint8_t>(ActionsTokenFeatureProcessorOptions::VT_LOWERCASE_TOKENS, static_cast<uint8_t>(lowercase_tokens), 0);
981 }
add_max_token_lengthActionsTokenFeatureProcessorOptionsBuilder982 void add_max_token_length(int32_t max_token_length) {
983 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_MAX_TOKEN_LENGTH, max_token_length, 20);
984 }
add_max_num_tokens_per_messageActionsTokenFeatureProcessorOptionsBuilder985 void add_max_num_tokens_per_message(int32_t max_num_tokens_per_message) {
986 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_MAX_NUM_TOKENS_PER_MESSAGE, max_num_tokens_per_message, -1);
987 }
add_min_num_tokens_per_messageActionsTokenFeatureProcessorOptionsBuilder988 void add_min_num_tokens_per_message(int32_t min_num_tokens_per_message) {
989 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_MIN_NUM_TOKENS_PER_MESSAGE, min_num_tokens_per_message, -1);
990 }
add_max_num_total_tokensActionsTokenFeatureProcessorOptionsBuilder991 void add_max_num_total_tokens(int32_t max_num_total_tokens) {
992 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_MAX_NUM_TOTAL_TOKENS, max_num_total_tokens, -1);
993 }
add_min_num_total_tokensActionsTokenFeatureProcessorOptionsBuilder994 void add_min_num_total_tokens(int32_t min_num_total_tokens) {
995 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_MIN_NUM_TOTAL_TOKENS, min_num_total_tokens, -1);
996 }
add_padding_token_idActionsTokenFeatureProcessorOptionsBuilder997 void add_padding_token_id(int32_t padding_token_id) {
998 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_PADDING_TOKEN_ID, padding_token_id, 0);
999 }
add_start_token_idActionsTokenFeatureProcessorOptionsBuilder1000 void add_start_token_id(int32_t start_token_id) {
1001 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_START_TOKEN_ID, start_token_id, 1);
1002 }
add_end_token_idActionsTokenFeatureProcessorOptionsBuilder1003 void add_end_token_id(int32_t end_token_id) {
1004 fbb_.AddElement<int32_t>(ActionsTokenFeatureProcessorOptions::VT_END_TOKEN_ID, end_token_id, 2);
1005 }
ActionsTokenFeatureProcessorOptionsBuilderActionsTokenFeatureProcessorOptionsBuilder1006 explicit ActionsTokenFeatureProcessorOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1007 : fbb_(_fbb) {
1008 start_ = fbb_.StartTable();
1009 }
FinishActionsTokenFeatureProcessorOptionsBuilder1010 flatbuffers::Offset<ActionsTokenFeatureProcessorOptions> Finish() {
1011 const auto end = fbb_.EndTable(start_);
1012 auto o = flatbuffers::Offset<ActionsTokenFeatureProcessorOptions>(end);
1013 return o;
1014 }
1015 };
1016
1017 inline flatbuffers::Offset<ActionsTokenFeatureProcessorOptions> CreateActionsTokenFeatureProcessorOptions(
1018 flatbuffers::FlatBufferBuilder &_fbb,
1019 flatbuffers::Offset<libtextclassifier3::ActionsTokenizerOptions> tokenizer_options = 0,
1020 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> embedding_model = 0,
1021 int32_t embedding_size = -1,
1022 int32_t embedding_quantization_bits = 8,
1023 int32_t num_buckets = -1,
1024 flatbuffers::Offset<flatbuffers::Vector<int32_t>> chargram_orders = 0,
1025 bool extract_case_feature = false,
1026 bool unicode_aware_features = false,
1027 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> regexp_features = 0,
1028 bool remap_digits = false,
1029 bool lowercase_tokens = false,
1030 int32_t max_token_length = 20,
1031 int32_t max_num_tokens_per_message = -1,
1032 int32_t min_num_tokens_per_message = -1,
1033 int32_t max_num_total_tokens = -1,
1034 int32_t min_num_total_tokens = -1,
1035 int32_t padding_token_id = 0,
1036 int32_t start_token_id = 1,
1037 int32_t end_token_id = 2) {
1038 ActionsTokenFeatureProcessorOptionsBuilder builder_(_fbb);
1039 builder_.add_end_token_id(end_token_id);
1040 builder_.add_start_token_id(start_token_id);
1041 builder_.add_padding_token_id(padding_token_id);
1042 builder_.add_min_num_total_tokens(min_num_total_tokens);
1043 builder_.add_max_num_total_tokens(max_num_total_tokens);
1044 builder_.add_min_num_tokens_per_message(min_num_tokens_per_message);
1045 builder_.add_max_num_tokens_per_message(max_num_tokens_per_message);
1046 builder_.add_max_token_length(max_token_length);
1047 builder_.add_regexp_features(regexp_features);
1048 builder_.add_chargram_orders(chargram_orders);
1049 builder_.add_num_buckets(num_buckets);
1050 builder_.add_embedding_quantization_bits(embedding_quantization_bits);
1051 builder_.add_embedding_size(embedding_size);
1052 builder_.add_embedding_model(embedding_model);
1053 builder_.add_tokenizer_options(tokenizer_options);
1054 builder_.add_lowercase_tokens(lowercase_tokens);
1055 builder_.add_remap_digits(remap_digits);
1056 builder_.add_unicode_aware_features(unicode_aware_features);
1057 builder_.add_extract_case_feature(extract_case_feature);
1058 return builder_.Finish();
1059 }
1060
1061 inline flatbuffers::Offset<ActionsTokenFeatureProcessorOptions> CreateActionsTokenFeatureProcessorOptionsDirect(
1062 flatbuffers::FlatBufferBuilder &_fbb,
1063 flatbuffers::Offset<libtextclassifier3::ActionsTokenizerOptions> tokenizer_options = 0,
1064 const std::vector<uint8_t> *embedding_model = nullptr,
1065 int32_t embedding_size = -1,
1066 int32_t embedding_quantization_bits = 8,
1067 int32_t num_buckets = -1,
1068 const std::vector<int32_t> *chargram_orders = nullptr,
1069 bool extract_case_feature = false,
1070 bool unicode_aware_features = false,
1071 const std::vector<flatbuffers::Offset<flatbuffers::String>> *regexp_features = nullptr,
1072 bool remap_digits = false,
1073 bool lowercase_tokens = false,
1074 int32_t max_token_length = 20,
1075 int32_t max_num_tokens_per_message = -1,
1076 int32_t min_num_tokens_per_message = -1,
1077 int32_t max_num_total_tokens = -1,
1078 int32_t min_num_total_tokens = -1,
1079 int32_t padding_token_id = 0,
1080 int32_t start_token_id = 1,
1081 int32_t end_token_id = 2) {
1082 if (embedding_model) { _fbb.ForceVectorAlignment(embedding_model->size(), sizeof(uint8_t), 16); }
1083 auto embedding_model__ = embedding_model ? _fbb.CreateVector<uint8_t>(*embedding_model) : 0;
1084 auto chargram_orders__ = chargram_orders ? _fbb.CreateVector<int32_t>(*chargram_orders) : 0;
1085 auto regexp_features__ = regexp_features ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*regexp_features) : 0;
1086 return libtextclassifier3::CreateActionsTokenFeatureProcessorOptions(
1087 _fbb,
1088 tokenizer_options,
1089 embedding_model__,
1090 embedding_size,
1091 embedding_quantization_bits,
1092 num_buckets,
1093 chargram_orders__,
1094 extract_case_feature,
1095 unicode_aware_features,
1096 regexp_features__,
1097 remap_digits,
1098 lowercase_tokens,
1099 max_token_length,
1100 max_num_tokens_per_message,
1101 min_num_tokens_per_message,
1102 max_num_total_tokens,
1103 min_num_total_tokens,
1104 padding_token_id,
1105 start_token_id,
1106 end_token_id);
1107 }
1108
1109 flatbuffers::Offset<ActionsTokenFeatureProcessorOptions> CreateActionsTokenFeatureProcessorOptions(flatbuffers::FlatBufferBuilder &_fbb, const ActionsTokenFeatureProcessorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1110
1111 struct NGramLinearRegressionModelT : public flatbuffers::NativeTable {
1112 typedef NGramLinearRegressionModel TableType;
1113 std::vector<uint32_t> hashed_ngram_tokens{};
1114 std::vector<uint16_t> ngram_start_offsets{};
1115 std::vector<float> ngram_weights{};
1116 float default_token_weight = 0.0f;
1117 int32_t max_denom_ngram_length = 0;
1118 int32_t max_skips = 0;
1119 float threshold = 0.0f;
1120 std::unique_ptr<libtextclassifier3::ActionsTokenizerOptionsT> tokenizer_options{};
1121 NGramLinearRegressionModelT() = default;
1122 NGramLinearRegressionModelT(const NGramLinearRegressionModelT &o);
1123 NGramLinearRegressionModelT(NGramLinearRegressionModelT&&) FLATBUFFERS_NOEXCEPT = default;
1124 NGramLinearRegressionModelT &operator=(NGramLinearRegressionModelT o) FLATBUFFERS_NOEXCEPT;
1125 };
1126
1127 struct NGramLinearRegressionModel FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1128 typedef NGramLinearRegressionModelT NativeTableType;
1129 typedef NGramLinearRegressionModelBuilder Builder;
1130 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1131 VT_HASHED_NGRAM_TOKENS = 4,
1132 VT_NGRAM_START_OFFSETS = 6,
1133 VT_NGRAM_WEIGHTS = 8,
1134 VT_DEFAULT_TOKEN_WEIGHT = 10,
1135 VT_MAX_DENOM_NGRAM_LENGTH = 12,
1136 VT_MAX_SKIPS = 14,
1137 VT_THRESHOLD = 16,
1138 VT_TOKENIZER_OPTIONS = 18
1139 };
hashed_ngram_tokensFLATBUFFERS_FINAL_CLASS1140 const flatbuffers::Vector<uint32_t> *hashed_ngram_tokens() const {
1141 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_HASHED_NGRAM_TOKENS);
1142 }
ngram_start_offsetsFLATBUFFERS_FINAL_CLASS1143 const flatbuffers::Vector<uint16_t> *ngram_start_offsets() const {
1144 return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_NGRAM_START_OFFSETS);
1145 }
ngram_weightsFLATBUFFERS_FINAL_CLASS1146 const flatbuffers::Vector<float> *ngram_weights() const {
1147 return GetPointer<const flatbuffers::Vector<float> *>(VT_NGRAM_WEIGHTS);
1148 }
default_token_weightFLATBUFFERS_FINAL_CLASS1149 float default_token_weight() const {
1150 return GetField<float>(VT_DEFAULT_TOKEN_WEIGHT, 0.0f);
1151 }
max_denom_ngram_lengthFLATBUFFERS_FINAL_CLASS1152 int32_t max_denom_ngram_length() const {
1153 return GetField<int32_t>(VT_MAX_DENOM_NGRAM_LENGTH, 0);
1154 }
max_skipsFLATBUFFERS_FINAL_CLASS1155 int32_t max_skips() const {
1156 return GetField<int32_t>(VT_MAX_SKIPS, 0);
1157 }
thresholdFLATBUFFERS_FINAL_CLASS1158 float threshold() const {
1159 return GetField<float>(VT_THRESHOLD, 0.0f);
1160 }
tokenizer_optionsFLATBUFFERS_FINAL_CLASS1161 const libtextclassifier3::ActionsTokenizerOptions *tokenizer_options() const {
1162 return GetPointer<const libtextclassifier3::ActionsTokenizerOptions *>(VT_TOKENIZER_OPTIONS);
1163 }
VerifyFLATBUFFERS_FINAL_CLASS1164 bool Verify(flatbuffers::Verifier &verifier) const {
1165 return VerifyTableStart(verifier) &&
1166 VerifyOffset(verifier, VT_HASHED_NGRAM_TOKENS) &&
1167 verifier.VerifyVector(hashed_ngram_tokens()) &&
1168 VerifyOffset(verifier, VT_NGRAM_START_OFFSETS) &&
1169 verifier.VerifyVector(ngram_start_offsets()) &&
1170 VerifyOffset(verifier, VT_NGRAM_WEIGHTS) &&
1171 verifier.VerifyVector(ngram_weights()) &&
1172 VerifyField<float>(verifier, VT_DEFAULT_TOKEN_WEIGHT, 4) &&
1173 VerifyField<int32_t>(verifier, VT_MAX_DENOM_NGRAM_LENGTH, 4) &&
1174 VerifyField<int32_t>(verifier, VT_MAX_SKIPS, 4) &&
1175 VerifyField<float>(verifier, VT_THRESHOLD, 4) &&
1176 VerifyOffset(verifier, VT_TOKENIZER_OPTIONS) &&
1177 verifier.VerifyTable(tokenizer_options()) &&
1178 verifier.EndTable();
1179 }
1180 NGramLinearRegressionModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1181 void UnPackTo(NGramLinearRegressionModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1182 static flatbuffers::Offset<NGramLinearRegressionModel> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NGramLinearRegressionModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1183 };
1184
1185 struct NGramLinearRegressionModelBuilder {
1186 typedef NGramLinearRegressionModel Table;
1187 flatbuffers::FlatBufferBuilder &fbb_;
1188 flatbuffers::uoffset_t start_;
add_hashed_ngram_tokensNGramLinearRegressionModelBuilder1189 void add_hashed_ngram_tokens(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> hashed_ngram_tokens) {
1190 fbb_.AddOffset(NGramLinearRegressionModel::VT_HASHED_NGRAM_TOKENS, hashed_ngram_tokens);
1191 }
add_ngram_start_offsetsNGramLinearRegressionModelBuilder1192 void add_ngram_start_offsets(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> ngram_start_offsets) {
1193 fbb_.AddOffset(NGramLinearRegressionModel::VT_NGRAM_START_OFFSETS, ngram_start_offsets);
1194 }
add_ngram_weightsNGramLinearRegressionModelBuilder1195 void add_ngram_weights(flatbuffers::Offset<flatbuffers::Vector<float>> ngram_weights) {
1196 fbb_.AddOffset(NGramLinearRegressionModel::VT_NGRAM_WEIGHTS, ngram_weights);
1197 }
add_default_token_weightNGramLinearRegressionModelBuilder1198 void add_default_token_weight(float default_token_weight) {
1199 fbb_.AddElement<float>(NGramLinearRegressionModel::VT_DEFAULT_TOKEN_WEIGHT, default_token_weight, 0.0f);
1200 }
add_max_denom_ngram_lengthNGramLinearRegressionModelBuilder1201 void add_max_denom_ngram_length(int32_t max_denom_ngram_length) {
1202 fbb_.AddElement<int32_t>(NGramLinearRegressionModel::VT_MAX_DENOM_NGRAM_LENGTH, max_denom_ngram_length, 0);
1203 }
add_max_skipsNGramLinearRegressionModelBuilder1204 void add_max_skips(int32_t max_skips) {
1205 fbb_.AddElement<int32_t>(NGramLinearRegressionModel::VT_MAX_SKIPS, max_skips, 0);
1206 }
add_thresholdNGramLinearRegressionModelBuilder1207 void add_threshold(float threshold) {
1208 fbb_.AddElement<float>(NGramLinearRegressionModel::VT_THRESHOLD, threshold, 0.0f);
1209 }
add_tokenizer_optionsNGramLinearRegressionModelBuilder1210 void add_tokenizer_options(flatbuffers::Offset<libtextclassifier3::ActionsTokenizerOptions> tokenizer_options) {
1211 fbb_.AddOffset(NGramLinearRegressionModel::VT_TOKENIZER_OPTIONS, tokenizer_options);
1212 }
NGramLinearRegressionModelBuilderNGramLinearRegressionModelBuilder1213 explicit NGramLinearRegressionModelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1214 : fbb_(_fbb) {
1215 start_ = fbb_.StartTable();
1216 }
FinishNGramLinearRegressionModelBuilder1217 flatbuffers::Offset<NGramLinearRegressionModel> Finish() {
1218 const auto end = fbb_.EndTable(start_);
1219 auto o = flatbuffers::Offset<NGramLinearRegressionModel>(end);
1220 return o;
1221 }
1222 };
1223
1224 inline flatbuffers::Offset<NGramLinearRegressionModel> CreateNGramLinearRegressionModel(
1225 flatbuffers::FlatBufferBuilder &_fbb,
1226 flatbuffers::Offset<flatbuffers::Vector<uint32_t>> hashed_ngram_tokens = 0,
1227 flatbuffers::Offset<flatbuffers::Vector<uint16_t>> ngram_start_offsets = 0,
1228 flatbuffers::Offset<flatbuffers::Vector<float>> ngram_weights = 0,
1229 float default_token_weight = 0.0f,
1230 int32_t max_denom_ngram_length = 0,
1231 int32_t max_skips = 0,
1232 float threshold = 0.0f,
1233 flatbuffers::Offset<libtextclassifier3::ActionsTokenizerOptions> tokenizer_options = 0) {
1234 NGramLinearRegressionModelBuilder builder_(_fbb);
1235 builder_.add_tokenizer_options(tokenizer_options);
1236 builder_.add_threshold(threshold);
1237 builder_.add_max_skips(max_skips);
1238 builder_.add_max_denom_ngram_length(max_denom_ngram_length);
1239 builder_.add_default_token_weight(default_token_weight);
1240 builder_.add_ngram_weights(ngram_weights);
1241 builder_.add_ngram_start_offsets(ngram_start_offsets);
1242 builder_.add_hashed_ngram_tokens(hashed_ngram_tokens);
1243 return builder_.Finish();
1244 }
1245
1246 inline flatbuffers::Offset<NGramLinearRegressionModel> CreateNGramLinearRegressionModelDirect(
1247 flatbuffers::FlatBufferBuilder &_fbb,
1248 const std::vector<uint32_t> *hashed_ngram_tokens = nullptr,
1249 const std::vector<uint16_t> *ngram_start_offsets = nullptr,
1250 const std::vector<float> *ngram_weights = nullptr,
1251 float default_token_weight = 0.0f,
1252 int32_t max_denom_ngram_length = 0,
1253 int32_t max_skips = 0,
1254 float threshold = 0.0f,
1255 flatbuffers::Offset<libtextclassifier3::ActionsTokenizerOptions> tokenizer_options = 0) {
1256 auto hashed_ngram_tokens__ = hashed_ngram_tokens ? _fbb.CreateVector<uint32_t>(*hashed_ngram_tokens) : 0;
1257 auto ngram_start_offsets__ = ngram_start_offsets ? _fbb.CreateVector<uint16_t>(*ngram_start_offsets) : 0;
1258 auto ngram_weights__ = ngram_weights ? _fbb.CreateVector<float>(*ngram_weights) : 0;
1259 return libtextclassifier3::CreateNGramLinearRegressionModel(
1260 _fbb,
1261 hashed_ngram_tokens__,
1262 ngram_start_offsets__,
1263 ngram_weights__,
1264 default_token_weight,
1265 max_denom_ngram_length,
1266 max_skips,
1267 threshold,
1268 tokenizer_options);
1269 }
1270
1271 flatbuffers::Offset<NGramLinearRegressionModel> CreateNGramLinearRegressionModel(flatbuffers::FlatBufferBuilder &_fbb, const NGramLinearRegressionModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1272
1273 struct TFLiteSensitiveClassifierConfigT : public flatbuffers::NativeTable {
1274 typedef TFLiteSensitiveClassifierConfig TableType;
1275 std::unique_ptr<libtextclassifier3::TensorflowLiteModelSpecT> model_spec{};
1276 float threshold = 0.0f;
1277 TFLiteSensitiveClassifierConfigT() = default;
1278 TFLiteSensitiveClassifierConfigT(const TFLiteSensitiveClassifierConfigT &o);
1279 TFLiteSensitiveClassifierConfigT(TFLiteSensitiveClassifierConfigT&&) FLATBUFFERS_NOEXCEPT = default;
1280 TFLiteSensitiveClassifierConfigT &operator=(TFLiteSensitiveClassifierConfigT o) FLATBUFFERS_NOEXCEPT;
1281 };
1282
1283 struct TFLiteSensitiveClassifierConfig FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1284 typedef TFLiteSensitiveClassifierConfigT NativeTableType;
1285 typedef TFLiteSensitiveClassifierConfigBuilder Builder;
1286 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1287 VT_MODEL_SPEC = 4,
1288 VT_THRESHOLD = 6
1289 };
model_specFLATBUFFERS_FINAL_CLASS1290 const libtextclassifier3::TensorflowLiteModelSpec *model_spec() const {
1291 return GetPointer<const libtextclassifier3::TensorflowLiteModelSpec *>(VT_MODEL_SPEC);
1292 }
thresholdFLATBUFFERS_FINAL_CLASS1293 float threshold() const {
1294 return GetField<float>(VT_THRESHOLD, 0.0f);
1295 }
VerifyFLATBUFFERS_FINAL_CLASS1296 bool Verify(flatbuffers::Verifier &verifier) const {
1297 return VerifyTableStart(verifier) &&
1298 VerifyOffset(verifier, VT_MODEL_SPEC) &&
1299 verifier.VerifyTable(model_spec()) &&
1300 VerifyField<float>(verifier, VT_THRESHOLD, 4) &&
1301 verifier.EndTable();
1302 }
1303 TFLiteSensitiveClassifierConfigT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1304 void UnPackTo(TFLiteSensitiveClassifierConfigT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1305 static flatbuffers::Offset<TFLiteSensitiveClassifierConfig> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TFLiteSensitiveClassifierConfigT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1306 };
1307
1308 struct TFLiteSensitiveClassifierConfigBuilder {
1309 typedef TFLiteSensitiveClassifierConfig Table;
1310 flatbuffers::FlatBufferBuilder &fbb_;
1311 flatbuffers::uoffset_t start_;
add_model_specTFLiteSensitiveClassifierConfigBuilder1312 void add_model_spec(flatbuffers::Offset<libtextclassifier3::TensorflowLiteModelSpec> model_spec) {
1313 fbb_.AddOffset(TFLiteSensitiveClassifierConfig::VT_MODEL_SPEC, model_spec);
1314 }
add_thresholdTFLiteSensitiveClassifierConfigBuilder1315 void add_threshold(float threshold) {
1316 fbb_.AddElement<float>(TFLiteSensitiveClassifierConfig::VT_THRESHOLD, threshold, 0.0f);
1317 }
TFLiteSensitiveClassifierConfigBuilderTFLiteSensitiveClassifierConfigBuilder1318 explicit TFLiteSensitiveClassifierConfigBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1319 : fbb_(_fbb) {
1320 start_ = fbb_.StartTable();
1321 }
FinishTFLiteSensitiveClassifierConfigBuilder1322 flatbuffers::Offset<TFLiteSensitiveClassifierConfig> Finish() {
1323 const auto end = fbb_.EndTable(start_);
1324 auto o = flatbuffers::Offset<TFLiteSensitiveClassifierConfig>(end);
1325 return o;
1326 }
1327 };
1328
1329 inline flatbuffers::Offset<TFLiteSensitiveClassifierConfig> CreateTFLiteSensitiveClassifierConfig(
1330 flatbuffers::FlatBufferBuilder &_fbb,
1331 flatbuffers::Offset<libtextclassifier3::TensorflowLiteModelSpec> model_spec = 0,
1332 float threshold = 0.0f) {
1333 TFLiteSensitiveClassifierConfigBuilder builder_(_fbb);
1334 builder_.add_threshold(threshold);
1335 builder_.add_model_spec(model_spec);
1336 return builder_.Finish();
1337 }
1338
1339 flatbuffers::Offset<TFLiteSensitiveClassifierConfig> CreateTFLiteSensitiveClassifierConfig(flatbuffers::FlatBufferBuilder &_fbb, const TFLiteSensitiveClassifierConfigT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1340
1341 struct TriggeringPreconditionsT : public flatbuffers::NativeTable {
1342 typedef TriggeringPreconditions TableType;
1343 float min_smart_reply_triggering_score = 0.0f;
1344 float max_sensitive_topic_score = 1.0f;
1345 bool suppress_on_sensitive_topic = true;
1346 int32_t min_input_length = 0;
1347 int32_t max_input_length = -1;
1348 float min_locale_match_fraction = 0.75f;
1349 bool handle_missing_locale_as_supported = false;
1350 bool handle_unknown_locale_as_supported = false;
1351 bool suppress_on_low_confidence_input = true;
1352 std::unique_ptr<libtextclassifier3::RulesModelT> low_confidence_rules{};
1353 float min_reply_score_threshold = 0.0f;
1354 TriggeringPreconditionsT() = default;
1355 TriggeringPreconditionsT(const TriggeringPreconditionsT &o);
1356 TriggeringPreconditionsT(TriggeringPreconditionsT&&) FLATBUFFERS_NOEXCEPT = default;
1357 TriggeringPreconditionsT &operator=(TriggeringPreconditionsT o) FLATBUFFERS_NOEXCEPT;
1358 };
1359
1360 struct TriggeringPreconditions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1361 typedef TriggeringPreconditionsT NativeTableType;
1362 typedef TriggeringPreconditionsBuilder Builder;
1363 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1364 VT_MIN_SMART_REPLY_TRIGGERING_SCORE = 4,
1365 VT_MAX_SENSITIVE_TOPIC_SCORE = 6,
1366 VT_SUPPRESS_ON_SENSITIVE_TOPIC = 8,
1367 VT_MIN_INPUT_LENGTH = 10,
1368 VT_MAX_INPUT_LENGTH = 12,
1369 VT_MIN_LOCALE_MATCH_FRACTION = 14,
1370 VT_HANDLE_MISSING_LOCALE_AS_SUPPORTED = 16,
1371 VT_HANDLE_UNKNOWN_LOCALE_AS_SUPPORTED = 18,
1372 VT_SUPPRESS_ON_LOW_CONFIDENCE_INPUT = 20,
1373 VT_LOW_CONFIDENCE_RULES = 22,
1374 VT_MIN_REPLY_SCORE_THRESHOLD = 30
1375 };
min_smart_reply_triggering_scoreFLATBUFFERS_FINAL_CLASS1376 float min_smart_reply_triggering_score() const {
1377 return GetField<float>(VT_MIN_SMART_REPLY_TRIGGERING_SCORE, 0.0f);
1378 }
max_sensitive_topic_scoreFLATBUFFERS_FINAL_CLASS1379 float max_sensitive_topic_score() const {
1380 return GetField<float>(VT_MAX_SENSITIVE_TOPIC_SCORE, 1.0f);
1381 }
suppress_on_sensitive_topicFLATBUFFERS_FINAL_CLASS1382 bool suppress_on_sensitive_topic() const {
1383 return GetField<uint8_t>(VT_SUPPRESS_ON_SENSITIVE_TOPIC, 1) != 0;
1384 }
min_input_lengthFLATBUFFERS_FINAL_CLASS1385 int32_t min_input_length() const {
1386 return GetField<int32_t>(VT_MIN_INPUT_LENGTH, 0);
1387 }
max_input_lengthFLATBUFFERS_FINAL_CLASS1388 int32_t max_input_length() const {
1389 return GetField<int32_t>(VT_MAX_INPUT_LENGTH, -1);
1390 }
min_locale_match_fractionFLATBUFFERS_FINAL_CLASS1391 float min_locale_match_fraction() const {
1392 return GetField<float>(VT_MIN_LOCALE_MATCH_FRACTION, 0.75f);
1393 }
handle_missing_locale_as_supportedFLATBUFFERS_FINAL_CLASS1394 bool handle_missing_locale_as_supported() const {
1395 return GetField<uint8_t>(VT_HANDLE_MISSING_LOCALE_AS_SUPPORTED, 0) != 0;
1396 }
handle_unknown_locale_as_supportedFLATBUFFERS_FINAL_CLASS1397 bool handle_unknown_locale_as_supported() const {
1398 return GetField<uint8_t>(VT_HANDLE_UNKNOWN_LOCALE_AS_SUPPORTED, 0) != 0;
1399 }
suppress_on_low_confidence_inputFLATBUFFERS_FINAL_CLASS1400 bool suppress_on_low_confidence_input() const {
1401 return GetField<uint8_t>(VT_SUPPRESS_ON_LOW_CONFIDENCE_INPUT, 1) != 0;
1402 }
low_confidence_rulesFLATBUFFERS_FINAL_CLASS1403 const libtextclassifier3::RulesModel *low_confidence_rules() const {
1404 return GetPointer<const libtextclassifier3::RulesModel *>(VT_LOW_CONFIDENCE_RULES);
1405 }
min_reply_score_thresholdFLATBUFFERS_FINAL_CLASS1406 float min_reply_score_threshold() const {
1407 return GetField<float>(VT_MIN_REPLY_SCORE_THRESHOLD, 0.0f);
1408 }
VerifyFLATBUFFERS_FINAL_CLASS1409 bool Verify(flatbuffers::Verifier &verifier) const {
1410 return VerifyTableStart(verifier) &&
1411 VerifyField<float>(verifier, VT_MIN_SMART_REPLY_TRIGGERING_SCORE, 4) &&
1412 VerifyField<float>(verifier, VT_MAX_SENSITIVE_TOPIC_SCORE, 4) &&
1413 VerifyField<uint8_t>(verifier, VT_SUPPRESS_ON_SENSITIVE_TOPIC, 1) &&
1414 VerifyField<int32_t>(verifier, VT_MIN_INPUT_LENGTH, 4) &&
1415 VerifyField<int32_t>(verifier, VT_MAX_INPUT_LENGTH, 4) &&
1416 VerifyField<float>(verifier, VT_MIN_LOCALE_MATCH_FRACTION, 4) &&
1417 VerifyField<uint8_t>(verifier, VT_HANDLE_MISSING_LOCALE_AS_SUPPORTED, 1) &&
1418 VerifyField<uint8_t>(verifier, VT_HANDLE_UNKNOWN_LOCALE_AS_SUPPORTED, 1) &&
1419 VerifyField<uint8_t>(verifier, VT_SUPPRESS_ON_LOW_CONFIDENCE_INPUT, 1) &&
1420 VerifyOffset(verifier, VT_LOW_CONFIDENCE_RULES) &&
1421 verifier.VerifyTable(low_confidence_rules()) &&
1422 VerifyField<float>(verifier, VT_MIN_REPLY_SCORE_THRESHOLD, 4) &&
1423 verifier.EndTable();
1424 }
1425 TriggeringPreconditionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1426 void UnPackTo(TriggeringPreconditionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1427 static flatbuffers::Offset<TriggeringPreconditions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TriggeringPreconditionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1428 };
1429
1430 struct TriggeringPreconditionsBuilder {
1431 typedef TriggeringPreconditions Table;
1432 flatbuffers::FlatBufferBuilder &fbb_;
1433 flatbuffers::uoffset_t start_;
add_min_smart_reply_triggering_scoreTriggeringPreconditionsBuilder1434 void add_min_smart_reply_triggering_score(float min_smart_reply_triggering_score) {
1435 fbb_.AddElement<float>(TriggeringPreconditions::VT_MIN_SMART_REPLY_TRIGGERING_SCORE, min_smart_reply_triggering_score, 0.0f);
1436 }
add_max_sensitive_topic_scoreTriggeringPreconditionsBuilder1437 void add_max_sensitive_topic_score(float max_sensitive_topic_score) {
1438 fbb_.AddElement<float>(TriggeringPreconditions::VT_MAX_SENSITIVE_TOPIC_SCORE, max_sensitive_topic_score, 1.0f);
1439 }
add_suppress_on_sensitive_topicTriggeringPreconditionsBuilder1440 void add_suppress_on_sensitive_topic(bool suppress_on_sensitive_topic) {
1441 fbb_.AddElement<uint8_t>(TriggeringPreconditions::VT_SUPPRESS_ON_SENSITIVE_TOPIC, static_cast<uint8_t>(suppress_on_sensitive_topic), 1);
1442 }
add_min_input_lengthTriggeringPreconditionsBuilder1443 void add_min_input_length(int32_t min_input_length) {
1444 fbb_.AddElement<int32_t>(TriggeringPreconditions::VT_MIN_INPUT_LENGTH, min_input_length, 0);
1445 }
add_max_input_lengthTriggeringPreconditionsBuilder1446 void add_max_input_length(int32_t max_input_length) {
1447 fbb_.AddElement<int32_t>(TriggeringPreconditions::VT_MAX_INPUT_LENGTH, max_input_length, -1);
1448 }
add_min_locale_match_fractionTriggeringPreconditionsBuilder1449 void add_min_locale_match_fraction(float min_locale_match_fraction) {
1450 fbb_.AddElement<float>(TriggeringPreconditions::VT_MIN_LOCALE_MATCH_FRACTION, min_locale_match_fraction, 0.75f);
1451 }
add_handle_missing_locale_as_supportedTriggeringPreconditionsBuilder1452 void add_handle_missing_locale_as_supported(bool handle_missing_locale_as_supported) {
1453 fbb_.AddElement<uint8_t>(TriggeringPreconditions::VT_HANDLE_MISSING_LOCALE_AS_SUPPORTED, static_cast<uint8_t>(handle_missing_locale_as_supported), 0);
1454 }
add_handle_unknown_locale_as_supportedTriggeringPreconditionsBuilder1455 void add_handle_unknown_locale_as_supported(bool handle_unknown_locale_as_supported) {
1456 fbb_.AddElement<uint8_t>(TriggeringPreconditions::VT_HANDLE_UNKNOWN_LOCALE_AS_SUPPORTED, static_cast<uint8_t>(handle_unknown_locale_as_supported), 0);
1457 }
add_suppress_on_low_confidence_inputTriggeringPreconditionsBuilder1458 void add_suppress_on_low_confidence_input(bool suppress_on_low_confidence_input) {
1459 fbb_.AddElement<uint8_t>(TriggeringPreconditions::VT_SUPPRESS_ON_LOW_CONFIDENCE_INPUT, static_cast<uint8_t>(suppress_on_low_confidence_input), 1);
1460 }
add_low_confidence_rulesTriggeringPreconditionsBuilder1461 void add_low_confidence_rules(flatbuffers::Offset<libtextclassifier3::RulesModel> low_confidence_rules) {
1462 fbb_.AddOffset(TriggeringPreconditions::VT_LOW_CONFIDENCE_RULES, low_confidence_rules);
1463 }
add_min_reply_score_thresholdTriggeringPreconditionsBuilder1464 void add_min_reply_score_threshold(float min_reply_score_threshold) {
1465 fbb_.AddElement<float>(TriggeringPreconditions::VT_MIN_REPLY_SCORE_THRESHOLD, min_reply_score_threshold, 0.0f);
1466 }
TriggeringPreconditionsBuilderTriggeringPreconditionsBuilder1467 explicit TriggeringPreconditionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1468 : fbb_(_fbb) {
1469 start_ = fbb_.StartTable();
1470 }
FinishTriggeringPreconditionsBuilder1471 flatbuffers::Offset<TriggeringPreconditions> Finish() {
1472 const auto end = fbb_.EndTable(start_);
1473 auto o = flatbuffers::Offset<TriggeringPreconditions>(end);
1474 return o;
1475 }
1476 };
1477
1478 inline flatbuffers::Offset<TriggeringPreconditions> CreateTriggeringPreconditions(
1479 flatbuffers::FlatBufferBuilder &_fbb,
1480 float min_smart_reply_triggering_score = 0.0f,
1481 float max_sensitive_topic_score = 1.0f,
1482 bool suppress_on_sensitive_topic = true,
1483 int32_t min_input_length = 0,
1484 int32_t max_input_length = -1,
1485 float min_locale_match_fraction = 0.75f,
1486 bool handle_missing_locale_as_supported = false,
1487 bool handle_unknown_locale_as_supported = false,
1488 bool suppress_on_low_confidence_input = true,
1489 flatbuffers::Offset<libtextclassifier3::RulesModel> low_confidence_rules = 0,
1490 float min_reply_score_threshold = 0.0f) {
1491 TriggeringPreconditionsBuilder builder_(_fbb);
1492 builder_.add_min_reply_score_threshold(min_reply_score_threshold);
1493 builder_.add_low_confidence_rules(low_confidence_rules);
1494 builder_.add_min_locale_match_fraction(min_locale_match_fraction);
1495 builder_.add_max_input_length(max_input_length);
1496 builder_.add_min_input_length(min_input_length);
1497 builder_.add_max_sensitive_topic_score(max_sensitive_topic_score);
1498 builder_.add_min_smart_reply_triggering_score(min_smart_reply_triggering_score);
1499 builder_.add_suppress_on_low_confidence_input(suppress_on_low_confidence_input);
1500 builder_.add_handle_unknown_locale_as_supported(handle_unknown_locale_as_supported);
1501 builder_.add_handle_missing_locale_as_supported(handle_missing_locale_as_supported);
1502 builder_.add_suppress_on_sensitive_topic(suppress_on_sensitive_topic);
1503 return builder_.Finish();
1504 }
1505
1506 flatbuffers::Offset<TriggeringPreconditions> CreateTriggeringPreconditions(flatbuffers::FlatBufferBuilder &_fbb, const TriggeringPreconditionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1507
1508 struct ActionConceptToSuggestionT : public flatbuffers::NativeTable {
1509 typedef ActionConceptToSuggestion TableType;
1510 std::string concept_name{};
1511 std::vector<std::string> candidates{};
1512 };
1513
1514 struct ActionConceptToSuggestion FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1515 typedef ActionConceptToSuggestionT NativeTableType;
1516 typedef ActionConceptToSuggestionBuilder Builder;
1517 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1518 VT_CONCEPT_NAME = 4,
1519 VT_CANDIDATES = 6
1520 };
concept_nameFLATBUFFERS_FINAL_CLASS1521 const flatbuffers::String *concept_name() const {
1522 return GetPointer<const flatbuffers::String *>(VT_CONCEPT_NAME);
1523 }
candidatesFLATBUFFERS_FINAL_CLASS1524 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *candidates() const {
1525 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_CANDIDATES);
1526 }
VerifyFLATBUFFERS_FINAL_CLASS1527 bool Verify(flatbuffers::Verifier &verifier) const {
1528 return VerifyTableStart(verifier) &&
1529 VerifyOffset(verifier, VT_CONCEPT_NAME) &&
1530 verifier.VerifyString(concept_name()) &&
1531 VerifyOffset(verifier, VT_CANDIDATES) &&
1532 verifier.VerifyVector(candidates()) &&
1533 verifier.VerifyVectorOfStrings(candidates()) &&
1534 verifier.EndTable();
1535 }
1536 ActionConceptToSuggestionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1537 void UnPackTo(ActionConceptToSuggestionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1538 static flatbuffers::Offset<ActionConceptToSuggestion> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ActionConceptToSuggestionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1539 };
1540
1541 struct ActionConceptToSuggestionBuilder {
1542 typedef ActionConceptToSuggestion Table;
1543 flatbuffers::FlatBufferBuilder &fbb_;
1544 flatbuffers::uoffset_t start_;
add_concept_nameActionConceptToSuggestionBuilder1545 void add_concept_name(flatbuffers::Offset<flatbuffers::String> concept_name) {
1546 fbb_.AddOffset(ActionConceptToSuggestion::VT_CONCEPT_NAME, concept_name);
1547 }
add_candidatesActionConceptToSuggestionBuilder1548 void add_candidates(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> candidates) {
1549 fbb_.AddOffset(ActionConceptToSuggestion::VT_CANDIDATES, candidates);
1550 }
ActionConceptToSuggestionBuilderActionConceptToSuggestionBuilder1551 explicit ActionConceptToSuggestionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1552 : fbb_(_fbb) {
1553 start_ = fbb_.StartTable();
1554 }
FinishActionConceptToSuggestionBuilder1555 flatbuffers::Offset<ActionConceptToSuggestion> Finish() {
1556 const auto end = fbb_.EndTable(start_);
1557 auto o = flatbuffers::Offset<ActionConceptToSuggestion>(end);
1558 return o;
1559 }
1560 };
1561
1562 inline flatbuffers::Offset<ActionConceptToSuggestion> CreateActionConceptToSuggestion(
1563 flatbuffers::FlatBufferBuilder &_fbb,
1564 flatbuffers::Offset<flatbuffers::String> concept_name = 0,
1565 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> candidates = 0) {
1566 ActionConceptToSuggestionBuilder builder_(_fbb);
1567 builder_.add_candidates(candidates);
1568 builder_.add_concept_name(concept_name);
1569 return builder_.Finish();
1570 }
1571
1572 inline flatbuffers::Offset<ActionConceptToSuggestion> CreateActionConceptToSuggestionDirect(
1573 flatbuffers::FlatBufferBuilder &_fbb,
1574 const char *concept_name = nullptr,
1575 const std::vector<flatbuffers::Offset<flatbuffers::String>> *candidates = nullptr) {
1576 auto concept_name__ = concept_name ? _fbb.CreateSharedString(concept_name) : 0;
1577 auto candidates__ = candidates ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*candidates) : 0;
1578 return libtextclassifier3::CreateActionConceptToSuggestion(
1579 _fbb,
1580 concept_name__,
1581 candidates__);
1582 }
1583
1584 flatbuffers::Offset<ActionConceptToSuggestion> CreateActionConceptToSuggestion(flatbuffers::FlatBufferBuilder &_fbb, const ActionConceptToSuggestionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1585
1586 struct ActionSuggestionSpecT : public flatbuffers::NativeTable {
1587 typedef ActionSuggestionSpec TableType;
1588 std::string type{};
1589 std::string response_text{};
1590 float score = 0.0f;
1591 std::string serialized_entity_data{};
1592 float priority_score = 0.0f;
1593 std::unique_ptr<libtextclassifier3::ActionsEntityDataT> entity_data{};
1594 std::vector<std::string> response_text_blocklist{};
1595 std::vector<std::unique_ptr<libtextclassifier3::ActionConceptToSuggestionT>> concept_mappings{};
1596 ActionSuggestionSpecT() = default;
1597 ActionSuggestionSpecT(const ActionSuggestionSpecT &o);
1598 ActionSuggestionSpecT(ActionSuggestionSpecT&&) FLATBUFFERS_NOEXCEPT = default;
1599 ActionSuggestionSpecT &operator=(ActionSuggestionSpecT o) FLATBUFFERS_NOEXCEPT;
1600 };
1601
1602 struct ActionSuggestionSpec FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1603 typedef ActionSuggestionSpecT NativeTableType;
1604 typedef ActionSuggestionSpecBuilder Builder;
1605 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1606 VT_TYPE = 4,
1607 VT_RESPONSE_TEXT = 6,
1608 VT_SCORE = 8,
1609 VT_SERIALIZED_ENTITY_DATA = 10,
1610 VT_PRIORITY_SCORE = 12,
1611 VT_ENTITY_DATA = 14,
1612 VT_RESPONSE_TEXT_BLOCKLIST = 16,
1613 VT_CONCEPT_MAPPINGS = 18
1614 };
typeFLATBUFFERS_FINAL_CLASS1615 const flatbuffers::String *type() const {
1616 return GetPointer<const flatbuffers::String *>(VT_TYPE);
1617 }
response_textFLATBUFFERS_FINAL_CLASS1618 const flatbuffers::String *response_text() const {
1619 return GetPointer<const flatbuffers::String *>(VT_RESPONSE_TEXT);
1620 }
scoreFLATBUFFERS_FINAL_CLASS1621 float score() const {
1622 return GetField<float>(VT_SCORE, 0.0f);
1623 }
serialized_entity_dataFLATBUFFERS_FINAL_CLASS1624 const flatbuffers::String *serialized_entity_data() const {
1625 return GetPointer<const flatbuffers::String *>(VT_SERIALIZED_ENTITY_DATA);
1626 }
priority_scoreFLATBUFFERS_FINAL_CLASS1627 float priority_score() const {
1628 return GetField<float>(VT_PRIORITY_SCORE, 0.0f);
1629 }
entity_dataFLATBUFFERS_FINAL_CLASS1630 const libtextclassifier3::ActionsEntityData *entity_data() const {
1631 return GetPointer<const libtextclassifier3::ActionsEntityData *>(VT_ENTITY_DATA);
1632 }
response_text_blocklistFLATBUFFERS_FINAL_CLASS1633 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *response_text_blocklist() const {
1634 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_RESPONSE_TEXT_BLOCKLIST);
1635 }
concept_mappingsFLATBUFFERS_FINAL_CLASS1636 const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::ActionConceptToSuggestion>> *concept_mappings() const {
1637 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::ActionConceptToSuggestion>> *>(VT_CONCEPT_MAPPINGS);
1638 }
VerifyFLATBUFFERS_FINAL_CLASS1639 bool Verify(flatbuffers::Verifier &verifier) const {
1640 return VerifyTableStart(verifier) &&
1641 VerifyOffset(verifier, VT_TYPE) &&
1642 verifier.VerifyString(type()) &&
1643 VerifyOffset(verifier, VT_RESPONSE_TEXT) &&
1644 verifier.VerifyString(response_text()) &&
1645 VerifyField<float>(verifier, VT_SCORE, 4) &&
1646 VerifyOffset(verifier, VT_SERIALIZED_ENTITY_DATA) &&
1647 verifier.VerifyString(serialized_entity_data()) &&
1648 VerifyField<float>(verifier, VT_PRIORITY_SCORE, 4) &&
1649 VerifyOffset(verifier, VT_ENTITY_DATA) &&
1650 verifier.VerifyTable(entity_data()) &&
1651 VerifyOffset(verifier, VT_RESPONSE_TEXT_BLOCKLIST) &&
1652 verifier.VerifyVector(response_text_blocklist()) &&
1653 verifier.VerifyVectorOfStrings(response_text_blocklist()) &&
1654 VerifyOffset(verifier, VT_CONCEPT_MAPPINGS) &&
1655 verifier.VerifyVector(concept_mappings()) &&
1656 verifier.VerifyVectorOfTables(concept_mappings()) &&
1657 verifier.EndTable();
1658 }
1659 ActionSuggestionSpecT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1660 void UnPackTo(ActionSuggestionSpecT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1661 static flatbuffers::Offset<ActionSuggestionSpec> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ActionSuggestionSpecT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1662 };
1663
1664 struct ActionSuggestionSpecBuilder {
1665 typedef ActionSuggestionSpec Table;
1666 flatbuffers::FlatBufferBuilder &fbb_;
1667 flatbuffers::uoffset_t start_;
add_typeActionSuggestionSpecBuilder1668 void add_type(flatbuffers::Offset<flatbuffers::String> type) {
1669 fbb_.AddOffset(ActionSuggestionSpec::VT_TYPE, type);
1670 }
add_response_textActionSuggestionSpecBuilder1671 void add_response_text(flatbuffers::Offset<flatbuffers::String> response_text) {
1672 fbb_.AddOffset(ActionSuggestionSpec::VT_RESPONSE_TEXT, response_text);
1673 }
add_scoreActionSuggestionSpecBuilder1674 void add_score(float score) {
1675 fbb_.AddElement<float>(ActionSuggestionSpec::VT_SCORE, score, 0.0f);
1676 }
add_serialized_entity_dataActionSuggestionSpecBuilder1677 void add_serialized_entity_data(flatbuffers::Offset<flatbuffers::String> serialized_entity_data) {
1678 fbb_.AddOffset(ActionSuggestionSpec::VT_SERIALIZED_ENTITY_DATA, serialized_entity_data);
1679 }
add_priority_scoreActionSuggestionSpecBuilder1680 void add_priority_score(float priority_score) {
1681 fbb_.AddElement<float>(ActionSuggestionSpec::VT_PRIORITY_SCORE, priority_score, 0.0f);
1682 }
add_entity_dataActionSuggestionSpecBuilder1683 void add_entity_data(flatbuffers::Offset<libtextclassifier3::ActionsEntityData> entity_data) {
1684 fbb_.AddOffset(ActionSuggestionSpec::VT_ENTITY_DATA, entity_data);
1685 }
add_response_text_blocklistActionSuggestionSpecBuilder1686 void add_response_text_blocklist(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> response_text_blocklist) {
1687 fbb_.AddOffset(ActionSuggestionSpec::VT_RESPONSE_TEXT_BLOCKLIST, response_text_blocklist);
1688 }
add_concept_mappingsActionSuggestionSpecBuilder1689 void add_concept_mappings(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::ActionConceptToSuggestion>>> concept_mappings) {
1690 fbb_.AddOffset(ActionSuggestionSpec::VT_CONCEPT_MAPPINGS, concept_mappings);
1691 }
ActionSuggestionSpecBuilderActionSuggestionSpecBuilder1692 explicit ActionSuggestionSpecBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1693 : fbb_(_fbb) {
1694 start_ = fbb_.StartTable();
1695 }
FinishActionSuggestionSpecBuilder1696 flatbuffers::Offset<ActionSuggestionSpec> Finish() {
1697 const auto end = fbb_.EndTable(start_);
1698 auto o = flatbuffers::Offset<ActionSuggestionSpec>(end);
1699 return o;
1700 }
1701 };
1702
1703 inline flatbuffers::Offset<ActionSuggestionSpec> CreateActionSuggestionSpec(
1704 flatbuffers::FlatBufferBuilder &_fbb,
1705 flatbuffers::Offset<flatbuffers::String> type = 0,
1706 flatbuffers::Offset<flatbuffers::String> response_text = 0,
1707 float score = 0.0f,
1708 flatbuffers::Offset<flatbuffers::String> serialized_entity_data = 0,
1709 float priority_score = 0.0f,
1710 flatbuffers::Offset<libtextclassifier3::ActionsEntityData> entity_data = 0,
1711 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> response_text_blocklist = 0,
1712 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::ActionConceptToSuggestion>>> concept_mappings = 0) {
1713 ActionSuggestionSpecBuilder builder_(_fbb);
1714 builder_.add_concept_mappings(concept_mappings);
1715 builder_.add_response_text_blocklist(response_text_blocklist);
1716 builder_.add_entity_data(entity_data);
1717 builder_.add_priority_score(priority_score);
1718 builder_.add_serialized_entity_data(serialized_entity_data);
1719 builder_.add_score(score);
1720 builder_.add_response_text(response_text);
1721 builder_.add_type(type);
1722 return builder_.Finish();
1723 }
1724
1725 inline flatbuffers::Offset<ActionSuggestionSpec> CreateActionSuggestionSpecDirect(
1726 flatbuffers::FlatBufferBuilder &_fbb,
1727 const char *type = nullptr,
1728 const char *response_text = nullptr,
1729 float score = 0.0f,
1730 const char *serialized_entity_data = nullptr,
1731 float priority_score = 0.0f,
1732 flatbuffers::Offset<libtextclassifier3::ActionsEntityData> entity_data = 0,
1733 const std::vector<flatbuffers::Offset<flatbuffers::String>> *response_text_blocklist = nullptr,
1734 const std::vector<flatbuffers::Offset<libtextclassifier3::ActionConceptToSuggestion>> *concept_mappings = nullptr) {
1735 auto type__ = type ? _fbb.CreateSharedString(type) : 0;
1736 auto response_text__ = response_text ? _fbb.CreateSharedString(response_text) : 0;
1737 auto serialized_entity_data__ = serialized_entity_data ? _fbb.CreateSharedString(serialized_entity_data) : 0;
1738 auto response_text_blocklist__ = response_text_blocklist ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*response_text_blocklist) : 0;
1739 auto concept_mappings__ = concept_mappings ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::ActionConceptToSuggestion>>(*concept_mappings) : 0;
1740 return libtextclassifier3::CreateActionSuggestionSpec(
1741 _fbb,
1742 type__,
1743 response_text__,
1744 score,
1745 serialized_entity_data__,
1746 priority_score,
1747 entity_data,
1748 response_text_blocklist__,
1749 concept_mappings__);
1750 }
1751
1752 flatbuffers::Offset<ActionSuggestionSpec> CreateActionSuggestionSpec(flatbuffers::FlatBufferBuilder &_fbb, const ActionSuggestionSpecT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1753
1754 struct ActionTypeOptionsT : public flatbuffers::NativeTable {
1755 typedef ActionTypeOptions TableType;
1756 std::string name{};
1757 bool enabled = true;
1758 float min_triggering_score = 0.0f;
1759 std::unique_ptr<libtextclassifier3::ActionSuggestionSpecT> action{};
1760 ActionTypeOptionsT() = default;
1761 ActionTypeOptionsT(const ActionTypeOptionsT &o);
1762 ActionTypeOptionsT(ActionTypeOptionsT&&) FLATBUFFERS_NOEXCEPT = default;
1763 ActionTypeOptionsT &operator=(ActionTypeOptionsT o) FLATBUFFERS_NOEXCEPT;
1764 };
1765
1766 struct ActionTypeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1767 typedef ActionTypeOptionsT NativeTableType;
1768 typedef ActionTypeOptionsBuilder Builder;
1769 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1770 VT_NAME = 4,
1771 VT_ENABLED = 6,
1772 VT_MIN_TRIGGERING_SCORE = 8,
1773 VT_ACTION = 10
1774 };
nameFLATBUFFERS_FINAL_CLASS1775 const flatbuffers::String *name() const {
1776 return GetPointer<const flatbuffers::String *>(VT_NAME);
1777 }
enabledFLATBUFFERS_FINAL_CLASS1778 bool enabled() const {
1779 return GetField<uint8_t>(VT_ENABLED, 1) != 0;
1780 }
min_triggering_scoreFLATBUFFERS_FINAL_CLASS1781 float min_triggering_score() const {
1782 return GetField<float>(VT_MIN_TRIGGERING_SCORE, 0.0f);
1783 }
actionFLATBUFFERS_FINAL_CLASS1784 const libtextclassifier3::ActionSuggestionSpec *action() const {
1785 return GetPointer<const libtextclassifier3::ActionSuggestionSpec *>(VT_ACTION);
1786 }
VerifyFLATBUFFERS_FINAL_CLASS1787 bool Verify(flatbuffers::Verifier &verifier) const {
1788 return VerifyTableStart(verifier) &&
1789 VerifyOffset(verifier, VT_NAME) &&
1790 verifier.VerifyString(name()) &&
1791 VerifyField<uint8_t>(verifier, VT_ENABLED, 1) &&
1792 VerifyField<float>(verifier, VT_MIN_TRIGGERING_SCORE, 4) &&
1793 VerifyOffset(verifier, VT_ACTION) &&
1794 verifier.VerifyTable(action()) &&
1795 verifier.EndTable();
1796 }
1797 ActionTypeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1798 void UnPackTo(ActionTypeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1799 static flatbuffers::Offset<ActionTypeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ActionTypeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1800 };
1801
1802 struct ActionTypeOptionsBuilder {
1803 typedef ActionTypeOptions Table;
1804 flatbuffers::FlatBufferBuilder &fbb_;
1805 flatbuffers::uoffset_t start_;
add_nameActionTypeOptionsBuilder1806 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
1807 fbb_.AddOffset(ActionTypeOptions::VT_NAME, name);
1808 }
add_enabledActionTypeOptionsBuilder1809 void add_enabled(bool enabled) {
1810 fbb_.AddElement<uint8_t>(ActionTypeOptions::VT_ENABLED, static_cast<uint8_t>(enabled), 1);
1811 }
add_min_triggering_scoreActionTypeOptionsBuilder1812 void add_min_triggering_score(float min_triggering_score) {
1813 fbb_.AddElement<float>(ActionTypeOptions::VT_MIN_TRIGGERING_SCORE, min_triggering_score, 0.0f);
1814 }
add_actionActionTypeOptionsBuilder1815 void add_action(flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> action) {
1816 fbb_.AddOffset(ActionTypeOptions::VT_ACTION, action);
1817 }
ActionTypeOptionsBuilderActionTypeOptionsBuilder1818 explicit ActionTypeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1819 : fbb_(_fbb) {
1820 start_ = fbb_.StartTable();
1821 }
FinishActionTypeOptionsBuilder1822 flatbuffers::Offset<ActionTypeOptions> Finish() {
1823 const auto end = fbb_.EndTable(start_);
1824 auto o = flatbuffers::Offset<ActionTypeOptions>(end);
1825 return o;
1826 }
1827 };
1828
1829 inline flatbuffers::Offset<ActionTypeOptions> CreateActionTypeOptions(
1830 flatbuffers::FlatBufferBuilder &_fbb,
1831 flatbuffers::Offset<flatbuffers::String> name = 0,
1832 bool enabled = true,
1833 float min_triggering_score = 0.0f,
1834 flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> action = 0) {
1835 ActionTypeOptionsBuilder builder_(_fbb);
1836 builder_.add_action(action);
1837 builder_.add_min_triggering_score(min_triggering_score);
1838 builder_.add_name(name);
1839 builder_.add_enabled(enabled);
1840 return builder_.Finish();
1841 }
1842
1843 inline flatbuffers::Offset<ActionTypeOptions> CreateActionTypeOptionsDirect(
1844 flatbuffers::FlatBufferBuilder &_fbb,
1845 const char *name = nullptr,
1846 bool enabled = true,
1847 float min_triggering_score = 0.0f,
1848 flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> action = 0) {
1849 auto name__ = name ? _fbb.CreateSharedString(name) : 0;
1850 return libtextclassifier3::CreateActionTypeOptions(
1851 _fbb,
1852 name__,
1853 enabled,
1854 min_triggering_score,
1855 action);
1856 }
1857
1858 flatbuffers::Offset<ActionTypeOptions> CreateActionTypeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ActionTypeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1859
1860 namespace AnnotationActionsSpec_ {
1861
1862 struct AnnotationMappingT : public flatbuffers::NativeTable {
1863 typedef AnnotationMapping TableType;
1864 std::string annotation_collection{};
1865 std::unique_ptr<libtextclassifier3::ActionSuggestionSpecT> action{};
1866 bool use_annotation_score = true;
1867 float min_annotation_score = 0.0f;
1868 std::unique_ptr<libtextclassifier3::FlatbufferFieldPathT> entity_field{};
1869 std::unique_ptr<libtextclassifier3::NormalizationOptionsT> normalization_options{};
1870 AnnotationMappingT() = default;
1871 AnnotationMappingT(const AnnotationMappingT &o);
1872 AnnotationMappingT(AnnotationMappingT&&) FLATBUFFERS_NOEXCEPT = default;
1873 AnnotationMappingT &operator=(AnnotationMappingT o) FLATBUFFERS_NOEXCEPT;
1874 };
1875
1876 struct AnnotationMapping FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1877 typedef AnnotationMappingT NativeTableType;
1878 typedef AnnotationMappingBuilder Builder;
1879 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1880 VT_ANNOTATION_COLLECTION = 4,
1881 VT_ACTION = 6,
1882 VT_USE_ANNOTATION_SCORE = 8,
1883 VT_MIN_ANNOTATION_SCORE = 10,
1884 VT_ENTITY_FIELD = 12,
1885 VT_NORMALIZATION_OPTIONS = 14
1886 };
annotation_collectionFLATBUFFERS_FINAL_CLASS1887 const flatbuffers::String *annotation_collection() const {
1888 return GetPointer<const flatbuffers::String *>(VT_ANNOTATION_COLLECTION);
1889 }
actionFLATBUFFERS_FINAL_CLASS1890 const libtextclassifier3::ActionSuggestionSpec *action() const {
1891 return GetPointer<const libtextclassifier3::ActionSuggestionSpec *>(VT_ACTION);
1892 }
use_annotation_scoreFLATBUFFERS_FINAL_CLASS1893 bool use_annotation_score() const {
1894 return GetField<uint8_t>(VT_USE_ANNOTATION_SCORE, 1) != 0;
1895 }
min_annotation_scoreFLATBUFFERS_FINAL_CLASS1896 float min_annotation_score() const {
1897 return GetField<float>(VT_MIN_ANNOTATION_SCORE, 0.0f);
1898 }
entity_fieldFLATBUFFERS_FINAL_CLASS1899 const libtextclassifier3::FlatbufferFieldPath *entity_field() const {
1900 return GetPointer<const libtextclassifier3::FlatbufferFieldPath *>(VT_ENTITY_FIELD);
1901 }
normalization_optionsFLATBUFFERS_FINAL_CLASS1902 const libtextclassifier3::NormalizationOptions *normalization_options() const {
1903 return GetPointer<const libtextclassifier3::NormalizationOptions *>(VT_NORMALIZATION_OPTIONS);
1904 }
VerifyFLATBUFFERS_FINAL_CLASS1905 bool Verify(flatbuffers::Verifier &verifier) const {
1906 return VerifyTableStart(verifier) &&
1907 VerifyOffset(verifier, VT_ANNOTATION_COLLECTION) &&
1908 verifier.VerifyString(annotation_collection()) &&
1909 VerifyOffset(verifier, VT_ACTION) &&
1910 verifier.VerifyTable(action()) &&
1911 VerifyField<uint8_t>(verifier, VT_USE_ANNOTATION_SCORE, 1) &&
1912 VerifyField<float>(verifier, VT_MIN_ANNOTATION_SCORE, 4) &&
1913 VerifyOffset(verifier, VT_ENTITY_FIELD) &&
1914 verifier.VerifyTable(entity_field()) &&
1915 VerifyOffset(verifier, VT_NORMALIZATION_OPTIONS) &&
1916 verifier.VerifyTable(normalization_options()) &&
1917 verifier.EndTable();
1918 }
1919 AnnotationMappingT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1920 void UnPackTo(AnnotationMappingT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1921 static flatbuffers::Offset<AnnotationMapping> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationMappingT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1922 };
1923
1924 struct AnnotationMappingBuilder {
1925 typedef AnnotationMapping Table;
1926 flatbuffers::FlatBufferBuilder &fbb_;
1927 flatbuffers::uoffset_t start_;
add_annotation_collectionAnnotationMappingBuilder1928 void add_annotation_collection(flatbuffers::Offset<flatbuffers::String> annotation_collection) {
1929 fbb_.AddOffset(AnnotationMapping::VT_ANNOTATION_COLLECTION, annotation_collection);
1930 }
add_actionAnnotationMappingBuilder1931 void add_action(flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> action) {
1932 fbb_.AddOffset(AnnotationMapping::VT_ACTION, action);
1933 }
add_use_annotation_scoreAnnotationMappingBuilder1934 void add_use_annotation_score(bool use_annotation_score) {
1935 fbb_.AddElement<uint8_t>(AnnotationMapping::VT_USE_ANNOTATION_SCORE, static_cast<uint8_t>(use_annotation_score), 1);
1936 }
add_min_annotation_scoreAnnotationMappingBuilder1937 void add_min_annotation_score(float min_annotation_score) {
1938 fbb_.AddElement<float>(AnnotationMapping::VT_MIN_ANNOTATION_SCORE, min_annotation_score, 0.0f);
1939 }
add_entity_fieldAnnotationMappingBuilder1940 void add_entity_field(flatbuffers::Offset<libtextclassifier3::FlatbufferFieldPath> entity_field) {
1941 fbb_.AddOffset(AnnotationMapping::VT_ENTITY_FIELD, entity_field);
1942 }
add_normalization_optionsAnnotationMappingBuilder1943 void add_normalization_options(flatbuffers::Offset<libtextclassifier3::NormalizationOptions> normalization_options) {
1944 fbb_.AddOffset(AnnotationMapping::VT_NORMALIZATION_OPTIONS, normalization_options);
1945 }
AnnotationMappingBuilderAnnotationMappingBuilder1946 explicit AnnotationMappingBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1947 : fbb_(_fbb) {
1948 start_ = fbb_.StartTable();
1949 }
FinishAnnotationMappingBuilder1950 flatbuffers::Offset<AnnotationMapping> Finish() {
1951 const auto end = fbb_.EndTable(start_);
1952 auto o = flatbuffers::Offset<AnnotationMapping>(end);
1953 return o;
1954 }
1955 };
1956
1957 inline flatbuffers::Offset<AnnotationMapping> CreateAnnotationMapping(
1958 flatbuffers::FlatBufferBuilder &_fbb,
1959 flatbuffers::Offset<flatbuffers::String> annotation_collection = 0,
1960 flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> action = 0,
1961 bool use_annotation_score = true,
1962 float min_annotation_score = 0.0f,
1963 flatbuffers::Offset<libtextclassifier3::FlatbufferFieldPath> entity_field = 0,
1964 flatbuffers::Offset<libtextclassifier3::NormalizationOptions> normalization_options = 0) {
1965 AnnotationMappingBuilder builder_(_fbb);
1966 builder_.add_normalization_options(normalization_options);
1967 builder_.add_entity_field(entity_field);
1968 builder_.add_min_annotation_score(min_annotation_score);
1969 builder_.add_action(action);
1970 builder_.add_annotation_collection(annotation_collection);
1971 builder_.add_use_annotation_score(use_annotation_score);
1972 return builder_.Finish();
1973 }
1974
1975 inline flatbuffers::Offset<AnnotationMapping> CreateAnnotationMappingDirect(
1976 flatbuffers::FlatBufferBuilder &_fbb,
1977 const char *annotation_collection = nullptr,
1978 flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> action = 0,
1979 bool use_annotation_score = true,
1980 float min_annotation_score = 0.0f,
1981 flatbuffers::Offset<libtextclassifier3::FlatbufferFieldPath> entity_field = 0,
1982 flatbuffers::Offset<libtextclassifier3::NormalizationOptions> normalization_options = 0) {
1983 auto annotation_collection__ = annotation_collection ? _fbb.CreateSharedString(annotation_collection) : 0;
1984 return libtextclassifier3::AnnotationActionsSpec_::CreateAnnotationMapping(
1985 _fbb,
1986 annotation_collection__,
1987 action,
1988 use_annotation_score,
1989 min_annotation_score,
1990 entity_field,
1991 normalization_options);
1992 }
1993
1994 flatbuffers::Offset<AnnotationMapping> CreateAnnotationMapping(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationMappingT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1995
1996 } // namespace AnnotationActionsSpec_
1997
1998 struct AnnotationActionsSpecT : public flatbuffers::NativeTable {
1999 typedef AnnotationActionsSpec TableType;
2000 std::vector<std::unique_ptr<libtextclassifier3::AnnotationActionsSpec_::AnnotationMappingT>> annotation_mapping{};
2001 bool deduplicate_annotations = true;
2002 libtextclassifier3::AnnotationUsecase annotation_usecase = libtextclassifier3::AnnotationUsecase_ANNOTATION_USECASE_SMART;
2003 int32_t max_history_from_any_person = 1;
2004 int32_t max_history_from_last_person = 1;
2005 bool include_local_user_messages = false;
2006 bool only_until_last_sent = true;
2007 bool is_serialized_entity_data_enabled = true;
2008 AnnotationActionsSpecT() = default;
2009 AnnotationActionsSpecT(const AnnotationActionsSpecT &o);
2010 AnnotationActionsSpecT(AnnotationActionsSpecT&&) FLATBUFFERS_NOEXCEPT = default;
2011 AnnotationActionsSpecT &operator=(AnnotationActionsSpecT o) FLATBUFFERS_NOEXCEPT;
2012 };
2013
2014 struct AnnotationActionsSpec FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2015 typedef AnnotationActionsSpecT NativeTableType;
2016 typedef AnnotationActionsSpecBuilder Builder;
2017 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2018 VT_ANNOTATION_MAPPING = 4,
2019 VT_DEDUPLICATE_ANNOTATIONS = 6,
2020 VT_ANNOTATION_USECASE = 8,
2021 VT_MAX_HISTORY_FROM_ANY_PERSON = 10,
2022 VT_MAX_HISTORY_FROM_LAST_PERSON = 12,
2023 VT_INCLUDE_LOCAL_USER_MESSAGES = 14,
2024 VT_ONLY_UNTIL_LAST_SENT = 16,
2025 VT_IS_SERIALIZED_ENTITY_DATA_ENABLED = 18
2026 };
annotation_mappingFLATBUFFERS_FINAL_CLASS2027 const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::AnnotationActionsSpec_::AnnotationMapping>> *annotation_mapping() const {
2028 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::AnnotationActionsSpec_::AnnotationMapping>> *>(VT_ANNOTATION_MAPPING);
2029 }
deduplicate_annotationsFLATBUFFERS_FINAL_CLASS2030 bool deduplicate_annotations() const {
2031 return GetField<uint8_t>(VT_DEDUPLICATE_ANNOTATIONS, 1) != 0;
2032 }
annotation_usecaseFLATBUFFERS_FINAL_CLASS2033 libtextclassifier3::AnnotationUsecase annotation_usecase() const {
2034 return static_cast<libtextclassifier3::AnnotationUsecase>(GetField<int32_t>(VT_ANNOTATION_USECASE, 0));
2035 }
max_history_from_any_personFLATBUFFERS_FINAL_CLASS2036 int32_t max_history_from_any_person() const {
2037 return GetField<int32_t>(VT_MAX_HISTORY_FROM_ANY_PERSON, 1);
2038 }
max_history_from_last_personFLATBUFFERS_FINAL_CLASS2039 int32_t max_history_from_last_person() const {
2040 return GetField<int32_t>(VT_MAX_HISTORY_FROM_LAST_PERSON, 1);
2041 }
include_local_user_messagesFLATBUFFERS_FINAL_CLASS2042 bool include_local_user_messages() const {
2043 return GetField<uint8_t>(VT_INCLUDE_LOCAL_USER_MESSAGES, 0) != 0;
2044 }
only_until_last_sentFLATBUFFERS_FINAL_CLASS2045 bool only_until_last_sent() const {
2046 return GetField<uint8_t>(VT_ONLY_UNTIL_LAST_SENT, 1) != 0;
2047 }
is_serialized_entity_data_enabledFLATBUFFERS_FINAL_CLASS2048 bool is_serialized_entity_data_enabled() const {
2049 return GetField<uint8_t>(VT_IS_SERIALIZED_ENTITY_DATA_ENABLED, 1) != 0;
2050 }
VerifyFLATBUFFERS_FINAL_CLASS2051 bool Verify(flatbuffers::Verifier &verifier) const {
2052 return VerifyTableStart(verifier) &&
2053 VerifyOffset(verifier, VT_ANNOTATION_MAPPING) &&
2054 verifier.VerifyVector(annotation_mapping()) &&
2055 verifier.VerifyVectorOfTables(annotation_mapping()) &&
2056 VerifyField<uint8_t>(verifier, VT_DEDUPLICATE_ANNOTATIONS, 1) &&
2057 VerifyField<int32_t>(verifier, VT_ANNOTATION_USECASE, 4) &&
2058 VerifyField<int32_t>(verifier, VT_MAX_HISTORY_FROM_ANY_PERSON, 4) &&
2059 VerifyField<int32_t>(verifier, VT_MAX_HISTORY_FROM_LAST_PERSON, 4) &&
2060 VerifyField<uint8_t>(verifier, VT_INCLUDE_LOCAL_USER_MESSAGES, 1) &&
2061 VerifyField<uint8_t>(verifier, VT_ONLY_UNTIL_LAST_SENT, 1) &&
2062 VerifyField<uint8_t>(verifier, VT_IS_SERIALIZED_ENTITY_DATA_ENABLED, 1) &&
2063 verifier.EndTable();
2064 }
2065 AnnotationActionsSpecT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2066 void UnPackTo(AnnotationActionsSpecT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2067 static flatbuffers::Offset<AnnotationActionsSpec> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationActionsSpecT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2068 };
2069
2070 struct AnnotationActionsSpecBuilder {
2071 typedef AnnotationActionsSpec Table;
2072 flatbuffers::FlatBufferBuilder &fbb_;
2073 flatbuffers::uoffset_t start_;
add_annotation_mappingAnnotationActionsSpecBuilder2074 void add_annotation_mapping(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::AnnotationActionsSpec_::AnnotationMapping>>> annotation_mapping) {
2075 fbb_.AddOffset(AnnotationActionsSpec::VT_ANNOTATION_MAPPING, annotation_mapping);
2076 }
add_deduplicate_annotationsAnnotationActionsSpecBuilder2077 void add_deduplicate_annotations(bool deduplicate_annotations) {
2078 fbb_.AddElement<uint8_t>(AnnotationActionsSpec::VT_DEDUPLICATE_ANNOTATIONS, static_cast<uint8_t>(deduplicate_annotations), 1);
2079 }
add_annotation_usecaseAnnotationActionsSpecBuilder2080 void add_annotation_usecase(libtextclassifier3::AnnotationUsecase annotation_usecase) {
2081 fbb_.AddElement<int32_t>(AnnotationActionsSpec::VT_ANNOTATION_USECASE, static_cast<int32_t>(annotation_usecase), 0);
2082 }
add_max_history_from_any_personAnnotationActionsSpecBuilder2083 void add_max_history_from_any_person(int32_t max_history_from_any_person) {
2084 fbb_.AddElement<int32_t>(AnnotationActionsSpec::VT_MAX_HISTORY_FROM_ANY_PERSON, max_history_from_any_person, 1);
2085 }
add_max_history_from_last_personAnnotationActionsSpecBuilder2086 void add_max_history_from_last_person(int32_t max_history_from_last_person) {
2087 fbb_.AddElement<int32_t>(AnnotationActionsSpec::VT_MAX_HISTORY_FROM_LAST_PERSON, max_history_from_last_person, 1);
2088 }
add_include_local_user_messagesAnnotationActionsSpecBuilder2089 void add_include_local_user_messages(bool include_local_user_messages) {
2090 fbb_.AddElement<uint8_t>(AnnotationActionsSpec::VT_INCLUDE_LOCAL_USER_MESSAGES, static_cast<uint8_t>(include_local_user_messages), 0);
2091 }
add_only_until_last_sentAnnotationActionsSpecBuilder2092 void add_only_until_last_sent(bool only_until_last_sent) {
2093 fbb_.AddElement<uint8_t>(AnnotationActionsSpec::VT_ONLY_UNTIL_LAST_SENT, static_cast<uint8_t>(only_until_last_sent), 1);
2094 }
add_is_serialized_entity_data_enabledAnnotationActionsSpecBuilder2095 void add_is_serialized_entity_data_enabled(bool is_serialized_entity_data_enabled) {
2096 fbb_.AddElement<uint8_t>(AnnotationActionsSpec::VT_IS_SERIALIZED_ENTITY_DATA_ENABLED, static_cast<uint8_t>(is_serialized_entity_data_enabled), 1);
2097 }
AnnotationActionsSpecBuilderAnnotationActionsSpecBuilder2098 explicit AnnotationActionsSpecBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2099 : fbb_(_fbb) {
2100 start_ = fbb_.StartTable();
2101 }
FinishAnnotationActionsSpecBuilder2102 flatbuffers::Offset<AnnotationActionsSpec> Finish() {
2103 const auto end = fbb_.EndTable(start_);
2104 auto o = flatbuffers::Offset<AnnotationActionsSpec>(end);
2105 return o;
2106 }
2107 };
2108
2109 inline flatbuffers::Offset<AnnotationActionsSpec> CreateAnnotationActionsSpec(
2110 flatbuffers::FlatBufferBuilder &_fbb,
2111 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::AnnotationActionsSpec_::AnnotationMapping>>> annotation_mapping = 0,
2112 bool deduplicate_annotations = true,
2113 libtextclassifier3::AnnotationUsecase annotation_usecase = libtextclassifier3::AnnotationUsecase_ANNOTATION_USECASE_SMART,
2114 int32_t max_history_from_any_person = 1,
2115 int32_t max_history_from_last_person = 1,
2116 bool include_local_user_messages = false,
2117 bool only_until_last_sent = true,
2118 bool is_serialized_entity_data_enabled = true) {
2119 AnnotationActionsSpecBuilder builder_(_fbb);
2120 builder_.add_max_history_from_last_person(max_history_from_last_person);
2121 builder_.add_max_history_from_any_person(max_history_from_any_person);
2122 builder_.add_annotation_usecase(annotation_usecase);
2123 builder_.add_annotation_mapping(annotation_mapping);
2124 builder_.add_is_serialized_entity_data_enabled(is_serialized_entity_data_enabled);
2125 builder_.add_only_until_last_sent(only_until_last_sent);
2126 builder_.add_include_local_user_messages(include_local_user_messages);
2127 builder_.add_deduplicate_annotations(deduplicate_annotations);
2128 return builder_.Finish();
2129 }
2130
2131 inline flatbuffers::Offset<AnnotationActionsSpec> CreateAnnotationActionsSpecDirect(
2132 flatbuffers::FlatBufferBuilder &_fbb,
2133 const std::vector<flatbuffers::Offset<libtextclassifier3::AnnotationActionsSpec_::AnnotationMapping>> *annotation_mapping = nullptr,
2134 bool deduplicate_annotations = true,
2135 libtextclassifier3::AnnotationUsecase annotation_usecase = libtextclassifier3::AnnotationUsecase_ANNOTATION_USECASE_SMART,
2136 int32_t max_history_from_any_person = 1,
2137 int32_t max_history_from_last_person = 1,
2138 bool include_local_user_messages = false,
2139 bool only_until_last_sent = true,
2140 bool is_serialized_entity_data_enabled = true) {
2141 auto annotation_mapping__ = annotation_mapping ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::AnnotationActionsSpec_::AnnotationMapping>>(*annotation_mapping) : 0;
2142 return libtextclassifier3::CreateAnnotationActionsSpec(
2143 _fbb,
2144 annotation_mapping__,
2145 deduplicate_annotations,
2146 annotation_usecase,
2147 max_history_from_any_person,
2148 max_history_from_last_person,
2149 include_local_user_messages,
2150 only_until_last_sent,
2151 is_serialized_entity_data_enabled);
2152 }
2153
2154 flatbuffers::Offset<AnnotationActionsSpec> CreateAnnotationActionsSpec(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationActionsSpecT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2155
2156 struct RankingOptionsT : public flatbuffers::NativeTable {
2157 typedef RankingOptions TableType;
2158 bool deduplicate_suggestions = true;
2159 bool deduplicate_suggestions_by_span = true;
2160 std::string lua_ranking_script{};
2161 std::unique_ptr<libtextclassifier3::CompressedBufferT> compressed_lua_ranking_script{};
2162 bool suppress_smart_replies_with_actions = false;
2163 bool group_by_annotations = true;
2164 libtextclassifier3::RankingOptionsSortType sort_type = libtextclassifier3::RankingOptionsSortType_SORT_TYPE_SCORE;
2165 RankingOptionsT() = default;
2166 RankingOptionsT(const RankingOptionsT &o);
2167 RankingOptionsT(RankingOptionsT&&) FLATBUFFERS_NOEXCEPT = default;
2168 RankingOptionsT &operator=(RankingOptionsT o) FLATBUFFERS_NOEXCEPT;
2169 };
2170
2171 struct RankingOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2172 typedef RankingOptionsT NativeTableType;
2173 typedef RankingOptionsBuilder Builder;
2174 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2175 VT_DEDUPLICATE_SUGGESTIONS = 4,
2176 VT_DEDUPLICATE_SUGGESTIONS_BY_SPAN = 6,
2177 VT_LUA_RANKING_SCRIPT = 8,
2178 VT_COMPRESSED_LUA_RANKING_SCRIPT = 10,
2179 VT_SUPPRESS_SMART_REPLIES_WITH_ACTIONS = 12,
2180 VT_GROUP_BY_ANNOTATIONS = 14,
2181 VT_SORT_TYPE = 16
2182 };
deduplicate_suggestionsFLATBUFFERS_FINAL_CLASS2183 bool deduplicate_suggestions() const {
2184 return GetField<uint8_t>(VT_DEDUPLICATE_SUGGESTIONS, 1) != 0;
2185 }
deduplicate_suggestions_by_spanFLATBUFFERS_FINAL_CLASS2186 bool deduplicate_suggestions_by_span() const {
2187 return GetField<uint8_t>(VT_DEDUPLICATE_SUGGESTIONS_BY_SPAN, 1) != 0;
2188 }
lua_ranking_scriptFLATBUFFERS_FINAL_CLASS2189 const flatbuffers::String *lua_ranking_script() const {
2190 return GetPointer<const flatbuffers::String *>(VT_LUA_RANKING_SCRIPT);
2191 }
compressed_lua_ranking_scriptFLATBUFFERS_FINAL_CLASS2192 const libtextclassifier3::CompressedBuffer *compressed_lua_ranking_script() const {
2193 return GetPointer<const libtextclassifier3::CompressedBuffer *>(VT_COMPRESSED_LUA_RANKING_SCRIPT);
2194 }
suppress_smart_replies_with_actionsFLATBUFFERS_FINAL_CLASS2195 bool suppress_smart_replies_with_actions() const {
2196 return GetField<uint8_t>(VT_SUPPRESS_SMART_REPLIES_WITH_ACTIONS, 0) != 0;
2197 }
group_by_annotationsFLATBUFFERS_FINAL_CLASS2198 bool group_by_annotations() const {
2199 return GetField<uint8_t>(VT_GROUP_BY_ANNOTATIONS, 1) != 0;
2200 }
sort_typeFLATBUFFERS_FINAL_CLASS2201 libtextclassifier3::RankingOptionsSortType sort_type() const {
2202 return static_cast<libtextclassifier3::RankingOptionsSortType>(GetField<int32_t>(VT_SORT_TYPE, 1));
2203 }
VerifyFLATBUFFERS_FINAL_CLASS2204 bool Verify(flatbuffers::Verifier &verifier) const {
2205 return VerifyTableStart(verifier) &&
2206 VerifyField<uint8_t>(verifier, VT_DEDUPLICATE_SUGGESTIONS, 1) &&
2207 VerifyField<uint8_t>(verifier, VT_DEDUPLICATE_SUGGESTIONS_BY_SPAN, 1) &&
2208 VerifyOffset(verifier, VT_LUA_RANKING_SCRIPT) &&
2209 verifier.VerifyString(lua_ranking_script()) &&
2210 VerifyOffset(verifier, VT_COMPRESSED_LUA_RANKING_SCRIPT) &&
2211 verifier.VerifyTable(compressed_lua_ranking_script()) &&
2212 VerifyField<uint8_t>(verifier, VT_SUPPRESS_SMART_REPLIES_WITH_ACTIONS, 1) &&
2213 VerifyField<uint8_t>(verifier, VT_GROUP_BY_ANNOTATIONS, 1) &&
2214 VerifyField<int32_t>(verifier, VT_SORT_TYPE, 4) &&
2215 verifier.EndTable();
2216 }
2217 RankingOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2218 void UnPackTo(RankingOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2219 static flatbuffers::Offset<RankingOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankingOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2220 };
2221
2222 struct RankingOptionsBuilder {
2223 typedef RankingOptions Table;
2224 flatbuffers::FlatBufferBuilder &fbb_;
2225 flatbuffers::uoffset_t start_;
add_deduplicate_suggestionsRankingOptionsBuilder2226 void add_deduplicate_suggestions(bool deduplicate_suggestions) {
2227 fbb_.AddElement<uint8_t>(RankingOptions::VT_DEDUPLICATE_SUGGESTIONS, static_cast<uint8_t>(deduplicate_suggestions), 1);
2228 }
add_deduplicate_suggestions_by_spanRankingOptionsBuilder2229 void add_deduplicate_suggestions_by_span(bool deduplicate_suggestions_by_span) {
2230 fbb_.AddElement<uint8_t>(RankingOptions::VT_DEDUPLICATE_SUGGESTIONS_BY_SPAN, static_cast<uint8_t>(deduplicate_suggestions_by_span), 1);
2231 }
add_lua_ranking_scriptRankingOptionsBuilder2232 void add_lua_ranking_script(flatbuffers::Offset<flatbuffers::String> lua_ranking_script) {
2233 fbb_.AddOffset(RankingOptions::VT_LUA_RANKING_SCRIPT, lua_ranking_script);
2234 }
add_compressed_lua_ranking_scriptRankingOptionsBuilder2235 void add_compressed_lua_ranking_script(flatbuffers::Offset<libtextclassifier3::CompressedBuffer> compressed_lua_ranking_script) {
2236 fbb_.AddOffset(RankingOptions::VT_COMPRESSED_LUA_RANKING_SCRIPT, compressed_lua_ranking_script);
2237 }
add_suppress_smart_replies_with_actionsRankingOptionsBuilder2238 void add_suppress_smart_replies_with_actions(bool suppress_smart_replies_with_actions) {
2239 fbb_.AddElement<uint8_t>(RankingOptions::VT_SUPPRESS_SMART_REPLIES_WITH_ACTIONS, static_cast<uint8_t>(suppress_smart_replies_with_actions), 0);
2240 }
add_group_by_annotationsRankingOptionsBuilder2241 void add_group_by_annotations(bool group_by_annotations) {
2242 fbb_.AddElement<uint8_t>(RankingOptions::VT_GROUP_BY_ANNOTATIONS, static_cast<uint8_t>(group_by_annotations), 1);
2243 }
add_sort_typeRankingOptionsBuilder2244 void add_sort_type(libtextclassifier3::RankingOptionsSortType sort_type) {
2245 fbb_.AddElement<int32_t>(RankingOptions::VT_SORT_TYPE, static_cast<int32_t>(sort_type), 1);
2246 }
RankingOptionsBuilderRankingOptionsBuilder2247 explicit RankingOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2248 : fbb_(_fbb) {
2249 start_ = fbb_.StartTable();
2250 }
FinishRankingOptionsBuilder2251 flatbuffers::Offset<RankingOptions> Finish() {
2252 const auto end = fbb_.EndTable(start_);
2253 auto o = flatbuffers::Offset<RankingOptions>(end);
2254 return o;
2255 }
2256 };
2257
2258 inline flatbuffers::Offset<RankingOptions> CreateRankingOptions(
2259 flatbuffers::FlatBufferBuilder &_fbb,
2260 bool deduplicate_suggestions = true,
2261 bool deduplicate_suggestions_by_span = true,
2262 flatbuffers::Offset<flatbuffers::String> lua_ranking_script = 0,
2263 flatbuffers::Offset<libtextclassifier3::CompressedBuffer> compressed_lua_ranking_script = 0,
2264 bool suppress_smart_replies_with_actions = false,
2265 bool group_by_annotations = true,
2266 libtextclassifier3::RankingOptionsSortType sort_type = libtextclassifier3::RankingOptionsSortType_SORT_TYPE_SCORE) {
2267 RankingOptionsBuilder builder_(_fbb);
2268 builder_.add_sort_type(sort_type);
2269 builder_.add_compressed_lua_ranking_script(compressed_lua_ranking_script);
2270 builder_.add_lua_ranking_script(lua_ranking_script);
2271 builder_.add_group_by_annotations(group_by_annotations);
2272 builder_.add_suppress_smart_replies_with_actions(suppress_smart_replies_with_actions);
2273 builder_.add_deduplicate_suggestions_by_span(deduplicate_suggestions_by_span);
2274 builder_.add_deduplicate_suggestions(deduplicate_suggestions);
2275 return builder_.Finish();
2276 }
2277
2278 inline flatbuffers::Offset<RankingOptions> CreateRankingOptionsDirect(
2279 flatbuffers::FlatBufferBuilder &_fbb,
2280 bool deduplicate_suggestions = true,
2281 bool deduplicate_suggestions_by_span = true,
2282 const char *lua_ranking_script = nullptr,
2283 flatbuffers::Offset<libtextclassifier3::CompressedBuffer> compressed_lua_ranking_script = 0,
2284 bool suppress_smart_replies_with_actions = false,
2285 bool group_by_annotations = true,
2286 libtextclassifier3::RankingOptionsSortType sort_type = libtextclassifier3::RankingOptionsSortType_SORT_TYPE_SCORE) {
2287 auto lua_ranking_script__ = lua_ranking_script ? _fbb.CreateSharedString(lua_ranking_script) : 0;
2288 return libtextclassifier3::CreateRankingOptions(
2289 _fbb,
2290 deduplicate_suggestions,
2291 deduplicate_suggestions_by_span,
2292 lua_ranking_script__,
2293 compressed_lua_ranking_script,
2294 suppress_smart_replies_with_actions,
2295 group_by_annotations,
2296 sort_type);
2297 }
2298
2299 flatbuffers::Offset<RankingOptions> CreateRankingOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankingOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2300
2301 namespace RulesModel_ {
2302 namespace RuleActionSpec_ {
2303
2304 struct RuleCapturingGroupT : public flatbuffers::NativeTable {
2305 typedef RuleCapturingGroup TableType;
2306 int32_t group_id = 0;
2307 std::unique_ptr<libtextclassifier3::FlatbufferFieldPathT> entity_field{};
2308 std::string annotation_type{};
2309 std::string annotation_name{};
2310 std::unique_ptr<libtextclassifier3::ActionSuggestionSpecT> text_reply{};
2311 std::unique_ptr<libtextclassifier3::NormalizationOptionsT> normalization_options{};
2312 bool use_annotation_match = false;
2313 std::unique_ptr<libtextclassifier3::ActionsEntityDataT> entity_data{};
2314 RuleCapturingGroupT() = default;
2315 RuleCapturingGroupT(const RuleCapturingGroupT &o);
2316 RuleCapturingGroupT(RuleCapturingGroupT&&) FLATBUFFERS_NOEXCEPT = default;
2317 RuleCapturingGroupT &operator=(RuleCapturingGroupT o) FLATBUFFERS_NOEXCEPT;
2318 };
2319
2320 struct RuleCapturingGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2321 typedef RuleCapturingGroupT NativeTableType;
2322 typedef RuleCapturingGroupBuilder Builder;
2323 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2324 VT_GROUP_ID = 4,
2325 VT_ENTITY_FIELD = 6,
2326 VT_ANNOTATION_TYPE = 8,
2327 VT_ANNOTATION_NAME = 10,
2328 VT_TEXT_REPLY = 12,
2329 VT_NORMALIZATION_OPTIONS = 14,
2330 VT_USE_ANNOTATION_MATCH = 16,
2331 VT_ENTITY_DATA = 18
2332 };
group_idFLATBUFFERS_FINAL_CLASS2333 int32_t group_id() const {
2334 return GetField<int32_t>(VT_GROUP_ID, 0);
2335 }
entity_fieldFLATBUFFERS_FINAL_CLASS2336 const libtextclassifier3::FlatbufferFieldPath *entity_field() const {
2337 return GetPointer<const libtextclassifier3::FlatbufferFieldPath *>(VT_ENTITY_FIELD);
2338 }
annotation_typeFLATBUFFERS_FINAL_CLASS2339 const flatbuffers::String *annotation_type() const {
2340 return GetPointer<const flatbuffers::String *>(VT_ANNOTATION_TYPE);
2341 }
annotation_nameFLATBUFFERS_FINAL_CLASS2342 const flatbuffers::String *annotation_name() const {
2343 return GetPointer<const flatbuffers::String *>(VT_ANNOTATION_NAME);
2344 }
text_replyFLATBUFFERS_FINAL_CLASS2345 const libtextclassifier3::ActionSuggestionSpec *text_reply() const {
2346 return GetPointer<const libtextclassifier3::ActionSuggestionSpec *>(VT_TEXT_REPLY);
2347 }
normalization_optionsFLATBUFFERS_FINAL_CLASS2348 const libtextclassifier3::NormalizationOptions *normalization_options() const {
2349 return GetPointer<const libtextclassifier3::NormalizationOptions *>(VT_NORMALIZATION_OPTIONS);
2350 }
use_annotation_matchFLATBUFFERS_FINAL_CLASS2351 bool use_annotation_match() const {
2352 return GetField<uint8_t>(VT_USE_ANNOTATION_MATCH, 0) != 0;
2353 }
entity_dataFLATBUFFERS_FINAL_CLASS2354 const libtextclassifier3::ActionsEntityData *entity_data() const {
2355 return GetPointer<const libtextclassifier3::ActionsEntityData *>(VT_ENTITY_DATA);
2356 }
VerifyFLATBUFFERS_FINAL_CLASS2357 bool Verify(flatbuffers::Verifier &verifier) const {
2358 return VerifyTableStart(verifier) &&
2359 VerifyField<int32_t>(verifier, VT_GROUP_ID, 4) &&
2360 VerifyOffset(verifier, VT_ENTITY_FIELD) &&
2361 verifier.VerifyTable(entity_field()) &&
2362 VerifyOffset(verifier, VT_ANNOTATION_TYPE) &&
2363 verifier.VerifyString(annotation_type()) &&
2364 VerifyOffset(verifier, VT_ANNOTATION_NAME) &&
2365 verifier.VerifyString(annotation_name()) &&
2366 VerifyOffset(verifier, VT_TEXT_REPLY) &&
2367 verifier.VerifyTable(text_reply()) &&
2368 VerifyOffset(verifier, VT_NORMALIZATION_OPTIONS) &&
2369 verifier.VerifyTable(normalization_options()) &&
2370 VerifyField<uint8_t>(verifier, VT_USE_ANNOTATION_MATCH, 1) &&
2371 VerifyOffset(verifier, VT_ENTITY_DATA) &&
2372 verifier.VerifyTable(entity_data()) &&
2373 verifier.EndTable();
2374 }
2375 RuleCapturingGroupT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2376 void UnPackTo(RuleCapturingGroupT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2377 static flatbuffers::Offset<RuleCapturingGroup> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RuleCapturingGroupT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2378 };
2379
2380 struct RuleCapturingGroupBuilder {
2381 typedef RuleCapturingGroup Table;
2382 flatbuffers::FlatBufferBuilder &fbb_;
2383 flatbuffers::uoffset_t start_;
add_group_idRuleCapturingGroupBuilder2384 void add_group_id(int32_t group_id) {
2385 fbb_.AddElement<int32_t>(RuleCapturingGroup::VT_GROUP_ID, group_id, 0);
2386 }
add_entity_fieldRuleCapturingGroupBuilder2387 void add_entity_field(flatbuffers::Offset<libtextclassifier3::FlatbufferFieldPath> entity_field) {
2388 fbb_.AddOffset(RuleCapturingGroup::VT_ENTITY_FIELD, entity_field);
2389 }
add_annotation_typeRuleCapturingGroupBuilder2390 void add_annotation_type(flatbuffers::Offset<flatbuffers::String> annotation_type) {
2391 fbb_.AddOffset(RuleCapturingGroup::VT_ANNOTATION_TYPE, annotation_type);
2392 }
add_annotation_nameRuleCapturingGroupBuilder2393 void add_annotation_name(flatbuffers::Offset<flatbuffers::String> annotation_name) {
2394 fbb_.AddOffset(RuleCapturingGroup::VT_ANNOTATION_NAME, annotation_name);
2395 }
add_text_replyRuleCapturingGroupBuilder2396 void add_text_reply(flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> text_reply) {
2397 fbb_.AddOffset(RuleCapturingGroup::VT_TEXT_REPLY, text_reply);
2398 }
add_normalization_optionsRuleCapturingGroupBuilder2399 void add_normalization_options(flatbuffers::Offset<libtextclassifier3::NormalizationOptions> normalization_options) {
2400 fbb_.AddOffset(RuleCapturingGroup::VT_NORMALIZATION_OPTIONS, normalization_options);
2401 }
add_use_annotation_matchRuleCapturingGroupBuilder2402 void add_use_annotation_match(bool use_annotation_match) {
2403 fbb_.AddElement<uint8_t>(RuleCapturingGroup::VT_USE_ANNOTATION_MATCH, static_cast<uint8_t>(use_annotation_match), 0);
2404 }
add_entity_dataRuleCapturingGroupBuilder2405 void add_entity_data(flatbuffers::Offset<libtextclassifier3::ActionsEntityData> entity_data) {
2406 fbb_.AddOffset(RuleCapturingGroup::VT_ENTITY_DATA, entity_data);
2407 }
RuleCapturingGroupBuilderRuleCapturingGroupBuilder2408 explicit RuleCapturingGroupBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2409 : fbb_(_fbb) {
2410 start_ = fbb_.StartTable();
2411 }
FinishRuleCapturingGroupBuilder2412 flatbuffers::Offset<RuleCapturingGroup> Finish() {
2413 const auto end = fbb_.EndTable(start_);
2414 auto o = flatbuffers::Offset<RuleCapturingGroup>(end);
2415 return o;
2416 }
2417 };
2418
2419 inline flatbuffers::Offset<RuleCapturingGroup> CreateRuleCapturingGroup(
2420 flatbuffers::FlatBufferBuilder &_fbb,
2421 int32_t group_id = 0,
2422 flatbuffers::Offset<libtextclassifier3::FlatbufferFieldPath> entity_field = 0,
2423 flatbuffers::Offset<flatbuffers::String> annotation_type = 0,
2424 flatbuffers::Offset<flatbuffers::String> annotation_name = 0,
2425 flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> text_reply = 0,
2426 flatbuffers::Offset<libtextclassifier3::NormalizationOptions> normalization_options = 0,
2427 bool use_annotation_match = false,
2428 flatbuffers::Offset<libtextclassifier3::ActionsEntityData> entity_data = 0) {
2429 RuleCapturingGroupBuilder builder_(_fbb);
2430 builder_.add_entity_data(entity_data);
2431 builder_.add_normalization_options(normalization_options);
2432 builder_.add_text_reply(text_reply);
2433 builder_.add_annotation_name(annotation_name);
2434 builder_.add_annotation_type(annotation_type);
2435 builder_.add_entity_field(entity_field);
2436 builder_.add_group_id(group_id);
2437 builder_.add_use_annotation_match(use_annotation_match);
2438 return builder_.Finish();
2439 }
2440
2441 inline flatbuffers::Offset<RuleCapturingGroup> CreateRuleCapturingGroupDirect(
2442 flatbuffers::FlatBufferBuilder &_fbb,
2443 int32_t group_id = 0,
2444 flatbuffers::Offset<libtextclassifier3::FlatbufferFieldPath> entity_field = 0,
2445 const char *annotation_type = nullptr,
2446 const char *annotation_name = nullptr,
2447 flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> text_reply = 0,
2448 flatbuffers::Offset<libtextclassifier3::NormalizationOptions> normalization_options = 0,
2449 bool use_annotation_match = false,
2450 flatbuffers::Offset<libtextclassifier3::ActionsEntityData> entity_data = 0) {
2451 auto annotation_type__ = annotation_type ? _fbb.CreateSharedString(annotation_type) : 0;
2452 auto annotation_name__ = annotation_name ? _fbb.CreateSharedString(annotation_name) : 0;
2453 return libtextclassifier3::RulesModel_::RuleActionSpec_::CreateRuleCapturingGroup(
2454 _fbb,
2455 group_id,
2456 entity_field,
2457 annotation_type__,
2458 annotation_name__,
2459 text_reply,
2460 normalization_options,
2461 use_annotation_match,
2462 entity_data);
2463 }
2464
2465 flatbuffers::Offset<RuleCapturingGroup> CreateRuleCapturingGroup(flatbuffers::FlatBufferBuilder &_fbb, const RuleCapturingGroupT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2466
2467 } // namespace RuleActionSpec_
2468
2469 struct RuleActionSpecT : public flatbuffers::NativeTable {
2470 typedef RuleActionSpec TableType;
2471 std::unique_ptr<libtextclassifier3::ActionSuggestionSpecT> action{};
2472 std::vector<std::unique_ptr<libtextclassifier3::RulesModel_::RuleActionSpec_::RuleCapturingGroupT>> capturing_group{};
2473 RuleActionSpecT() = default;
2474 RuleActionSpecT(const RuleActionSpecT &o);
2475 RuleActionSpecT(RuleActionSpecT&&) FLATBUFFERS_NOEXCEPT = default;
2476 RuleActionSpecT &operator=(RuleActionSpecT o) FLATBUFFERS_NOEXCEPT;
2477 };
2478
2479 struct RuleActionSpec FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2480 typedef RuleActionSpecT NativeTableType;
2481 typedef RuleActionSpecBuilder Builder;
2482 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2483 VT_ACTION = 4,
2484 VT_CAPTURING_GROUP = 6
2485 };
actionFLATBUFFERS_FINAL_CLASS2486 const libtextclassifier3::ActionSuggestionSpec *action() const {
2487 return GetPointer<const libtextclassifier3::ActionSuggestionSpec *>(VT_ACTION);
2488 }
capturing_groupFLATBUFFERS_FINAL_CLASS2489 const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::RulesModel_::RuleActionSpec_::RuleCapturingGroup>> *capturing_group() const {
2490 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::RulesModel_::RuleActionSpec_::RuleCapturingGroup>> *>(VT_CAPTURING_GROUP);
2491 }
VerifyFLATBUFFERS_FINAL_CLASS2492 bool Verify(flatbuffers::Verifier &verifier) const {
2493 return VerifyTableStart(verifier) &&
2494 VerifyOffset(verifier, VT_ACTION) &&
2495 verifier.VerifyTable(action()) &&
2496 VerifyOffset(verifier, VT_CAPTURING_GROUP) &&
2497 verifier.VerifyVector(capturing_group()) &&
2498 verifier.VerifyVectorOfTables(capturing_group()) &&
2499 verifier.EndTable();
2500 }
2501 RuleActionSpecT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2502 void UnPackTo(RuleActionSpecT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2503 static flatbuffers::Offset<RuleActionSpec> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RuleActionSpecT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2504 };
2505
2506 struct RuleActionSpecBuilder {
2507 typedef RuleActionSpec Table;
2508 flatbuffers::FlatBufferBuilder &fbb_;
2509 flatbuffers::uoffset_t start_;
add_actionRuleActionSpecBuilder2510 void add_action(flatbuffers::Offset<libtextclassifier3::ActionSuggestionSpec> action) {
2511 fbb_.AddOffset(RuleActionSpec::VT_ACTION, action);
2512 }
add_capturing_groupRuleActionSpecBuilder2513 void add_capturing_group(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::RulesModel_::RuleActionSpec_::RuleCapturingGroup>>> capturing_group) {
2514 fbb_.AddOffset(RuleActionSpec::VT_CAPTURING_GROUP, capturing_group);
2515 }
RuleActionSpecBuilderRuleActionSpecBuilder2516 explicit RuleActionSpecBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2517 : fbb_(_fbb) {
2518 start_ = fbb_.StartTable();
2519 }
FinishRuleActionSpecBuilder2520