supermemory 3.7.0__py3-none-any.whl → 3.19.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (53) hide show
  1. supermemory/_base_client.py +140 -11
  2. supermemory/_client.py +226 -52
  3. supermemory/_models.py +16 -1
  4. supermemory/_streaming.py +12 -10
  5. supermemory/_types.py +12 -2
  6. supermemory/_version.py +1 -1
  7. supermemory/resources/connections.py +219 -29
  8. supermemory/resources/documents.py +306 -2
  9. supermemory/resources/memories.py +270 -1
  10. supermemory/resources/search.py +14 -0
  11. supermemory/resources/settings.py +12 -0
  12. supermemory/types/__init__.py +15 -2
  13. supermemory/types/client_profile_params.py +6 -0
  14. supermemory/types/connection_configure_params.py +12 -0
  15. supermemory/types/connection_configure_response.py +17 -0
  16. supermemory/types/connection_get_by_id_response.py +3 -1
  17. supermemory/types/{connection_get_by_tags_params.py → connection_get_by_tag_params.py} +2 -2
  18. supermemory/types/{connection_get_by_tags_response.py → connection_get_by_tag_response.py} +5 -3
  19. supermemory/types/connection_list_response.py +2 -0
  20. supermemory/types/connection_resources_params.py +13 -0
  21. supermemory/types/connection_resources_response.py +13 -0
  22. supermemory/types/document_batch_add_params.py +84 -0
  23. supermemory/types/document_batch_add_response.py +19 -0
  24. supermemory/types/document_delete_bulk_params.py +18 -0
  25. supermemory/types/document_delete_bulk_response.py +37 -0
  26. supermemory/types/document_get_response.py +7 -0
  27. supermemory/types/document_list_params.py +3790 -3
  28. supermemory/types/document_list_processing_response.py +75 -0
  29. supermemory/types/document_list_response.py +5 -0
  30. supermemory/types/document_upload_file_params.py +8 -0
  31. supermemory/types/memory_forget_params.py +26 -0
  32. supermemory/types/memory_forget_response.py +15 -0
  33. supermemory/types/memory_get_response.py +7 -0
  34. supermemory/types/memory_list_params.py +3790 -3
  35. supermemory/types/memory_list_response.py +5 -0
  36. supermemory/types/memory_update_memory_params.py +31 -0
  37. supermemory/types/memory_update_memory_response.py +31 -0
  38. supermemory/types/memory_upload_file_params.py +8 -0
  39. supermemory/types/profile_response.py +2 -0
  40. supermemory/types/search_documents_params.py +3791 -4
  41. supermemory/types/search_documents_response.py +2 -0
  42. supermemory/types/search_execute_params.py +3791 -4
  43. supermemory/types/search_execute_response.py +2 -0
  44. supermemory/types/search_memories_params.py +3809 -8
  45. supermemory/types/search_memories_response.py +33 -5
  46. supermemory/types/setting_get_response.py +6 -0
  47. supermemory/types/setting_update_params.py +6 -0
  48. supermemory/types/setting_update_response.py +6 -0
  49. {supermemory-3.7.0.dist-info → supermemory-3.19.0.dist-info}/METADATA +12 -2
  50. supermemory-3.19.0.dist-info/RECORD +97 -0
  51. {supermemory-3.7.0.dist-info → supermemory-3.19.0.dist-info}/licenses/LICENSE +1 -1
  52. supermemory-3.7.0.dist-info/RECORD +0 -84
  53. {supermemory-3.7.0.dist-info → supermemory-3.19.0.dist-info}/WHEEL +0 -0
supermemory/types/memory_list_params.py CHANGED
@@ -8,7 +8,324 @@ from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
8
8
  from .._types import SequenceNotStr
9
9
  from .._utils import PropertyInfo
10
10
 
11
- __all__ = ["MemoryListParams", "Filters", "FiltersOr", "FiltersAnd"]
11
+ __all__ = [
12
+ "MemoryListParams",
13
+ "Filters",
14
+ "FiltersOr",
15
+ "FiltersOrOr",
16
+ "FiltersOrOrUnionMember0",
17
+ "FiltersOrOrOr",
18
+ "FiltersOrOrOrOr",
19
+ "FiltersOrOrOrOrUnionMember0",
20
+ "FiltersOrOrOrOrOr",
21
+ "FiltersOrOrOrOrOrOr",
22
+ "FiltersOrOrOrOrOrOrUnionMember0",
23
+ "FiltersOrOrOrOrOrOrOr",
24
+ "FiltersOrOrOrOrOrOrOrOr",
25
+ "FiltersOrOrOrOrOrOrOrOrUnionMember0",
26
+ "FiltersOrOrOrOrOrOrOrOrOr",
27
+ "FiltersOrOrOrOrOrOrOrOrOrOr",
28
+ "FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0",
29
+ "FiltersOrOrOrOrOrOrOrOrOrOrOr",
30
+ "FiltersOrOrOrOrOrOrOrOrOrOrOrOr",
31
+ "FiltersOrOrOrOrOrOrOrOrOrOrAnd",
32
+ "FiltersOrOrOrOrOrOrOrOrOrOrAndAnd",
33
+ "FiltersOrOrOrOrOrOrOrOrAnd",
34
+ "FiltersOrOrOrOrOrOrOrOrAndAnd",
35
+ "FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0",
36
+ "FiltersOrOrOrOrOrOrOrOrAndAndOr",
37
+ "FiltersOrOrOrOrOrOrOrOrAndAndOrOr",
38
+ "FiltersOrOrOrOrOrOrOrOrAndAndAnd",
39
+ "FiltersOrOrOrOrOrOrOrOrAndAndAndAnd",
40
+ "FiltersOrOrOrOrOrOrAnd",
41
+ "FiltersOrOrOrOrOrOrAndAnd",
42
+ "FiltersOrOrOrOrOrOrAndAndUnionMember0",
43
+ "FiltersOrOrOrOrOrOrAndAndOr",
44
+ "FiltersOrOrOrOrOrOrAndAndOrOr",
45
+ "FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0",
46
+ "FiltersOrOrOrOrOrOrAndAndOrOrOr",
47
+ "FiltersOrOrOrOrOrOrAndAndOrOrOrOr",
48
+ "FiltersOrOrOrOrOrOrAndAndOrOrAnd",
49
+ "FiltersOrOrOrOrOrOrAndAndOrOrAndAnd",
50
+ "FiltersOrOrOrOrOrOrAndAndAnd",
51
+ "FiltersOrOrOrOrOrOrAndAndAndAnd",
52
+ "FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0",
53
+ "FiltersOrOrOrOrOrOrAndAndAndAndOr",
54
+ "FiltersOrOrOrOrOrOrAndAndAndAndOrOr",
55
+ "FiltersOrOrOrOrOrOrAndAndAndAndAnd",
56
+ "FiltersOrOrOrOrOrOrAndAndAndAndAndAnd",
57
+ "FiltersOrOrOrOrAnd",
58
+ "FiltersOrOrOrOrAndAnd",
59
+ "FiltersOrOrOrOrAndAndUnionMember0",
60
+ "FiltersOrOrOrOrAndAndOr",
61
+ "FiltersOrOrOrOrAndAndOrOr",
62
+ "FiltersOrOrOrOrAndAndOrOrUnionMember0",
63
+ "FiltersOrOrOrOrAndAndOrOrOr",
64
+ "FiltersOrOrOrOrAndAndOrOrOrOr",
65
+ "FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0",
66
+ "FiltersOrOrOrOrAndAndOrOrOrOrOr",
67
+ "FiltersOrOrOrOrAndAndOrOrOrOrOrOr",
68
+ "FiltersOrOrOrOrAndAndOrOrOrOrAnd",
69
+ "FiltersOrOrOrOrAndAndOrOrOrOrAndAnd",
70
+ "FiltersOrOrOrOrAndAndOrOrAnd",
71
+ "FiltersOrOrOrOrAndAndOrOrAndAnd",
72
+ "FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0",
73
+ "FiltersOrOrOrOrAndAndOrOrAndAndOr",
74
+ "FiltersOrOrOrOrAndAndOrOrAndAndOrOr",
75
+ "FiltersOrOrOrOrAndAndOrOrAndAndAnd",
76
+ "FiltersOrOrOrOrAndAndOrOrAndAndAndAnd",
77
+ "FiltersOrOrOrOrAndAndAnd",
78
+ "FiltersOrOrOrOrAndAndAndAnd",
79
+ "FiltersOrOrOrOrAndAndAndAndUnionMember0",
80
+ "FiltersOrOrOrOrAndAndAndAndOr",
81
+ "FiltersOrOrOrOrAndAndAndAndOrOr",
82
+ "FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0",
83
+ "FiltersOrOrOrOrAndAndAndAndOrOrOr",
84
+ "FiltersOrOrOrOrAndAndAndAndOrOrOrOr",
85
+ "FiltersOrOrOrOrAndAndAndAndOrOrAnd",
86
+ "FiltersOrOrOrOrAndAndAndAndOrOrAndAnd",
87
+ "FiltersOrOrOrOrAndAndAndAndAnd",
88
+ "FiltersOrOrOrOrAndAndAndAndAndAnd",
89
+ "FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0",
90
+ "FiltersOrOrOrOrAndAndAndAndAndAndOr",
91
+ "FiltersOrOrOrOrAndAndAndAndAndAndOrOr",
92
+ "FiltersOrOrOrOrAndAndAndAndAndAndAnd",
93
+ "FiltersOrOrOrOrAndAndAndAndAndAndAndAnd",
94
+ "FiltersOrOrAnd",
95
+ "FiltersOrOrAndAnd",
96
+ "FiltersOrOrAndAndUnionMember0",
97
+ "FiltersOrOrAndAndOr",
98
+ "FiltersOrOrAndAndOrOr",
99
+ "FiltersOrOrAndAndOrOrUnionMember0",
100
+ "FiltersOrOrAndAndOrOrOr",
101
+ "FiltersOrOrAndAndOrOrOrOr",
102
+ "FiltersOrOrAndAndOrOrOrOrUnionMember0",
103
+ "FiltersOrOrAndAndOrOrOrOrOr",
104
+ "FiltersOrOrAndAndOrOrOrOrOrOr",
105
+ "FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0",
106
+ "FiltersOrOrAndAndOrOrOrOrOrOrOr",
107
+ "FiltersOrOrAndAndOrOrOrOrOrOrOrOr",
108
+ "FiltersOrOrAndAndOrOrOrOrOrOrAnd",
109
+ "FiltersOrOrAndAndOrOrOrOrOrOrAndAnd",
110
+ "FiltersOrOrAndAndOrOrOrOrAnd",
111
+ "FiltersOrOrAndAndOrOrOrOrAndAnd",
112
+ "FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0",
113
+ "FiltersOrOrAndAndOrOrOrOrAndAndOr",
114
+ "FiltersOrOrAndAndOrOrOrOrAndAndOrOr",
115
+ "FiltersOrOrAndAndOrOrOrOrAndAndAnd",
116
+ "FiltersOrOrAndAndOrOrOrOrAndAndAndAnd",
117
+ "FiltersOrOrAndAndOrOrAnd",
118
+ "FiltersOrOrAndAndOrOrAndAnd",
119
+ "FiltersOrOrAndAndOrOrAndAndUnionMember0",
120
+ "FiltersOrOrAndAndOrOrAndAndOr",
121
+ "FiltersOrOrAndAndOrOrAndAndOrOr",
122
+ "FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0",
123
+ "FiltersOrOrAndAndOrOrAndAndOrOrOr",
124
+ "FiltersOrOrAndAndOrOrAndAndOrOrOrOr",
125
+ "FiltersOrOrAndAndOrOrAndAndOrOrAnd",
126
+ "FiltersOrOrAndAndOrOrAndAndOrOrAndAnd",
127
+ "FiltersOrOrAndAndOrOrAndAndAnd",
128
+ "FiltersOrOrAndAndOrOrAndAndAndAnd",
129
+ "FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0",
130
+ "FiltersOrOrAndAndOrOrAndAndAndAndOr",
131
+ "FiltersOrOrAndAndOrOrAndAndAndAndOrOr",
132
+ "FiltersOrOrAndAndOrOrAndAndAndAndAnd",
133
+ "FiltersOrOrAndAndOrOrAndAndAndAndAndAnd",
134
+ "FiltersOrOrAndAndAnd",
135
+ "FiltersOrOrAndAndAndAnd",
136
+ "FiltersOrOrAndAndAndAndUnionMember0",
137
+ "FiltersOrOrAndAndAndAndOr",
138
+ "FiltersOrOrAndAndAndAndOrOr",
139
+ "FiltersOrOrAndAndAndAndOrOrUnionMember0",
140
+ "FiltersOrOrAndAndAndAndOrOrOr",
141
+ "FiltersOrOrAndAndAndAndOrOrOrOr",
142
+ "FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0",
143
+ "FiltersOrOrAndAndAndAndOrOrOrOrOr",
144
+ "FiltersOrOrAndAndAndAndOrOrOrOrOrOr",
145
+ "FiltersOrOrAndAndAndAndOrOrOrOrAnd",
146
+ "FiltersOrOrAndAndAndAndOrOrOrOrAndAnd",
147
+ "FiltersOrOrAndAndAndAndOrOrAnd",
148
+ "FiltersOrOrAndAndAndAndOrOrAndAnd",
149
+ "FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0",
150
+ "FiltersOrOrAndAndAndAndOrOrAndAndOr",
151
+ "FiltersOrOrAndAndAndAndOrOrAndAndOrOr",
152
+ "FiltersOrOrAndAndAndAndOrOrAndAndAnd",
153
+ "FiltersOrOrAndAndAndAndOrOrAndAndAndAnd",
154
+ "FiltersOrOrAndAndAndAndAnd",
155
+ "FiltersOrOrAndAndAndAndAndAnd",
156
+ "FiltersOrOrAndAndAndAndAndAndUnionMember0",
157
+ "FiltersOrOrAndAndAndAndAndAndOr",
158
+ "FiltersOrOrAndAndAndAndAndAndOrOr",
159
+ "FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0",
160
+ "FiltersOrOrAndAndAndAndAndAndOrOrOr",
161
+ "FiltersOrOrAndAndAndAndAndAndOrOrOrOr",
162
+ "FiltersOrOrAndAndAndAndAndAndOrOrAnd",
163
+ "FiltersOrOrAndAndAndAndAndAndOrOrAndAnd",
164
+ "FiltersOrOrAndAndAndAndAndAndAnd",
165
+ "FiltersOrOrAndAndAndAndAndAndAndAnd",
166
+ "FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0",
167
+ "FiltersOrOrAndAndAndAndAndAndAndAndOr",
168
+ "FiltersOrOrAndAndAndAndAndAndAndAndOrOr",
169
+ "FiltersOrOrAndAndAndAndAndAndAndAndAnd",
170
+ "FiltersOrOrAndAndAndAndAndAndAndAndAndAnd",
171
+ "FiltersAnd",
172
+ "FiltersAndAnd",
173
+ "FiltersAndAndUnionMember0",
174
+ "FiltersAndAndOr",
175
+ "FiltersAndAndOrOr",
176
+ "FiltersAndAndOrOrUnionMember0",
177
+ "FiltersAndAndOrOrOr",
178
+ "FiltersAndAndOrOrOrOr",
179
+ "FiltersAndAndOrOrOrOrUnionMember0",
180
+ "FiltersAndAndOrOrOrOrOr",
181
+ "FiltersAndAndOrOrOrOrOrOr",
182
+ "FiltersAndAndOrOrOrOrOrOrUnionMember0",
183
+ "FiltersAndAndOrOrOrOrOrOrOr",
184
+ "FiltersAndAndOrOrOrOrOrOrOrOr",
185
+ "FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0",
186
+ "FiltersAndAndOrOrOrOrOrOrOrOrOr",
187
+ "FiltersAndAndOrOrOrOrOrOrOrOrOrOr",
188
+ "FiltersAndAndOrOrOrOrOrOrOrOrAnd",
189
+ "FiltersAndAndOrOrOrOrOrOrOrOrAndAnd",
190
+ "FiltersAndAndOrOrOrOrOrOrAnd",
191
+ "FiltersAndAndOrOrOrOrOrOrAndAnd",
192
+ "FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0",
193
+ "FiltersAndAndOrOrOrOrOrOrAndAndOr",
194
+ "FiltersAndAndOrOrOrOrOrOrAndAndOrOr",
195
+ "FiltersAndAndOrOrOrOrOrOrAndAndAnd",
196
+ "FiltersAndAndOrOrOrOrOrOrAndAndAndAnd",
197
+ "FiltersAndAndOrOrOrOrAnd",
198
+ "FiltersAndAndOrOrOrOrAndAnd",
199
+ "FiltersAndAndOrOrOrOrAndAndUnionMember0",
200
+ "FiltersAndAndOrOrOrOrAndAndOr",
201
+ "FiltersAndAndOrOrOrOrAndAndOrOr",
202
+ "FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0",
203
+ "FiltersAndAndOrOrOrOrAndAndOrOrOr",
204
+ "FiltersAndAndOrOrOrOrAndAndOrOrOrOr",
205
+ "FiltersAndAndOrOrOrOrAndAndOrOrAnd",
206
+ "FiltersAndAndOrOrOrOrAndAndOrOrAndAnd",
207
+ "FiltersAndAndOrOrOrOrAndAndAnd",
208
+ "FiltersAndAndOrOrOrOrAndAndAndAnd",
209
+ "FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0",
210
+ "FiltersAndAndOrOrOrOrAndAndAndAndOr",
211
+ "FiltersAndAndOrOrOrOrAndAndAndAndOrOr",
212
+ "FiltersAndAndOrOrOrOrAndAndAndAndAnd",
213
+ "FiltersAndAndOrOrOrOrAndAndAndAndAndAnd",
214
+ "FiltersAndAndOrOrAnd",
215
+ "FiltersAndAndOrOrAndAnd",
216
+ "FiltersAndAndOrOrAndAndUnionMember0",
217
+ "FiltersAndAndOrOrAndAndOr",
218
+ "FiltersAndAndOrOrAndAndOrOr",
219
+ "FiltersAndAndOrOrAndAndOrOrUnionMember0",
220
+ "FiltersAndAndOrOrAndAndOrOrOr",
221
+ "FiltersAndAndOrOrAndAndOrOrOrOr",
222
+ "FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0",
223
+ "FiltersAndAndOrOrAndAndOrOrOrOrOr",
224
+ "FiltersAndAndOrOrAndAndOrOrOrOrOrOr",
225
+ "FiltersAndAndOrOrAndAndOrOrOrOrAnd",
226
+ "FiltersAndAndOrOrAndAndOrOrOrOrAndAnd",
227
+ "FiltersAndAndOrOrAndAndOrOrAnd",
228
+ "FiltersAndAndOrOrAndAndOrOrAndAnd",
229
+ "FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0",
230
+ "FiltersAndAndOrOrAndAndOrOrAndAndOr",
231
+ "FiltersAndAndOrOrAndAndOrOrAndAndOrOr",
232
+ "FiltersAndAndOrOrAndAndOrOrAndAndAnd",
233
+ "FiltersAndAndOrOrAndAndOrOrAndAndAndAnd",
234
+ "FiltersAndAndOrOrAndAndAnd",
235
+ "FiltersAndAndOrOrAndAndAndAnd",
236
+ "FiltersAndAndOrOrAndAndAndAndUnionMember0",
237
+ "FiltersAndAndOrOrAndAndAndAndOr",
238
+ "FiltersAndAndOrOrAndAndAndAndOrOr",
239
+ "FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0",
240
+ "FiltersAndAndOrOrAndAndAndAndOrOrOr",
241
+ "FiltersAndAndOrOrAndAndAndAndOrOrOrOr",
242
+ "FiltersAndAndOrOrAndAndAndAndOrOrAnd",
243
+ "FiltersAndAndOrOrAndAndAndAndOrOrAndAnd",
244
+ "FiltersAndAndOrOrAndAndAndAndAnd",
245
+ "FiltersAndAndOrOrAndAndAndAndAndAnd",
246
+ "FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0",
247
+ "FiltersAndAndOrOrAndAndAndAndAndAndOr",
248
+ "FiltersAndAndOrOrAndAndAndAndAndAndOrOr",
249
+ "FiltersAndAndOrOrAndAndAndAndAndAndAnd",
250
+ "FiltersAndAndOrOrAndAndAndAndAndAndAndAnd",
251
+ "FiltersAndAndAnd",
252
+ "FiltersAndAndAndAnd",
253
+ "FiltersAndAndAndAndUnionMember0",
254
+ "FiltersAndAndAndAndOr",
255
+ "FiltersAndAndAndAndOrOr",
256
+ "FiltersAndAndAndAndOrOrUnionMember0",
257
+ "FiltersAndAndAndAndOrOrOr",
258
+ "FiltersAndAndAndAndOrOrOrOr",
259
+ "FiltersAndAndAndAndOrOrOrOrUnionMember0",
260
+ "FiltersAndAndAndAndOrOrOrOrOr",
261
+ "FiltersAndAndAndAndOrOrOrOrOrOr",
262
+ "FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0",
263
+ "FiltersAndAndAndAndOrOrOrOrOrOrOr",
264
+ "FiltersAndAndAndAndOrOrOrOrOrOrOrOr",
265
+ "FiltersAndAndAndAndOrOrOrOrOrOrAnd",
266
+ "FiltersAndAndAndAndOrOrOrOrOrOrAndAnd",
267
+ "FiltersAndAndAndAndOrOrOrOrAnd",
268
+ "FiltersAndAndAndAndOrOrOrOrAndAnd",
269
+ "FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0",
270
+ "FiltersAndAndAndAndOrOrOrOrAndAndOr",
271
+ "FiltersAndAndAndAndOrOrOrOrAndAndOrOr",
272
+ "FiltersAndAndAndAndOrOrOrOrAndAndAnd",
273
+ "FiltersAndAndAndAndOrOrOrOrAndAndAndAnd",
274
+ "FiltersAndAndAndAndOrOrAnd",
275
+ "FiltersAndAndAndAndOrOrAndAnd",
276
+ "FiltersAndAndAndAndOrOrAndAndUnionMember0",
277
+ "FiltersAndAndAndAndOrOrAndAndOr",
278
+ "FiltersAndAndAndAndOrOrAndAndOrOr",
279
+ "FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0",
280
+ "FiltersAndAndAndAndOrOrAndAndOrOrOr",
281
+ "FiltersAndAndAndAndOrOrAndAndOrOrOrOr",
282
+ "FiltersAndAndAndAndOrOrAndAndOrOrAnd",
283
+ "FiltersAndAndAndAndOrOrAndAndOrOrAndAnd",
284
+ "FiltersAndAndAndAndOrOrAndAndAnd",
285
+ "FiltersAndAndAndAndOrOrAndAndAndAnd",
286
+ "FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0",
287
+ "FiltersAndAndAndAndOrOrAndAndAndAndOr",
288
+ "FiltersAndAndAndAndOrOrAndAndAndAndOrOr",
289
+ "FiltersAndAndAndAndOrOrAndAndAndAndAnd",
290
+ "FiltersAndAndAndAndOrOrAndAndAndAndAndAnd",
291
+ "FiltersAndAndAndAndAnd",
292
+ "FiltersAndAndAndAndAndAnd",
293
+ "FiltersAndAndAndAndAndAndUnionMember0",
294
+ "FiltersAndAndAndAndAndAndOr",
295
+ "FiltersAndAndAndAndAndAndOrOr",
296
+ "FiltersAndAndAndAndAndAndOrOrUnionMember0",
297
+ "FiltersAndAndAndAndAndAndOrOrOr",
298
+ "FiltersAndAndAndAndAndAndOrOrOrOr",
299
+ "FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0",
300
+ "FiltersAndAndAndAndAndAndOrOrOrOrOr",
301
+ "FiltersAndAndAndAndAndAndOrOrOrOrOrOr",
302
+ "FiltersAndAndAndAndAndAndOrOrOrOrAnd",
303
+ "FiltersAndAndAndAndAndAndOrOrOrOrAndAnd",
304
+ "FiltersAndAndAndAndAndAndOrOrAnd",
305
+ "FiltersAndAndAndAndAndAndOrOrAndAnd",
306
+ "FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0",
307
+ "FiltersAndAndAndAndAndAndOrOrAndAndOr",
308
+ "FiltersAndAndAndAndAndAndOrOrAndAndOrOr",
309
+ "FiltersAndAndAndAndAndAndOrOrAndAndAnd",
310
+ "FiltersAndAndAndAndAndAndOrOrAndAndAndAnd",
311
+ "FiltersAndAndAndAndAndAndAnd",
312
+ "FiltersAndAndAndAndAndAndAndAnd",
313
+ "FiltersAndAndAndAndAndAndAndAndUnionMember0",
314
+ "FiltersAndAndAndAndAndAndAndAndOr",
315
+ "FiltersAndAndAndAndAndAndAndAndOrOr",
316
+ "FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0",
317
+ "FiltersAndAndAndAndAndAndAndAndOrOrOr",
318
+ "FiltersAndAndAndAndAndAndAndAndOrOrOrOr",
319
+ "FiltersAndAndAndAndAndAndAndAndOrOrAnd",
320
+ "FiltersAndAndAndAndAndAndAndAndOrOrAndAnd",
321
+ "FiltersAndAndAndAndAndAndAndAndAnd",
322
+ "FiltersAndAndAndAndAndAndAndAndAndAnd",
323
+ "FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0",
324
+ "FiltersAndAndAndAndAndAndAndAndAndAndOr",
325
+ "FiltersAndAndAndAndAndAndAndAndAndAndOrOr",
326
+ "FiltersAndAndAndAndAndAndAndAndAndAndAnd",
327
+ "FiltersAndAndAndAndAndAndAndAndAndAndAndAnd",
328
+ ]
12
329
 
13
330
 
14
331
  class MemoryListParams(TypedDict, total=False):
@@ -41,12 +358,3482 @@ class MemoryListParams(TypedDict, total=False):
41
358
  """Field to sort by"""
42
359
 
43
360
 
361
+ class FiltersOrOrUnionMember0(TypedDict, total=False):
362
+ """
363
+ A single filter condition based on metadata, numeric values, array contents, or string matching
364
+ """
365
+
366
+ key: Required[str]
367
+
368
+ value: Required[str]
369
+
370
+ filter_type: Annotated[
371
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
372
+ ]
373
+
374
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
375
+
376
+ negate: Union[bool, Literal["true", "false"]]
377
+
378
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
379
+
380
+
381
+ class FiltersOrOrOrOrUnionMember0(TypedDict, total=False):
382
+ """
383
+ A single filter condition based on metadata, numeric values, array contents, or string matching
384
+ """
385
+
386
+ key: Required[str]
387
+
388
+ value: Required[str]
389
+
390
+ filter_type: Annotated[
391
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
392
+ ]
393
+
394
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
395
+
396
+ negate: Union[bool, Literal["true", "false"]]
397
+
398
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
399
+
400
+
401
+ class FiltersOrOrOrOrOrOrUnionMember0(TypedDict, total=False):
402
+ """
403
+ A single filter condition based on metadata, numeric values, array contents, or string matching
404
+ """
405
+
406
+ key: Required[str]
407
+
408
+ value: Required[str]
409
+
410
+ filter_type: Annotated[
411
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
412
+ ]
413
+
414
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
415
+
416
+ negate: Union[bool, Literal["true", "false"]]
417
+
418
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
419
+
420
+
421
+ class FiltersOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False):
422
+ """
423
+ A single filter condition based on metadata, numeric values, array contents, or string matching
424
+ """
425
+
426
+ key: Required[str]
427
+
428
+ value: Required[str]
429
+
430
+ filter_type: Annotated[
431
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
432
+ ]
433
+
434
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
435
+
436
+ negate: Union[bool, Literal["true", "false"]]
437
+
438
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
439
+
440
+
441
+ class FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False):
442
+ """
443
+ A single filter condition based on metadata, numeric values, array contents, or string matching
444
+ """
445
+
446
+ key: Required[str]
447
+
448
+ value: Required[str]
449
+
450
+ filter_type: Annotated[
451
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
452
+ ]
453
+
454
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
455
+
456
+ negate: Union[bool, Literal["true", "false"]]
457
+
458
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
459
+
460
+
461
+ class FiltersOrOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False):
462
+ """
463
+ A single filter condition based on metadata, numeric values, array contents, or string matching
464
+ """
465
+
466
+ key: Required[str]
467
+
468
+ value: Required[str]
469
+
470
+ filter_type: Annotated[
471
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
472
+ ]
473
+
474
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
475
+
476
+ negate: Union[bool, Literal["true", "false"]]
477
+
478
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
479
+
480
+
481
+ class FiltersOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False):
482
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
483
+ """OR: Array of conditions"""
484
+
485
+
486
+ class FiltersOrOrOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False):
487
+ """
488
+ A single filter condition based on metadata, numeric values, array contents, or string matching
489
+ """
490
+
491
+ key: Required[str]
492
+
493
+ value: Required[str]
494
+
495
+ filter_type: Annotated[
496
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
497
+ ]
498
+
499
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
500
+
501
+ negate: Union[bool, Literal["true", "false"]]
502
+
503
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
504
+
505
+
506
+ class FiltersOrOrOrOrOrOrOrOrOrOrAnd(TypedDict, total=False):
507
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
508
+ """AND: Array of conditions"""
509
+
510
+
511
+ FiltersOrOrOrOrOrOrOrOrOrOr: TypeAlias = Union[
512
+ FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrOrOrAnd
513
+ ]
514
+
515
+
516
+ class FiltersOrOrOrOrOrOrOrOrOr(TypedDict, total=False):
517
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
518
+ """OR: Array of conditions or nested expressions"""
519
+
520
+
521
+ class FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False):
522
+ """
523
+ A single filter condition based on metadata, numeric values, array contents, or string matching
524
+ """
525
+
526
+ key: Required[str]
527
+
528
+ value: Required[str]
529
+
530
+ filter_type: Annotated[
531
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
532
+ ]
533
+
534
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
535
+
536
+ negate: Union[bool, Literal["true", "false"]]
537
+
538
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
539
+
540
+
541
+ class FiltersOrOrOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False):
542
+ """
543
+ A single filter condition based on metadata, numeric values, array contents, or string matching
544
+ """
545
+
546
+ key: Required[str]
547
+
548
+ value: Required[str]
549
+
550
+ filter_type: Annotated[
551
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
552
+ ]
553
+
554
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
555
+
556
+ negate: Union[bool, Literal["true", "false"]]
557
+
558
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
559
+
560
+
561
+ class FiltersOrOrOrOrOrOrOrOrAndAndOr(TypedDict, total=False):
562
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
563
+ """OR: Array of conditions"""
564
+
565
+
566
+ class FiltersOrOrOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False):
567
+ """
568
+ A single filter condition based on metadata, numeric values, array contents, or string matching
569
+ """
570
+
571
+ key: Required[str]
572
+
573
+ value: Required[str]
574
+
575
+ filter_type: Annotated[
576
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
577
+ ]
578
+
579
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
580
+
581
+ negate: Union[bool, Literal["true", "false"]]
582
+
583
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
584
+
585
+
586
+ class FiltersOrOrOrOrOrOrOrOrAndAndAnd(TypedDict, total=False):
587
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
588
+ """AND: Array of conditions"""
589
+
590
+
591
+ FiltersOrOrOrOrOrOrOrOrAndAnd: TypeAlias = Union[
592
+ FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrOrOrAndAndAnd
593
+ ]
594
+
595
+
596
+ class FiltersOrOrOrOrOrOrOrOrAnd(TypedDict, total=False):
597
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
598
+ """AND: Array of conditions or nested expressions"""
599
+
600
+
601
+ FiltersOrOrOrOrOrOrOrOr: TypeAlias = Union[
602
+ FiltersOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrAnd
603
+ ]
604
+
605
+
606
+ class FiltersOrOrOrOrOrOrOr(TypedDict, total=False):
607
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
608
+ """OR: Array of conditions or nested expressions"""
609
+
610
+
611
+ class FiltersOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False):
612
+ """
613
+ A single filter condition based on metadata, numeric values, array contents, or string matching
614
+ """
615
+
616
+ key: Required[str]
617
+
618
+ value: Required[str]
619
+
620
+ filter_type: Annotated[
621
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
622
+ ]
623
+
624
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
625
+
626
+ negate: Union[bool, Literal["true", "false"]]
627
+
628
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
629
+
630
+
631
+ class FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False):
632
+ """
633
+ A single filter condition based on metadata, numeric values, array contents, or string matching
634
+ """
635
+
636
+ key: Required[str]
637
+
638
+ value: Required[str]
639
+
640
+ filter_type: Annotated[
641
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
642
+ ]
643
+
644
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
645
+
646
+ negate: Union[bool, Literal["true", "false"]]
647
+
648
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
649
+
650
+
651
+ class FiltersOrOrOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False):
652
+ """
653
+ A single filter condition based on metadata, numeric values, array contents, or string matching
654
+ """
655
+
656
+ key: Required[str]
657
+
658
+ value: Required[str]
659
+
660
+ filter_type: Annotated[
661
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
662
+ ]
663
+
664
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
665
+
666
+ negate: Union[bool, Literal["true", "false"]]
667
+
668
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
669
+
670
+
671
+ class FiltersOrOrOrOrOrOrAndAndOrOrOr(TypedDict, total=False):
672
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
673
+ """OR: Array of conditions"""
674
+
675
+
676
+ class FiltersOrOrOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False):
677
+ """
678
+ A single filter condition based on metadata, numeric values, array contents, or string matching
679
+ """
680
+
681
+ key: Required[str]
682
+
683
+ value: Required[str]
684
+
685
+ filter_type: Annotated[
686
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
687
+ ]
688
+
689
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
690
+
691
+ negate: Union[bool, Literal["true", "false"]]
692
+
693
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
694
+
695
+
696
+ class FiltersOrOrOrOrOrOrAndAndOrOrAnd(TypedDict, total=False):
697
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
698
+ """AND: Array of conditions"""
699
+
700
+
701
+ FiltersOrOrOrOrOrOrAndAndOrOr: TypeAlias = Union[
702
+ FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrOrOrAndAndOrOrAnd
703
+ ]
704
+
705
+
706
+ class FiltersOrOrOrOrOrOrAndAndOr(TypedDict, total=False):
707
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
708
+ """OR: Array of conditions or nested expressions"""
709
+
710
+
711
+ class FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False):
712
+ """
713
+ A single filter condition based on metadata, numeric values, array contents, or string matching
714
+ """
715
+
716
+ key: Required[str]
717
+
718
+ value: Required[str]
719
+
720
+ filter_type: Annotated[
721
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
722
+ ]
723
+
724
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
725
+
726
+ negate: Union[bool, Literal["true", "false"]]
727
+
728
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
729
+
730
+
731
+ class FiltersOrOrOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False):
732
+ """
733
+ A single filter condition based on metadata, numeric values, array contents, or string matching
734
+ """
735
+
736
+ key: Required[str]
737
+
738
+ value: Required[str]
739
+
740
+ filter_type: Annotated[
741
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
742
+ ]
743
+
744
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
745
+
746
+ negate: Union[bool, Literal["true", "false"]]
747
+
748
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
749
+
750
+
751
+ class FiltersOrOrOrOrOrOrAndAndAndAndOr(TypedDict, total=False):
752
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
753
+ """OR: Array of conditions"""
754
+
755
+
756
+ class FiltersOrOrOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False):
757
+ """
758
+ A single filter condition based on metadata, numeric values, array contents, or string matching
759
+ """
760
+
761
+ key: Required[str]
762
+
763
+ value: Required[str]
764
+
765
+ filter_type: Annotated[
766
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
767
+ ]
768
+
769
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
770
+
771
+ negate: Union[bool, Literal["true", "false"]]
772
+
773
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
774
+
775
+
776
+ class FiltersOrOrOrOrOrOrAndAndAndAndAnd(TypedDict, total=False):
777
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
778
+ """AND: Array of conditions"""
779
+
780
+
781
+ FiltersOrOrOrOrOrOrAndAndAndAnd: TypeAlias = Union[
782
+ FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrOrOrAndAndAndAndAnd
783
+ ]
784
+
785
+
786
+ class FiltersOrOrOrOrOrOrAndAndAnd(TypedDict, total=False):
787
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
788
+ """AND: Array of conditions or nested expressions"""
789
+
790
+
791
+ FiltersOrOrOrOrOrOrAndAnd: TypeAlias = Union[
792
+ FiltersOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrAndAndAnd
793
+ ]
794
+
795
+
796
+ class FiltersOrOrOrOrOrOrAnd(TypedDict, total=False):
797
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
798
+ """AND: Array of conditions or nested expressions"""
799
+
800
+
801
+ FiltersOrOrOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrAnd]
802
+
803
+
804
+ class FiltersOrOrOrOrOr(TypedDict, total=False):
805
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
806
+ """OR: Array of conditions or nested expressions"""
807
+
808
+
809
+ class FiltersOrOrOrOrAndAndUnionMember0(TypedDict, total=False):
810
+ """
811
+ A single filter condition based on metadata, numeric values, array contents, or string matching
812
+ """
813
+
814
+ key: Required[str]
815
+
816
+ value: Required[str]
817
+
818
+ filter_type: Annotated[
819
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
820
+ ]
821
+
822
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
823
+
824
+ negate: Union[bool, Literal["true", "false"]]
825
+
826
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
827
+
828
+
829
+ class FiltersOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False):
830
+ """
831
+ A single filter condition based on metadata, numeric values, array contents, or string matching
832
+ """
833
+
834
+ key: Required[str]
835
+
836
+ value: Required[str]
837
+
838
+ filter_type: Annotated[
839
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
840
+ ]
841
+
842
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
843
+
844
+ negate: Union[bool, Literal["true", "false"]]
845
+
846
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
847
+
848
+
849
+ class FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False):
850
+ """
851
+ A single filter condition based on metadata, numeric values, array contents, or string matching
852
+ """
853
+
854
+ key: Required[str]
855
+
856
+ value: Required[str]
857
+
858
+ filter_type: Annotated[
859
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
860
+ ]
861
+
862
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
863
+
864
+ negate: Union[bool, Literal["true", "false"]]
865
+
866
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
867
+
868
+
869
+ class FiltersOrOrOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False):
870
+ """
871
+ A single filter condition based on metadata, numeric values, array contents, or string matching
872
+ """
873
+
874
+ key: Required[str]
875
+
876
+ value: Required[str]
877
+
878
+ filter_type: Annotated[
879
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
880
+ ]
881
+
882
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
883
+
884
+ negate: Union[bool, Literal["true", "false"]]
885
+
886
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
887
+
888
+
889
+ class FiltersOrOrOrOrAndAndOrOrOrOrOr(TypedDict, total=False):
890
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
891
+ """OR: Array of conditions"""
892
+
893
+
894
+ class FiltersOrOrOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False):
895
+ """
896
+ A single filter condition based on metadata, numeric values, array contents, or string matching
897
+ """
898
+
899
+ key: Required[str]
900
+
901
+ value: Required[str]
902
+
903
+ filter_type: Annotated[
904
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
905
+ ]
906
+
907
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
908
+
909
+ negate: Union[bool, Literal["true", "false"]]
910
+
911
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
912
+
913
+
914
+ class FiltersOrOrOrOrAndAndOrOrOrOrAnd(TypedDict, total=False):
915
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
916
+ """AND: Array of conditions"""
917
+
918
+
919
+ FiltersOrOrOrOrAndAndOrOrOrOr: TypeAlias = Union[
920
+ FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOrOrOr, FiltersOrOrOrOrAndAndOrOrOrOrAnd
921
+ ]
922
+
923
+
924
+ class FiltersOrOrOrOrAndAndOrOrOr(TypedDict, total=False):
925
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
926
+ """OR: Array of conditions or nested expressions"""
927
+
928
+
929
+ class FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False):
930
+ """
931
+ A single filter condition based on metadata, numeric values, array contents, or string matching
932
+ """
933
+
934
+ key: Required[str]
935
+
936
+ value: Required[str]
937
+
938
+ filter_type: Annotated[
939
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
940
+ ]
941
+
942
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
943
+
944
+ negate: Union[bool, Literal["true", "false"]]
945
+
946
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
947
+
948
+
949
+ class FiltersOrOrOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False):
950
+ """
951
+ A single filter condition based on metadata, numeric values, array contents, or string matching
952
+ """
953
+
954
+ key: Required[str]
955
+
956
+ value: Required[str]
957
+
958
+ filter_type: Annotated[
959
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
960
+ ]
961
+
962
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
963
+
964
+ negate: Union[bool, Literal["true", "false"]]
965
+
966
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
967
+
968
+
969
+ class FiltersOrOrOrOrAndAndOrOrAndAndOr(TypedDict, total=False):
970
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
971
+ """OR: Array of conditions"""
972
+
973
+
974
+ class FiltersOrOrOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False):
975
+ """
976
+ A single filter condition based on metadata, numeric values, array contents, or string matching
977
+ """
978
+
979
+ key: Required[str]
980
+
981
+ value: Required[str]
982
+
983
+ filter_type: Annotated[
984
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
985
+ ]
986
+
987
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
988
+
989
+ negate: Union[bool, Literal["true", "false"]]
990
+
991
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
992
+
993
+
994
+ class FiltersOrOrOrOrAndAndOrOrAndAndAnd(TypedDict, total=False):
995
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
996
+ """AND: Array of conditions"""
997
+
998
+
999
+ FiltersOrOrOrOrAndAndOrOrAndAnd: TypeAlias = Union[
1000
+ FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOrOrAndAndOr, FiltersOrOrOrOrAndAndOrOrAndAndAnd
1001
+ ]
1002
+
1003
+
1004
+ class FiltersOrOrOrOrAndAndOrOrAnd(TypedDict, total=False):
1005
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
1006
+ """AND: Array of conditions or nested expressions"""
1007
+
1008
+
1009
+ FiltersOrOrOrOrAndAndOrOr: TypeAlias = Union[
1010
+ FiltersOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrAndAndOrOrAnd
1011
+ ]
1012
+
1013
+
1014
+ class FiltersOrOrOrOrAndAndOr(TypedDict, total=False):
1015
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
1016
+ """OR: Array of conditions or nested expressions"""
1017
+
1018
+
1019
+ class FiltersOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False):
1020
+ """
1021
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1022
+ """
1023
+
1024
+ key: Required[str]
1025
+
1026
+ value: Required[str]
1027
+
1028
+ filter_type: Annotated[
1029
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1030
+ ]
1031
+
1032
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1033
+
1034
+ negate: Union[bool, Literal["true", "false"]]
1035
+
1036
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1037
+
1038
+
1039
+ class FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False):
1040
+ """
1041
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1042
+ """
1043
+
1044
+ key: Required[str]
1045
+
1046
+ value: Required[str]
1047
+
1048
+ filter_type: Annotated[
1049
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1050
+ ]
1051
+
1052
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1053
+
1054
+ negate: Union[bool, Literal["true", "false"]]
1055
+
1056
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1057
+
1058
+
1059
+ class FiltersOrOrOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False):
1060
+ """
1061
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1062
+ """
1063
+
1064
+ key: Required[str]
1065
+
1066
+ value: Required[str]
1067
+
1068
+ filter_type: Annotated[
1069
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1070
+ ]
1071
+
1072
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1073
+
1074
+ negate: Union[bool, Literal["true", "false"]]
1075
+
1076
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1077
+
1078
+
1079
+ class FiltersOrOrOrOrAndAndAndAndOrOrOr(TypedDict, total=False):
1080
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
1081
+ """OR: Array of conditions"""
1082
+
1083
+
1084
+ class FiltersOrOrOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False):
1085
+ """
1086
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1087
+ """
1088
+
1089
+ key: Required[str]
1090
+
1091
+ value: Required[str]
1092
+
1093
+ filter_type: Annotated[
1094
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1095
+ ]
1096
+
1097
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1098
+
1099
+ negate: Union[bool, Literal["true", "false"]]
1100
+
1101
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1102
+
1103
+
1104
+ class FiltersOrOrOrOrAndAndAndAndOrOrAnd(TypedDict, total=False):
1105
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
1106
+ """AND: Array of conditions"""
1107
+
1108
+
1109
+ FiltersOrOrOrOrAndAndAndAndOrOr: TypeAlias = Union[
1110
+ FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndAndAndOrOrOr, FiltersOrOrOrOrAndAndAndAndOrOrAnd
1111
+ ]
1112
+
1113
+
1114
+ class FiltersOrOrOrOrAndAndAndAndOr(TypedDict, total=False):
1115
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
1116
+ """OR: Array of conditions or nested expressions"""
1117
+
1118
+
1119
+ class FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False):
1120
+ """
1121
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1122
+ """
1123
+
1124
+ key: Required[str]
1125
+
1126
+ value: Required[str]
1127
+
1128
+ filter_type: Annotated[
1129
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1130
+ ]
1131
+
1132
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1133
+
1134
+ negate: Union[bool, Literal["true", "false"]]
1135
+
1136
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1137
+
1138
+
1139
+ class FiltersOrOrOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False):
1140
+ """
1141
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1142
+ """
1143
+
1144
+ key: Required[str]
1145
+
1146
+ value: Required[str]
1147
+
1148
+ filter_type: Annotated[
1149
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1150
+ ]
1151
+
1152
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1153
+
1154
+ negate: Union[bool, Literal["true", "false"]]
1155
+
1156
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1157
+
1158
+
1159
+ class FiltersOrOrOrOrAndAndAndAndAndAndOr(TypedDict, total=False):
1160
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
1161
+ """OR: Array of conditions"""
1162
+
1163
+
1164
+ class FiltersOrOrOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False):
1165
+ """
1166
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1167
+ """
1168
+
1169
+ key: Required[str]
1170
+
1171
+ value: Required[str]
1172
+
1173
+ filter_type: Annotated[
1174
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1175
+ ]
1176
+
1177
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1178
+
1179
+ negate: Union[bool, Literal["true", "false"]]
1180
+
1181
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1182
+
1183
+
1184
+ class FiltersOrOrOrOrAndAndAndAndAndAndAnd(TypedDict, total=False):
1185
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
1186
+ """AND: Array of conditions"""
1187
+
1188
+
1189
+ FiltersOrOrOrOrAndAndAndAndAndAnd: TypeAlias = Union[
1190
+ FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0,
1191
+ FiltersOrOrOrOrAndAndAndAndAndAndOr,
1192
+ FiltersOrOrOrOrAndAndAndAndAndAndAnd,
1193
+ ]
1194
+
1195
+
1196
+ class FiltersOrOrOrOrAndAndAndAndAnd(TypedDict, total=False):
1197
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
1198
+ """AND: Array of conditions or nested expressions"""
1199
+
1200
+
1201
+ FiltersOrOrOrOrAndAndAndAnd: TypeAlias = Union[
1202
+ FiltersOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrAndAndAndAndAnd
1203
+ ]
1204
+
1205
+
1206
+ class FiltersOrOrOrOrAndAndAnd(TypedDict, total=False):
1207
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
1208
+ """AND: Array of conditions or nested expressions"""
1209
+
1210
+
1211
+ FiltersOrOrOrOrAndAnd: TypeAlias = Union[
1212
+ FiltersOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOr, FiltersOrOrOrOrAndAndAnd
1213
+ ]
1214
+
1215
+
1216
+ class FiltersOrOrOrOrAnd(TypedDict, total=False):
1217
+ and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
1218
+ """AND: Array of conditions or nested expressions"""
1219
+
1220
+
1221
+ FiltersOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrUnionMember0, FiltersOrOrOrOrOr, FiltersOrOrOrOrAnd]
1222
+
1223
+
1224
+ class FiltersOrOrOr(TypedDict, total=False):
1225
+ or_: Required[Annotated[Iterable[FiltersOrOrOrOr], PropertyInfo(alias="OR")]]
1226
+ """OR: Array of conditions or nested expressions"""
1227
+
1228
+
1229
+ class FiltersOrOrAndAndUnionMember0(TypedDict, total=False):
1230
+ """
1231
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1232
+ """
1233
+
1234
+ key: Required[str]
1235
+
1236
+ value: Required[str]
1237
+
1238
+ filter_type: Annotated[
1239
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1240
+ ]
1241
+
1242
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1243
+
1244
+ negate: Union[bool, Literal["true", "false"]]
1245
+
1246
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1247
+
1248
+
1249
+ class FiltersOrOrAndAndOrOrUnionMember0(TypedDict, total=False):
1250
+ """
1251
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1252
+ """
1253
+
1254
+ key: Required[str]
1255
+
1256
+ value: Required[str]
1257
+
1258
+ filter_type: Annotated[
1259
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1260
+ ]
1261
+
1262
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1263
+
1264
+ negate: Union[bool, Literal["true", "false"]]
1265
+
1266
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1267
+
1268
+
1269
+ class FiltersOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False):
1270
+ """
1271
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1272
+ """
1273
+
1274
+ key: Required[str]
1275
+
1276
+ value: Required[str]
1277
+
1278
+ filter_type: Annotated[
1279
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1280
+ ]
1281
+
1282
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1283
+
1284
+ negate: Union[bool, Literal["true", "false"]]
1285
+
1286
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1287
+
1288
+
1289
+ class FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False):
1290
+ """
1291
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1292
+ """
1293
+
1294
+ key: Required[str]
1295
+
1296
+ value: Required[str]
1297
+
1298
+ filter_type: Annotated[
1299
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1300
+ ]
1301
+
1302
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1303
+
1304
+ negate: Union[bool, Literal["true", "false"]]
1305
+
1306
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1307
+
1308
+
1309
+ class FiltersOrOrAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False):
1310
+ """
1311
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1312
+ """
1313
+
1314
+ key: Required[str]
1315
+
1316
+ value: Required[str]
1317
+
1318
+ filter_type: Annotated[
1319
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1320
+ ]
1321
+
1322
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1323
+
1324
+ negate: Union[bool, Literal["true", "false"]]
1325
+
1326
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1327
+
1328
+
1329
+ class FiltersOrOrAndAndOrOrOrOrOrOrOr(TypedDict, total=False):
1330
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
1331
+ """OR: Array of conditions"""
1332
+
1333
+
1334
+ class FiltersOrOrAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False):
1335
+ """
1336
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1337
+ """
1338
+
1339
+ key: Required[str]
1340
+
1341
+ value: Required[str]
1342
+
1343
+ filter_type: Annotated[
1344
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1345
+ ]
1346
+
1347
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1348
+
1349
+ negate: Union[bool, Literal["true", "false"]]
1350
+
1351
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1352
+
1353
+
1354
+ class FiltersOrOrAndAndOrOrOrOrOrOrAnd(TypedDict, total=False):
1355
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
1356
+ """AND: Array of conditions"""
1357
+
1358
+
1359
+ FiltersOrOrAndAndOrOrOrOrOrOr: TypeAlias = Union[
1360
+ FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrOrOrAnd
1361
+ ]
1362
+
1363
+
1364
+ class FiltersOrOrAndAndOrOrOrOrOr(TypedDict, total=False):
1365
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
1366
+ """OR: Array of conditions or nested expressions"""
1367
+
1368
+
1369
+ class FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False):
1370
+ """
1371
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1372
+ """
1373
+
1374
+ key: Required[str]
1375
+
1376
+ value: Required[str]
1377
+
1378
+ filter_type: Annotated[
1379
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1380
+ ]
1381
+
1382
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1383
+
1384
+ negate: Union[bool, Literal["true", "false"]]
1385
+
1386
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1387
+
1388
+
1389
+ class FiltersOrOrAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False):
1390
+ """
1391
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1392
+ """
1393
+
1394
+ key: Required[str]
1395
+
1396
+ value: Required[str]
1397
+
1398
+ filter_type: Annotated[
1399
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1400
+ ]
1401
+
1402
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1403
+
1404
+ negate: Union[bool, Literal["true", "false"]]
1405
+
1406
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1407
+
1408
+
1409
+ class FiltersOrOrAndAndOrOrOrOrAndAndOr(TypedDict, total=False):
1410
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
1411
+ """OR: Array of conditions"""
1412
+
1413
+
1414
+ class FiltersOrOrAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False):
1415
+ """
1416
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1417
+ """
1418
+
1419
+ key: Required[str]
1420
+
1421
+ value: Required[str]
1422
+
1423
+ filter_type: Annotated[
1424
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1425
+ ]
1426
+
1427
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1428
+
1429
+ negate: Union[bool, Literal["true", "false"]]
1430
+
1431
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1432
+
1433
+
1434
+ class FiltersOrOrAndAndOrOrOrOrAndAndAnd(TypedDict, total=False):
1435
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
1436
+ """AND: Array of conditions"""
1437
+
1438
+
1439
+ FiltersOrOrAndAndOrOrOrOrAndAnd: TypeAlias = Union[
1440
+ FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrOrOrAndAndOr, FiltersOrOrAndAndOrOrOrOrAndAndAnd
1441
+ ]
1442
+
1443
+
1444
+ class FiltersOrOrAndAndOrOrOrOrAnd(TypedDict, total=False):
1445
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
1446
+ """AND: Array of conditions or nested expressions"""
1447
+
1448
+
1449
+ FiltersOrOrAndAndOrOrOrOr: TypeAlias = Union[
1450
+ FiltersOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrAnd
1451
+ ]
1452
+
1453
+
1454
+ class FiltersOrOrAndAndOrOrOr(TypedDict, total=False):
1455
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
1456
+ """OR: Array of conditions or nested expressions"""
1457
+
1458
+
1459
+ class FiltersOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False):
1460
+ """
1461
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1462
+ """
1463
+
1464
+ key: Required[str]
1465
+
1466
+ value: Required[str]
1467
+
1468
+ filter_type: Annotated[
1469
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1470
+ ]
1471
+
1472
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1473
+
1474
+ negate: Union[bool, Literal["true", "false"]]
1475
+
1476
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1477
+
1478
+
1479
+ class FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False):
1480
+ """
1481
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1482
+ """
1483
+
1484
+ key: Required[str]
1485
+
1486
+ value: Required[str]
1487
+
1488
+ filter_type: Annotated[
1489
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1490
+ ]
1491
+
1492
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1493
+
1494
+ negate: Union[bool, Literal["true", "false"]]
1495
+
1496
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1497
+
1498
+
1499
+ class FiltersOrOrAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False):
1500
+ """
1501
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1502
+ """
1503
+
1504
+ key: Required[str]
1505
+
1506
+ value: Required[str]
1507
+
1508
+ filter_type: Annotated[
1509
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1510
+ ]
1511
+
1512
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1513
+
1514
+ negate: Union[bool, Literal["true", "false"]]
1515
+
1516
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1517
+
1518
+
1519
+ class FiltersOrOrAndAndOrOrAndAndOrOrOr(TypedDict, total=False):
1520
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
1521
+ """OR: Array of conditions"""
1522
+
1523
+
1524
+ class FiltersOrOrAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False):
1525
+ """
1526
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1527
+ """
1528
+
1529
+ key: Required[str]
1530
+
1531
+ value: Required[str]
1532
+
1533
+ filter_type: Annotated[
1534
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1535
+ ]
1536
+
1537
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1538
+
1539
+ negate: Union[bool, Literal["true", "false"]]
1540
+
1541
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1542
+
1543
+
1544
+ class FiltersOrOrAndAndOrOrAndAndOrOrAnd(TypedDict, total=False):
1545
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
1546
+ """AND: Array of conditions"""
1547
+
1548
+
1549
+ FiltersOrOrAndAndOrOrAndAndOrOr: TypeAlias = Union[
1550
+ FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAndAndOrOrAnd
1551
+ ]
1552
+
1553
+
1554
+ class FiltersOrOrAndAndOrOrAndAndOr(TypedDict, total=False):
1555
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
1556
+ """OR: Array of conditions or nested expressions"""
1557
+
1558
+
1559
+ class FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False):
1560
+ """
1561
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1562
+ """
1563
+
1564
+ key: Required[str]
1565
+
1566
+ value: Required[str]
1567
+
1568
+ filter_type: Annotated[
1569
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1570
+ ]
1571
+
1572
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1573
+
1574
+ negate: Union[bool, Literal["true", "false"]]
1575
+
1576
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1577
+
1578
+
1579
+ class FiltersOrOrAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False):
1580
+ """
1581
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1582
+ """
1583
+
1584
+ key: Required[str]
1585
+
1586
+ value: Required[str]
1587
+
1588
+ filter_type: Annotated[
1589
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1590
+ ]
1591
+
1592
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1593
+
1594
+ negate: Union[bool, Literal["true", "false"]]
1595
+
1596
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1597
+
1598
+
1599
+ class FiltersOrOrAndAndOrOrAndAndAndAndOr(TypedDict, total=False):
1600
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
1601
+ """OR: Array of conditions"""
1602
+
1603
+
1604
+ class FiltersOrOrAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False):
1605
+ """
1606
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1607
+ """
1608
+
1609
+ key: Required[str]
1610
+
1611
+ value: Required[str]
1612
+
1613
+ filter_type: Annotated[
1614
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1615
+ ]
1616
+
1617
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1618
+
1619
+ negate: Union[bool, Literal["true", "false"]]
1620
+
1621
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1622
+
1623
+
1624
+ class FiltersOrOrAndAndOrOrAndAndAndAndAnd(TypedDict, total=False):
1625
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
1626
+ """AND: Array of conditions"""
1627
+
1628
+
1629
+ FiltersOrOrAndAndOrOrAndAndAndAnd: TypeAlias = Union[
1630
+ FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0,
1631
+ FiltersOrOrAndAndOrOrAndAndAndAndOr,
1632
+ FiltersOrOrAndAndOrOrAndAndAndAndAnd,
1633
+ ]
1634
+
1635
+
1636
+ class FiltersOrOrAndAndOrOrAndAndAnd(TypedDict, total=False):
1637
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
1638
+ """AND: Array of conditions or nested expressions"""
1639
+
1640
+
1641
+ FiltersOrOrAndAndOrOrAndAnd: TypeAlias = Union[
1642
+ FiltersOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrAndAndOr, FiltersOrOrAndAndOrOrAndAndAnd
1643
+ ]
1644
+
1645
+
1646
+ class FiltersOrOrAndAndOrOrAnd(TypedDict, total=False):
1647
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
1648
+ """AND: Array of conditions or nested expressions"""
1649
+
1650
+
1651
+ FiltersOrOrAndAndOrOr: TypeAlias = Union[
1652
+ FiltersOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAnd
1653
+ ]
1654
+
1655
+
1656
+ class FiltersOrOrAndAndOr(TypedDict, total=False):
1657
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
1658
+ """OR: Array of conditions or nested expressions"""
1659
+
1660
+
1661
+ class FiltersOrOrAndAndAndAndUnionMember0(TypedDict, total=False):
1662
+ """
1663
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1664
+ """
1665
+
1666
+ key: Required[str]
1667
+
1668
+ value: Required[str]
1669
+
1670
+ filter_type: Annotated[
1671
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1672
+ ]
1673
+
1674
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1675
+
1676
+ negate: Union[bool, Literal["true", "false"]]
1677
+
1678
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1679
+
1680
+
1681
+ class FiltersOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False):
1682
+ """
1683
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1684
+ """
1685
+
1686
+ key: Required[str]
1687
+
1688
+ value: Required[str]
1689
+
1690
+ filter_type: Annotated[
1691
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1692
+ ]
1693
+
1694
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1695
+
1696
+ negate: Union[bool, Literal["true", "false"]]
1697
+
1698
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1699
+
1700
+
1701
+ class FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False):
1702
+ """
1703
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1704
+ """
1705
+
1706
+ key: Required[str]
1707
+
1708
+ value: Required[str]
1709
+
1710
+ filter_type: Annotated[
1711
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1712
+ ]
1713
+
1714
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1715
+
1716
+ negate: Union[bool, Literal["true", "false"]]
1717
+
1718
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1719
+
1720
+
1721
+ class FiltersOrOrAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False):
1722
+ """
1723
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1724
+ """
1725
+
1726
+ key: Required[str]
1727
+
1728
+ value: Required[str]
1729
+
1730
+ filter_type: Annotated[
1731
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1732
+ ]
1733
+
1734
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1735
+
1736
+ negate: Union[bool, Literal["true", "false"]]
1737
+
1738
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1739
+
1740
+
1741
+ class FiltersOrOrAndAndAndAndOrOrOrOrOr(TypedDict, total=False):
1742
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
1743
+ """OR: Array of conditions"""
1744
+
1745
+
1746
+ class FiltersOrOrAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False):
1747
+ """
1748
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1749
+ """
1750
+
1751
+ key: Required[str]
1752
+
1753
+ value: Required[str]
1754
+
1755
+ filter_type: Annotated[
1756
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1757
+ ]
1758
+
1759
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1760
+
1761
+ negate: Union[bool, Literal["true", "false"]]
1762
+
1763
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1764
+
1765
+
1766
+ class FiltersOrOrAndAndAndAndOrOrOrOrAnd(TypedDict, total=False):
1767
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
1768
+ """AND: Array of conditions"""
1769
+
1770
+
1771
+ FiltersOrOrAndAndAndAndOrOrOrOr: TypeAlias = Union[
1772
+ FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOrOrOr, FiltersOrOrAndAndAndAndOrOrOrOrAnd
1773
+ ]
1774
+
1775
+
1776
+ class FiltersOrOrAndAndAndAndOrOrOr(TypedDict, total=False):
1777
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
1778
+ """OR: Array of conditions or nested expressions"""
1779
+
1780
+
1781
+ class FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False):
1782
+ """
1783
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1784
+ """
1785
+
1786
+ key: Required[str]
1787
+
1788
+ value: Required[str]
1789
+
1790
+ filter_type: Annotated[
1791
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1792
+ ]
1793
+
1794
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1795
+
1796
+ negate: Union[bool, Literal["true", "false"]]
1797
+
1798
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1799
+
1800
+
1801
+ class FiltersOrOrAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False):
1802
+ """
1803
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1804
+ """
1805
+
1806
+ key: Required[str]
1807
+
1808
+ value: Required[str]
1809
+
1810
+ filter_type: Annotated[
1811
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1812
+ ]
1813
+
1814
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1815
+
1816
+ negate: Union[bool, Literal["true", "false"]]
1817
+
1818
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1819
+
1820
+
1821
+ class FiltersOrOrAndAndAndAndOrOrAndAndOr(TypedDict, total=False):
1822
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
1823
+ """OR: Array of conditions"""
1824
+
1825
+
1826
+ class FiltersOrOrAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False):
1827
+ """
1828
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1829
+ """
1830
+
1831
+ key: Required[str]
1832
+
1833
+ value: Required[str]
1834
+
1835
+ filter_type: Annotated[
1836
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1837
+ ]
1838
+
1839
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1840
+
1841
+ negate: Union[bool, Literal["true", "false"]]
1842
+
1843
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1844
+
1845
+
1846
+ class FiltersOrOrAndAndAndAndOrOrAndAndAnd(TypedDict, total=False):
1847
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
1848
+ """AND: Array of conditions"""
1849
+
1850
+
1851
+ FiltersOrOrAndAndAndAndOrOrAndAnd: TypeAlias = Union[
1852
+ FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0,
1853
+ FiltersOrOrAndAndAndAndOrOrAndAndOr,
1854
+ FiltersOrOrAndAndAndAndOrOrAndAndAnd,
1855
+ ]
1856
+
1857
+
1858
+ class FiltersOrOrAndAndAndAndOrOrAnd(TypedDict, total=False):
1859
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
1860
+ """AND: Array of conditions or nested expressions"""
1861
+
1862
+
1863
+ FiltersOrOrAndAndAndAndOrOr: TypeAlias = Union[
1864
+ FiltersOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOr, FiltersOrOrAndAndAndAndOrOrAnd
1865
+ ]
1866
+
1867
+
1868
+ class FiltersOrOrAndAndAndAndOr(TypedDict, total=False):
1869
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
1870
+ """OR: Array of conditions or nested expressions"""
1871
+
1872
+
1873
+ class FiltersOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False):
1874
+ """
1875
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1876
+ """
1877
+
1878
+ key: Required[str]
1879
+
1880
+ value: Required[str]
1881
+
1882
+ filter_type: Annotated[
1883
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1884
+ ]
1885
+
1886
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1887
+
1888
+ negate: Union[bool, Literal["true", "false"]]
1889
+
1890
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1891
+
1892
+
1893
+ class FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False):
1894
+ """
1895
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1896
+ """
1897
+
1898
+ key: Required[str]
1899
+
1900
+ value: Required[str]
1901
+
1902
+ filter_type: Annotated[
1903
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1904
+ ]
1905
+
1906
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1907
+
1908
+ negate: Union[bool, Literal["true", "false"]]
1909
+
1910
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1911
+
1912
+
1913
+ class FiltersOrOrAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False):
1914
+ """
1915
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1916
+ """
1917
+
1918
+ key: Required[str]
1919
+
1920
+ value: Required[str]
1921
+
1922
+ filter_type: Annotated[
1923
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1924
+ ]
1925
+
1926
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1927
+
1928
+ negate: Union[bool, Literal["true", "false"]]
1929
+
1930
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1931
+
1932
+
1933
+ class FiltersOrOrAndAndAndAndAndAndOrOrOr(TypedDict, total=False):
1934
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
1935
+ """OR: Array of conditions"""
1936
+
1937
+
1938
+ class FiltersOrOrAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False):
1939
+ """
1940
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1941
+ """
1942
+
1943
+ key: Required[str]
1944
+
1945
+ value: Required[str]
1946
+
1947
+ filter_type: Annotated[
1948
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1949
+ ]
1950
+
1951
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1952
+
1953
+ negate: Union[bool, Literal["true", "false"]]
1954
+
1955
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1956
+
1957
+
1958
+ class FiltersOrOrAndAndAndAndAndAndOrOrAnd(TypedDict, total=False):
1959
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
1960
+ """AND: Array of conditions"""
1961
+
1962
+
1963
+ FiltersOrOrAndAndAndAndAndAndOrOr: TypeAlias = Union[
1964
+ FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0,
1965
+ FiltersOrOrAndAndAndAndAndAndOrOrOr,
1966
+ FiltersOrOrAndAndAndAndAndAndOrOrAnd,
1967
+ ]
1968
+
1969
+
1970
+ class FiltersOrOrAndAndAndAndAndAndOr(TypedDict, total=False):
1971
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
1972
+ """OR: Array of conditions or nested expressions"""
1973
+
1974
+
1975
+ class FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False):
1976
+ """
1977
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1978
+ """
1979
+
1980
+ key: Required[str]
1981
+
1982
+ value: Required[str]
1983
+
1984
+ filter_type: Annotated[
1985
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
1986
+ ]
1987
+
1988
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
1989
+
1990
+ negate: Union[bool, Literal["true", "false"]]
1991
+
1992
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
1993
+
1994
+
1995
+ class FiltersOrOrAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False):
1996
+ """
1997
+ A single filter condition based on metadata, numeric values, array contents, or string matching
1998
+ """
1999
+
2000
+ key: Required[str]
2001
+
2002
+ value: Required[str]
2003
+
2004
+ filter_type: Annotated[
2005
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2006
+ ]
2007
+
2008
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2009
+
2010
+ negate: Union[bool, Literal["true", "false"]]
2011
+
2012
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2013
+
2014
+
2015
+ class FiltersOrOrAndAndAndAndAndAndAndAndOr(TypedDict, total=False):
2016
+ or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
2017
+ """OR: Array of conditions"""
2018
+
2019
+
2020
+ class FiltersOrOrAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False):
2021
+ """
2022
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2023
+ """
2024
+
2025
+ key: Required[str]
2026
+
2027
+ value: Required[str]
2028
+
2029
+ filter_type: Annotated[
2030
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2031
+ ]
2032
+
2033
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2034
+
2035
+ negate: Union[bool, Literal["true", "false"]]
2036
+
2037
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2038
+
2039
+
2040
+ class FiltersOrOrAndAndAndAndAndAndAndAndAnd(TypedDict, total=False):
2041
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
2042
+ """AND: Array of conditions"""
2043
+
2044
+
2045
+ FiltersOrOrAndAndAndAndAndAndAndAnd: TypeAlias = Union[
2046
+ FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0,
2047
+ FiltersOrOrAndAndAndAndAndAndAndAndOr,
2048
+ FiltersOrOrAndAndAndAndAndAndAndAndAnd,
2049
+ ]
2050
+
2051
+
2052
+ class FiltersOrOrAndAndAndAndAndAndAnd(TypedDict, total=False):
2053
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
2054
+ """AND: Array of conditions or nested expressions"""
2055
+
2056
+
2057
+ FiltersOrOrAndAndAndAndAndAnd: TypeAlias = Union[
2058
+ FiltersOrOrAndAndAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndAndAndOr, FiltersOrOrAndAndAndAndAndAndAnd
2059
+ ]
2060
+
2061
+
2062
+ class FiltersOrOrAndAndAndAndAnd(TypedDict, total=False):
2063
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
2064
+ """AND: Array of conditions or nested expressions"""
2065
+
2066
+
2067
+ FiltersOrOrAndAndAndAnd: TypeAlias = Union[
2068
+ FiltersOrOrAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndOr, FiltersOrOrAndAndAndAndAnd
2069
+ ]
2070
+
2071
+
2072
+ class FiltersOrOrAndAndAnd(TypedDict, total=False):
2073
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
2074
+ """AND: Array of conditions or nested expressions"""
2075
+
2076
+
2077
+ FiltersOrOrAndAnd: TypeAlias = Union[FiltersOrOrAndAndUnionMember0, FiltersOrOrAndAndOr, FiltersOrOrAndAndAnd]
2078
+
2079
+
2080
+ class FiltersOrOrAnd(TypedDict, total=False):
2081
+ and_: Required[Annotated[Iterable[FiltersOrOrAndAnd], PropertyInfo(alias="AND")]]
2082
+ """AND: Array of conditions or nested expressions"""
2083
+
2084
+
2085
+ FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd]
2086
+
2087
+
44
2088
  class FiltersOr(TypedDict, total=False):
45
- or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]]
2089
+ or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]]
2090
+ """Array of OR filter expressions"""
2091
+
2092
+
2093
+ class FiltersAndAndUnionMember0(TypedDict, total=False):
2094
+ """
2095
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2096
+ """
2097
+
2098
+ key: Required[str]
2099
+
2100
+ value: Required[str]
2101
+
2102
+ filter_type: Annotated[
2103
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2104
+ ]
2105
+
2106
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2107
+
2108
+ negate: Union[bool, Literal["true", "false"]]
2109
+
2110
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2111
+
2112
+
2113
+ class FiltersAndAndOrOrUnionMember0(TypedDict, total=False):
2114
+ """
2115
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2116
+ """
2117
+
2118
+ key: Required[str]
2119
+
2120
+ value: Required[str]
2121
+
2122
+ filter_type: Annotated[
2123
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2124
+ ]
2125
+
2126
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2127
+
2128
+ negate: Union[bool, Literal["true", "false"]]
2129
+
2130
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2131
+
2132
+
2133
+ class FiltersAndAndOrOrOrOrUnionMember0(TypedDict, total=False):
2134
+ """
2135
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2136
+ """
2137
+
2138
+ key: Required[str]
2139
+
2140
+ value: Required[str]
2141
+
2142
+ filter_type: Annotated[
2143
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2144
+ ]
2145
+
2146
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2147
+
2148
+ negate: Union[bool, Literal["true", "false"]]
2149
+
2150
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2151
+
2152
+
2153
+ class FiltersAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False):
2154
+ """
2155
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2156
+ """
2157
+
2158
+ key: Required[str]
2159
+
2160
+ value: Required[str]
2161
+
2162
+ filter_type: Annotated[
2163
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2164
+ ]
2165
+
2166
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2167
+
2168
+ negate: Union[bool, Literal["true", "false"]]
2169
+
2170
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2171
+
2172
+
2173
+ class FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False):
2174
+ """
2175
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2176
+ """
2177
+
2178
+ key: Required[str]
2179
+
2180
+ value: Required[str]
2181
+
2182
+ filter_type: Annotated[
2183
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2184
+ ]
2185
+
2186
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2187
+
2188
+ negate: Union[bool, Literal["true", "false"]]
2189
+
2190
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2191
+
2192
+
2193
+ class FiltersAndAndOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False):
2194
+ """
2195
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2196
+ """
2197
+
2198
+ key: Required[str]
2199
+
2200
+ value: Required[str]
2201
+
2202
+ filter_type: Annotated[
2203
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2204
+ ]
2205
+
2206
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2207
+
2208
+ negate: Union[bool, Literal["true", "false"]]
2209
+
2210
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2211
+
2212
+
2213
+ class FiltersAndAndOrOrOrOrOrOrOrOrOr(TypedDict, total=False):
2214
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
2215
+ """OR: Array of conditions"""
2216
+
2217
+
2218
+ class FiltersAndAndOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False):
2219
+ """
2220
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2221
+ """
2222
+
2223
+ key: Required[str]
2224
+
2225
+ value: Required[str]
2226
+
2227
+ filter_type: Annotated[
2228
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2229
+ ]
2230
+
2231
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2232
+
2233
+ negate: Union[bool, Literal["true", "false"]]
2234
+
2235
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2236
+
2237
+
2238
+ class FiltersAndAndOrOrOrOrOrOrOrOrAnd(TypedDict, total=False):
2239
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
2240
+ """AND: Array of conditions"""
2241
+
2242
+
2243
+ FiltersAndAndOrOrOrOrOrOrOrOr: TypeAlias = Union[
2244
+ FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrOrOrAnd
2245
+ ]
2246
+
2247
+
2248
+ class FiltersAndAndOrOrOrOrOrOrOr(TypedDict, total=False):
2249
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
2250
+ """OR: Array of conditions or nested expressions"""
2251
+
2252
+
2253
+ class FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False):
2254
+ """
2255
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2256
+ """
2257
+
2258
+ key: Required[str]
2259
+
2260
+ value: Required[str]
2261
+
2262
+ filter_type: Annotated[
2263
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2264
+ ]
2265
+
2266
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2267
+
2268
+ negate: Union[bool, Literal["true", "false"]]
2269
+
2270
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2271
+
2272
+
2273
+ class FiltersAndAndOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False):
2274
+ """
2275
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2276
+ """
2277
+
2278
+ key: Required[str]
2279
+
2280
+ value: Required[str]
2281
+
2282
+ filter_type: Annotated[
2283
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2284
+ ]
2285
+
2286
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2287
+
2288
+ negate: Union[bool, Literal["true", "false"]]
2289
+
2290
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2291
+
2292
+
2293
+ class FiltersAndAndOrOrOrOrOrOrAndAndOr(TypedDict, total=False):
2294
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
2295
+ """OR: Array of conditions"""
2296
+
2297
+
2298
+ class FiltersAndAndOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False):
2299
+ """
2300
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2301
+ """
2302
+
2303
+ key: Required[str]
2304
+
2305
+ value: Required[str]
2306
+
2307
+ filter_type: Annotated[
2308
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2309
+ ]
2310
+
2311
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2312
+
2313
+ negate: Union[bool, Literal["true", "false"]]
2314
+
2315
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2316
+
2317
+
2318
+ class FiltersAndAndOrOrOrOrOrOrAndAndAnd(TypedDict, total=False):
2319
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
2320
+ """AND: Array of conditions"""
2321
+
2322
+
2323
+ FiltersAndAndOrOrOrOrOrOrAndAnd: TypeAlias = Union[
2324
+ FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrOrOrAndAndAnd
2325
+ ]
2326
+
2327
+
2328
+ class FiltersAndAndOrOrOrOrOrOrAnd(TypedDict, total=False):
2329
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
2330
+ """AND: Array of conditions or nested expressions"""
2331
+
2332
+
2333
+ FiltersAndAndOrOrOrOrOrOr: TypeAlias = Union[
2334
+ FiltersAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrAnd
2335
+ ]
2336
+
2337
+
2338
+ class FiltersAndAndOrOrOrOrOr(TypedDict, total=False):
2339
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
2340
+ """OR: Array of conditions or nested expressions"""
2341
+
2342
+
2343
+ class FiltersAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False):
2344
+ """
2345
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2346
+ """
2347
+
2348
+ key: Required[str]
2349
+
2350
+ value: Required[str]
2351
+
2352
+ filter_type: Annotated[
2353
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2354
+ ]
2355
+
2356
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2357
+
2358
+ negate: Union[bool, Literal["true", "false"]]
2359
+
2360
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2361
+
2362
+
2363
+ class FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False):
2364
+ """
2365
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2366
+ """
2367
+
2368
+ key: Required[str]
2369
+
2370
+ value: Required[str]
2371
+
2372
+ filter_type: Annotated[
2373
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2374
+ ]
2375
+
2376
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2377
+
2378
+ negate: Union[bool, Literal["true", "false"]]
2379
+
2380
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2381
+
2382
+
2383
+ class FiltersAndAndOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False):
2384
+ """
2385
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2386
+ """
2387
+
2388
+ key: Required[str]
2389
+
2390
+ value: Required[str]
2391
+
2392
+ filter_type: Annotated[
2393
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2394
+ ]
2395
+
2396
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2397
+
2398
+ negate: Union[bool, Literal["true", "false"]]
2399
+
2400
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2401
+
2402
+
2403
+ class FiltersAndAndOrOrOrOrAndAndOrOrOr(TypedDict, total=False):
2404
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
2405
+ """OR: Array of conditions"""
2406
+
2407
+
2408
+ class FiltersAndAndOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False):
2409
+ """
2410
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2411
+ """
2412
+
2413
+ key: Required[str]
2414
+
2415
+ value: Required[str]
2416
+
2417
+ filter_type: Annotated[
2418
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2419
+ ]
2420
+
2421
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2422
+
2423
+ negate: Union[bool, Literal["true", "false"]]
2424
+
2425
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2426
+
2427
+
2428
+ class FiltersAndAndOrOrOrOrAndAndOrOrAnd(TypedDict, total=False):
2429
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
2430
+ """AND: Array of conditions"""
2431
+
2432
+
2433
+ FiltersAndAndOrOrOrOrAndAndOrOr: TypeAlias = Union[
2434
+ FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrOrOrAndAndOrOrOr, FiltersAndAndOrOrOrOrAndAndOrOrAnd
2435
+ ]
2436
+
2437
+
2438
+ class FiltersAndAndOrOrOrOrAndAndOr(TypedDict, total=False):
2439
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
2440
+ """OR: Array of conditions or nested expressions"""
2441
+
2442
+
2443
+ class FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False):
2444
+ """
2445
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2446
+ """
2447
+
2448
+ key: Required[str]
2449
+
2450
+ value: Required[str]
2451
+
2452
+ filter_type: Annotated[
2453
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2454
+ ]
2455
+
2456
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2457
+
2458
+ negate: Union[bool, Literal["true", "false"]]
2459
+
2460
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2461
+
2462
+
2463
+ class FiltersAndAndOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False):
2464
+ """
2465
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2466
+ """
2467
+
2468
+ key: Required[str]
2469
+
2470
+ value: Required[str]
2471
+
2472
+ filter_type: Annotated[
2473
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2474
+ ]
2475
+
2476
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2477
+
2478
+ negate: Union[bool, Literal["true", "false"]]
2479
+
2480
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2481
+
2482
+
2483
+ class FiltersAndAndOrOrOrOrAndAndAndAndOr(TypedDict, total=False):
2484
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
2485
+ """OR: Array of conditions"""
2486
+
2487
+
2488
+ class FiltersAndAndOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False):
2489
+ """
2490
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2491
+ """
2492
+
2493
+ key: Required[str]
2494
+
2495
+ value: Required[str]
2496
+
2497
+ filter_type: Annotated[
2498
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2499
+ ]
2500
+
2501
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2502
+
2503
+ negate: Union[bool, Literal["true", "false"]]
2504
+
2505
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2506
+
2507
+
2508
+ class FiltersAndAndOrOrOrOrAndAndAndAndAnd(TypedDict, total=False):
2509
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
2510
+ """AND: Array of conditions"""
2511
+
2512
+
2513
+ FiltersAndAndOrOrOrOrAndAndAndAnd: TypeAlias = Union[
2514
+ FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0,
2515
+ FiltersAndAndOrOrOrOrAndAndAndAndOr,
2516
+ FiltersAndAndOrOrOrOrAndAndAndAndAnd,
2517
+ ]
2518
+
2519
+
2520
+ class FiltersAndAndOrOrOrOrAndAndAnd(TypedDict, total=False):
2521
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
2522
+ """AND: Array of conditions or nested expressions"""
2523
+
2524
+
2525
+ FiltersAndAndOrOrOrOrAndAnd: TypeAlias = Union[
2526
+ FiltersAndAndOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrAndAndAnd
2527
+ ]
2528
+
2529
+
2530
+ class FiltersAndAndOrOrOrOrAnd(TypedDict, total=False):
2531
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
2532
+ """AND: Array of conditions or nested expressions"""
2533
+
2534
+
2535
+ FiltersAndAndOrOrOrOr: TypeAlias = Union[
2536
+ FiltersAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOr, FiltersAndAndOrOrOrOrAnd
2537
+ ]
2538
+
2539
+
2540
+ class FiltersAndAndOrOrOr(TypedDict, total=False):
2541
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
2542
+ """OR: Array of conditions or nested expressions"""
2543
+
2544
+
2545
+ class FiltersAndAndOrOrAndAndUnionMember0(TypedDict, total=False):
2546
+ """
2547
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2548
+ """
2549
+
2550
+ key: Required[str]
2551
+
2552
+ value: Required[str]
2553
+
2554
+ filter_type: Annotated[
2555
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2556
+ ]
2557
+
2558
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2559
+
2560
+ negate: Union[bool, Literal["true", "false"]]
2561
+
2562
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2563
+
2564
+
2565
+ class FiltersAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False):
2566
+ """
2567
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2568
+ """
2569
+
2570
+ key: Required[str]
2571
+
2572
+ value: Required[str]
2573
+
2574
+ filter_type: Annotated[
2575
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2576
+ ]
2577
+
2578
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2579
+
2580
+ negate: Union[bool, Literal["true", "false"]]
2581
+
2582
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2583
+
2584
+
2585
+ class FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False):
2586
+ """
2587
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2588
+ """
2589
+
2590
+ key: Required[str]
2591
+
2592
+ value: Required[str]
2593
+
2594
+ filter_type: Annotated[
2595
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2596
+ ]
2597
+
2598
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2599
+
2600
+ negate: Union[bool, Literal["true", "false"]]
2601
+
2602
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2603
+
2604
+
2605
+ class FiltersAndAndOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False):
2606
+ """
2607
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2608
+ """
2609
+
2610
+ key: Required[str]
2611
+
2612
+ value: Required[str]
2613
+
2614
+ filter_type: Annotated[
2615
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2616
+ ]
2617
+
2618
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2619
+
2620
+ negate: Union[bool, Literal["true", "false"]]
2621
+
2622
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2623
+
2624
+
2625
+ class FiltersAndAndOrOrAndAndOrOrOrOrOr(TypedDict, total=False):
2626
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
2627
+ """OR: Array of conditions"""
2628
+
2629
+
2630
+ class FiltersAndAndOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False):
2631
+ """
2632
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2633
+ """
2634
+
2635
+ key: Required[str]
2636
+
2637
+ value: Required[str]
2638
+
2639
+ filter_type: Annotated[
2640
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2641
+ ]
2642
+
2643
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2644
+
2645
+ negate: Union[bool, Literal["true", "false"]]
2646
+
2647
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2648
+
2649
+
2650
+ class FiltersAndAndOrOrAndAndOrOrOrOrAnd(TypedDict, total=False):
2651
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
2652
+ """AND: Array of conditions"""
2653
+
2654
+
2655
+ FiltersAndAndOrOrAndAndOrOrOrOr: TypeAlias = Union[
2656
+ FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOrOrOr, FiltersAndAndOrOrAndAndOrOrOrOrAnd
2657
+ ]
2658
+
2659
+
2660
+ class FiltersAndAndOrOrAndAndOrOrOr(TypedDict, total=False):
2661
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
2662
+ """OR: Array of conditions or nested expressions"""
2663
+
2664
+
2665
+ class FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False):
2666
+ """
2667
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2668
+ """
2669
+
2670
+ key: Required[str]
2671
+
2672
+ value: Required[str]
2673
+
2674
+ filter_type: Annotated[
2675
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2676
+ ]
2677
+
2678
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2679
+
2680
+ negate: Union[bool, Literal["true", "false"]]
2681
+
2682
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2683
+
2684
+
2685
+ class FiltersAndAndOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False):
2686
+ """
2687
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2688
+ """
2689
+
2690
+ key: Required[str]
2691
+
2692
+ value: Required[str]
2693
+
2694
+ filter_type: Annotated[
2695
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2696
+ ]
2697
+
2698
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2699
+
2700
+ negate: Union[bool, Literal["true", "false"]]
2701
+
2702
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2703
+
2704
+
2705
+ class FiltersAndAndOrOrAndAndOrOrAndAndOr(TypedDict, total=False):
2706
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
2707
+ """OR: Array of conditions"""
2708
+
2709
+
2710
+ class FiltersAndAndOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False):
2711
+ """
2712
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2713
+ """
2714
+
2715
+ key: Required[str]
2716
+
2717
+ value: Required[str]
2718
+
2719
+ filter_type: Annotated[
2720
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2721
+ ]
2722
+
2723
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2724
+
2725
+ negate: Union[bool, Literal["true", "false"]]
2726
+
2727
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2728
+
2729
+
2730
+ class FiltersAndAndOrOrAndAndOrOrAndAndAnd(TypedDict, total=False):
2731
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
2732
+ """AND: Array of conditions"""
2733
+
2734
+
2735
+ FiltersAndAndOrOrAndAndOrOrAndAnd: TypeAlias = Union[
2736
+ FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0,
2737
+ FiltersAndAndOrOrAndAndOrOrAndAndOr,
2738
+ FiltersAndAndOrOrAndAndOrOrAndAndAnd,
2739
+ ]
2740
+
2741
+
2742
+ class FiltersAndAndOrOrAndAndOrOrAnd(TypedDict, total=False):
2743
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
2744
+ """AND: Array of conditions or nested expressions"""
2745
+
2746
+
2747
+ FiltersAndAndOrOrAndAndOrOr: TypeAlias = Union[
2748
+ FiltersAndAndOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOr, FiltersAndAndOrOrAndAndOrOrAnd
2749
+ ]
2750
+
2751
+
2752
+ class FiltersAndAndOrOrAndAndOr(TypedDict, total=False):
2753
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
2754
+ """OR: Array of conditions or nested expressions"""
2755
+
2756
+
2757
+ class FiltersAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False):
2758
+ """
2759
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2760
+ """
2761
+
2762
+ key: Required[str]
2763
+
2764
+ value: Required[str]
2765
+
2766
+ filter_type: Annotated[
2767
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2768
+ ]
2769
+
2770
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2771
+
2772
+ negate: Union[bool, Literal["true", "false"]]
2773
+
2774
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2775
+
2776
+
2777
+ class FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False):
2778
+ """
2779
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2780
+ """
2781
+
2782
+ key: Required[str]
2783
+
2784
+ value: Required[str]
2785
+
2786
+ filter_type: Annotated[
2787
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2788
+ ]
2789
+
2790
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2791
+
2792
+ negate: Union[bool, Literal["true", "false"]]
2793
+
2794
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2795
+
2796
+
2797
+ class FiltersAndAndOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False):
2798
+ """
2799
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2800
+ """
2801
+
2802
+ key: Required[str]
2803
+
2804
+ value: Required[str]
2805
+
2806
+ filter_type: Annotated[
2807
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2808
+ ]
2809
+
2810
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2811
+
2812
+ negate: Union[bool, Literal["true", "false"]]
2813
+
2814
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2815
+
2816
+
2817
+ class FiltersAndAndOrOrAndAndAndAndOrOrOr(TypedDict, total=False):
2818
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
2819
+ """OR: Array of conditions"""
2820
+
2821
+
2822
+ class FiltersAndAndOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False):
2823
+ """
2824
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2825
+ """
2826
+
2827
+ key: Required[str]
2828
+
2829
+ value: Required[str]
2830
+
2831
+ filter_type: Annotated[
2832
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2833
+ ]
2834
+
2835
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2836
+
2837
+ negate: Union[bool, Literal["true", "false"]]
2838
+
2839
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2840
+
2841
+
2842
+ class FiltersAndAndOrOrAndAndAndAndOrOrAnd(TypedDict, total=False):
2843
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
2844
+ """AND: Array of conditions"""
2845
+
2846
+
2847
+ FiltersAndAndOrOrAndAndAndAndOrOr: TypeAlias = Union[
2848
+ FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0,
2849
+ FiltersAndAndOrOrAndAndAndAndOrOrOr,
2850
+ FiltersAndAndOrOrAndAndAndAndOrOrAnd,
2851
+ ]
2852
+
2853
+
2854
+ class FiltersAndAndOrOrAndAndAndAndOr(TypedDict, total=False):
2855
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
2856
+ """OR: Array of conditions or nested expressions"""
2857
+
2858
+
2859
+ class FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False):
2860
+ """
2861
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2862
+ """
2863
+
2864
+ key: Required[str]
2865
+
2866
+ value: Required[str]
2867
+
2868
+ filter_type: Annotated[
2869
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2870
+ ]
2871
+
2872
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2873
+
2874
+ negate: Union[bool, Literal["true", "false"]]
2875
+
2876
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2877
+
2878
+
2879
+ class FiltersAndAndOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False):
2880
+ """
2881
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2882
+ """
2883
+
2884
+ key: Required[str]
2885
+
2886
+ value: Required[str]
2887
+
2888
+ filter_type: Annotated[
2889
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2890
+ ]
2891
+
2892
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2893
+
2894
+ negate: Union[bool, Literal["true", "false"]]
2895
+
2896
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2897
+
2898
+
2899
+ class FiltersAndAndOrOrAndAndAndAndAndAndOr(TypedDict, total=False):
2900
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
2901
+ """OR: Array of conditions"""
2902
+
2903
+
2904
+ class FiltersAndAndOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False):
2905
+ """
2906
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2907
+ """
2908
+
2909
+ key: Required[str]
2910
+
2911
+ value: Required[str]
2912
+
2913
+ filter_type: Annotated[
2914
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2915
+ ]
2916
+
2917
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2918
+
2919
+ negate: Union[bool, Literal["true", "false"]]
2920
+
2921
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2922
+
2923
+
2924
+ class FiltersAndAndOrOrAndAndAndAndAndAndAnd(TypedDict, total=False):
2925
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
2926
+ """AND: Array of conditions"""
2927
+
2928
+
2929
+ FiltersAndAndOrOrAndAndAndAndAndAnd: TypeAlias = Union[
2930
+ FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0,
2931
+ FiltersAndAndOrOrAndAndAndAndAndAndOr,
2932
+ FiltersAndAndOrOrAndAndAndAndAndAndAnd,
2933
+ ]
2934
+
2935
+
2936
+ class FiltersAndAndOrOrAndAndAndAndAnd(TypedDict, total=False):
2937
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
2938
+ """AND: Array of conditions or nested expressions"""
2939
+
2940
+
2941
+ FiltersAndAndOrOrAndAndAndAnd: TypeAlias = Union[
2942
+ FiltersAndAndOrOrAndAndAndAndUnionMember0, FiltersAndAndOrOrAndAndAndAndOr, FiltersAndAndOrOrAndAndAndAndAnd
2943
+ ]
2944
+
2945
+
2946
+ class FiltersAndAndOrOrAndAndAnd(TypedDict, total=False):
2947
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
2948
+ """AND: Array of conditions or nested expressions"""
2949
+
2950
+
2951
+ FiltersAndAndOrOrAndAnd: TypeAlias = Union[
2952
+ FiltersAndAndOrOrAndAndUnionMember0, FiltersAndAndOrOrAndAndOr, FiltersAndAndOrOrAndAndAnd
2953
+ ]
2954
+
2955
+
2956
+ class FiltersAndAndOrOrAnd(TypedDict, total=False):
2957
+ and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
2958
+ """AND: Array of conditions or nested expressions"""
2959
+
2960
+
2961
+ FiltersAndAndOrOr: TypeAlias = Union[FiltersAndAndOrOrUnionMember0, FiltersAndAndOrOrOr, FiltersAndAndOrOrAnd]
2962
+
2963
+
2964
+ class FiltersAndAndOr(TypedDict, total=False):
2965
+ or_: Required[Annotated[Iterable[FiltersAndAndOrOr], PropertyInfo(alias="OR")]]
2966
+ """OR: Array of conditions or nested expressions"""
2967
+
2968
+
2969
+ class FiltersAndAndAndAndUnionMember0(TypedDict, total=False):
2970
+ """
2971
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2972
+ """
2973
+
2974
+ key: Required[str]
2975
+
2976
+ value: Required[str]
2977
+
2978
+ filter_type: Annotated[
2979
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
2980
+ ]
2981
+
2982
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
2983
+
2984
+ negate: Union[bool, Literal["true", "false"]]
2985
+
2986
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
2987
+
2988
+
2989
+ class FiltersAndAndAndAndOrOrUnionMember0(TypedDict, total=False):
2990
+ """
2991
+ A single filter condition based on metadata, numeric values, array contents, or string matching
2992
+ """
2993
+
2994
+ key: Required[str]
2995
+
2996
+ value: Required[str]
2997
+
2998
+ filter_type: Annotated[
2999
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3000
+ ]
3001
+
3002
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3003
+
3004
+ negate: Union[bool, Literal["true", "false"]]
3005
+
3006
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3007
+
3008
+
3009
+ class FiltersAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False):
3010
+ """
3011
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3012
+ """
3013
+
3014
+ key: Required[str]
3015
+
3016
+ value: Required[str]
3017
+
3018
+ filter_type: Annotated[
3019
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3020
+ ]
3021
+
3022
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3023
+
3024
+ negate: Union[bool, Literal["true", "false"]]
3025
+
3026
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3027
+
3028
+
3029
+ class FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False):
3030
+ """
3031
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3032
+ """
3033
+
3034
+ key: Required[str]
3035
+
3036
+ value: Required[str]
3037
+
3038
+ filter_type: Annotated[
3039
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3040
+ ]
3041
+
3042
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3043
+
3044
+ negate: Union[bool, Literal["true", "false"]]
3045
+
3046
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3047
+
3048
+
3049
+ class FiltersAndAndAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False):
3050
+ """
3051
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3052
+ """
3053
+
3054
+ key: Required[str]
3055
+
3056
+ value: Required[str]
3057
+
3058
+ filter_type: Annotated[
3059
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3060
+ ]
3061
+
3062
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3063
+
3064
+ negate: Union[bool, Literal["true", "false"]]
3065
+
3066
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3067
+
3068
+
3069
+ class FiltersAndAndAndAndOrOrOrOrOrOrOr(TypedDict, total=False):
3070
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
3071
+ """OR: Array of conditions"""
3072
+
3073
+
3074
+ class FiltersAndAndAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False):
3075
+ """
3076
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3077
+ """
3078
+
3079
+ key: Required[str]
3080
+
3081
+ value: Required[str]
3082
+
3083
+ filter_type: Annotated[
3084
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3085
+ ]
3086
+
3087
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3088
+
3089
+ negate: Union[bool, Literal["true", "false"]]
3090
+
3091
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3092
+
3093
+
3094
+ class FiltersAndAndAndAndOrOrOrOrOrOrAnd(TypedDict, total=False):
3095
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
3096
+ """AND: Array of conditions"""
3097
+
3098
+
3099
+ FiltersAndAndAndAndOrOrOrOrOrOr: TypeAlias = Union[
3100
+ FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrOrOrAnd
3101
+ ]
3102
+
3103
+
3104
+ class FiltersAndAndAndAndOrOrOrOrOr(TypedDict, total=False):
3105
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
3106
+ """OR: Array of conditions or nested expressions"""
3107
+
3108
+
3109
+ class FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False):
3110
+ """
3111
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3112
+ """
3113
+
3114
+ key: Required[str]
3115
+
3116
+ value: Required[str]
3117
+
3118
+ filter_type: Annotated[
3119
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3120
+ ]
3121
+
3122
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3123
+
3124
+ negate: Union[bool, Literal["true", "false"]]
3125
+
3126
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3127
+
3128
+
3129
+ class FiltersAndAndAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False):
3130
+ """
3131
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3132
+ """
3133
+
3134
+ key: Required[str]
3135
+
3136
+ value: Required[str]
3137
+
3138
+ filter_type: Annotated[
3139
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3140
+ ]
3141
+
3142
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3143
+
3144
+ negate: Union[bool, Literal["true", "false"]]
3145
+
3146
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3147
+
3148
+
3149
+ class FiltersAndAndAndAndOrOrOrOrAndAndOr(TypedDict, total=False):
3150
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
3151
+ """OR: Array of conditions"""
3152
+
3153
+
3154
+ class FiltersAndAndAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False):
3155
+ """
3156
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3157
+ """
3158
+
3159
+ key: Required[str]
3160
+
3161
+ value: Required[str]
3162
+
3163
+ filter_type: Annotated[
3164
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3165
+ ]
3166
+
3167
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3168
+
3169
+ negate: Union[bool, Literal["true", "false"]]
3170
+
3171
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3172
+
3173
+
3174
+ class FiltersAndAndAndAndOrOrOrOrAndAndAnd(TypedDict, total=False):
3175
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
3176
+ """AND: Array of conditions"""
3177
+
3178
+
3179
+ FiltersAndAndAndAndOrOrOrOrAndAnd: TypeAlias = Union[
3180
+ FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0,
3181
+ FiltersAndAndAndAndOrOrOrOrAndAndOr,
3182
+ FiltersAndAndAndAndOrOrOrOrAndAndAnd,
3183
+ ]
3184
+
3185
+
3186
+ class FiltersAndAndAndAndOrOrOrOrAnd(TypedDict, total=False):
3187
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
3188
+ """AND: Array of conditions or nested expressions"""
3189
+
3190
+
3191
+ FiltersAndAndAndAndOrOrOrOr: TypeAlias = Union[
3192
+ FiltersAndAndAndAndOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrAnd
3193
+ ]
3194
+
3195
+
3196
+ class FiltersAndAndAndAndOrOrOr(TypedDict, total=False):
3197
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
3198
+ """OR: Array of conditions or nested expressions"""
3199
+
3200
+
3201
+ class FiltersAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False):
3202
+ """
3203
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3204
+ """
3205
+
3206
+ key: Required[str]
3207
+
3208
+ value: Required[str]
3209
+
3210
+ filter_type: Annotated[
3211
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3212
+ ]
3213
+
3214
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3215
+
3216
+ negate: Union[bool, Literal["true", "false"]]
3217
+
3218
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3219
+
3220
+
3221
+ class FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False):
3222
+ """
3223
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3224
+ """
3225
+
3226
+ key: Required[str]
3227
+
3228
+ value: Required[str]
3229
+
3230
+ filter_type: Annotated[
3231
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3232
+ ]
3233
+
3234
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3235
+
3236
+ negate: Union[bool, Literal["true", "false"]]
3237
+
3238
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3239
+
3240
+
3241
+ class FiltersAndAndAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False):
3242
+ """
3243
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3244
+ """
3245
+
3246
+ key: Required[str]
3247
+
3248
+ value: Required[str]
3249
+
3250
+ filter_type: Annotated[
3251
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3252
+ ]
3253
+
3254
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3255
+
3256
+ negate: Union[bool, Literal["true", "false"]]
3257
+
3258
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3259
+
3260
+
3261
+ class FiltersAndAndAndAndOrOrAndAndOrOrOr(TypedDict, total=False):
3262
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
3263
+ """OR: Array of conditions"""
3264
+
3265
+
3266
+ class FiltersAndAndAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False):
3267
+ """
3268
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3269
+ """
3270
+
3271
+ key: Required[str]
3272
+
3273
+ value: Required[str]
3274
+
3275
+ filter_type: Annotated[
3276
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3277
+ ]
3278
+
3279
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3280
+
3281
+ negate: Union[bool, Literal["true", "false"]]
3282
+
3283
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3284
+
3285
+
3286
+ class FiltersAndAndAndAndOrOrAndAndOrOrAnd(TypedDict, total=False):
3287
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
3288
+ """AND: Array of conditions"""
3289
+
3290
+
3291
+ FiltersAndAndAndAndOrOrAndAndOrOr: TypeAlias = Union[
3292
+ FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0,
3293
+ FiltersAndAndAndAndOrOrAndAndOrOrOr,
3294
+ FiltersAndAndAndAndOrOrAndAndOrOrAnd,
3295
+ ]
3296
+
3297
+
3298
+ class FiltersAndAndAndAndOrOrAndAndOr(TypedDict, total=False):
3299
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
3300
+ """OR: Array of conditions or nested expressions"""
3301
+
3302
+
3303
+ class FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False):
3304
+ """
3305
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3306
+ """
3307
+
3308
+ key: Required[str]
3309
+
3310
+ value: Required[str]
3311
+
3312
+ filter_type: Annotated[
3313
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3314
+ ]
3315
+
3316
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3317
+
3318
+ negate: Union[bool, Literal["true", "false"]]
3319
+
3320
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3321
+
3322
+
3323
+ class FiltersAndAndAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False):
3324
+ """
3325
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3326
+ """
3327
+
3328
+ key: Required[str]
3329
+
3330
+ value: Required[str]
3331
+
3332
+ filter_type: Annotated[
3333
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3334
+ ]
3335
+
3336
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3337
+
3338
+ negate: Union[bool, Literal["true", "false"]]
3339
+
3340
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3341
+
3342
+
3343
+ class FiltersAndAndAndAndOrOrAndAndAndAndOr(TypedDict, total=False):
3344
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
3345
+ """OR: Array of conditions"""
3346
+
3347
+
3348
+ class FiltersAndAndAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False):
3349
+ """
3350
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3351
+ """
3352
+
3353
+ key: Required[str]
3354
+
3355
+ value: Required[str]
3356
+
3357
+ filter_type: Annotated[
3358
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3359
+ ]
3360
+
3361
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3362
+
3363
+ negate: Union[bool, Literal["true", "false"]]
3364
+
3365
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3366
+
3367
+
3368
+ class FiltersAndAndAndAndOrOrAndAndAndAndAnd(TypedDict, total=False):
3369
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
3370
+ """AND: Array of conditions"""
3371
+
3372
+
3373
+ FiltersAndAndAndAndOrOrAndAndAndAnd: TypeAlias = Union[
3374
+ FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0,
3375
+ FiltersAndAndAndAndOrOrAndAndAndAndOr,
3376
+ FiltersAndAndAndAndOrOrAndAndAndAndAnd,
3377
+ ]
3378
+
3379
+
3380
+ class FiltersAndAndAndAndOrOrAndAndAnd(TypedDict, total=False):
3381
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
3382
+ """AND: Array of conditions or nested expressions"""
3383
+
3384
+
3385
+ FiltersAndAndAndAndOrOrAndAnd: TypeAlias = Union[
3386
+ FiltersAndAndAndAndOrOrAndAndUnionMember0, FiltersAndAndAndAndOrOrAndAndOr, FiltersAndAndAndAndOrOrAndAndAnd
3387
+ ]
3388
+
3389
+
3390
+ class FiltersAndAndAndAndOrOrAnd(TypedDict, total=False):
3391
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
3392
+ """AND: Array of conditions or nested expressions"""
3393
+
3394
+
3395
+ FiltersAndAndAndAndOrOr: TypeAlias = Union[
3396
+ FiltersAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndOrOrOr, FiltersAndAndAndAndOrOrAnd
3397
+ ]
3398
+
3399
+
3400
+ class FiltersAndAndAndAndOr(TypedDict, total=False):
3401
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
3402
+ """OR: Array of conditions or nested expressions"""
3403
+
3404
+
3405
+ class FiltersAndAndAndAndAndAndUnionMember0(TypedDict, total=False):
3406
+ """
3407
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3408
+ """
3409
+
3410
+ key: Required[str]
3411
+
3412
+ value: Required[str]
3413
+
3414
+ filter_type: Annotated[
3415
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3416
+ ]
3417
+
3418
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3419
+
3420
+ negate: Union[bool, Literal["true", "false"]]
3421
+
3422
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3423
+
3424
+
3425
+ class FiltersAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False):
3426
+ """
3427
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3428
+ """
3429
+
3430
+ key: Required[str]
3431
+
3432
+ value: Required[str]
3433
+
3434
+ filter_type: Annotated[
3435
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3436
+ ]
3437
+
3438
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3439
+
3440
+ negate: Union[bool, Literal["true", "false"]]
3441
+
3442
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3443
+
3444
+
3445
+ class FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False):
3446
+ """
3447
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3448
+ """
3449
+
3450
+ key: Required[str]
3451
+
3452
+ value: Required[str]
3453
+
3454
+ filter_type: Annotated[
3455
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3456
+ ]
3457
+
3458
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3459
+
3460
+ negate: Union[bool, Literal["true", "false"]]
3461
+
3462
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3463
+
3464
+
3465
+ class FiltersAndAndAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False):
3466
+ """
3467
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3468
+ """
3469
+
3470
+ key: Required[str]
3471
+
3472
+ value: Required[str]
3473
+
3474
+ filter_type: Annotated[
3475
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3476
+ ]
3477
+
3478
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3479
+
3480
+ negate: Union[bool, Literal["true", "false"]]
3481
+
3482
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3483
+
3484
+
3485
+ class FiltersAndAndAndAndAndAndOrOrOrOrOr(TypedDict, total=False):
3486
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]]
3487
+ """OR: Array of conditions"""
3488
+
3489
+
3490
+ class FiltersAndAndAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False):
3491
+ """
3492
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3493
+ """
3494
+
3495
+ key: Required[str]
3496
+
3497
+ value: Required[str]
3498
+
3499
+ filter_type: Annotated[
3500
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3501
+ ]
3502
+
3503
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3504
+
3505
+ negate: Union[bool, Literal["true", "false"]]
3506
+
3507
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3508
+
3509
+
3510
+ class FiltersAndAndAndAndAndAndOrOrOrOrAnd(TypedDict, total=False):
3511
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]]
3512
+ """AND: Array of conditions"""
3513
+
3514
+
3515
+ FiltersAndAndAndAndAndAndOrOrOrOr: TypeAlias = Union[
3516
+ FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0,
3517
+ FiltersAndAndAndAndAndAndOrOrOrOrOr,
3518
+ FiltersAndAndAndAndAndAndOrOrOrOrAnd,
3519
+ ]
3520
+
3521
+
3522
+ class FiltersAndAndAndAndAndAndOrOrOr(TypedDict, total=False):
3523
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
3524
+ """OR: Array of conditions or nested expressions"""
3525
+
3526
+
3527
+ class FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False):
3528
+ """
3529
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3530
+ """
3531
+
3532
+ key: Required[str]
3533
+
3534
+ value: Required[str]
3535
+
3536
+ filter_type: Annotated[
3537
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3538
+ ]
3539
+
3540
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3541
+
3542
+ negate: Union[bool, Literal["true", "false"]]
3543
+
3544
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3545
+
3546
+
3547
+ class FiltersAndAndAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False):
3548
+ """
3549
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3550
+ """
3551
+
3552
+ key: Required[str]
3553
+
3554
+ value: Required[str]
3555
+
3556
+ filter_type: Annotated[
3557
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3558
+ ]
3559
+
3560
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3561
+
3562
+ negate: Union[bool, Literal["true", "false"]]
3563
+
3564
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3565
+
3566
+
3567
+ class FiltersAndAndAndAndAndAndOrOrAndAndOr(TypedDict, total=False):
3568
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]]
3569
+ """OR: Array of conditions"""
3570
+
3571
+
3572
+ class FiltersAndAndAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False):
3573
+ """
3574
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3575
+ """
3576
+
3577
+ key: Required[str]
3578
+
3579
+ value: Required[str]
3580
+
3581
+ filter_type: Annotated[
3582
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3583
+ ]
3584
+
3585
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3586
+
3587
+ negate: Union[bool, Literal["true", "false"]]
3588
+
3589
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3590
+
3591
+
3592
+ class FiltersAndAndAndAndAndAndOrOrAndAndAnd(TypedDict, total=False):
3593
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]]
3594
+ """AND: Array of conditions"""
3595
+
3596
+
3597
+ FiltersAndAndAndAndAndAndOrOrAndAnd: TypeAlias = Union[
3598
+ FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0,
3599
+ FiltersAndAndAndAndAndAndOrOrAndAndOr,
3600
+ FiltersAndAndAndAndAndAndOrOrAndAndAnd,
3601
+ ]
3602
+
3603
+
3604
+ class FiltersAndAndAndAndAndAndOrOrAnd(TypedDict, total=False):
3605
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
3606
+ """AND: Array of conditions or nested expressions"""
3607
+
3608
+
3609
+ FiltersAndAndAndAndAndAndOrOr: TypeAlias = Union[
3610
+ FiltersAndAndAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndAndAndOrOrOr, FiltersAndAndAndAndAndAndOrOrAnd
3611
+ ]
3612
+
3613
+
3614
+ class FiltersAndAndAndAndAndAndOr(TypedDict, total=False):
3615
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
3616
+ """OR: Array of conditions or nested expressions"""
3617
+
3618
+
3619
+ class FiltersAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False):
3620
+ """
3621
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3622
+ """
3623
+
3624
+ key: Required[str]
3625
+
3626
+ value: Required[str]
3627
+
3628
+ filter_type: Annotated[
3629
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3630
+ ]
3631
+
3632
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3633
+
3634
+ negate: Union[bool, Literal["true", "false"]]
3635
+
3636
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3637
+
3638
+
3639
+ class FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False):
3640
+ """
3641
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3642
+ """
3643
+
3644
+ key: Required[str]
3645
+
3646
+ value: Required[str]
3647
+
3648
+ filter_type: Annotated[
3649
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3650
+ ]
3651
+
3652
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3653
+
3654
+ negate: Union[bool, Literal["true", "false"]]
3655
+
3656
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3657
+
3658
+
3659
+ class FiltersAndAndAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False):
3660
+ """
3661
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3662
+ """
3663
+
3664
+ key: Required[str]
3665
+
3666
+ value: Required[str]
3667
+
3668
+ filter_type: Annotated[
3669
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3670
+ ]
3671
+
3672
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3673
+
3674
+ negate: Union[bool, Literal["true", "false"]]
3675
+
3676
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3677
+
3678
+
3679
+ class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False):
3680
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]]
3681
+ """OR: Array of conditions"""
3682
+
3683
+
3684
+ class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False):
3685
+ """
3686
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3687
+ """
3688
+
3689
+ key: Required[str]
3690
+
3691
+ value: Required[str]
3692
+
3693
+ filter_type: Annotated[
3694
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3695
+ ]
3696
+
3697
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3698
+
3699
+ negate: Union[bool, Literal["true", "false"]]
3700
+
3701
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3702
+
3703
+
3704
+ class FiltersAndAndAndAndAndAndAndAndOrOrAnd(TypedDict, total=False):
3705
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]]
3706
+ """AND: Array of conditions"""
3707
+
3708
+
3709
+ FiltersAndAndAndAndAndAndAndAndOrOr: TypeAlias = Union[
3710
+ FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0,
3711
+ FiltersAndAndAndAndAndAndAndAndOrOrOr,
3712
+ FiltersAndAndAndAndAndAndAndAndOrOrAnd,
3713
+ ]
3714
+
3715
+
3716
+ class FiltersAndAndAndAndAndAndAndAndOr(TypedDict, total=False):
3717
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
3718
+ """OR: Array of conditions or nested expressions"""
3719
+
3720
+
3721
+ class FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False):
3722
+ """
3723
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3724
+ """
3725
+
3726
+ key: Required[str]
3727
+
3728
+ value: Required[str]
3729
+
3730
+ filter_type: Annotated[
3731
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3732
+ ]
3733
+
3734
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3735
+
3736
+ negate: Union[bool, Literal["true", "false"]]
3737
+
3738
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3739
+
3740
+
3741
+ class FiltersAndAndAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False):
3742
+ """
3743
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3744
+ """
3745
+
3746
+ key: Required[str]
3747
+
3748
+ value: Required[str]
3749
+
3750
+ filter_type: Annotated[
3751
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3752
+ ]
3753
+
3754
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3755
+
3756
+ negate: Union[bool, Literal["true", "false"]]
3757
+
3758
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3759
+
3760
+
3761
+ class FiltersAndAndAndAndAndAndAndAndAndAndOr(TypedDict, total=False):
3762
+ or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]]
3763
+ """OR: Array of conditions"""
3764
+
3765
+
3766
+ class FiltersAndAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False):
3767
+ """
3768
+ A single filter condition based on metadata, numeric values, array contents, or string matching
3769
+ """
3770
+
3771
+ key: Required[str]
3772
+
3773
+ value: Required[str]
3774
+
3775
+ filter_type: Annotated[
3776
+ Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType")
3777
+ ]
3778
+
3779
+ ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")]
3780
+
3781
+ negate: Union[bool, Literal["true", "false"]]
3782
+
3783
+ numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")]
3784
+
3785
+
3786
+ class FiltersAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False):
3787
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
3788
+ """AND: Array of conditions"""
3789
+
3790
+
3791
+ FiltersAndAndAndAndAndAndAndAndAndAnd: TypeAlias = Union[
3792
+ FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0,
3793
+ FiltersAndAndAndAndAndAndAndAndAndAndOr,
3794
+ FiltersAndAndAndAndAndAndAndAndAndAndAnd,
3795
+ ]
3796
+
3797
+
3798
+ class FiltersAndAndAndAndAndAndAndAndAnd(TypedDict, total=False):
3799
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
3800
+ """AND: Array of conditions or nested expressions"""
3801
+
3802
+
3803
+ FiltersAndAndAndAndAndAndAndAnd: TypeAlias = Union[
3804
+ FiltersAndAndAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAndAndAnd
3805
+ ]
3806
+
3807
+
3808
+ class FiltersAndAndAndAndAndAndAnd(TypedDict, total=False):
3809
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
3810
+ """AND: Array of conditions or nested expressions"""
3811
+
3812
+
3813
+ FiltersAndAndAndAndAndAnd: TypeAlias = Union[
3814
+ FiltersAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAnd
3815
+ ]
3816
+
3817
+
3818
+ class FiltersAndAndAndAndAnd(TypedDict, total=False):
3819
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAnd], PropertyInfo(alias="AND")]]
3820
+ """AND: Array of conditions or nested expressions"""
3821
+
3822
+
3823
+ FiltersAndAndAndAnd: TypeAlias = Union[FiltersAndAndAndAndUnionMember0, FiltersAndAndAndAndOr, FiltersAndAndAndAndAnd]
3824
+
3825
+
3826
+ class FiltersAndAndAnd(TypedDict, total=False):
3827
+ and_: Required[Annotated[Iterable[FiltersAndAndAndAnd], PropertyInfo(alias="AND")]]
3828
+ """AND: Array of conditions or nested expressions"""
3829
+
3830
+
3831
+ FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd]
46
3832
 
47
3833
 
48
3834
  class FiltersAnd(TypedDict, total=False):
49
- and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]]
3835
+ and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]]
3836
+ """Array of AND filter expressions"""
50
3837
 
51
3838
 
52
3839
  Filters: TypeAlias = Union[FiltersOr, FiltersAnd]