@zeroin.earth/appwrite-graphql 0.15.6 → 0.15.8

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 (7) hide show
  1. package/dist/index.d.mts +567 -919
  2. package/dist/index.d.ts +567 -919
  3. package/dist/index.js +113 -1961
  4. package/dist/index.js.map +1 -1
  5. package/dist/index.mjs +58 -1887
  6. package/dist/index.mjs.map +1 -1
  7. package/package.json +3 -3
package/dist/index.d.ts CHANGED
@@ -55,14 +55,6 @@ type Account_UserFragment = {
55
55
  } & {
56
56
  ' $fragmentName'?: 'Account_UserFragment';
57
57
  };
58
- type Identity_ProviderFragment = {
59
- __typename?: 'Identity';
60
- _id?: string | null;
61
- userId?: string | null;
62
- provider?: string | null;
63
- } & {
64
- ' $fragmentName'?: 'Identity_ProviderFragment';
65
- };
66
58
  type GetSessionQueryVariables = Exact<{
67
59
  sessionId: Scalars['String']['input'];
68
60
  }>;
@@ -111,7 +103,7 @@ declare function useAccount<Preferences extends Models.Preferences>(): _tanstack
111
103
  ' $fragmentRefs'?: {
112
104
  Account_UserFragment: Account_UserFragment;
113
105
  };
114
- }, AppwriteException>;
106
+ }, AppwriteException[]>;
115
107
 
116
108
  declare function useCreateAnonymousSession(): {
117
109
  data: undefined;
@@ -127,11 +119,11 @@ declare function useCreateAnonymousSession(): {
127
119
  _id?: string;
128
120
  expire?: any;
129
121
  current?: boolean;
130
- }, AppwriteException, void, unknown>;
122
+ }, AppwriteException[], void, unknown>;
131
123
  reset: () => void;
132
124
  context: unknown;
133
125
  failureCount: number;
134
- failureReason: AppwriteException;
126
+ failureReason: AppwriteException[];
135
127
  isPaused: boolean;
136
128
  submittedAt: number;
137
129
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -139,7 +131,7 @@ declare function useCreateAnonymousSession(): {
139
131
  _id?: string;
140
132
  expire?: any;
141
133
  current?: boolean;
142
- }, AppwriteException, void, unknown>;
134
+ }, AppwriteException[], void, unknown>;
143
135
  } | {
144
136
  data: undefined;
145
137
  variables: void;
@@ -154,11 +146,11 @@ declare function useCreateAnonymousSession(): {
154
146
  _id?: string;
155
147
  expire?: any;
156
148
  current?: boolean;
157
- }, AppwriteException, void, unknown>;
149
+ }, AppwriteException[], void, unknown>;
158
150
  reset: () => void;
159
151
  context: unknown;
160
152
  failureCount: number;
161
- failureReason: AppwriteException;
153
+ failureReason: AppwriteException[];
162
154
  isPaused: boolean;
163
155
  submittedAt: number;
164
156
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -166,10 +158,10 @@ declare function useCreateAnonymousSession(): {
166
158
  _id?: string;
167
159
  expire?: any;
168
160
  current?: boolean;
169
- }, AppwriteException, void, unknown>;
161
+ }, AppwriteException[], void, unknown>;
170
162
  } | {
171
163
  data: undefined;
172
- error: AppwriteException;
164
+ error: AppwriteException[];
173
165
  variables: void;
174
166
  isError: true;
175
167
  isIdle: false;
@@ -181,11 +173,11 @@ declare function useCreateAnonymousSession(): {
181
173
  _id?: string;
182
174
  expire?: any;
183
175
  current?: boolean;
184
- }, AppwriteException, void, unknown>;
176
+ }, AppwriteException[], void, unknown>;
185
177
  reset: () => void;
186
178
  context: unknown;
187
179
  failureCount: number;
188
- failureReason: AppwriteException;
180
+ failureReason: AppwriteException[];
189
181
  isPaused: boolean;
190
182
  submittedAt: number;
191
183
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -193,7 +185,7 @@ declare function useCreateAnonymousSession(): {
193
185
  _id?: string;
194
186
  expire?: any;
195
187
  current?: boolean;
196
- }, AppwriteException, void, unknown>;
188
+ }, AppwriteException[], void, unknown>;
197
189
  } | {
198
190
  data: {
199
191
  __typename?: "Session";
@@ -213,11 +205,11 @@ declare function useCreateAnonymousSession(): {
213
205
  _id?: string;
214
206
  expire?: any;
215
207
  current?: boolean;
216
- }, AppwriteException, void, unknown>;
208
+ }, AppwriteException[], void, unknown>;
217
209
  reset: () => void;
218
210
  context: unknown;
219
211
  failureCount: number;
220
- failureReason: AppwriteException;
212
+ failureReason: AppwriteException[];
221
213
  isPaused: boolean;
222
214
  submittedAt: number;
223
215
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -225,7 +217,7 @@ declare function useCreateAnonymousSession(): {
225
217
  _id?: string;
226
218
  expire?: any;
227
219
  current?: boolean;
228
- }, AppwriteException, void, unknown>;
220
+ }, AppwriteException[], void, unknown>;
229
221
  };
230
222
 
231
223
  declare function useCreateEmailToken(): {
@@ -240,7 +232,7 @@ declare function useCreateEmailToken(): {
240
232
  mutate: _tanstack_react_query.UseMutateFunction<{
241
233
  __typename?: "Token";
242
234
  expire?: any;
243
- }, AppwriteException, Exact<{
235
+ }, AppwriteException[], Exact<{
244
236
  userId: string;
245
237
  email: string;
246
238
  phrase?: boolean;
@@ -248,13 +240,13 @@ declare function useCreateEmailToken(): {
248
240
  reset: () => void;
249
241
  context: unknown;
250
242
  failureCount: number;
251
- failureReason: AppwriteException;
243
+ failureReason: AppwriteException[];
252
244
  isPaused: boolean;
253
245
  submittedAt: number;
254
246
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
255
247
  __typename?: "Token";
256
248
  expire?: any;
257
- }, AppwriteException, Exact<{
249
+ }, AppwriteException[], Exact<{
258
250
  userId: string;
259
251
  email: string;
260
252
  phrase?: boolean;
@@ -275,7 +267,7 @@ declare function useCreateEmailToken(): {
275
267
  mutate: _tanstack_react_query.UseMutateFunction<{
276
268
  __typename?: "Token";
277
269
  expire?: any;
278
- }, AppwriteException, Exact<{
270
+ }, AppwriteException[], Exact<{
279
271
  userId: string;
280
272
  email: string;
281
273
  phrase?: boolean;
@@ -283,20 +275,20 @@ declare function useCreateEmailToken(): {
283
275
  reset: () => void;
284
276
  context: unknown;
285
277
  failureCount: number;
286
- failureReason: AppwriteException;
278
+ failureReason: AppwriteException[];
287
279
  isPaused: boolean;
288
280
  submittedAt: number;
289
281
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
290
282
  __typename?: "Token";
291
283
  expire?: any;
292
- }, AppwriteException, Exact<{
284
+ }, AppwriteException[], Exact<{
293
285
  userId: string;
294
286
  email: string;
295
287
  phrase?: boolean;
296
288
  }>, unknown>;
297
289
  } | {
298
290
  data: undefined;
299
- error: AppwriteException;
291
+ error: AppwriteException[];
300
292
  variables: Exact<{
301
293
  userId: string;
302
294
  email: string;
@@ -310,7 +302,7 @@ declare function useCreateEmailToken(): {
310
302
  mutate: _tanstack_react_query.UseMutateFunction<{
311
303
  __typename?: "Token";
312
304
  expire?: any;
313
- }, AppwriteException, Exact<{
305
+ }, AppwriteException[], Exact<{
314
306
  userId: string;
315
307
  email: string;
316
308
  phrase?: boolean;
@@ -318,13 +310,13 @@ declare function useCreateEmailToken(): {
318
310
  reset: () => void;
319
311
  context: unknown;
320
312
  failureCount: number;
321
- failureReason: AppwriteException;
313
+ failureReason: AppwriteException[];
322
314
  isPaused: boolean;
323
315
  submittedAt: number;
324
316
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
325
317
  __typename?: "Token";
326
318
  expire?: any;
327
- }, AppwriteException, Exact<{
319
+ }, AppwriteException[], Exact<{
328
320
  userId: string;
329
321
  email: string;
330
322
  phrase?: boolean;
@@ -348,7 +340,7 @@ declare function useCreateEmailToken(): {
348
340
  mutate: _tanstack_react_query.UseMutateFunction<{
349
341
  __typename?: "Token";
350
342
  expire?: any;
351
- }, AppwriteException, Exact<{
343
+ }, AppwriteException[], Exact<{
352
344
  userId: string;
353
345
  email: string;
354
346
  phrase?: boolean;
@@ -356,13 +348,13 @@ declare function useCreateEmailToken(): {
356
348
  reset: () => void;
357
349
  context: unknown;
358
350
  failureCount: number;
359
- failureReason: AppwriteException;
351
+ failureReason: AppwriteException[];
360
352
  isPaused: boolean;
361
353
  submittedAt: number;
362
354
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
363
355
  __typename?: "Token";
364
356
  expire?: any;
365
- }, AppwriteException, Exact<{
357
+ }, AppwriteException[], Exact<{
366
358
  userId: string;
367
359
  email: string;
368
360
  phrase?: boolean;
@@ -383,17 +375,17 @@ declare function useCreateJWT({ gcTime }?: {
383
375
  mutate: _tanstack_react_query.UseMutateFunction<{
384
376
  __typename?: "JWT";
385
377
  jwt?: string;
386
- }, AppwriteException, void, unknown>;
378
+ }, AppwriteException[], void, unknown>;
387
379
  reset: () => void;
388
380
  context: unknown;
389
381
  failureCount: number;
390
- failureReason: AppwriteException;
382
+ failureReason: AppwriteException[];
391
383
  isPaused: boolean;
392
384
  submittedAt: number;
393
385
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
394
386
  __typename?: "JWT";
395
387
  jwt?: string;
396
- }, AppwriteException, void, unknown>;
388
+ }, AppwriteException[], void, unknown>;
397
389
  } | {
398
390
  data: undefined;
399
391
  variables: void;
@@ -406,20 +398,20 @@ declare function useCreateJWT({ gcTime }?: {
406
398
  mutate: _tanstack_react_query.UseMutateFunction<{
407
399
  __typename?: "JWT";
408
400
  jwt?: string;
409
- }, AppwriteException, void, unknown>;
401
+ }, AppwriteException[], void, unknown>;
410
402
  reset: () => void;
411
403
  context: unknown;
412
404
  failureCount: number;
413
- failureReason: AppwriteException;
405
+ failureReason: AppwriteException[];
414
406
  isPaused: boolean;
415
407
  submittedAt: number;
416
408
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
417
409
  __typename?: "JWT";
418
410
  jwt?: string;
419
- }, AppwriteException, void, unknown>;
411
+ }, AppwriteException[], void, unknown>;
420
412
  } | {
421
413
  data: undefined;
422
- error: AppwriteException;
414
+ error: AppwriteException[];
423
415
  variables: void;
424
416
  isError: true;
425
417
  isIdle: false;
@@ -429,17 +421,17 @@ declare function useCreateJWT({ gcTime }?: {
429
421
  mutate: _tanstack_react_query.UseMutateFunction<{
430
422
  __typename?: "JWT";
431
423
  jwt?: string;
432
- }, AppwriteException, void, unknown>;
424
+ }, AppwriteException[], void, unknown>;
433
425
  reset: () => void;
434
426
  context: unknown;
435
427
  failureCount: number;
436
- failureReason: AppwriteException;
428
+ failureReason: AppwriteException[];
437
429
  isPaused: boolean;
438
430
  submittedAt: number;
439
431
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
440
432
  __typename?: "JWT";
441
433
  jwt?: string;
442
- }, AppwriteException, void, unknown>;
434
+ }, AppwriteException[], void, unknown>;
443
435
  } | {
444
436
  data: {
445
437
  __typename?: "JWT";
@@ -455,17 +447,17 @@ declare function useCreateJWT({ gcTime }?: {
455
447
  mutate: _tanstack_react_query.UseMutateFunction<{
456
448
  __typename?: "JWT";
457
449
  jwt?: string;
458
- }, AppwriteException, void, unknown>;
450
+ }, AppwriteException[], void, unknown>;
459
451
  reset: () => void;
460
452
  context: unknown;
461
453
  failureCount: number;
462
- failureReason: AppwriteException;
454
+ failureReason: AppwriteException[];
463
455
  isPaused: boolean;
464
456
  submittedAt: number;
465
457
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
466
458
  __typename?: "JWT";
467
459
  jwt?: string;
468
- }, AppwriteException, void, unknown>;
460
+ }, AppwriteException[], void, unknown>;
469
461
  };
470
462
  declare function useSuspenseCreateJWT({ gcTime }?: {
471
463
  gcTime?: number;
@@ -475,12 +467,12 @@ declare function useSuspenseCreateJWT({ gcTime }?: {
475
467
  jwt?: string;
476
468
  };
477
469
  status: "error" | "success";
478
- error: AppwriteException;
470
+ error: AppwriteException[];
479
471
  isError: boolean;
480
472
  isPending: false;
481
473
  isSuccess: boolean;
482
474
  failureCount: number;
483
- failureReason: AppwriteException;
475
+ failureReason: AppwriteException[];
484
476
  isPaused: boolean;
485
477
  isLoading: false;
486
478
  isLoadingError: false;
@@ -497,7 +489,7 @@ declare function useSuspenseCreateJWT({ gcTime }?: {
497
489
  refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
498
490
  __typename?: "JWT";
499
491
  jwt?: string;
500
- }, AppwriteException>>;
492
+ }, AppwriteException[]>>;
501
493
  fetchStatus: _tanstack_query_core.FetchStatus;
502
494
  };
503
495
 
@@ -513,7 +505,7 @@ declare function useCreateMagicURLToken(): {
513
505
  mutate: _tanstack_react_query.UseMutateFunction<{
514
506
  __typename?: "Token";
515
507
  expire?: any;
516
- }, AppwriteException, Exact<{
508
+ }, AppwriteException[], Exact<{
517
509
  userId: string;
518
510
  email: string;
519
511
  url?: string;
@@ -522,13 +514,13 @@ declare function useCreateMagicURLToken(): {
522
514
  reset: () => void;
523
515
  context: unknown;
524
516
  failureCount: number;
525
- failureReason: AppwriteException;
517
+ failureReason: AppwriteException[];
526
518
  isPaused: boolean;
527
519
  submittedAt: number;
528
520
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
529
521
  __typename?: "Token";
530
522
  expire?: any;
531
- }, AppwriteException, Exact<{
523
+ }, AppwriteException[], Exact<{
532
524
  userId: string;
533
525
  email: string;
534
526
  url?: string;
@@ -551,7 +543,7 @@ declare function useCreateMagicURLToken(): {
551
543
  mutate: _tanstack_react_query.UseMutateFunction<{
552
544
  __typename?: "Token";
553
545
  expire?: any;
554
- }, AppwriteException, Exact<{
546
+ }, AppwriteException[], Exact<{
555
547
  userId: string;
556
548
  email: string;
557
549
  url?: string;
@@ -560,13 +552,13 @@ declare function useCreateMagicURLToken(): {
560
552
  reset: () => void;
561
553
  context: unknown;
562
554
  failureCount: number;
563
- failureReason: AppwriteException;
555
+ failureReason: AppwriteException[];
564
556
  isPaused: boolean;
565
557
  submittedAt: number;
566
558
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
567
559
  __typename?: "Token";
568
560
  expire?: any;
569
- }, AppwriteException, Exact<{
561
+ }, AppwriteException[], Exact<{
570
562
  userId: string;
571
563
  email: string;
572
564
  url?: string;
@@ -574,7 +566,7 @@ declare function useCreateMagicURLToken(): {
574
566
  }>, unknown>;
575
567
  } | {
576
568
  data: undefined;
577
- error: AppwriteException;
569
+ error: AppwriteException[];
578
570
  variables: Exact<{
579
571
  userId: string;
580
572
  email: string;
@@ -589,7 +581,7 @@ declare function useCreateMagicURLToken(): {
589
581
  mutate: _tanstack_react_query.UseMutateFunction<{
590
582
  __typename?: "Token";
591
583
  expire?: any;
592
- }, AppwriteException, Exact<{
584
+ }, AppwriteException[], Exact<{
593
585
  userId: string;
594
586
  email: string;
595
587
  url?: string;
@@ -598,13 +590,13 @@ declare function useCreateMagicURLToken(): {
598
590
  reset: () => void;
599
591
  context: unknown;
600
592
  failureCount: number;
601
- failureReason: AppwriteException;
593
+ failureReason: AppwriteException[];
602
594
  isPaused: boolean;
603
595
  submittedAt: number;
604
596
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
605
597
  __typename?: "Token";
606
598
  expire?: any;
607
- }, AppwriteException, Exact<{
599
+ }, AppwriteException[], Exact<{
608
600
  userId: string;
609
601
  email: string;
610
602
  url?: string;
@@ -630,7 +622,7 @@ declare function useCreateMagicURLToken(): {
630
622
  mutate: _tanstack_react_query.UseMutateFunction<{
631
623
  __typename?: "Token";
632
624
  expire?: any;
633
- }, AppwriteException, Exact<{
625
+ }, AppwriteException[], Exact<{
634
626
  userId: string;
635
627
  email: string;
636
628
  url?: string;
@@ -639,13 +631,13 @@ declare function useCreateMagicURLToken(): {
639
631
  reset: () => void;
640
632
  context: unknown;
641
633
  failureCount: number;
642
- failureReason: AppwriteException;
634
+ failureReason: AppwriteException[];
643
635
  isPaused: boolean;
644
636
  submittedAt: number;
645
637
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
646
638
  __typename?: "Token";
647
639
  expire?: any;
648
- }, AppwriteException, Exact<{
640
+ }, AppwriteException[], Exact<{
649
641
  userId: string;
650
642
  email: string;
651
643
  url?: string;
@@ -666,20 +658,20 @@ declare function useCreateMfaAuthenticator(): {
666
658
  __typename?: "MFAType";
667
659
  secret?: string;
668
660
  uri?: string;
669
- }, AppwriteException, Exact<{
661
+ }, AppwriteException[], Exact<{
670
662
  type: string;
671
663
  }>, unknown>;
672
664
  reset: () => void;
673
665
  context: unknown;
674
666
  failureCount: number;
675
- failureReason: AppwriteException;
667
+ failureReason: AppwriteException[];
676
668
  isPaused: boolean;
677
669
  submittedAt: number;
678
670
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
679
671
  __typename?: "MFAType";
680
672
  secret?: string;
681
673
  uri?: string;
682
- }, AppwriteException, Exact<{
674
+ }, AppwriteException[], Exact<{
683
675
  type: string;
684
676
  }>, unknown>;
685
677
  } | {
@@ -697,25 +689,25 @@ declare function useCreateMfaAuthenticator(): {
697
689
  __typename?: "MFAType";
698
690
  secret?: string;
699
691
  uri?: string;
700
- }, AppwriteException, Exact<{
692
+ }, AppwriteException[], Exact<{
701
693
  type: string;
702
694
  }>, unknown>;
703
695
  reset: () => void;
704
696
  context: unknown;
705
697
  failureCount: number;
706
- failureReason: AppwriteException;
698
+ failureReason: AppwriteException[];
707
699
  isPaused: boolean;
708
700
  submittedAt: number;
709
701
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
710
702
  __typename?: "MFAType";
711
703
  secret?: string;
712
704
  uri?: string;
713
- }, AppwriteException, Exact<{
705
+ }, AppwriteException[], Exact<{
714
706
  type: string;
715
707
  }>, unknown>;
716
708
  } | {
717
709
  data: undefined;
718
- error: AppwriteException;
710
+ error: AppwriteException[];
719
711
  variables: Exact<{
720
712
  type: string;
721
713
  }>;
@@ -728,20 +720,20 @@ declare function useCreateMfaAuthenticator(): {
728
720
  __typename?: "MFAType";
729
721
  secret?: string;
730
722
  uri?: string;
731
- }, AppwriteException, Exact<{
723
+ }, AppwriteException[], Exact<{
732
724
  type: string;
733
725
  }>, unknown>;
734
726
  reset: () => void;
735
727
  context: unknown;
736
728
  failureCount: number;
737
- failureReason: AppwriteException;
729
+ failureReason: AppwriteException[];
738
730
  isPaused: boolean;
739
731
  submittedAt: number;
740
732
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
741
733
  __typename?: "MFAType";
742
734
  secret?: string;
743
735
  uri?: string;
744
- }, AppwriteException, Exact<{
736
+ }, AppwriteException[], Exact<{
745
737
  type: string;
746
738
  }>, unknown>;
747
739
  } | {
@@ -763,20 +755,20 @@ declare function useCreateMfaAuthenticator(): {
763
755
  __typename?: "MFAType";
764
756
  secret?: string;
765
757
  uri?: string;
766
- }, AppwriteException, Exact<{
758
+ }, AppwriteException[], Exact<{
767
759
  type: string;
768
760
  }>, unknown>;
769
761
  reset: () => void;
770
762
  context: unknown;
771
763
  failureCount: number;
772
- failureReason: AppwriteException;
764
+ failureReason: AppwriteException[];
773
765
  isPaused: boolean;
774
766
  submittedAt: number;
775
767
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
776
768
  __typename?: "MFAType";
777
769
  secret?: string;
778
770
  uri?: string;
779
- }, AppwriteException, Exact<{
771
+ }, AppwriteException[], Exact<{
780
772
  type: string;
781
773
  }>, unknown>;
782
774
  };
@@ -794,20 +786,20 @@ declare function useCreateMfaChallenge(): {
794
786
  __typename?: "MFAChallenge";
795
787
  userId?: string;
796
788
  expire?: any;
797
- }, AppwriteException, {
789
+ }, AppwriteException[], {
798
790
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
799
791
  }, unknown>;
800
792
  reset: () => void;
801
793
  context: unknown;
802
794
  failureCount: number;
803
- failureReason: AppwriteException;
795
+ failureReason: AppwriteException[];
804
796
  isPaused: boolean;
805
797
  submittedAt: number;
806
798
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
807
799
  __typename?: "MFAChallenge";
808
800
  userId?: string;
809
801
  expire?: any;
810
- }, AppwriteException, {
802
+ }, AppwriteException[], {
811
803
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
812
804
  }, unknown>;
813
805
  } | {
@@ -825,25 +817,25 @@ declare function useCreateMfaChallenge(): {
825
817
  __typename?: "MFAChallenge";
826
818
  userId?: string;
827
819
  expire?: any;
828
- }, AppwriteException, {
820
+ }, AppwriteException[], {
829
821
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
830
822
  }, unknown>;
831
823
  reset: () => void;
832
824
  context: unknown;
833
825
  failureCount: number;
834
- failureReason: AppwriteException;
826
+ failureReason: AppwriteException[];
835
827
  isPaused: boolean;
836
828
  submittedAt: number;
837
829
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
838
830
  __typename?: "MFAChallenge";
839
831
  userId?: string;
840
832
  expire?: any;
841
- }, AppwriteException, {
833
+ }, AppwriteException[], {
842
834
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
843
835
  }, unknown>;
844
836
  } | {
845
837
  data: undefined;
846
- error: AppwriteException;
838
+ error: AppwriteException[];
847
839
  variables: {
848
840
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
849
841
  };
@@ -856,20 +848,20 @@ declare function useCreateMfaChallenge(): {
856
848
  __typename?: "MFAChallenge";
857
849
  userId?: string;
858
850
  expire?: any;
859
- }, AppwriteException, {
851
+ }, AppwriteException[], {
860
852
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
861
853
  }, unknown>;
862
854
  reset: () => void;
863
855
  context: unknown;
864
856
  failureCount: number;
865
- failureReason: AppwriteException;
857
+ failureReason: AppwriteException[];
866
858
  isPaused: boolean;
867
859
  submittedAt: number;
868
860
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
869
861
  __typename?: "MFAChallenge";
870
862
  userId?: string;
871
863
  expire?: any;
872
- }, AppwriteException, {
864
+ }, AppwriteException[], {
873
865
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
874
866
  }, unknown>;
875
867
  } | {
@@ -891,20 +883,20 @@ declare function useCreateMfaChallenge(): {
891
883
  __typename?: "MFAChallenge";
892
884
  userId?: string;
893
885
  expire?: any;
894
- }, AppwriteException, {
886
+ }, AppwriteException[], {
895
887
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
896
888
  }, unknown>;
897
889
  reset: () => void;
898
890
  context: unknown;
899
891
  failureCount: number;
900
- failureReason: AppwriteException;
892
+ failureReason: AppwriteException[];
901
893
  isPaused: boolean;
902
894
  submittedAt: number;
903
895
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
904
896
  __typename?: "MFAChallenge";
905
897
  userId?: string;
906
898
  expire?: any;
907
- }, AppwriteException, {
899
+ }, AppwriteException[], {
908
900
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
909
901
  }, unknown>;
910
902
  };
@@ -921,17 +913,17 @@ declare function useCreateMfaRecoveryCodes(): {
921
913
  mutate: _tanstack_react_query.UseMutateFunction<{
922
914
  __typename?: "MFARecoveryCodes";
923
915
  recoveryCodes: string[];
924
- }, AppwriteException, void, unknown>;
916
+ }, AppwriteException[], void, unknown>;
925
917
  reset: () => void;
926
918
  context: unknown;
927
919
  failureCount: number;
928
- failureReason: AppwriteException;
920
+ failureReason: AppwriteException[];
929
921
  isPaused: boolean;
930
922
  submittedAt: number;
931
923
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
932
924
  __typename?: "MFARecoveryCodes";
933
925
  recoveryCodes: string[];
934
- }, AppwriteException, void, unknown>;
926
+ }, AppwriteException[], void, unknown>;
935
927
  } | {
936
928
  data: undefined;
937
929
  variables: void;
@@ -944,20 +936,20 @@ declare function useCreateMfaRecoveryCodes(): {
944
936
  mutate: _tanstack_react_query.UseMutateFunction<{
945
937
  __typename?: "MFARecoveryCodes";
946
938
  recoveryCodes: string[];
947
- }, AppwriteException, void, unknown>;
939
+ }, AppwriteException[], void, unknown>;
948
940
  reset: () => void;
949
941
  context: unknown;
950
942
  failureCount: number;
951
- failureReason: AppwriteException;
943
+ failureReason: AppwriteException[];
952
944
  isPaused: boolean;
953
945
  submittedAt: number;
954
946
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
955
947
  __typename?: "MFARecoveryCodes";
956
948
  recoveryCodes: string[];
957
- }, AppwriteException, void, unknown>;
949
+ }, AppwriteException[], void, unknown>;
958
950
  } | {
959
951
  data: undefined;
960
- error: AppwriteException;
952
+ error: AppwriteException[];
961
953
  variables: void;
962
954
  isError: true;
963
955
  isIdle: false;
@@ -967,17 +959,17 @@ declare function useCreateMfaRecoveryCodes(): {
967
959
  mutate: _tanstack_react_query.UseMutateFunction<{
968
960
  __typename?: "MFARecoveryCodes";
969
961
  recoveryCodes: string[];
970
- }, AppwriteException, void, unknown>;
962
+ }, AppwriteException[], void, unknown>;
971
963
  reset: () => void;
972
964
  context: unknown;
973
965
  failureCount: number;
974
- failureReason: AppwriteException;
966
+ failureReason: AppwriteException[];
975
967
  isPaused: boolean;
976
968
  submittedAt: number;
977
969
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
978
970
  __typename?: "MFARecoveryCodes";
979
971
  recoveryCodes: string[];
980
- }, AppwriteException, void, unknown>;
972
+ }, AppwriteException[], void, unknown>;
981
973
  } | {
982
974
  data: {
983
975
  __typename?: "MFARecoveryCodes";
@@ -993,17 +985,17 @@ declare function useCreateMfaRecoveryCodes(): {
993
985
  mutate: _tanstack_react_query.UseMutateFunction<{
994
986
  __typename?: "MFARecoveryCodes";
995
987
  recoveryCodes: string[];
996
- }, AppwriteException, void, unknown>;
988
+ }, AppwriteException[], void, unknown>;
997
989
  reset: () => void;
998
990
  context: unknown;
999
991
  failureCount: number;
1000
- failureReason: AppwriteException;
992
+ failureReason: AppwriteException[];
1001
993
  isPaused: boolean;
1002
994
  submittedAt: number;
1003
995
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1004
996
  __typename?: "MFARecoveryCodes";
1005
997
  recoveryCodes: string[];
1006
- }, AppwriteException, void, unknown>;
998
+ }, AppwriteException[], void, unknown>;
1007
999
  };
1008
1000
 
1009
1001
  declare function useCreatePhoneToken(): {
@@ -1018,20 +1010,20 @@ declare function useCreatePhoneToken(): {
1018
1010
  mutate: _tanstack_react_query.UseMutateFunction<{
1019
1011
  __typename?: "Token";
1020
1012
  expire?: any;
1021
- }, AppwriteException, Exact<{
1013
+ }, AppwriteException[], Exact<{
1022
1014
  userId: string;
1023
1015
  phone: string;
1024
1016
  }>, unknown>;
1025
1017
  reset: () => void;
1026
1018
  context: unknown;
1027
1019
  failureCount: number;
1028
- failureReason: AppwriteException;
1020
+ failureReason: AppwriteException[];
1029
1021
  isPaused: boolean;
1030
1022
  submittedAt: number;
1031
1023
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1032
1024
  __typename?: "Token";
1033
1025
  expire?: any;
1034
- }, AppwriteException, Exact<{
1026
+ }, AppwriteException[], Exact<{
1035
1027
  userId: string;
1036
1028
  phone: string;
1037
1029
  }>, unknown>;
@@ -1050,26 +1042,26 @@ declare function useCreatePhoneToken(): {
1050
1042
  mutate: _tanstack_react_query.UseMutateFunction<{
1051
1043
  __typename?: "Token";
1052
1044
  expire?: any;
1053
- }, AppwriteException, Exact<{
1045
+ }, AppwriteException[], Exact<{
1054
1046
  userId: string;
1055
1047
  phone: string;
1056
1048
  }>, unknown>;
1057
1049
  reset: () => void;
1058
1050
  context: unknown;
1059
1051
  failureCount: number;
1060
- failureReason: AppwriteException;
1052
+ failureReason: AppwriteException[];
1061
1053
  isPaused: boolean;
1062
1054
  submittedAt: number;
1063
1055
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1064
1056
  __typename?: "Token";
1065
1057
  expire?: any;
1066
- }, AppwriteException, Exact<{
1058
+ }, AppwriteException[], Exact<{
1067
1059
  userId: string;
1068
1060
  phone: string;
1069
1061
  }>, unknown>;
1070
1062
  } | {
1071
1063
  data: undefined;
1072
- error: AppwriteException;
1064
+ error: AppwriteException[];
1073
1065
  variables: Exact<{
1074
1066
  userId: string;
1075
1067
  phone: string;
@@ -1082,20 +1074,20 @@ declare function useCreatePhoneToken(): {
1082
1074
  mutate: _tanstack_react_query.UseMutateFunction<{
1083
1075
  __typename?: "Token";
1084
1076
  expire?: any;
1085
- }, AppwriteException, Exact<{
1077
+ }, AppwriteException[], Exact<{
1086
1078
  userId: string;
1087
1079
  phone: string;
1088
1080
  }>, unknown>;
1089
1081
  reset: () => void;
1090
1082
  context: unknown;
1091
1083
  failureCount: number;
1092
- failureReason: AppwriteException;
1084
+ failureReason: AppwriteException[];
1093
1085
  isPaused: boolean;
1094
1086
  submittedAt: number;
1095
1087
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1096
1088
  __typename?: "Token";
1097
1089
  expire?: any;
1098
- }, AppwriteException, Exact<{
1090
+ }, AppwriteException[], Exact<{
1099
1091
  userId: string;
1100
1092
  phone: string;
1101
1093
  }>, unknown>;
@@ -1117,20 +1109,20 @@ declare function useCreatePhoneToken(): {
1117
1109
  mutate: _tanstack_react_query.UseMutateFunction<{
1118
1110
  __typename?: "Token";
1119
1111
  expire?: any;
1120
- }, AppwriteException, Exact<{
1112
+ }, AppwriteException[], Exact<{
1121
1113
  userId: string;
1122
1114
  phone: string;
1123
1115
  }>, unknown>;
1124
1116
  reset: () => void;
1125
1117
  context: unknown;
1126
1118
  failureCount: number;
1127
- failureReason: AppwriteException;
1119
+ failureReason: AppwriteException[];
1128
1120
  isPaused: boolean;
1129
1121
  submittedAt: number;
1130
1122
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1131
1123
  __typename?: "Token";
1132
1124
  expire?: any;
1133
- }, AppwriteException, Exact<{
1125
+ }, AppwriteException[], Exact<{
1134
1126
  userId: string;
1135
1127
  phone: string;
1136
1128
  }>, unknown>;
@@ -1148,17 +1140,17 @@ declare function useCreatePhoneVerification(): {
1148
1140
  mutate: _tanstack_react_query.UseMutateFunction<{
1149
1141
  __typename?: "Token";
1150
1142
  expire?: any;
1151
- }, AppwriteException, void, unknown>;
1143
+ }, AppwriteException[], void, unknown>;
1152
1144
  reset: () => void;
1153
1145
  context: unknown;
1154
1146
  failureCount: number;
1155
- failureReason: AppwriteException;
1147
+ failureReason: AppwriteException[];
1156
1148
  isPaused: boolean;
1157
1149
  submittedAt: number;
1158
1150
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1159
1151
  __typename?: "Token";
1160
1152
  expire?: any;
1161
- }, AppwriteException, void, unknown>;
1153
+ }, AppwriteException[], void, unknown>;
1162
1154
  } | {
1163
1155
  data: undefined;
1164
1156
  variables: void;
@@ -1171,20 +1163,20 @@ declare function useCreatePhoneVerification(): {
1171
1163
  mutate: _tanstack_react_query.UseMutateFunction<{
1172
1164
  __typename?: "Token";
1173
1165
  expire?: any;
1174
- }, AppwriteException, void, unknown>;
1166
+ }, AppwriteException[], void, unknown>;
1175
1167
  reset: () => void;
1176
1168
  context: unknown;
1177
1169
  failureCount: number;
1178
- failureReason: AppwriteException;
1170
+ failureReason: AppwriteException[];
1179
1171
  isPaused: boolean;
1180
1172
  submittedAt: number;
1181
1173
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1182
1174
  __typename?: "Token";
1183
1175
  expire?: any;
1184
- }, AppwriteException, void, unknown>;
1176
+ }, AppwriteException[], void, unknown>;
1185
1177
  } | {
1186
1178
  data: undefined;
1187
- error: AppwriteException;
1179
+ error: AppwriteException[];
1188
1180
  variables: void;
1189
1181
  isError: true;
1190
1182
  isIdle: false;
@@ -1194,17 +1186,17 @@ declare function useCreatePhoneVerification(): {
1194
1186
  mutate: _tanstack_react_query.UseMutateFunction<{
1195
1187
  __typename?: "Token";
1196
1188
  expire?: any;
1197
- }, AppwriteException, void, unknown>;
1189
+ }, AppwriteException[], void, unknown>;
1198
1190
  reset: () => void;
1199
1191
  context: unknown;
1200
1192
  failureCount: number;
1201
- failureReason: AppwriteException;
1193
+ failureReason: AppwriteException[];
1202
1194
  isPaused: boolean;
1203
1195
  submittedAt: number;
1204
1196
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1205
1197
  __typename?: "Token";
1206
1198
  expire?: any;
1207
- }, AppwriteException, void, unknown>;
1199
+ }, AppwriteException[], void, unknown>;
1208
1200
  } | {
1209
1201
  data: {
1210
1202
  __typename?: "Token";
@@ -1220,17 +1212,17 @@ declare function useCreatePhoneVerification(): {
1220
1212
  mutate: _tanstack_react_query.UseMutateFunction<{
1221
1213
  __typename?: "Token";
1222
1214
  expire?: any;
1223
- }, AppwriteException, void, unknown>;
1215
+ }, AppwriteException[], void, unknown>;
1224
1216
  reset: () => void;
1225
1217
  context: unknown;
1226
1218
  failureCount: number;
1227
- failureReason: AppwriteException;
1219
+ failureReason: AppwriteException[];
1228
1220
  isPaused: boolean;
1229
1221
  submittedAt: number;
1230
1222
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1231
1223
  __typename?: "Token";
1232
1224
  expire?: any;
1233
- }, AppwriteException, void, unknown>;
1225
+ }, AppwriteException[], void, unknown>;
1234
1226
  };
1235
1227
 
1236
1228
  declare function useCreateSession(): {
@@ -1247,14 +1239,14 @@ declare function useCreateSession(): {
1247
1239
  userId?: string;
1248
1240
  expire?: any;
1249
1241
  current?: boolean;
1250
- }, AppwriteException, Exact<{
1242
+ }, AppwriteException[], Exact<{
1251
1243
  userId: string;
1252
1244
  secret: string;
1253
1245
  }>, unknown>;
1254
1246
  reset: () => void;
1255
1247
  context: unknown;
1256
1248
  failureCount: number;
1257
- failureReason: AppwriteException;
1249
+ failureReason: AppwriteException[];
1258
1250
  isPaused: boolean;
1259
1251
  submittedAt: number;
1260
1252
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -1262,7 +1254,7 @@ declare function useCreateSession(): {
1262
1254
  userId?: string;
1263
1255
  expire?: any;
1264
1256
  current?: boolean;
1265
- }, AppwriteException, Exact<{
1257
+ }, AppwriteException[], Exact<{
1266
1258
  userId: string;
1267
1259
  secret: string;
1268
1260
  }>, unknown>;
@@ -1283,14 +1275,14 @@ declare function useCreateSession(): {
1283
1275
  userId?: string;
1284
1276
  expire?: any;
1285
1277
  current?: boolean;
1286
- }, AppwriteException, Exact<{
1278
+ }, AppwriteException[], Exact<{
1287
1279
  userId: string;
1288
1280
  secret: string;
1289
1281
  }>, unknown>;
1290
1282
  reset: () => void;
1291
1283
  context: unknown;
1292
1284
  failureCount: number;
1293
- failureReason: AppwriteException;
1285
+ failureReason: AppwriteException[];
1294
1286
  isPaused: boolean;
1295
1287
  submittedAt: number;
1296
1288
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -1298,13 +1290,13 @@ declare function useCreateSession(): {
1298
1290
  userId?: string;
1299
1291
  expire?: any;
1300
1292
  current?: boolean;
1301
- }, AppwriteException, Exact<{
1293
+ }, AppwriteException[], Exact<{
1302
1294
  userId: string;
1303
1295
  secret: string;
1304
1296
  }>, unknown>;
1305
1297
  } | {
1306
1298
  data: undefined;
1307
- error: AppwriteException;
1299
+ error: AppwriteException[];
1308
1300
  variables: Exact<{
1309
1301
  userId: string;
1310
1302
  secret: string;
@@ -1319,14 +1311,14 @@ declare function useCreateSession(): {
1319
1311
  userId?: string;
1320
1312
  expire?: any;
1321
1313
  current?: boolean;
1322
- }, AppwriteException, Exact<{
1314
+ }, AppwriteException[], Exact<{
1323
1315
  userId: string;
1324
1316
  secret: string;
1325
1317
  }>, unknown>;
1326
1318
  reset: () => void;
1327
1319
  context: unknown;
1328
1320
  failureCount: number;
1329
- failureReason: AppwriteException;
1321
+ failureReason: AppwriteException[];
1330
1322
  isPaused: boolean;
1331
1323
  submittedAt: number;
1332
1324
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -1334,7 +1326,7 @@ declare function useCreateSession(): {
1334
1326
  userId?: string;
1335
1327
  expire?: any;
1336
1328
  current?: boolean;
1337
- }, AppwriteException, Exact<{
1329
+ }, AppwriteException[], Exact<{
1338
1330
  userId: string;
1339
1331
  secret: string;
1340
1332
  }>, unknown>;
@@ -1360,14 +1352,14 @@ declare function useCreateSession(): {
1360
1352
  userId?: string;
1361
1353
  expire?: any;
1362
1354
  current?: boolean;
1363
- }, AppwriteException, Exact<{
1355
+ }, AppwriteException[], Exact<{
1364
1356
  userId: string;
1365
1357
  secret: string;
1366
1358
  }>, unknown>;
1367
1359
  reset: () => void;
1368
1360
  context: unknown;
1369
1361
  failureCount: number;
1370
- failureReason: AppwriteException;
1362
+ failureReason: AppwriteException[];
1371
1363
  isPaused: boolean;
1372
1364
  submittedAt: number;
1373
1365
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -1375,7 +1367,7 @@ declare function useCreateSession(): {
1375
1367
  userId?: string;
1376
1368
  expire?: any;
1377
1369
  current?: boolean;
1378
- }, AppwriteException, Exact<{
1370
+ }, AppwriteException[], Exact<{
1379
1371
  userId: string;
1380
1372
  secret: string;
1381
1373
  }>, unknown>;
@@ -1393,19 +1385,19 @@ declare function useDeleteIdentity(): {
1393
1385
  mutate: _tanstack_react_query.UseMutateFunction<{
1394
1386
  __typename?: "Status";
1395
1387
  status?: boolean;
1396
- }, AppwriteException, Exact<{
1388
+ }, AppwriteException[], Exact<{
1397
1389
  identityId: string;
1398
1390
  }>, unknown>;
1399
1391
  reset: () => void;
1400
1392
  context: unknown;
1401
1393
  failureCount: number;
1402
- failureReason: AppwriteException;
1394
+ failureReason: AppwriteException[];
1403
1395
  isPaused: boolean;
1404
1396
  submittedAt: number;
1405
1397
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1406
1398
  __typename?: "Status";
1407
1399
  status?: boolean;
1408
- }, AppwriteException, Exact<{
1400
+ }, AppwriteException[], Exact<{
1409
1401
  identityId: string;
1410
1402
  }>, unknown>;
1411
1403
  } | {
@@ -1422,24 +1414,24 @@ declare function useDeleteIdentity(): {
1422
1414
  mutate: _tanstack_react_query.UseMutateFunction<{
1423
1415
  __typename?: "Status";
1424
1416
  status?: boolean;
1425
- }, AppwriteException, Exact<{
1417
+ }, AppwriteException[], Exact<{
1426
1418
  identityId: string;
1427
1419
  }>, unknown>;
1428
1420
  reset: () => void;
1429
1421
  context: unknown;
1430
1422
  failureCount: number;
1431
- failureReason: AppwriteException;
1423
+ failureReason: AppwriteException[];
1432
1424
  isPaused: boolean;
1433
1425
  submittedAt: number;
1434
1426
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1435
1427
  __typename?: "Status";
1436
1428
  status?: boolean;
1437
- }, AppwriteException, Exact<{
1429
+ }, AppwriteException[], Exact<{
1438
1430
  identityId: string;
1439
1431
  }>, unknown>;
1440
1432
  } | {
1441
1433
  data: undefined;
1442
- error: AppwriteException;
1434
+ error: AppwriteException[];
1443
1435
  variables: Exact<{
1444
1436
  identityId: string;
1445
1437
  }>;
@@ -1451,19 +1443,19 @@ declare function useDeleteIdentity(): {
1451
1443
  mutate: _tanstack_react_query.UseMutateFunction<{
1452
1444
  __typename?: "Status";
1453
1445
  status?: boolean;
1454
- }, AppwriteException, Exact<{
1446
+ }, AppwriteException[], Exact<{
1455
1447
  identityId: string;
1456
1448
  }>, unknown>;
1457
1449
  reset: () => void;
1458
1450
  context: unknown;
1459
1451
  failureCount: number;
1460
- failureReason: AppwriteException;
1452
+ failureReason: AppwriteException[];
1461
1453
  isPaused: boolean;
1462
1454
  submittedAt: number;
1463
1455
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1464
1456
  __typename?: "Status";
1465
1457
  status?: boolean;
1466
- }, AppwriteException, Exact<{
1458
+ }, AppwriteException[], Exact<{
1467
1459
  identityId: string;
1468
1460
  }>, unknown>;
1469
1461
  } | {
@@ -1483,19 +1475,19 @@ declare function useDeleteIdentity(): {
1483
1475
  mutate: _tanstack_react_query.UseMutateFunction<{
1484
1476
  __typename?: "Status";
1485
1477
  status?: boolean;
1486
- }, AppwriteException, Exact<{
1478
+ }, AppwriteException[], Exact<{
1487
1479
  identityId: string;
1488
1480
  }>, unknown>;
1489
1481
  reset: () => void;
1490
1482
  context: unknown;
1491
1483
  failureCount: number;
1492
- failureReason: AppwriteException;
1484
+ failureReason: AppwriteException[];
1493
1485
  isPaused: boolean;
1494
1486
  submittedAt: number;
1495
1487
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1496
1488
  __typename?: "Status";
1497
1489
  status?: boolean;
1498
- }, AppwriteException, Exact<{
1490
+ }, AppwriteException[], Exact<{
1499
1491
  identityId: string;
1500
1492
  }>, unknown>;
1501
1493
  };
@@ -1512,20 +1504,20 @@ declare function useDeleteMfaAuthenticator(): {
1512
1504
  mutate: _tanstack_react_query.UseMutateFunction<{
1513
1505
  __typename?: "User";
1514
1506
  mfa?: boolean;
1515
- }, AppwriteException, Exact<{
1507
+ }, AppwriteException[], Exact<{
1516
1508
  type: string;
1517
1509
  otp: string;
1518
1510
  }>, unknown>;
1519
1511
  reset: () => void;
1520
1512
  context: unknown;
1521
1513
  failureCount: number;
1522
- failureReason: AppwriteException;
1514
+ failureReason: AppwriteException[];
1523
1515
  isPaused: boolean;
1524
1516
  submittedAt: number;
1525
1517
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1526
1518
  __typename?: "User";
1527
1519
  mfa?: boolean;
1528
- }, AppwriteException, Exact<{
1520
+ }, AppwriteException[], Exact<{
1529
1521
  type: string;
1530
1522
  otp: string;
1531
1523
  }>, unknown>;
@@ -1544,26 +1536,26 @@ declare function useDeleteMfaAuthenticator(): {
1544
1536
  mutate: _tanstack_react_query.UseMutateFunction<{
1545
1537
  __typename?: "User";
1546
1538
  mfa?: boolean;
1547
- }, AppwriteException, Exact<{
1539
+ }, AppwriteException[], Exact<{
1548
1540
  type: string;
1549
1541
  otp: string;
1550
1542
  }>, unknown>;
1551
1543
  reset: () => void;
1552
1544
  context: unknown;
1553
1545
  failureCount: number;
1554
- failureReason: AppwriteException;
1546
+ failureReason: AppwriteException[];
1555
1547
  isPaused: boolean;
1556
1548
  submittedAt: number;
1557
1549
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1558
1550
  __typename?: "User";
1559
1551
  mfa?: boolean;
1560
- }, AppwriteException, Exact<{
1552
+ }, AppwriteException[], Exact<{
1561
1553
  type: string;
1562
1554
  otp: string;
1563
1555
  }>, unknown>;
1564
1556
  } | {
1565
1557
  data: undefined;
1566
- error: AppwriteException;
1558
+ error: AppwriteException[];
1567
1559
  variables: Exact<{
1568
1560
  type: string;
1569
1561
  otp: string;
@@ -1576,20 +1568,20 @@ declare function useDeleteMfaAuthenticator(): {
1576
1568
  mutate: _tanstack_react_query.UseMutateFunction<{
1577
1569
  __typename?: "User";
1578
1570
  mfa?: boolean;
1579
- }, AppwriteException, Exact<{
1571
+ }, AppwriteException[], Exact<{
1580
1572
  type: string;
1581
1573
  otp: string;
1582
1574
  }>, unknown>;
1583
1575
  reset: () => void;
1584
1576
  context: unknown;
1585
1577
  failureCount: number;
1586
- failureReason: AppwriteException;
1578
+ failureReason: AppwriteException[];
1587
1579
  isPaused: boolean;
1588
1580
  submittedAt: number;
1589
1581
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1590
1582
  __typename?: "User";
1591
1583
  mfa?: boolean;
1592
- }, AppwriteException, Exact<{
1584
+ }, AppwriteException[], Exact<{
1593
1585
  type: string;
1594
1586
  otp: string;
1595
1587
  }>, unknown>;
@@ -1611,20 +1603,20 @@ declare function useDeleteMfaAuthenticator(): {
1611
1603
  mutate: _tanstack_react_query.UseMutateFunction<{
1612
1604
  __typename?: "User";
1613
1605
  mfa?: boolean;
1614
- }, AppwriteException, Exact<{
1606
+ }, AppwriteException[], Exact<{
1615
1607
  type: string;
1616
1608
  otp: string;
1617
1609
  }>, unknown>;
1618
1610
  reset: () => void;
1619
1611
  context: unknown;
1620
1612
  failureCount: number;
1621
- failureReason: AppwriteException;
1613
+ failureReason: AppwriteException[];
1622
1614
  isPaused: boolean;
1623
1615
  submittedAt: number;
1624
1616
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1625
1617
  __typename?: "User";
1626
1618
  mfa?: boolean;
1627
- }, AppwriteException, Exact<{
1619
+ }, AppwriteException[], Exact<{
1628
1620
  type: string;
1629
1621
  otp: string;
1630
1622
  }>, unknown>;
@@ -1642,19 +1634,19 @@ declare function useDeleteSession(): {
1642
1634
  mutate: _tanstack_react_query.UseMutateFunction<{
1643
1635
  __typename?: "Status";
1644
1636
  status?: boolean;
1645
- }, AppwriteException, Exact<{
1637
+ }, AppwriteException[], Exact<{
1646
1638
  sessionId: string;
1647
1639
  }>, unknown>;
1648
1640
  reset: () => void;
1649
1641
  context: unknown;
1650
1642
  failureCount: number;
1651
- failureReason: AppwriteException;
1643
+ failureReason: AppwriteException[];
1652
1644
  isPaused: boolean;
1653
1645
  submittedAt: number;
1654
1646
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1655
1647
  __typename?: "Status";
1656
1648
  status?: boolean;
1657
- }, AppwriteException, Exact<{
1649
+ }, AppwriteException[], Exact<{
1658
1650
  sessionId: string;
1659
1651
  }>, unknown>;
1660
1652
  } | {
@@ -1671,24 +1663,24 @@ declare function useDeleteSession(): {
1671
1663
  mutate: _tanstack_react_query.UseMutateFunction<{
1672
1664
  __typename?: "Status";
1673
1665
  status?: boolean;
1674
- }, AppwriteException, Exact<{
1666
+ }, AppwriteException[], Exact<{
1675
1667
  sessionId: string;
1676
1668
  }>, unknown>;
1677
1669
  reset: () => void;
1678
1670
  context: unknown;
1679
1671
  failureCount: number;
1680
- failureReason: AppwriteException;
1672
+ failureReason: AppwriteException[];
1681
1673
  isPaused: boolean;
1682
1674
  submittedAt: number;
1683
1675
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1684
1676
  __typename?: "Status";
1685
1677
  status?: boolean;
1686
- }, AppwriteException, Exact<{
1678
+ }, AppwriteException[], Exact<{
1687
1679
  sessionId: string;
1688
1680
  }>, unknown>;
1689
1681
  } | {
1690
1682
  data: undefined;
1691
- error: AppwriteException;
1683
+ error: AppwriteException[];
1692
1684
  variables: Exact<{
1693
1685
  sessionId: string;
1694
1686
  }>;
@@ -1700,19 +1692,19 @@ declare function useDeleteSession(): {
1700
1692
  mutate: _tanstack_react_query.UseMutateFunction<{
1701
1693
  __typename?: "Status";
1702
1694
  status?: boolean;
1703
- }, AppwriteException, Exact<{
1695
+ }, AppwriteException[], Exact<{
1704
1696
  sessionId: string;
1705
1697
  }>, unknown>;
1706
1698
  reset: () => void;
1707
1699
  context: unknown;
1708
1700
  failureCount: number;
1709
- failureReason: AppwriteException;
1701
+ failureReason: AppwriteException[];
1710
1702
  isPaused: boolean;
1711
1703
  submittedAt: number;
1712
1704
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1713
1705
  __typename?: "Status";
1714
1706
  status?: boolean;
1715
- }, AppwriteException, Exact<{
1707
+ }, AppwriteException[], Exact<{
1716
1708
  sessionId: string;
1717
1709
  }>, unknown>;
1718
1710
  } | {
@@ -1732,19 +1724,19 @@ declare function useDeleteSession(): {
1732
1724
  mutate: _tanstack_react_query.UseMutateFunction<{
1733
1725
  __typename?: "Status";
1734
1726
  status?: boolean;
1735
- }, AppwriteException, Exact<{
1727
+ }, AppwriteException[], Exact<{
1736
1728
  sessionId: string;
1737
1729
  }>, unknown>;
1738
1730
  reset: () => void;
1739
1731
  context: unknown;
1740
1732
  failureCount: number;
1741
- failureReason: AppwriteException;
1733
+ failureReason: AppwriteException[];
1742
1734
  isPaused: boolean;
1743
1735
  submittedAt: number;
1744
1736
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1745
1737
  __typename?: "Status";
1746
1738
  status?: boolean;
1747
- }, AppwriteException, Exact<{
1739
+ }, AppwriteException[], Exact<{
1748
1740
  sessionId: string;
1749
1741
  }>, unknown>;
1750
1742
  };
@@ -1761,17 +1753,17 @@ declare function useDeleteSessions(): {
1761
1753
  mutate: _tanstack_react_query.UseMutateFunction<{
1762
1754
  __typename?: "Status";
1763
1755
  status?: boolean;
1764
- }, AppwriteException, void, unknown>;
1756
+ }, AppwriteException[], void, unknown>;
1765
1757
  reset: () => void;
1766
1758
  context: unknown;
1767
1759
  failureCount: number;
1768
- failureReason: AppwriteException;
1760
+ failureReason: AppwriteException[];
1769
1761
  isPaused: boolean;
1770
1762
  submittedAt: number;
1771
1763
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1772
1764
  __typename?: "Status";
1773
1765
  status?: boolean;
1774
- }, AppwriteException, void, unknown>;
1766
+ }, AppwriteException[], void, unknown>;
1775
1767
  } | {
1776
1768
  data: undefined;
1777
1769
  variables: void;
@@ -1784,20 +1776,20 @@ declare function useDeleteSessions(): {
1784
1776
  mutate: _tanstack_react_query.UseMutateFunction<{
1785
1777
  __typename?: "Status";
1786
1778
  status?: boolean;
1787
- }, AppwriteException, void, unknown>;
1779
+ }, AppwriteException[], void, unknown>;
1788
1780
  reset: () => void;
1789
1781
  context: unknown;
1790
1782
  failureCount: number;
1791
- failureReason: AppwriteException;
1783
+ failureReason: AppwriteException[];
1792
1784
  isPaused: boolean;
1793
1785
  submittedAt: number;
1794
1786
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1795
1787
  __typename?: "Status";
1796
1788
  status?: boolean;
1797
- }, AppwriteException, void, unknown>;
1789
+ }, AppwriteException[], void, unknown>;
1798
1790
  } | {
1799
1791
  data: undefined;
1800
- error: AppwriteException;
1792
+ error: AppwriteException[];
1801
1793
  variables: void;
1802
1794
  isError: true;
1803
1795
  isIdle: false;
@@ -1807,17 +1799,17 @@ declare function useDeleteSessions(): {
1807
1799
  mutate: _tanstack_react_query.UseMutateFunction<{
1808
1800
  __typename?: "Status";
1809
1801
  status?: boolean;
1810
- }, AppwriteException, void, unknown>;
1802
+ }, AppwriteException[], void, unknown>;
1811
1803
  reset: () => void;
1812
1804
  context: unknown;
1813
1805
  failureCount: number;
1814
- failureReason: AppwriteException;
1806
+ failureReason: AppwriteException[];
1815
1807
  isPaused: boolean;
1816
1808
  submittedAt: number;
1817
1809
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1818
1810
  __typename?: "Status";
1819
1811
  status?: boolean;
1820
- }, AppwriteException, void, unknown>;
1812
+ }, AppwriteException[], void, unknown>;
1821
1813
  } | {
1822
1814
  data: {
1823
1815
  __typename?: "Status";
@@ -1833,22 +1825,22 @@ declare function useDeleteSessions(): {
1833
1825
  mutate: _tanstack_react_query.UseMutateFunction<{
1834
1826
  __typename?: "Status";
1835
1827
  status?: boolean;
1836
- }, AppwriteException, void, unknown>;
1828
+ }, AppwriteException[], void, unknown>;
1837
1829
  reset: () => void;
1838
1830
  context: unknown;
1839
1831
  failureCount: number;
1840
- failureReason: AppwriteException;
1832
+ failureReason: AppwriteException[];
1841
1833
  isPaused: boolean;
1842
1834
  submittedAt: number;
1843
1835
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1844
1836
  __typename?: "Status";
1845
1837
  status?: boolean;
1846
- }, AppwriteException, void, unknown>;
1838
+ }, AppwriteException[], void, unknown>;
1847
1839
  };
1848
1840
 
1849
1841
  declare function useGetMfaRecoveryCodes(): {
1850
1842
  data: void;
1851
- error: AppwriteException;
1843
+ error: AppwriteException[];
1852
1844
  isError: true;
1853
1845
  isPending: false;
1854
1846
  isLoading: false;
@@ -1859,7 +1851,7 @@ declare function useGetMfaRecoveryCodes(): {
1859
1851
  dataUpdatedAt: number;
1860
1852
  errorUpdatedAt: number;
1861
1853
  failureCount: number;
1862
- failureReason: AppwriteException;
1854
+ failureReason: AppwriteException[];
1863
1855
  errorUpdateCount: number;
1864
1856
  isFetched: boolean;
1865
1857
  isFetchedAfterMount: boolean;
@@ -1869,7 +1861,7 @@ declare function useGetMfaRecoveryCodes(): {
1869
1861
  isPlaceholderData: boolean;
1870
1862
  isRefetching: boolean;
1871
1863
  isStale: boolean;
1872
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1864
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
1873
1865
  fetchStatus: _tanstack_query_core.FetchStatus;
1874
1866
  } | {
1875
1867
  data: void;
@@ -1884,7 +1876,7 @@ declare function useGetMfaRecoveryCodes(): {
1884
1876
  dataUpdatedAt: number;
1885
1877
  errorUpdatedAt: number;
1886
1878
  failureCount: number;
1887
- failureReason: AppwriteException;
1879
+ failureReason: AppwriteException[];
1888
1880
  errorUpdateCount: number;
1889
1881
  isFetched: boolean;
1890
1882
  isFetchedAfterMount: boolean;
@@ -1894,11 +1886,11 @@ declare function useGetMfaRecoveryCodes(): {
1894
1886
  isPlaceholderData: boolean;
1895
1887
  isRefetching: boolean;
1896
1888
  isStale: boolean;
1897
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1889
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
1898
1890
  fetchStatus: _tanstack_query_core.FetchStatus;
1899
1891
  } | {
1900
1892
  data: undefined;
1901
- error: AppwriteException;
1893
+ error: AppwriteException[];
1902
1894
  isError: true;
1903
1895
  isPending: false;
1904
1896
  isLoading: false;
@@ -1909,7 +1901,7 @@ declare function useGetMfaRecoveryCodes(): {
1909
1901
  dataUpdatedAt: number;
1910
1902
  errorUpdatedAt: number;
1911
1903
  failureCount: number;
1912
- failureReason: AppwriteException;
1904
+ failureReason: AppwriteException[];
1913
1905
  errorUpdateCount: number;
1914
1906
  isFetched: boolean;
1915
1907
  isFetchedAfterMount: boolean;
@@ -1919,7 +1911,7 @@ declare function useGetMfaRecoveryCodes(): {
1919
1911
  isPlaceholderData: boolean;
1920
1912
  isRefetching: boolean;
1921
1913
  isStale: boolean;
1922
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1914
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
1923
1915
  fetchStatus: _tanstack_query_core.FetchStatus;
1924
1916
  } | {
1925
1917
  data: undefined;
@@ -1934,7 +1926,7 @@ declare function useGetMfaRecoveryCodes(): {
1934
1926
  dataUpdatedAt: number;
1935
1927
  errorUpdatedAt: number;
1936
1928
  failureCount: number;
1937
- failureReason: AppwriteException;
1929
+ failureReason: AppwriteException[];
1938
1930
  errorUpdateCount: number;
1939
1931
  isFetched: boolean;
1940
1932
  isFetchedAfterMount: boolean;
@@ -1944,7 +1936,7 @@ declare function useGetMfaRecoveryCodes(): {
1944
1936
  isPlaceholderData: boolean;
1945
1937
  isRefetching: boolean;
1946
1938
  isStale: boolean;
1947
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1939
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
1948
1940
  fetchStatus: _tanstack_query_core.FetchStatus;
1949
1941
  } | {
1950
1942
  data: undefined;
@@ -1958,7 +1950,7 @@ declare function useGetMfaRecoveryCodes(): {
1958
1950
  dataUpdatedAt: number;
1959
1951
  errorUpdatedAt: number;
1960
1952
  failureCount: number;
1961
- failureReason: AppwriteException;
1953
+ failureReason: AppwriteException[];
1962
1954
  errorUpdateCount: number;
1963
1955
  isFetched: boolean;
1964
1956
  isFetchedAfterMount: boolean;
@@ -1969,13 +1961,13 @@ declare function useGetMfaRecoveryCodes(): {
1969
1961
  isPlaceholderData: boolean;
1970
1962
  isRefetching: boolean;
1971
1963
  isStale: boolean;
1972
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1964
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
1973
1965
  fetchStatus: _tanstack_query_core.FetchStatus;
1974
1966
  };
1975
1967
 
1976
1968
  declare function useGetPrefs(): {
1977
1969
  data: void;
1978
- error: AppwriteException;
1970
+ error: AppwriteException[];
1979
1971
  isError: true;
1980
1972
  isPending: false;
1981
1973
  isLoading: false;
@@ -1986,7 +1978,7 @@ declare function useGetPrefs(): {
1986
1978
  dataUpdatedAt: number;
1987
1979
  errorUpdatedAt: number;
1988
1980
  failureCount: number;
1989
- failureReason: AppwriteException;
1981
+ failureReason: AppwriteException[];
1990
1982
  errorUpdateCount: number;
1991
1983
  isFetched: boolean;
1992
1984
  isFetchedAfterMount: boolean;
@@ -1996,7 +1988,7 @@ declare function useGetPrefs(): {
1996
1988
  isPlaceholderData: boolean;
1997
1989
  isRefetching: boolean;
1998
1990
  isStale: boolean;
1999
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1991
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2000
1992
  fetchStatus: _tanstack_query_core.FetchStatus;
2001
1993
  } | {
2002
1994
  data: void;
@@ -2011,7 +2003,7 @@ declare function useGetPrefs(): {
2011
2003
  dataUpdatedAt: number;
2012
2004
  errorUpdatedAt: number;
2013
2005
  failureCount: number;
2014
- failureReason: AppwriteException;
2006
+ failureReason: AppwriteException[];
2015
2007
  errorUpdateCount: number;
2016
2008
  isFetched: boolean;
2017
2009
  isFetchedAfterMount: boolean;
@@ -2021,11 +2013,11 @@ declare function useGetPrefs(): {
2021
2013
  isPlaceholderData: boolean;
2022
2014
  isRefetching: boolean;
2023
2015
  isStale: boolean;
2024
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
2016
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2025
2017
  fetchStatus: _tanstack_query_core.FetchStatus;
2026
2018
  } | {
2027
2019
  data: undefined;
2028
- error: AppwriteException;
2020
+ error: AppwriteException[];
2029
2021
  isError: true;
2030
2022
  isPending: false;
2031
2023
  isLoading: false;
@@ -2036,7 +2028,7 @@ declare function useGetPrefs(): {
2036
2028
  dataUpdatedAt: number;
2037
2029
  errorUpdatedAt: number;
2038
2030
  failureCount: number;
2039
- failureReason: AppwriteException;
2031
+ failureReason: AppwriteException[];
2040
2032
  errorUpdateCount: number;
2041
2033
  isFetched: boolean;
2042
2034
  isFetchedAfterMount: boolean;
@@ -2046,7 +2038,7 @@ declare function useGetPrefs(): {
2046
2038
  isPlaceholderData: boolean;
2047
2039
  isRefetching: boolean;
2048
2040
  isStale: boolean;
2049
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
2041
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2050
2042
  fetchStatus: _tanstack_query_core.FetchStatus;
2051
2043
  } | {
2052
2044
  data: undefined;
@@ -2061,7 +2053,7 @@ declare function useGetPrefs(): {
2061
2053
  dataUpdatedAt: number;
2062
2054
  errorUpdatedAt: number;
2063
2055
  failureCount: number;
2064
- failureReason: AppwriteException;
2056
+ failureReason: AppwriteException[];
2065
2057
  errorUpdateCount: number;
2066
2058
  isFetched: boolean;
2067
2059
  isFetchedAfterMount: boolean;
@@ -2071,7 +2063,7 @@ declare function useGetPrefs(): {
2071
2063
  isPlaceholderData: boolean;
2072
2064
  isRefetching: boolean;
2073
2065
  isStale: boolean;
2074
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
2066
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2075
2067
  fetchStatus: _tanstack_query_core.FetchStatus;
2076
2068
  } | {
2077
2069
  data: undefined;
@@ -2085,7 +2077,7 @@ declare function useGetPrefs(): {
2085
2077
  dataUpdatedAt: number;
2086
2078
  errorUpdatedAt: number;
2087
2079
  failureCount: number;
2088
- failureReason: AppwriteException;
2080
+ failureReason: AppwriteException[];
2089
2081
  errorUpdateCount: number;
2090
2082
  isFetched: boolean;
2091
2083
  isFetchedAfterMount: boolean;
@@ -2096,30 +2088,17 @@ declare function useGetPrefs(): {
2096
2088
  isPlaceholderData: boolean;
2097
2089
  isRefetching: boolean;
2098
2090
  isStale: boolean;
2099
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
2091
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2100
2092
  fetchStatus: _tanstack_query_core.FetchStatus;
2101
2093
  };
2102
2094
 
2103
- declare function useGetSession({ sessionId }: GetSessionQueryVariables): _tanstack_react_query.UseQueryResult<{
2104
- __typename?: "Session";
2105
- userId?: string;
2106
- expire?: any;
2107
- current?: boolean;
2108
- }, AppwriteException>;
2095
+ declare function useGetSession({ sessionId }: GetSessionQueryVariables): _tanstack_react_query.UseQueryResult<Exact<{
2096
+ sessionId: string;
2097
+ }>, AppwriteException[]>;
2109
2098
 
2110
2099
  declare function useListIdentities(): {
2111
- data: {
2112
- __typename?: "IdentityList";
2113
- total: number;
2114
- identities?: ({
2115
- __typename?: "Identity";
2116
- } & {
2117
- ' $fragmentRefs'?: {
2118
- Identity_ProviderFragment: Identity_ProviderFragment;
2119
- };
2120
- })[];
2121
- };
2122
- error: AppwriteException;
2100
+ data: void;
2101
+ error: AppwriteException[];
2123
2102
  isError: true;
2124
2103
  isPending: false;
2125
2104
  isLoading: false;
@@ -2130,7 +2109,7 @@ declare function useListIdentities(): {
2130
2109
  dataUpdatedAt: number;
2131
2110
  errorUpdatedAt: number;
2132
2111
  failureCount: number;
2133
- failureReason: AppwriteException;
2112
+ failureReason: AppwriteException[];
2134
2113
  errorUpdateCount: number;
2135
2114
  isFetched: boolean;
2136
2115
  isFetchedAfterMount: boolean;
@@ -2140,30 +2119,10 @@ declare function useListIdentities(): {
2140
2119
  isPlaceholderData: boolean;
2141
2120
  isRefetching: boolean;
2142
2121
  isStale: boolean;
2143
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2144
- __typename?: "IdentityList";
2145
- total: number;
2146
- identities?: ({
2147
- __typename?: "Identity";
2148
- } & {
2149
- ' $fragmentRefs'?: {
2150
- Identity_ProviderFragment: Identity_ProviderFragment;
2151
- };
2152
- })[];
2153
- }, AppwriteException>>;
2122
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2154
2123
  fetchStatus: _tanstack_query_core.FetchStatus;
2155
2124
  } | {
2156
- data: {
2157
- __typename?: "IdentityList";
2158
- total: number;
2159
- identities?: ({
2160
- __typename?: "Identity";
2161
- } & {
2162
- ' $fragmentRefs'?: {
2163
- Identity_ProviderFragment: Identity_ProviderFragment;
2164
- };
2165
- })[];
2166
- };
2125
+ data: void;
2167
2126
  error: null;
2168
2127
  isError: false;
2169
2128
  isPending: false;
@@ -2175,7 +2134,7 @@ declare function useListIdentities(): {
2175
2134
  dataUpdatedAt: number;
2176
2135
  errorUpdatedAt: number;
2177
2136
  failureCount: number;
2178
- failureReason: AppwriteException;
2137
+ failureReason: AppwriteException[];
2179
2138
  errorUpdateCount: number;
2180
2139
  isFetched: boolean;
2181
2140
  isFetchedAfterMount: boolean;
@@ -2185,21 +2144,11 @@ declare function useListIdentities(): {
2185
2144
  isPlaceholderData: boolean;
2186
2145
  isRefetching: boolean;
2187
2146
  isStale: boolean;
2188
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2189
- __typename?: "IdentityList";
2190
- total: number;
2191
- identities?: ({
2192
- __typename?: "Identity";
2193
- } & {
2194
- ' $fragmentRefs'?: {
2195
- Identity_ProviderFragment: Identity_ProviderFragment;
2196
- };
2197
- })[];
2198
- }, AppwriteException>>;
2147
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2199
2148
  fetchStatus: _tanstack_query_core.FetchStatus;
2200
2149
  } | {
2201
2150
  data: undefined;
2202
- error: AppwriteException;
2151
+ error: AppwriteException[];
2203
2152
  isError: true;
2204
2153
  isPending: false;
2205
2154
  isLoading: false;
@@ -2210,7 +2159,7 @@ declare function useListIdentities(): {
2210
2159
  dataUpdatedAt: number;
2211
2160
  errorUpdatedAt: number;
2212
2161
  failureCount: number;
2213
- failureReason: AppwriteException;
2162
+ failureReason: AppwriteException[];
2214
2163
  errorUpdateCount: number;
2215
2164
  isFetched: boolean;
2216
2165
  isFetchedAfterMount: boolean;
@@ -2220,17 +2169,7 @@ declare function useListIdentities(): {
2220
2169
  isPlaceholderData: boolean;
2221
2170
  isRefetching: boolean;
2222
2171
  isStale: boolean;
2223
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2224
- __typename?: "IdentityList";
2225
- total: number;
2226
- identities?: ({
2227
- __typename?: "Identity";
2228
- } & {
2229
- ' $fragmentRefs'?: {
2230
- Identity_ProviderFragment: Identity_ProviderFragment;
2231
- };
2232
- })[];
2233
- }, AppwriteException>>;
2172
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2234
2173
  fetchStatus: _tanstack_query_core.FetchStatus;
2235
2174
  } | {
2236
2175
  data: undefined;
@@ -2245,7 +2184,7 @@ declare function useListIdentities(): {
2245
2184
  dataUpdatedAt: number;
2246
2185
  errorUpdatedAt: number;
2247
2186
  failureCount: number;
2248
- failureReason: AppwriteException;
2187
+ failureReason: AppwriteException[];
2249
2188
  errorUpdateCount: number;
2250
2189
  isFetched: boolean;
2251
2190
  isFetchedAfterMount: boolean;
@@ -2255,17 +2194,7 @@ declare function useListIdentities(): {
2255
2194
  isPlaceholderData: boolean;
2256
2195
  isRefetching: boolean;
2257
2196
  isStale: boolean;
2258
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2259
- __typename?: "IdentityList";
2260
- total: number;
2261
- identities?: ({
2262
- __typename?: "Identity";
2263
- } & {
2264
- ' $fragmentRefs'?: {
2265
- Identity_ProviderFragment: Identity_ProviderFragment;
2266
- };
2267
- })[];
2268
- }, AppwriteException>>;
2197
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2269
2198
  fetchStatus: _tanstack_query_core.FetchStatus;
2270
2199
  } | {
2271
2200
  data: undefined;
@@ -2279,7 +2208,7 @@ declare function useListIdentities(): {
2279
2208
  dataUpdatedAt: number;
2280
2209
  errorUpdatedAt: number;
2281
2210
  failureCount: number;
2282
- failureReason: AppwriteException;
2211
+ failureReason: AppwriteException[];
2283
2212
  errorUpdateCount: number;
2284
2213
  isFetched: boolean;
2285
2214
  isFetchedAfterMount: boolean;
@@ -2290,28 +2219,13 @@ declare function useListIdentities(): {
2290
2219
  isPlaceholderData: boolean;
2291
2220
  isRefetching: boolean;
2292
2221
  isStale: boolean;
2293
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2294
- __typename?: "IdentityList";
2295
- total: number;
2296
- identities?: ({
2297
- __typename?: "Identity";
2298
- } & {
2299
- ' $fragmentRefs'?: {
2300
- Identity_ProviderFragment: Identity_ProviderFragment;
2301
- };
2302
- })[];
2303
- }, AppwriteException>>;
2222
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2304
2223
  fetchStatus: _tanstack_query_core.FetchStatus;
2305
2224
  };
2306
2225
 
2307
2226
  declare function useListMfaFactors(): {
2308
- data: {
2309
- __typename?: "MFAFactors";
2310
- totp?: boolean;
2311
- phone?: boolean;
2312
- email?: boolean;
2313
- };
2314
- error: AppwriteException;
2227
+ data: void;
2228
+ error: AppwriteException[];
2315
2229
  isError: true;
2316
2230
  isPending: false;
2317
2231
  isLoading: false;
@@ -2322,7 +2236,7 @@ declare function useListMfaFactors(): {
2322
2236
  dataUpdatedAt: number;
2323
2237
  errorUpdatedAt: number;
2324
2238
  failureCount: number;
2325
- failureReason: AppwriteException;
2239
+ failureReason: AppwriteException[];
2326
2240
  errorUpdateCount: number;
2327
2241
  isFetched: boolean;
2328
2242
  isFetchedAfterMount: boolean;
@@ -2332,20 +2246,10 @@ declare function useListMfaFactors(): {
2332
2246
  isPlaceholderData: boolean;
2333
2247
  isRefetching: boolean;
2334
2248
  isStale: boolean;
2335
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2336
- __typename?: "MFAFactors";
2337
- totp?: boolean;
2338
- phone?: boolean;
2339
- email?: boolean;
2340
- }, AppwriteException>>;
2249
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2341
2250
  fetchStatus: _tanstack_query_core.FetchStatus;
2342
2251
  } | {
2343
- data: {
2344
- __typename?: "MFAFactors";
2345
- totp?: boolean;
2346
- phone?: boolean;
2347
- email?: boolean;
2348
- };
2252
+ data: void;
2349
2253
  error: null;
2350
2254
  isError: false;
2351
2255
  isPending: false;
@@ -2357,7 +2261,7 @@ declare function useListMfaFactors(): {
2357
2261
  dataUpdatedAt: number;
2358
2262
  errorUpdatedAt: number;
2359
2263
  failureCount: number;
2360
- failureReason: AppwriteException;
2264
+ failureReason: AppwriteException[];
2361
2265
  errorUpdateCount: number;
2362
2266
  isFetched: boolean;
2363
2267
  isFetchedAfterMount: boolean;
@@ -2367,16 +2271,11 @@ declare function useListMfaFactors(): {
2367
2271
  isPlaceholderData: boolean;
2368
2272
  isRefetching: boolean;
2369
2273
  isStale: boolean;
2370
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2371
- __typename?: "MFAFactors";
2372
- totp?: boolean;
2373
- phone?: boolean;
2374
- email?: boolean;
2375
- }, AppwriteException>>;
2274
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2376
2275
  fetchStatus: _tanstack_query_core.FetchStatus;
2377
2276
  } | {
2378
2277
  data: undefined;
2379
- error: AppwriteException;
2278
+ error: AppwriteException[];
2380
2279
  isError: true;
2381
2280
  isPending: false;
2382
2281
  isLoading: false;
@@ -2387,7 +2286,7 @@ declare function useListMfaFactors(): {
2387
2286
  dataUpdatedAt: number;
2388
2287
  errorUpdatedAt: number;
2389
2288
  failureCount: number;
2390
- failureReason: AppwriteException;
2289
+ failureReason: AppwriteException[];
2391
2290
  errorUpdateCount: number;
2392
2291
  isFetched: boolean;
2393
2292
  isFetchedAfterMount: boolean;
@@ -2397,12 +2296,7 @@ declare function useListMfaFactors(): {
2397
2296
  isPlaceholderData: boolean;
2398
2297
  isRefetching: boolean;
2399
2298
  isStale: boolean;
2400
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2401
- __typename?: "MFAFactors";
2402
- totp?: boolean;
2403
- phone?: boolean;
2404
- email?: boolean;
2405
- }, AppwriteException>>;
2299
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2406
2300
  fetchStatus: _tanstack_query_core.FetchStatus;
2407
2301
  } | {
2408
2302
  data: undefined;
@@ -2417,7 +2311,7 @@ declare function useListMfaFactors(): {
2417
2311
  dataUpdatedAt: number;
2418
2312
  errorUpdatedAt: number;
2419
2313
  failureCount: number;
2420
- failureReason: AppwriteException;
2314
+ failureReason: AppwriteException[];
2421
2315
  errorUpdateCount: number;
2422
2316
  isFetched: boolean;
2423
2317
  isFetchedAfterMount: boolean;
@@ -2427,12 +2321,7 @@ declare function useListMfaFactors(): {
2427
2321
  isPlaceholderData: boolean;
2428
2322
  isRefetching: boolean;
2429
2323
  isStale: boolean;
2430
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2431
- __typename?: "MFAFactors";
2432
- totp?: boolean;
2433
- phone?: boolean;
2434
- email?: boolean;
2435
- }, AppwriteException>>;
2324
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2436
2325
  fetchStatus: _tanstack_query_core.FetchStatus;
2437
2326
  } | {
2438
2327
  data: undefined;
@@ -2446,7 +2335,7 @@ declare function useListMfaFactors(): {
2446
2335
  dataUpdatedAt: number;
2447
2336
  errorUpdatedAt: number;
2448
2337
  failureCount: number;
2449
- failureReason: AppwriteException;
2338
+ failureReason: AppwriteException[];
2450
2339
  errorUpdateCount: number;
2451
2340
  isFetched: boolean;
2452
2341
  isFetchedAfterMount: boolean;
@@ -2457,27 +2346,13 @@ declare function useListMfaFactors(): {
2457
2346
  isPlaceholderData: boolean;
2458
2347
  isRefetching: boolean;
2459
2348
  isStale: boolean;
2460
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2461
- __typename?: "MFAFactors";
2462
- totp?: boolean;
2463
- phone?: boolean;
2464
- email?: boolean;
2465
- }, AppwriteException>>;
2349
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2466
2350
  fetchStatus: _tanstack_query_core.FetchStatus;
2467
2351
  };
2468
2352
 
2469
2353
  declare function useListSessions(): {
2470
- data: {
2471
- __typename?: "SessionList";
2472
- sessions?: {
2473
- __typename?: "Session";
2474
- _id?: string;
2475
- _createdAt?: any;
2476
- osName?: string;
2477
- clientName?: string;
2478
- }[];
2479
- };
2480
- error: AppwriteException;
2354
+ data: void;
2355
+ error: AppwriteException[];
2481
2356
  isError: true;
2482
2357
  isPending: false;
2483
2358
  isLoading: false;
@@ -2488,7 +2363,7 @@ declare function useListSessions(): {
2488
2363
  dataUpdatedAt: number;
2489
2364
  errorUpdatedAt: number;
2490
2365
  failureCount: number;
2491
- failureReason: AppwriteException;
2366
+ failureReason: AppwriteException[];
2492
2367
  errorUpdateCount: number;
2493
2368
  isFetched: boolean;
2494
2369
  isFetchedAfterMount: boolean;
@@ -2498,28 +2373,10 @@ declare function useListSessions(): {
2498
2373
  isPlaceholderData: boolean;
2499
2374
  isRefetching: boolean;
2500
2375
  isStale: boolean;
2501
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2502
- __typename?: "SessionList";
2503
- sessions?: {
2504
- __typename?: "Session";
2505
- _id?: string;
2506
- _createdAt?: any;
2507
- osName?: string;
2508
- clientName?: string;
2509
- }[];
2510
- }, AppwriteException>>;
2376
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2511
2377
  fetchStatus: _tanstack_query_core.FetchStatus;
2512
2378
  } | {
2513
- data: {
2514
- __typename?: "SessionList";
2515
- sessions?: {
2516
- __typename?: "Session";
2517
- _id?: string;
2518
- _createdAt?: any;
2519
- osName?: string;
2520
- clientName?: string;
2521
- }[];
2522
- };
2379
+ data: void;
2523
2380
  error: null;
2524
2381
  isError: false;
2525
2382
  isPending: false;
@@ -2531,7 +2388,7 @@ declare function useListSessions(): {
2531
2388
  dataUpdatedAt: number;
2532
2389
  errorUpdatedAt: number;
2533
2390
  failureCount: number;
2534
- failureReason: AppwriteException;
2391
+ failureReason: AppwriteException[];
2535
2392
  errorUpdateCount: number;
2536
2393
  isFetched: boolean;
2537
2394
  isFetchedAfterMount: boolean;
@@ -2541,20 +2398,11 @@ declare function useListSessions(): {
2541
2398
  isPlaceholderData: boolean;
2542
2399
  isRefetching: boolean;
2543
2400
  isStale: boolean;
2544
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2545
- __typename?: "SessionList";
2546
- sessions?: {
2547
- __typename?: "Session";
2548
- _id?: string;
2549
- _createdAt?: any;
2550
- osName?: string;
2551
- clientName?: string;
2552
- }[];
2553
- }, AppwriteException>>;
2401
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2554
2402
  fetchStatus: _tanstack_query_core.FetchStatus;
2555
2403
  } | {
2556
2404
  data: undefined;
2557
- error: AppwriteException;
2405
+ error: AppwriteException[];
2558
2406
  isError: true;
2559
2407
  isPending: false;
2560
2408
  isLoading: false;
@@ -2565,7 +2413,7 @@ declare function useListSessions(): {
2565
2413
  dataUpdatedAt: number;
2566
2414
  errorUpdatedAt: number;
2567
2415
  failureCount: number;
2568
- failureReason: AppwriteException;
2416
+ failureReason: AppwriteException[];
2569
2417
  errorUpdateCount: number;
2570
2418
  isFetched: boolean;
2571
2419
  isFetchedAfterMount: boolean;
@@ -2575,16 +2423,7 @@ declare function useListSessions(): {
2575
2423
  isPlaceholderData: boolean;
2576
2424
  isRefetching: boolean;
2577
2425
  isStale: boolean;
2578
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2579
- __typename?: "SessionList";
2580
- sessions?: {
2581
- __typename?: "Session";
2582
- _id?: string;
2583
- _createdAt?: any;
2584
- osName?: string;
2585
- clientName?: string;
2586
- }[];
2587
- }, AppwriteException>>;
2426
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2588
2427
  fetchStatus: _tanstack_query_core.FetchStatus;
2589
2428
  } | {
2590
2429
  data: undefined;
@@ -2599,7 +2438,7 @@ declare function useListSessions(): {
2599
2438
  dataUpdatedAt: number;
2600
2439
  errorUpdatedAt: number;
2601
2440
  failureCount: number;
2602
- failureReason: AppwriteException;
2441
+ failureReason: AppwriteException[];
2603
2442
  errorUpdateCount: number;
2604
2443
  isFetched: boolean;
2605
2444
  isFetchedAfterMount: boolean;
@@ -2609,16 +2448,7 @@ declare function useListSessions(): {
2609
2448
  isPlaceholderData: boolean;
2610
2449
  isRefetching: boolean;
2611
2450
  isStale: boolean;
2612
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2613
- __typename?: "SessionList";
2614
- sessions?: {
2615
- __typename?: "Session";
2616
- _id?: string;
2617
- _createdAt?: any;
2618
- osName?: string;
2619
- clientName?: string;
2620
- }[];
2621
- }, AppwriteException>>;
2451
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2622
2452
  fetchStatus: _tanstack_query_core.FetchStatus;
2623
2453
  } | {
2624
2454
  data: undefined;
@@ -2632,7 +2462,7 @@ declare function useListSessions(): {
2632
2462
  dataUpdatedAt: number;
2633
2463
  errorUpdatedAt: number;
2634
2464
  failureCount: number;
2635
- failureReason: AppwriteException;
2465
+ failureReason: AppwriteException[];
2636
2466
  errorUpdateCount: number;
2637
2467
  isFetched: boolean;
2638
2468
  isFetchedAfterMount: boolean;
@@ -2643,16 +2473,7 @@ declare function useListSessions(): {
2643
2473
  isPlaceholderData: boolean;
2644
2474
  isRefetching: boolean;
2645
2475
  isStale: boolean;
2646
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2647
- __typename?: "SessionList";
2648
- sessions?: {
2649
- __typename?: "Session";
2650
- _id?: string;
2651
- _createdAt?: any;
2652
- osName?: string;
2653
- clientName?: string;
2654
- }[];
2655
- }, AppwriteException>>;
2476
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException[]>>;
2656
2477
  fetchStatus: _tanstack_query_core.FetchStatus;
2657
2478
  };
2658
2479
 
@@ -2667,18 +2488,18 @@ declare function useLogin(): {
2667
2488
  userId?: string;
2668
2489
  expire?: any;
2669
2490
  current?: boolean;
2670
- }, AppwriteException, Exact<{
2491
+ }, AppwriteException[], Exact<{
2671
2492
  email: string;
2672
2493
  password: string;
2673
2494
  }>, unknown>;
2674
- oAuthLogin: _tanstack_react_query.UseMutationResult<void | URL, AppwriteException, OAuthLoginProps, unknown>;
2495
+ oAuthLogin: _tanstack_react_query.UseMutationResult<void | URL, AppwriteException[], OAuthLoginProps, unknown>;
2675
2496
  };
2676
2497
 
2677
2498
  declare function useLogout(): {
2678
2499
  mutate: _tanstack_react_query.UseMutateFunction<{
2679
2500
  __typename?: "Status";
2680
2501
  status?: boolean;
2681
- }, AppwriteException, Exact<{
2502
+ }, AppwriteException[], Exact<{
2682
2503
  sessionId: string;
2683
2504
  }>, unknown>;
2684
2505
  data: undefined;
@@ -2692,20 +2513,20 @@ declare function useLogout(): {
2692
2513
  reset: () => void;
2693
2514
  context: unknown;
2694
2515
  failureCount: number;
2695
- failureReason: AppwriteException;
2516
+ failureReason: AppwriteException[];
2696
2517
  isPaused: boolean;
2697
2518
  submittedAt: number;
2698
2519
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
2699
2520
  __typename?: "Status";
2700
2521
  status?: boolean;
2701
- }, AppwriteException, Exact<{
2522
+ }, AppwriteException[], Exact<{
2702
2523
  sessionId: string;
2703
2524
  }>, unknown>;
2704
2525
  } | {
2705
2526
  mutate: _tanstack_react_query.UseMutateFunction<{
2706
2527
  __typename?: "Status";
2707
2528
  status?: boolean;
2708
- }, AppwriteException, Exact<{
2529
+ }, AppwriteException[], Exact<{
2709
2530
  sessionId: string;
2710
2531
  }>, unknown>;
2711
2532
  data: undefined;
@@ -2721,24 +2542,24 @@ declare function useLogout(): {
2721
2542
  reset: () => void;
2722
2543
  context: unknown;
2723
2544
  failureCount: number;
2724
- failureReason: AppwriteException;
2545
+ failureReason: AppwriteException[];
2725
2546
  isPaused: boolean;
2726
2547
  submittedAt: number;
2727
2548
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
2728
2549
  __typename?: "Status";
2729
2550
  status?: boolean;
2730
- }, AppwriteException, Exact<{
2551
+ }, AppwriteException[], Exact<{
2731
2552
  sessionId: string;
2732
2553
  }>, unknown>;
2733
2554
  } | {
2734
2555
  mutate: _tanstack_react_query.UseMutateFunction<{
2735
2556
  __typename?: "Status";
2736
2557
  status?: boolean;
2737
- }, AppwriteException, Exact<{
2558
+ }, AppwriteException[], Exact<{
2738
2559
  sessionId: string;
2739
2560
  }>, unknown>;
2740
2561
  data: undefined;
2741
- error: AppwriteException;
2562
+ error: AppwriteException[];
2742
2563
  variables: Exact<{
2743
2564
  sessionId: string;
2744
2565
  }>;
@@ -2750,20 +2571,20 @@ declare function useLogout(): {
2750
2571
  reset: () => void;
2751
2572
  context: unknown;
2752
2573
  failureCount: number;
2753
- failureReason: AppwriteException;
2574
+ failureReason: AppwriteException[];
2754
2575
  isPaused: boolean;
2755
2576
  submittedAt: number;
2756
2577
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
2757
2578
  __typename?: "Status";
2758
2579
  status?: boolean;
2759
- }, AppwriteException, Exact<{
2580
+ }, AppwriteException[], Exact<{
2760
2581
  sessionId: string;
2761
2582
  }>, unknown>;
2762
2583
  } | {
2763
2584
  mutate: _tanstack_react_query.UseMutateFunction<{
2764
2585
  __typename?: "Status";
2765
2586
  status?: boolean;
2766
- }, AppwriteException, Exact<{
2587
+ }, AppwriteException[], Exact<{
2767
2588
  sessionId: string;
2768
2589
  }>, unknown>;
2769
2590
  data: {
@@ -2782,47 +2603,22 @@ declare function useLogout(): {
2782
2603
  reset: () => void;
2783
2604
  context: unknown;
2784
2605
  failureCount: number;
2785
- failureReason: AppwriteException;
2606
+ failureReason: AppwriteException[];
2786
2607
  isPaused: boolean;
2787
2608
  submittedAt: number;
2788
2609
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
2789
2610
  __typename?: "Status";
2790
2611
  status?: boolean;
2791
- }, AppwriteException, Exact<{
2612
+ }, AppwriteException[], Exact<{
2792
2613
  sessionId: string;
2793
2614
  }>, unknown>;
2794
2615
  };
2795
2616
 
2796
2617
  declare function useLogs({ queries }: ListLogsQueryVariables): {
2797
- data: {
2798
- __typename?: "LogsList";
2799
- total: number;
2800
- logs?: {
2801
- __typename?: "Log";
2802
- event?: string;
2803
- userId?: string;
2804
- userEmail?: string;
2805
- userName?: string;
2806
- mode?: string;
2807
- ip?: string;
2808
- time?: string;
2809
- osCode?: string;
2810
- osName?: string;
2811
- osVersion?: string;
2812
- clientType?: string;
2813
- clientCode?: string;
2814
- clientName?: string;
2815
- clientVersion?: string;
2816
- clientEngine?: string;
2817
- clientEngineVersion?: string;
2818
- deviceName?: string;
2819
- deviceBrand?: string;
2820
- deviceModel?: string;
2821
- countryCode?: string;
2822
- countryName?: string;
2823
- }[];
2824
- };
2825
- error: AppwriteException;
2618
+ data: Exact<{
2619
+ queries?: string | string[];
2620
+ }>;
2621
+ error: AppwriteException[];
2826
2622
  isError: true;
2827
2623
  isPending: false;
2828
2624
  isLoading: false;
@@ -2833,7 +2629,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2833
2629
  dataUpdatedAt: number;
2834
2630
  errorUpdatedAt: number;
2835
2631
  failureCount: number;
2836
- failureReason: AppwriteException;
2632
+ failureReason: AppwriteException[];
2837
2633
  errorUpdateCount: number;
2838
2634
  isFetched: boolean;
2839
2635
  isFetchedAfterMount: boolean;
@@ -2843,64 +2639,14 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2843
2639
  isPlaceholderData: boolean;
2844
2640
  isRefetching: boolean;
2845
2641
  isStale: boolean;
2846
- refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
2847
- __typename?: "LogsList";
2848
- total: number;
2849
- logs?: {
2850
- __typename?: "Log";
2851
- event?: string;
2852
- userId?: string;
2853
- userEmail?: string;
2854
- userName?: string;
2855
- mode?: string;
2856
- ip?: string;
2857
- time?: string;
2858
- osCode?: string;
2859
- osName?: string;
2860
- osVersion?: string;
2861
- clientType?: string;
2862
- clientCode?: string;
2863
- clientName?: string;
2864
- clientVersion?: string;
2865
- clientEngine?: string;
2866
- clientEngineVersion?: string;
2867
- deviceName?: string;
2868
- deviceBrand?: string;
2869
- deviceModel?: string;
2870
- countryCode?: string;
2871
- countryName?: string;
2872
- }[];
2873
- }, AppwriteException>>;
2642
+ refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Exact<{
2643
+ queries?: string | string[];
2644
+ }>, AppwriteException[]>>;
2874
2645
  fetchStatus: _tanstack_react_query.FetchStatus;
2875
2646
  } | {
2876
- data: {
2877
- __typename?: "LogsList";
2878
- total: number;
2879
- logs?: {
2880
- __typename?: "Log";
2881
- event?: string;
2882
- userId?: string;
2883
- userEmail?: string;
2884
- userName?: string;
2885
- mode?: string;
2886
- ip?: string;
2887
- time?: string;
2888
- osCode?: string;
2889
- osName?: string;
2890
- osVersion?: string;
2891
- clientType?: string;
2892
- clientCode?: string;
2893
- clientName?: string;
2894
- clientVersion?: string;
2895
- clientEngine?: string;
2896
- clientEngineVersion?: string;
2897
- deviceName?: string;
2898
- deviceBrand?: string;
2899
- deviceModel?: string;
2900
- countryCode?: string;
2901
- countryName?: string;
2902
- }[];
2903
- };
2647
+ data: Exact<{
2648
+ queries?: string | string[];
2649
+ }>;
2904
2650
  error: null;
2905
2651
  isError: false;
2906
2652
  isPending: false;
@@ -2912,7 +2658,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2912
2658
  dataUpdatedAt: number;
2913
2659
  errorUpdatedAt: number;
2914
2660
  failureCount: number;
2915
- failureReason: AppwriteException;
2661
+ failureReason: AppwriteException[];
2916
2662
  errorUpdateCount: number;
2917
2663
  isFetched: boolean;
2918
2664
  isFetchedAfterMount: boolean;
@@ -2922,38 +2668,13 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2922
2668
  isPlaceholderData: boolean;
2923
2669
  isRefetching: boolean;
2924
2670
  isStale: boolean;
2925
- refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
2926
- __typename?: "LogsList";
2927
- total: number;
2928
- logs?: {
2929
- __typename?: "Log";
2930
- event?: string;
2931
- userId?: string;
2932
- userEmail?: string;
2933
- userName?: string;
2934
- mode?: string;
2935
- ip?: string;
2936
- time?: string;
2937
- osCode?: string;
2938
- osName?: string;
2939
- osVersion?: string;
2940
- clientType?: string;
2941
- clientCode?: string;
2942
- clientName?: string;
2943
- clientVersion?: string;
2944
- clientEngine?: string;
2945
- clientEngineVersion?: string;
2946
- deviceName?: string;
2947
- deviceBrand?: string;
2948
- deviceModel?: string;
2949
- countryCode?: string;
2950
- countryName?: string;
2951
- }[];
2952
- }, AppwriteException>>;
2671
+ refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Exact<{
2672
+ queries?: string | string[];
2673
+ }>, AppwriteException[]>>;
2953
2674
  fetchStatus: _tanstack_react_query.FetchStatus;
2954
2675
  } | {
2955
2676
  data: undefined;
2956
- error: AppwriteException;
2677
+ error: AppwriteException[];
2957
2678
  isError: true;
2958
2679
  isPending: false;
2959
2680
  isLoading: false;
@@ -2964,7 +2685,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2964
2685
  dataUpdatedAt: number;
2965
2686
  errorUpdatedAt: number;
2966
2687
  failureCount: number;
2967
- failureReason: AppwriteException;
2688
+ failureReason: AppwriteException[];
2968
2689
  errorUpdateCount: number;
2969
2690
  isFetched: boolean;
2970
2691
  isFetchedAfterMount: boolean;
@@ -2974,34 +2695,9 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2974
2695
  isPlaceholderData: boolean;
2975
2696
  isRefetching: boolean;
2976
2697
  isStale: boolean;
2977
- refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
2978
- __typename?: "LogsList";
2979
- total: number;
2980
- logs?: {
2981
- __typename?: "Log";
2982
- event?: string;
2983
- userId?: string;
2984
- userEmail?: string;
2985
- userName?: string;
2986
- mode?: string;
2987
- ip?: string;
2988
- time?: string;
2989
- osCode?: string;
2990
- osName?: string;
2991
- osVersion?: string;
2992
- clientType?: string;
2993
- clientCode?: string;
2994
- clientName?: string;
2995
- clientVersion?: string;
2996
- clientEngine?: string;
2997
- clientEngineVersion?: string;
2998
- deviceName?: string;
2999
- deviceBrand?: string;
3000
- deviceModel?: string;
3001
- countryCode?: string;
3002
- countryName?: string;
3003
- }[];
3004
- }, AppwriteException>>;
2698
+ refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Exact<{
2699
+ queries?: string | string[];
2700
+ }>, AppwriteException[]>>;
3005
2701
  fetchStatus: _tanstack_react_query.FetchStatus;
3006
2702
  } | {
3007
2703
  data: undefined;
@@ -3016,7 +2712,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
3016
2712
  dataUpdatedAt: number;
3017
2713
  errorUpdatedAt: number;
3018
2714
  failureCount: number;
3019
- failureReason: AppwriteException;
2715
+ failureReason: AppwriteException[];
3020
2716
  errorUpdateCount: number;
3021
2717
  isFetched: boolean;
3022
2718
  isFetchedAfterMount: boolean;
@@ -3026,34 +2722,9 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
3026
2722
  isPlaceholderData: boolean;
3027
2723
  isRefetching: boolean;
3028
2724
  isStale: boolean;
3029
- refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
3030
- __typename?: "LogsList";
3031
- total: number;
3032
- logs?: {
3033
- __typename?: "Log";
3034
- event?: string;
3035
- userId?: string;
3036
- userEmail?: string;
3037
- userName?: string;
3038
- mode?: string;
3039
- ip?: string;
3040
- time?: string;
3041
- osCode?: string;
3042
- osName?: string;
3043
- osVersion?: string;
3044
- clientType?: string;
3045
- clientCode?: string;
3046
- clientName?: string;
3047
- clientVersion?: string;
3048
- clientEngine?: string;
3049
- clientEngineVersion?: string;
3050
- deviceName?: string;
3051
- deviceBrand?: string;
3052
- deviceModel?: string;
3053
- countryCode?: string;
3054
- countryName?: string;
3055
- }[];
3056
- }, AppwriteException>>;
2725
+ refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Exact<{
2726
+ queries?: string | string[];
2727
+ }>, AppwriteException[]>>;
3057
2728
  fetchStatus: _tanstack_react_query.FetchStatus;
3058
2729
  } | {
3059
2730
  data: undefined;
@@ -3067,7 +2738,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
3067
2738
  dataUpdatedAt: number;
3068
2739
  errorUpdatedAt: number;
3069
2740
  failureCount: number;
3070
- failureReason: AppwriteException;
2741
+ failureReason: AppwriteException[];
3071
2742
  errorUpdateCount: number;
3072
2743
  isFetched: boolean;
3073
2744
  isFetchedAfterMount: boolean;
@@ -3078,34 +2749,9 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
3078
2749
  isPlaceholderData: boolean;
3079
2750
  isRefetching: boolean;
3080
2751
  isStale: boolean;
3081
- refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<{
3082
- __typename?: "LogsList";
3083
- total: number;
3084
- logs?: {
3085
- __typename?: "Log";
3086
- event?: string;
3087
- userId?: string;
3088
- userEmail?: string;
3089
- userName?: string;
3090
- mode?: string;
3091
- ip?: string;
3092
- time?: string;
3093
- osCode?: string;
3094
- osName?: string;
3095
- osVersion?: string;
3096
- clientType?: string;
3097
- clientCode?: string;
3098
- clientName?: string;
3099
- clientVersion?: string;
3100
- clientEngine?: string;
3101
- clientEngineVersion?: string;
3102
- deviceName?: string;
3103
- deviceBrand?: string;
3104
- deviceModel?: string;
3105
- countryCode?: string;
3106
- countryName?: string;
3107
- }[];
3108
- }, AppwriteException>>;
2752
+ refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Exact<{
2753
+ queries?: string | string[];
2754
+ }>, AppwriteException[]>>;
3109
2755
  fetchStatus: _tanstack_react_query.FetchStatus;
3110
2756
  };
3111
2757
 
@@ -3124,20 +2770,20 @@ declare function usePasswordRecovery(): {
3124
2770
  mutate: _tanstack_react_query.UseMutateFunction<{
3125
2771
  __typename?: "Token";
3126
2772
  expire?: any;
3127
- }, AppwriteException, Exact<{
2773
+ }, AppwriteException[], Exact<{
3128
2774
  email: string;
3129
2775
  url: string;
3130
2776
  }>, unknown>;
3131
2777
  reset: () => void;
3132
2778
  context: unknown;
3133
2779
  failureCount: number;
3134
- failureReason: AppwriteException;
2780
+ failureReason: AppwriteException[];
3135
2781
  isPaused: boolean;
3136
2782
  submittedAt: number;
3137
2783
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3138
2784
  __typename?: "Token";
3139
2785
  expire?: any;
3140
- }, AppwriteException, Exact<{
2786
+ }, AppwriteException[], Exact<{
3141
2787
  email: string;
3142
2788
  url: string;
3143
2789
  }>, unknown>;
@@ -3156,26 +2802,26 @@ declare function usePasswordRecovery(): {
3156
2802
  mutate: _tanstack_react_query.UseMutateFunction<{
3157
2803
  __typename?: "Token";
3158
2804
  expire?: any;
3159
- }, AppwriteException, Exact<{
2805
+ }, AppwriteException[], Exact<{
3160
2806
  email: string;
3161
2807
  url: string;
3162
2808
  }>, unknown>;
3163
2809
  reset: () => void;
3164
2810
  context: unknown;
3165
2811
  failureCount: number;
3166
- failureReason: AppwriteException;
2812
+ failureReason: AppwriteException[];
3167
2813
  isPaused: boolean;
3168
2814
  submittedAt: number;
3169
2815
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3170
2816
  __typename?: "Token";
3171
2817
  expire?: any;
3172
- }, AppwriteException, Exact<{
2818
+ }, AppwriteException[], Exact<{
3173
2819
  email: string;
3174
2820
  url: string;
3175
2821
  }>, unknown>;
3176
2822
  } | {
3177
2823
  data: undefined;
3178
- error: AppwriteException;
2824
+ error: AppwriteException[];
3179
2825
  variables: Exact<{
3180
2826
  email: string;
3181
2827
  url: string;
@@ -3188,20 +2834,20 @@ declare function usePasswordRecovery(): {
3188
2834
  mutate: _tanstack_react_query.UseMutateFunction<{
3189
2835
  __typename?: "Token";
3190
2836
  expire?: any;
3191
- }, AppwriteException, Exact<{
2837
+ }, AppwriteException[], Exact<{
3192
2838
  email: string;
3193
2839
  url: string;
3194
2840
  }>, unknown>;
3195
2841
  reset: () => void;
3196
2842
  context: unknown;
3197
2843
  failureCount: number;
3198
- failureReason: AppwriteException;
2844
+ failureReason: AppwriteException[];
3199
2845
  isPaused: boolean;
3200
2846
  submittedAt: number;
3201
2847
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3202
2848
  __typename?: "Token";
3203
2849
  expire?: any;
3204
- }, AppwriteException, Exact<{
2850
+ }, AppwriteException[], Exact<{
3205
2851
  email: string;
3206
2852
  url: string;
3207
2853
  }>, unknown>;
@@ -3223,20 +2869,20 @@ declare function usePasswordRecovery(): {
3223
2869
  mutate: _tanstack_react_query.UseMutateFunction<{
3224
2870
  __typename?: "Token";
3225
2871
  expire?: any;
3226
- }, AppwriteException, Exact<{
2872
+ }, AppwriteException[], Exact<{
3227
2873
  email: string;
3228
2874
  url: string;
3229
2875
  }>, unknown>;
3230
2876
  reset: () => void;
3231
2877
  context: unknown;
3232
2878
  failureCount: number;
3233
- failureReason: AppwriteException;
2879
+ failureReason: AppwriteException[];
3234
2880
  isPaused: boolean;
3235
2881
  submittedAt: number;
3236
2882
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3237
2883
  __typename?: "Token";
3238
2884
  expire?: any;
3239
- }, AppwriteException, Exact<{
2885
+ }, AppwriteException[], Exact<{
3240
2886
  email: string;
3241
2887
  url: string;
3242
2888
  }>, unknown>;
@@ -3254,7 +2900,7 @@ declare function useResetPassword(): {
3254
2900
  mutate: _tanstack_react_query.UseMutateFunction<{
3255
2901
  __typename?: "Token";
3256
2902
  expire?: any;
3257
- }, AppwriteException, Exact<{
2903
+ }, AppwriteException[], Exact<{
3258
2904
  userId: string;
3259
2905
  secret: string;
3260
2906
  password: string;
@@ -3262,13 +2908,13 @@ declare function useResetPassword(): {
3262
2908
  reset: () => void;
3263
2909
  context: unknown;
3264
2910
  failureCount: number;
3265
- failureReason: AppwriteException;
2911
+ failureReason: AppwriteException[];
3266
2912
  isPaused: boolean;
3267
2913
  submittedAt: number;
3268
2914
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3269
2915
  __typename?: "Token";
3270
2916
  expire?: any;
3271
- }, AppwriteException, Exact<{
2917
+ }, AppwriteException[], Exact<{
3272
2918
  userId: string;
3273
2919
  secret: string;
3274
2920
  password: string;
@@ -3289,7 +2935,7 @@ declare function useResetPassword(): {
3289
2935
  mutate: _tanstack_react_query.UseMutateFunction<{
3290
2936
  __typename?: "Token";
3291
2937
  expire?: any;
3292
- }, AppwriteException, Exact<{
2938
+ }, AppwriteException[], Exact<{
3293
2939
  userId: string;
3294
2940
  secret: string;
3295
2941
  password: string;
@@ -3297,20 +2943,20 @@ declare function useResetPassword(): {
3297
2943
  reset: () => void;
3298
2944
  context: unknown;
3299
2945
  failureCount: number;
3300
- failureReason: AppwriteException;
2946
+ failureReason: AppwriteException[];
3301
2947
  isPaused: boolean;
3302
2948
  submittedAt: number;
3303
2949
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3304
2950
  __typename?: "Token";
3305
2951
  expire?: any;
3306
- }, AppwriteException, Exact<{
2952
+ }, AppwriteException[], Exact<{
3307
2953
  userId: string;
3308
2954
  secret: string;
3309
2955
  password: string;
3310
2956
  }>, unknown>;
3311
2957
  } | {
3312
2958
  data: undefined;
3313
- error: AppwriteException;
2959
+ error: AppwriteException[];
3314
2960
  variables: Exact<{
3315
2961
  userId: string;
3316
2962
  secret: string;
@@ -3324,7 +2970,7 @@ declare function useResetPassword(): {
3324
2970
  mutate: _tanstack_react_query.UseMutateFunction<{
3325
2971
  __typename?: "Token";
3326
2972
  expire?: any;
3327
- }, AppwriteException, Exact<{
2973
+ }, AppwriteException[], Exact<{
3328
2974
  userId: string;
3329
2975
  secret: string;
3330
2976
  password: string;
@@ -3332,13 +2978,13 @@ declare function useResetPassword(): {
3332
2978
  reset: () => void;
3333
2979
  context: unknown;
3334
2980
  failureCount: number;
3335
- failureReason: AppwriteException;
2981
+ failureReason: AppwriteException[];
3336
2982
  isPaused: boolean;
3337
2983
  submittedAt: number;
3338
2984
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3339
2985
  __typename?: "Token";
3340
2986
  expire?: any;
3341
- }, AppwriteException, Exact<{
2987
+ }, AppwriteException[], Exact<{
3342
2988
  userId: string;
3343
2989
  secret: string;
3344
2990
  password: string;
@@ -3362,7 +3008,7 @@ declare function useResetPassword(): {
3362
3008
  mutate: _tanstack_react_query.UseMutateFunction<{
3363
3009
  __typename?: "Token";
3364
3010
  expire?: any;
3365
- }, AppwriteException, Exact<{
3011
+ }, AppwriteException[], Exact<{
3366
3012
  userId: string;
3367
3013
  secret: string;
3368
3014
  password: string;
@@ -3370,13 +3016,13 @@ declare function useResetPassword(): {
3370
3016
  reset: () => void;
3371
3017
  context: unknown;
3372
3018
  failureCount: number;
3373
- failureReason: AppwriteException;
3019
+ failureReason: AppwriteException[];
3374
3020
  isPaused: boolean;
3375
3021
  submittedAt: number;
3376
3022
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3377
3023
  __typename?: "Token";
3378
3024
  expire?: any;
3379
- }, AppwriteException, Exact<{
3025
+ }, AppwriteException[], Exact<{
3380
3026
  userId: string;
3381
3027
  secret: string;
3382
3028
  password: string;
@@ -3391,7 +3037,7 @@ declare function useSignUp(): {
3391
3037
  __typename?: "User";
3392
3038
  name?: string;
3393
3039
  email?: string;
3394
- }, Error, Exact<{
3040
+ }, AppwriteException[], Exact<{
3395
3041
  userId: string;
3396
3042
  name?: string;
3397
3043
  email: string;
@@ -3416,21 +3062,21 @@ declare function useUpdateEmail(): {
3416
3062
  __typename?: "User";
3417
3063
  name?: string;
3418
3064
  email?: string;
3419
- }, AppwriteException, Exact<{
3065
+ }, AppwriteException[], Exact<{
3420
3066
  email: string;
3421
3067
  password: string;
3422
3068
  }>, unknown>;
3423
3069
  reset: () => void;
3424
3070
  context: unknown;
3425
3071
  failureCount: number;
3426
- failureReason: AppwriteException;
3072
+ failureReason: AppwriteException[];
3427
3073
  isPaused: boolean;
3428
3074
  submittedAt: number;
3429
3075
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3430
3076
  __typename?: "User";
3431
3077
  name?: string;
3432
3078
  email?: string;
3433
- }, AppwriteException, Exact<{
3079
+ }, AppwriteException[], Exact<{
3434
3080
  email: string;
3435
3081
  password: string;
3436
3082
  }>, unknown>;
@@ -3450,27 +3096,27 @@ declare function useUpdateEmail(): {
3450
3096
  __typename?: "User";
3451
3097
  name?: string;
3452
3098
  email?: string;
3453
- }, AppwriteException, Exact<{
3099
+ }, AppwriteException[], Exact<{
3454
3100
  email: string;
3455
3101
  password: string;
3456
3102
  }>, unknown>;
3457
3103
  reset: () => void;
3458
3104
  context: unknown;
3459
3105
  failureCount: number;
3460
- failureReason: AppwriteException;
3106
+ failureReason: AppwriteException[];
3461
3107
  isPaused: boolean;
3462
3108
  submittedAt: number;
3463
3109
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3464
3110
  __typename?: "User";
3465
3111
  name?: string;
3466
3112
  email?: string;
3467
- }, AppwriteException, Exact<{
3113
+ }, AppwriteException[], Exact<{
3468
3114
  email: string;
3469
3115
  password: string;
3470
3116
  }>, unknown>;
3471
3117
  } | {
3472
3118
  data: undefined;
3473
- error: AppwriteException;
3119
+ error: AppwriteException[];
3474
3120
  variables: Exact<{
3475
3121
  email: string;
3476
3122
  password: string;
@@ -3484,21 +3130,21 @@ declare function useUpdateEmail(): {
3484
3130
  __typename?: "User";
3485
3131
  name?: string;
3486
3132
  email?: string;
3487
- }, AppwriteException, Exact<{
3133
+ }, AppwriteException[], Exact<{
3488
3134
  email: string;
3489
3135
  password: string;
3490
3136
  }>, unknown>;
3491
3137
  reset: () => void;
3492
3138
  context: unknown;
3493
3139
  failureCount: number;
3494
- failureReason: AppwriteException;
3140
+ failureReason: AppwriteException[];
3495
3141
  isPaused: boolean;
3496
3142
  submittedAt: number;
3497
3143
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3498
3144
  __typename?: "User";
3499
3145
  name?: string;
3500
3146
  email?: string;
3501
- }, AppwriteException, Exact<{
3147
+ }, AppwriteException[], Exact<{
3502
3148
  email: string;
3503
3149
  password: string;
3504
3150
  }>, unknown>;
@@ -3522,21 +3168,21 @@ declare function useUpdateEmail(): {
3522
3168
  __typename?: "User";
3523
3169
  name?: string;
3524
3170
  email?: string;
3525
- }, AppwriteException, Exact<{
3171
+ }, AppwriteException[], Exact<{
3526
3172
  email: string;
3527
3173
  password: string;
3528
3174
  }>, unknown>;
3529
3175
  reset: () => void;
3530
3176
  context: unknown;
3531
3177
  failureCount: number;
3532
- failureReason: AppwriteException;
3178
+ failureReason: AppwriteException[];
3533
3179
  isPaused: boolean;
3534
3180
  submittedAt: number;
3535
3181
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3536
3182
  __typename?: "User";
3537
3183
  name?: string;
3538
3184
  email?: string;
3539
- }, AppwriteException, Exact<{
3185
+ }, AppwriteException[], Exact<{
3540
3186
  email: string;
3541
3187
  password: string;
3542
3188
  }>, unknown>;
@@ -3556,14 +3202,14 @@ declare function useUpdateMagicURLSession(): {
3556
3202
  userId?: string;
3557
3203
  expire?: any;
3558
3204
  current?: boolean;
3559
- }, AppwriteException, Exact<{
3205
+ }, AppwriteException[], Exact<{
3560
3206
  userId: string;
3561
3207
  secret: string;
3562
3208
  }>, unknown>;
3563
3209
  reset: () => void;
3564
3210
  context: unknown;
3565
3211
  failureCount: number;
3566
- failureReason: AppwriteException;
3212
+ failureReason: AppwriteException[];
3567
3213
  isPaused: boolean;
3568
3214
  submittedAt: number;
3569
3215
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -3571,7 +3217,7 @@ declare function useUpdateMagicURLSession(): {
3571
3217
  userId?: string;
3572
3218
  expire?: any;
3573
3219
  current?: boolean;
3574
- }, AppwriteException, Exact<{
3220
+ }, AppwriteException[], Exact<{
3575
3221
  userId: string;
3576
3222
  secret: string;
3577
3223
  }>, unknown>;
@@ -3592,14 +3238,14 @@ declare function useUpdateMagicURLSession(): {
3592
3238
  userId?: string;
3593
3239
  expire?: any;
3594
3240
  current?: boolean;
3595
- }, AppwriteException, Exact<{
3241
+ }, AppwriteException[], Exact<{
3596
3242
  userId: string;
3597
3243
  secret: string;
3598
3244
  }>, unknown>;
3599
3245
  reset: () => void;
3600
3246
  context: unknown;
3601
3247
  failureCount: number;
3602
- failureReason: AppwriteException;
3248
+ failureReason: AppwriteException[];
3603
3249
  isPaused: boolean;
3604
3250
  submittedAt: number;
3605
3251
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -3607,13 +3253,13 @@ declare function useUpdateMagicURLSession(): {
3607
3253
  userId?: string;
3608
3254
  expire?: any;
3609
3255
  current?: boolean;
3610
- }, AppwriteException, Exact<{
3256
+ }, AppwriteException[], Exact<{
3611
3257
  userId: string;
3612
3258
  secret: string;
3613
3259
  }>, unknown>;
3614
3260
  } | {
3615
3261
  data: undefined;
3616
- error: AppwriteException;
3262
+ error: AppwriteException[];
3617
3263
  variables: Exact<{
3618
3264
  userId: string;
3619
3265
  secret: string;
@@ -3628,14 +3274,14 @@ declare function useUpdateMagicURLSession(): {
3628
3274
  userId?: string;
3629
3275
  expire?: any;
3630
3276
  current?: boolean;
3631
- }, AppwriteException, Exact<{
3277
+ }, AppwriteException[], Exact<{
3632
3278
  userId: string;
3633
3279
  secret: string;
3634
3280
  }>, unknown>;
3635
3281
  reset: () => void;
3636
3282
  context: unknown;
3637
3283
  failureCount: number;
3638
- failureReason: AppwriteException;
3284
+ failureReason: AppwriteException[];
3639
3285
  isPaused: boolean;
3640
3286
  submittedAt: number;
3641
3287
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -3643,7 +3289,7 @@ declare function useUpdateMagicURLSession(): {
3643
3289
  userId?: string;
3644
3290
  expire?: any;
3645
3291
  current?: boolean;
3646
- }, AppwriteException, Exact<{
3292
+ }, AppwriteException[], Exact<{
3647
3293
  userId: string;
3648
3294
  secret: string;
3649
3295
  }>, unknown>;
@@ -3669,14 +3315,14 @@ declare function useUpdateMagicURLSession(): {
3669
3315
  userId?: string;
3670
3316
  expire?: any;
3671
3317
  current?: boolean;
3672
- }, AppwriteException, Exact<{
3318
+ }, AppwriteException[], Exact<{
3673
3319
  userId: string;
3674
3320
  secret: string;
3675
3321
  }>, unknown>;
3676
3322
  reset: () => void;
3677
3323
  context: unknown;
3678
3324
  failureCount: number;
3679
- failureReason: AppwriteException;
3325
+ failureReason: AppwriteException[];
3680
3326
  isPaused: boolean;
3681
3327
  submittedAt: number;
3682
3328
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -3684,7 +3330,7 @@ declare function useUpdateMagicURLSession(): {
3684
3330
  userId?: string;
3685
3331
  expire?: any;
3686
3332
  current?: boolean;
3687
- }, AppwriteException, Exact<{
3333
+ }, AppwriteException[], Exact<{
3688
3334
  userId: string;
3689
3335
  secret: string;
3690
3336
  }>, unknown>;
@@ -3702,19 +3348,19 @@ declare function useUpdateMfa(): {
3702
3348
  mutate: _tanstack_react_query.UseMutateFunction<{
3703
3349
  __typename?: "User";
3704
3350
  mfa?: boolean;
3705
- }, AppwriteException, Exact<{
3351
+ }, AppwriteException[], Exact<{
3706
3352
  mfa: boolean;
3707
3353
  }>, unknown>;
3708
3354
  reset: () => void;
3709
3355
  context: unknown;
3710
3356
  failureCount: number;
3711
- failureReason: AppwriteException;
3357
+ failureReason: AppwriteException[];
3712
3358
  isPaused: boolean;
3713
3359
  submittedAt: number;
3714
3360
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3715
3361
  __typename?: "User";
3716
3362
  mfa?: boolean;
3717
- }, AppwriteException, Exact<{
3363
+ }, AppwriteException[], Exact<{
3718
3364
  mfa: boolean;
3719
3365
  }>, unknown>;
3720
3366
  } | {
@@ -3731,24 +3377,24 @@ declare function useUpdateMfa(): {
3731
3377
  mutate: _tanstack_react_query.UseMutateFunction<{
3732
3378
  __typename?: "User";
3733
3379
  mfa?: boolean;
3734
- }, AppwriteException, Exact<{
3380
+ }, AppwriteException[], Exact<{
3735
3381
  mfa: boolean;
3736
3382
  }>, unknown>;
3737
3383
  reset: () => void;
3738
3384
  context: unknown;
3739
3385
  failureCount: number;
3740
- failureReason: AppwriteException;
3386
+ failureReason: AppwriteException[];
3741
3387
  isPaused: boolean;
3742
3388
  submittedAt: number;
3743
3389
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3744
3390
  __typename?: "User";
3745
3391
  mfa?: boolean;
3746
- }, AppwriteException, Exact<{
3392
+ }, AppwriteException[], Exact<{
3747
3393
  mfa: boolean;
3748
3394
  }>, unknown>;
3749
3395
  } | {
3750
3396
  data: undefined;
3751
- error: AppwriteException;
3397
+ error: AppwriteException[];
3752
3398
  variables: Exact<{
3753
3399
  mfa: boolean;
3754
3400
  }>;
@@ -3760,19 +3406,19 @@ declare function useUpdateMfa(): {
3760
3406
  mutate: _tanstack_react_query.UseMutateFunction<{
3761
3407
  __typename?: "User";
3762
3408
  mfa?: boolean;
3763
- }, AppwriteException, Exact<{
3409
+ }, AppwriteException[], Exact<{
3764
3410
  mfa: boolean;
3765
3411
  }>, unknown>;
3766
3412
  reset: () => void;
3767
3413
  context: unknown;
3768
3414
  failureCount: number;
3769
- failureReason: AppwriteException;
3415
+ failureReason: AppwriteException[];
3770
3416
  isPaused: boolean;
3771
3417
  submittedAt: number;
3772
3418
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3773
3419
  __typename?: "User";
3774
3420
  mfa?: boolean;
3775
- }, AppwriteException, Exact<{
3421
+ }, AppwriteException[], Exact<{
3776
3422
  mfa: boolean;
3777
3423
  }>, unknown>;
3778
3424
  } | {
@@ -3792,19 +3438,19 @@ declare function useUpdateMfa(): {
3792
3438
  mutate: _tanstack_react_query.UseMutateFunction<{
3793
3439
  __typename?: "User";
3794
3440
  mfa?: boolean;
3795
- }, AppwriteException, Exact<{
3441
+ }, AppwriteException[], Exact<{
3796
3442
  mfa: boolean;
3797
3443
  }>, unknown>;
3798
3444
  reset: () => void;
3799
3445
  context: unknown;
3800
3446
  failureCount: number;
3801
- failureReason: AppwriteException;
3447
+ failureReason: AppwriteException[];
3802
3448
  isPaused: boolean;
3803
3449
  submittedAt: number;
3804
3450
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3805
3451
  __typename?: "User";
3806
3452
  mfa?: boolean;
3807
- }, AppwriteException, Exact<{
3453
+ }, AppwriteException[], Exact<{
3808
3454
  mfa: boolean;
3809
3455
  }>, unknown>;
3810
3456
  };
@@ -3821,20 +3467,20 @@ declare function useUpdateMfaAuthenticator(): {
3821
3467
  mutate: _tanstack_react_query.UseMutateFunction<{
3822
3468
  __typename?: "User";
3823
3469
  mfa?: boolean;
3824
- }, AppwriteException, Exact<{
3470
+ }, AppwriteException[], Exact<{
3825
3471
  type: string;
3826
3472
  otp: string;
3827
3473
  }>, unknown>;
3828
3474
  reset: () => void;
3829
3475
  context: unknown;
3830
3476
  failureCount: number;
3831
- failureReason: AppwriteException;
3477
+ failureReason: AppwriteException[];
3832
3478
  isPaused: boolean;
3833
3479
  submittedAt: number;
3834
3480
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3835
3481
  __typename?: "User";
3836
3482
  mfa?: boolean;
3837
- }, AppwriteException, Exact<{
3483
+ }, AppwriteException[], Exact<{
3838
3484
  type: string;
3839
3485
  otp: string;
3840
3486
  }>, unknown>;
@@ -3853,26 +3499,26 @@ declare function useUpdateMfaAuthenticator(): {
3853
3499
  mutate: _tanstack_react_query.UseMutateFunction<{
3854
3500
  __typename?: "User";
3855
3501
  mfa?: boolean;
3856
- }, AppwriteException, Exact<{
3502
+ }, AppwriteException[], Exact<{
3857
3503
  type: string;
3858
3504
  otp: string;
3859
3505
  }>, unknown>;
3860
3506
  reset: () => void;
3861
3507
  context: unknown;
3862
3508
  failureCount: number;
3863
- failureReason: AppwriteException;
3509
+ failureReason: AppwriteException[];
3864
3510
  isPaused: boolean;
3865
3511
  submittedAt: number;
3866
3512
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3867
3513
  __typename?: "User";
3868
3514
  mfa?: boolean;
3869
- }, AppwriteException, Exact<{
3515
+ }, AppwriteException[], Exact<{
3870
3516
  type: string;
3871
3517
  otp: string;
3872
3518
  }>, unknown>;
3873
3519
  } | {
3874
3520
  data: undefined;
3875
- error: AppwriteException;
3521
+ error: AppwriteException[];
3876
3522
  variables: Exact<{
3877
3523
  type: string;
3878
3524
  otp: string;
@@ -3885,20 +3531,20 @@ declare function useUpdateMfaAuthenticator(): {
3885
3531
  mutate: _tanstack_react_query.UseMutateFunction<{
3886
3532
  __typename?: "User";
3887
3533
  mfa?: boolean;
3888
- }, AppwriteException, Exact<{
3534
+ }, AppwriteException[], Exact<{
3889
3535
  type: string;
3890
3536
  otp: string;
3891
3537
  }>, unknown>;
3892
3538
  reset: () => void;
3893
3539
  context: unknown;
3894
3540
  failureCount: number;
3895
- failureReason: AppwriteException;
3541
+ failureReason: AppwriteException[];
3896
3542
  isPaused: boolean;
3897
3543
  submittedAt: number;
3898
3544
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3899
3545
  __typename?: "User";
3900
3546
  mfa?: boolean;
3901
- }, AppwriteException, Exact<{
3547
+ }, AppwriteException[], Exact<{
3902
3548
  type: string;
3903
3549
  otp: string;
3904
3550
  }>, unknown>;
@@ -3920,20 +3566,20 @@ declare function useUpdateMfaAuthenticator(): {
3920
3566
  mutate: _tanstack_react_query.UseMutateFunction<{
3921
3567
  __typename?: "User";
3922
3568
  mfa?: boolean;
3923
- }, AppwriteException, Exact<{
3569
+ }, AppwriteException[], Exact<{
3924
3570
  type: string;
3925
3571
  otp: string;
3926
3572
  }>, unknown>;
3927
3573
  reset: () => void;
3928
3574
  context: unknown;
3929
3575
  failureCount: number;
3930
- failureReason: AppwriteException;
3576
+ failureReason: AppwriteException[];
3931
3577
  isPaused: boolean;
3932
3578
  submittedAt: number;
3933
3579
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3934
3580
  __typename?: "User";
3935
3581
  mfa?: boolean;
3936
- }, AppwriteException, Exact<{
3582
+ }, AppwriteException[], Exact<{
3937
3583
  type: string;
3938
3584
  otp: string;
3939
3585
  }>, unknown>;
@@ -3951,20 +3597,20 @@ declare function useUpdateMfaChallenge(): {
3951
3597
  mutate: _tanstack_react_query.UseMutateFunction<{
3952
3598
  __typename?: "Status";
3953
3599
  status?: boolean;
3954
- }, AppwriteException, Exact<{
3600
+ }, AppwriteException[], Exact<{
3955
3601
  challengeId: string;
3956
3602
  otp: string;
3957
3603
  }>, unknown>;
3958
3604
  reset: () => void;
3959
3605
  context: unknown;
3960
3606
  failureCount: number;
3961
- failureReason: AppwriteException;
3607
+ failureReason: AppwriteException[];
3962
3608
  isPaused: boolean;
3963
3609
  submittedAt: number;
3964
3610
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3965
3611
  __typename?: "Status";
3966
3612
  status?: boolean;
3967
- }, AppwriteException, Exact<{
3613
+ }, AppwriteException[], Exact<{
3968
3614
  challengeId: string;
3969
3615
  otp: string;
3970
3616
  }>, unknown>;
@@ -3983,26 +3629,26 @@ declare function useUpdateMfaChallenge(): {
3983
3629
  mutate: _tanstack_react_query.UseMutateFunction<{
3984
3630
  __typename?: "Status";
3985
3631
  status?: boolean;
3986
- }, AppwriteException, Exact<{
3632
+ }, AppwriteException[], Exact<{
3987
3633
  challengeId: string;
3988
3634
  otp: string;
3989
3635
  }>, unknown>;
3990
3636
  reset: () => void;
3991
3637
  context: unknown;
3992
3638
  failureCount: number;
3993
- failureReason: AppwriteException;
3639
+ failureReason: AppwriteException[];
3994
3640
  isPaused: boolean;
3995
3641
  submittedAt: number;
3996
3642
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3997
3643
  __typename?: "Status";
3998
3644
  status?: boolean;
3999
- }, AppwriteException, Exact<{
3645
+ }, AppwriteException[], Exact<{
4000
3646
  challengeId: string;
4001
3647
  otp: string;
4002
3648
  }>, unknown>;
4003
3649
  } | {
4004
3650
  data: undefined;
4005
- error: AppwriteException;
3651
+ error: AppwriteException[];
4006
3652
  variables: Exact<{
4007
3653
  challengeId: string;
4008
3654
  otp: string;
@@ -4015,20 +3661,20 @@ declare function useUpdateMfaChallenge(): {
4015
3661
  mutate: _tanstack_react_query.UseMutateFunction<{
4016
3662
  __typename?: "Status";
4017
3663
  status?: boolean;
4018
- }, AppwriteException, Exact<{
3664
+ }, AppwriteException[], Exact<{
4019
3665
  challengeId: string;
4020
3666
  otp: string;
4021
3667
  }>, unknown>;
4022
3668
  reset: () => void;
4023
3669
  context: unknown;
4024
3670
  failureCount: number;
4025
- failureReason: AppwriteException;
3671
+ failureReason: AppwriteException[];
4026
3672
  isPaused: boolean;
4027
3673
  submittedAt: number;
4028
3674
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4029
3675
  __typename?: "Status";
4030
3676
  status?: boolean;
4031
- }, AppwriteException, Exact<{
3677
+ }, AppwriteException[], Exact<{
4032
3678
  challengeId: string;
4033
3679
  otp: string;
4034
3680
  }>, unknown>;
@@ -4050,20 +3696,20 @@ declare function useUpdateMfaChallenge(): {
4050
3696
  mutate: _tanstack_react_query.UseMutateFunction<{
4051
3697
  __typename?: "Status";
4052
3698
  status?: boolean;
4053
- }, AppwriteException, Exact<{
3699
+ }, AppwriteException[], Exact<{
4054
3700
  challengeId: string;
4055
3701
  otp: string;
4056
3702
  }>, unknown>;
4057
3703
  reset: () => void;
4058
3704
  context: unknown;
4059
3705
  failureCount: number;
4060
- failureReason: AppwriteException;
3706
+ failureReason: AppwriteException[];
4061
3707
  isPaused: boolean;
4062
3708
  submittedAt: number;
4063
3709
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4064
3710
  __typename?: "Status";
4065
3711
  status?: boolean;
4066
- }, AppwriteException, Exact<{
3712
+ }, AppwriteException[], Exact<{
4067
3713
  challengeId: string;
4068
3714
  otp: string;
4069
3715
  }>, unknown>;
@@ -4081,17 +3727,17 @@ declare function useUpdateMfaRecoveryCodes(): {
4081
3727
  mutate: _tanstack_react_query.UseMutateFunction<{
4082
3728
  __typename?: "MFARecoveryCodes";
4083
3729
  recoveryCodes: string[];
4084
- }, AppwriteException, void, unknown>;
3730
+ }, AppwriteException[], void, unknown>;
4085
3731
  reset: () => void;
4086
3732
  context: unknown;
4087
3733
  failureCount: number;
4088
- failureReason: AppwriteException;
3734
+ failureReason: AppwriteException[];
4089
3735
  isPaused: boolean;
4090
3736
  submittedAt: number;
4091
3737
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4092
3738
  __typename?: "MFARecoveryCodes";
4093
3739
  recoveryCodes: string[];
4094
- }, AppwriteException, void, unknown>;
3740
+ }, AppwriteException[], void, unknown>;
4095
3741
  } | {
4096
3742
  data: undefined;
4097
3743
  variables: void;
@@ -4104,20 +3750,20 @@ declare function useUpdateMfaRecoveryCodes(): {
4104
3750
  mutate: _tanstack_react_query.UseMutateFunction<{
4105
3751
  __typename?: "MFARecoveryCodes";
4106
3752
  recoveryCodes: string[];
4107
- }, AppwriteException, void, unknown>;
3753
+ }, AppwriteException[], void, unknown>;
4108
3754
  reset: () => void;
4109
3755
  context: unknown;
4110
3756
  failureCount: number;
4111
- failureReason: AppwriteException;
3757
+ failureReason: AppwriteException[];
4112
3758
  isPaused: boolean;
4113
3759
  submittedAt: number;
4114
3760
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4115
3761
  __typename?: "MFARecoveryCodes";
4116
3762
  recoveryCodes: string[];
4117
- }, AppwriteException, void, unknown>;
3763
+ }, AppwriteException[], void, unknown>;
4118
3764
  } | {
4119
3765
  data: undefined;
4120
- error: AppwriteException;
3766
+ error: AppwriteException[];
4121
3767
  variables: void;
4122
3768
  isError: true;
4123
3769
  isIdle: false;
@@ -4127,17 +3773,17 @@ declare function useUpdateMfaRecoveryCodes(): {
4127
3773
  mutate: _tanstack_react_query.UseMutateFunction<{
4128
3774
  __typename?: "MFARecoveryCodes";
4129
3775
  recoveryCodes: string[];
4130
- }, AppwriteException, void, unknown>;
3776
+ }, AppwriteException[], void, unknown>;
4131
3777
  reset: () => void;
4132
3778
  context: unknown;
4133
3779
  failureCount: number;
4134
- failureReason: AppwriteException;
3780
+ failureReason: AppwriteException[];
4135
3781
  isPaused: boolean;
4136
3782
  submittedAt: number;
4137
3783
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4138
3784
  __typename?: "MFARecoveryCodes";
4139
3785
  recoveryCodes: string[];
4140
- }, AppwriteException, void, unknown>;
3786
+ }, AppwriteException[], void, unknown>;
4141
3787
  } | {
4142
3788
  data: {
4143
3789
  __typename?: "MFARecoveryCodes";
@@ -4153,17 +3799,17 @@ declare function useUpdateMfaRecoveryCodes(): {
4153
3799
  mutate: _tanstack_react_query.UseMutateFunction<{
4154
3800
  __typename?: "MFARecoveryCodes";
4155
3801
  recoveryCodes: string[];
4156
- }, AppwriteException, void, unknown>;
3802
+ }, AppwriteException[], void, unknown>;
4157
3803
  reset: () => void;
4158
3804
  context: unknown;
4159
3805
  failureCount: number;
4160
- failureReason: AppwriteException;
3806
+ failureReason: AppwriteException[];
4161
3807
  isPaused: boolean;
4162
3808
  submittedAt: number;
4163
3809
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4164
3810
  __typename?: "MFARecoveryCodes";
4165
3811
  recoveryCodes: string[];
4166
- }, AppwriteException, void, unknown>;
3812
+ }, AppwriteException[], void, unknown>;
4167
3813
  };
4168
3814
 
4169
3815
  declare function useUpdateName(): {
@@ -4178,19 +3824,19 @@ declare function useUpdateName(): {
4178
3824
  mutate: _tanstack_react_query.UseMutateFunction<{
4179
3825
  __typename?: "User";
4180
3826
  name?: string;
4181
- }, AppwriteException, Exact<{
3827
+ }, AppwriteException[], Exact<{
4182
3828
  name: string;
4183
3829
  }>, unknown>;
4184
3830
  reset: () => void;
4185
3831
  context: unknown;
4186
3832
  failureCount: number;
4187
- failureReason: AppwriteException;
3833
+ failureReason: AppwriteException[];
4188
3834
  isPaused: boolean;
4189
3835
  submittedAt: number;
4190
3836
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4191
3837
  __typename?: "User";
4192
3838
  name?: string;
4193
- }, AppwriteException, Exact<{
3839
+ }, AppwriteException[], Exact<{
4194
3840
  name: string;
4195
3841
  }>, unknown>;
4196
3842
  } | {
@@ -4207,24 +3853,24 @@ declare function useUpdateName(): {
4207
3853
  mutate: _tanstack_react_query.UseMutateFunction<{
4208
3854
  __typename?: "User";
4209
3855
  name?: string;
4210
- }, AppwriteException, Exact<{
3856
+ }, AppwriteException[], Exact<{
4211
3857
  name: string;
4212
3858
  }>, unknown>;
4213
3859
  reset: () => void;
4214
3860
  context: unknown;
4215
3861
  failureCount: number;
4216
- failureReason: AppwriteException;
3862
+ failureReason: AppwriteException[];
4217
3863
  isPaused: boolean;
4218
3864
  submittedAt: number;
4219
3865
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4220
3866
  __typename?: "User";
4221
3867
  name?: string;
4222
- }, AppwriteException, Exact<{
3868
+ }, AppwriteException[], Exact<{
4223
3869
  name: string;
4224
3870
  }>, unknown>;
4225
3871
  } | {
4226
3872
  data: undefined;
4227
- error: AppwriteException;
3873
+ error: AppwriteException[];
4228
3874
  variables: Exact<{
4229
3875
  name: string;
4230
3876
  }>;
@@ -4236,19 +3882,19 @@ declare function useUpdateName(): {
4236
3882
  mutate: _tanstack_react_query.UseMutateFunction<{
4237
3883
  __typename?: "User";
4238
3884
  name?: string;
4239
- }, AppwriteException, Exact<{
3885
+ }, AppwriteException[], Exact<{
4240
3886
  name: string;
4241
3887
  }>, unknown>;
4242
3888
  reset: () => void;
4243
3889
  context: unknown;
4244
3890
  failureCount: number;
4245
- failureReason: AppwriteException;
3891
+ failureReason: AppwriteException[];
4246
3892
  isPaused: boolean;
4247
3893
  submittedAt: number;
4248
3894
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4249
3895
  __typename?: "User";
4250
3896
  name?: string;
4251
- }, AppwriteException, Exact<{
3897
+ }, AppwriteException[], Exact<{
4252
3898
  name: string;
4253
3899
  }>, unknown>;
4254
3900
  } | {
@@ -4268,19 +3914,19 @@ declare function useUpdateName(): {
4268
3914
  mutate: _tanstack_react_query.UseMutateFunction<{
4269
3915
  __typename?: "User";
4270
3916
  name?: string;
4271
- }, AppwriteException, Exact<{
3917
+ }, AppwriteException[], Exact<{
4272
3918
  name: string;
4273
3919
  }>, unknown>;
4274
3920
  reset: () => void;
4275
3921
  context: unknown;
4276
3922
  failureCount: number;
4277
- failureReason: AppwriteException;
3923
+ failureReason: AppwriteException[];
4278
3924
  isPaused: boolean;
4279
3925
  submittedAt: number;
4280
3926
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4281
3927
  __typename?: "User";
4282
3928
  name?: string;
4283
- }, AppwriteException, Exact<{
3929
+ }, AppwriteException[], Exact<{
4284
3930
  name: string;
4285
3931
  }>, unknown>;
4286
3932
  };
@@ -4297,20 +3943,20 @@ declare function useUpdatePassword(): {
4297
3943
  mutate: _tanstack_react_query.UseMutateFunction<{
4298
3944
  __typename?: "User";
4299
3945
  status?: string;
4300
- }, AppwriteException, Exact<{
3946
+ }, AppwriteException[], Exact<{
4301
3947
  password: string;
4302
3948
  oldPassword: string;
4303
3949
  }>, unknown>;
4304
3950
  reset: () => void;
4305
3951
  context: unknown;
4306
3952
  failureCount: number;
4307
- failureReason: AppwriteException;
3953
+ failureReason: AppwriteException[];
4308
3954
  isPaused: boolean;
4309
3955
  submittedAt: number;
4310
3956
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4311
3957
  __typename?: "User";
4312
3958
  status?: string;
4313
- }, AppwriteException, Exact<{
3959
+ }, AppwriteException[], Exact<{
4314
3960
  password: string;
4315
3961
  oldPassword: string;
4316
3962
  }>, unknown>;
@@ -4329,26 +3975,26 @@ declare function useUpdatePassword(): {
4329
3975
  mutate: _tanstack_react_query.UseMutateFunction<{
4330
3976
  __typename?: "User";
4331
3977
  status?: string;
4332
- }, AppwriteException, Exact<{
3978
+ }, AppwriteException[], Exact<{
4333
3979
  password: string;
4334
3980
  oldPassword: string;
4335
3981
  }>, unknown>;
4336
3982
  reset: () => void;
4337
3983
  context: unknown;
4338
3984
  failureCount: number;
4339
- failureReason: AppwriteException;
3985
+ failureReason: AppwriteException[];
4340
3986
  isPaused: boolean;
4341
3987
  submittedAt: number;
4342
3988
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4343
3989
  __typename?: "User";
4344
3990
  status?: string;
4345
- }, AppwriteException, Exact<{
3991
+ }, AppwriteException[], Exact<{
4346
3992
  password: string;
4347
3993
  oldPassword: string;
4348
3994
  }>, unknown>;
4349
3995
  } | {
4350
3996
  data: undefined;
4351
- error: AppwriteException;
3997
+ error: AppwriteException[];
4352
3998
  variables: Exact<{
4353
3999
  password: string;
4354
4000
  oldPassword: string;
@@ -4361,20 +4007,20 @@ declare function useUpdatePassword(): {
4361
4007
  mutate: _tanstack_react_query.UseMutateFunction<{
4362
4008
  __typename?: "User";
4363
4009
  status?: string;
4364
- }, AppwriteException, Exact<{
4010
+ }, AppwriteException[], Exact<{
4365
4011
  password: string;
4366
4012
  oldPassword: string;
4367
4013
  }>, unknown>;
4368
4014
  reset: () => void;
4369
4015
  context: unknown;
4370
4016
  failureCount: number;
4371
- failureReason: AppwriteException;
4017
+ failureReason: AppwriteException[];
4372
4018
  isPaused: boolean;
4373
4019
  submittedAt: number;
4374
4020
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4375
4021
  __typename?: "User";
4376
4022
  status?: string;
4377
- }, AppwriteException, Exact<{
4023
+ }, AppwriteException[], Exact<{
4378
4024
  password: string;
4379
4025
  oldPassword: string;
4380
4026
  }>, unknown>;
@@ -4396,20 +4042,20 @@ declare function useUpdatePassword(): {
4396
4042
  mutate: _tanstack_react_query.UseMutateFunction<{
4397
4043
  __typename?: "User";
4398
4044
  status?: string;
4399
- }, AppwriteException, Exact<{
4045
+ }, AppwriteException[], Exact<{
4400
4046
  password: string;
4401
4047
  oldPassword: string;
4402
4048
  }>, unknown>;
4403
4049
  reset: () => void;
4404
4050
  context: unknown;
4405
4051
  failureCount: number;
4406
- failureReason: AppwriteException;
4052
+ failureReason: AppwriteException[];
4407
4053
  isPaused: boolean;
4408
4054
  submittedAt: number;
4409
4055
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4410
4056
  __typename?: "User";
4411
4057
  status?: string;
4412
- }, AppwriteException, Exact<{
4058
+ }, AppwriteException[], Exact<{
4413
4059
  password: string;
4414
4060
  oldPassword: string;
4415
4061
  }>, unknown>;
@@ -4427,20 +4073,20 @@ declare function useUpdatePhone(): {
4427
4073
  mutate: _tanstack_react_query.UseMutateFunction<{
4428
4074
  __typename?: "User";
4429
4075
  phone?: string;
4430
- }, AppwriteException, Exact<{
4076
+ }, AppwriteException[], Exact<{
4431
4077
  phone: string;
4432
4078
  password: string;
4433
4079
  }>, unknown>;
4434
4080
  reset: () => void;
4435
4081
  context: unknown;
4436
4082
  failureCount: number;
4437
- failureReason: AppwriteException;
4083
+ failureReason: AppwriteException[];
4438
4084
  isPaused: boolean;
4439
4085
  submittedAt: number;
4440
4086
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4441
4087
  __typename?: "User";
4442
4088
  phone?: string;
4443
- }, AppwriteException, Exact<{
4089
+ }, AppwriteException[], Exact<{
4444
4090
  phone: string;
4445
4091
  password: string;
4446
4092
  }>, unknown>;
@@ -4459,26 +4105,26 @@ declare function useUpdatePhone(): {
4459
4105
  mutate: _tanstack_react_query.UseMutateFunction<{
4460
4106
  __typename?: "User";
4461
4107
  phone?: string;
4462
- }, AppwriteException, Exact<{
4108
+ }, AppwriteException[], Exact<{
4463
4109
  phone: string;
4464
4110
  password: string;
4465
4111
  }>, unknown>;
4466
4112
  reset: () => void;
4467
4113
  context: unknown;
4468
4114
  failureCount: number;
4469
- failureReason: AppwriteException;
4115
+ failureReason: AppwriteException[];
4470
4116
  isPaused: boolean;
4471
4117
  submittedAt: number;
4472
4118
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4473
4119
  __typename?: "User";
4474
4120
  phone?: string;
4475
- }, AppwriteException, Exact<{
4121
+ }, AppwriteException[], Exact<{
4476
4122
  phone: string;
4477
4123
  password: string;
4478
4124
  }>, unknown>;
4479
4125
  } | {
4480
4126
  data: undefined;
4481
- error: AppwriteException;
4127
+ error: AppwriteException[];
4482
4128
  variables: Exact<{
4483
4129
  phone: string;
4484
4130
  password: string;
@@ -4491,20 +4137,20 @@ declare function useUpdatePhone(): {
4491
4137
  mutate: _tanstack_react_query.UseMutateFunction<{
4492
4138
  __typename?: "User";
4493
4139
  phone?: string;
4494
- }, AppwriteException, Exact<{
4140
+ }, AppwriteException[], Exact<{
4495
4141
  phone: string;
4496
4142
  password: string;
4497
4143
  }>, unknown>;
4498
4144
  reset: () => void;
4499
4145
  context: unknown;
4500
4146
  failureCount: number;
4501
- failureReason: AppwriteException;
4147
+ failureReason: AppwriteException[];
4502
4148
  isPaused: boolean;
4503
4149
  submittedAt: number;
4504
4150
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4505
4151
  __typename?: "User";
4506
4152
  phone?: string;
4507
- }, AppwriteException, Exact<{
4153
+ }, AppwriteException[], Exact<{
4508
4154
  phone: string;
4509
4155
  password: string;
4510
4156
  }>, unknown>;
@@ -4526,20 +4172,20 @@ declare function useUpdatePhone(): {
4526
4172
  mutate: _tanstack_react_query.UseMutateFunction<{
4527
4173
  __typename?: "User";
4528
4174
  phone?: string;
4529
- }, AppwriteException, Exact<{
4175
+ }, AppwriteException[], Exact<{
4530
4176
  phone: string;
4531
4177
  password: string;
4532
4178
  }>, unknown>;
4533
4179
  reset: () => void;
4534
4180
  context: unknown;
4535
4181
  failureCount: number;
4536
- failureReason: AppwriteException;
4182
+ failureReason: AppwriteException[];
4537
4183
  isPaused: boolean;
4538
4184
  submittedAt: number;
4539
4185
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4540
4186
  __typename?: "User";
4541
4187
  phone?: string;
4542
- }, AppwriteException, Exact<{
4188
+ }, AppwriteException[], Exact<{
4543
4189
  phone: string;
4544
4190
  password: string;
4545
4191
  }>, unknown>;
@@ -4559,14 +4205,14 @@ declare function useUpdatePhoneSession(): {
4559
4205
  userId?: string;
4560
4206
  expire?: any;
4561
4207
  current?: boolean;
4562
- }, AppwriteException, Exact<{
4208
+ }, AppwriteException[], Exact<{
4563
4209
  userId: string;
4564
4210
  secret: string;
4565
4211
  }>, unknown>;
4566
4212
  reset: () => void;
4567
4213
  context: unknown;
4568
4214
  failureCount: number;
4569
- failureReason: AppwriteException;
4215
+ failureReason: AppwriteException[];
4570
4216
  isPaused: boolean;
4571
4217
  submittedAt: number;
4572
4218
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4574,7 +4220,7 @@ declare function useUpdatePhoneSession(): {
4574
4220
  userId?: string;
4575
4221
  expire?: any;
4576
4222
  current?: boolean;
4577
- }, AppwriteException, Exact<{
4223
+ }, AppwriteException[], Exact<{
4578
4224
  userId: string;
4579
4225
  secret: string;
4580
4226
  }>, unknown>;
@@ -4595,14 +4241,14 @@ declare function useUpdatePhoneSession(): {
4595
4241
  userId?: string;
4596
4242
  expire?: any;
4597
4243
  current?: boolean;
4598
- }, AppwriteException, Exact<{
4244
+ }, AppwriteException[], Exact<{
4599
4245
  userId: string;
4600
4246
  secret: string;
4601
4247
  }>, unknown>;
4602
4248
  reset: () => void;
4603
4249
  context: unknown;
4604
4250
  failureCount: number;
4605
- failureReason: AppwriteException;
4251
+ failureReason: AppwriteException[];
4606
4252
  isPaused: boolean;
4607
4253
  submittedAt: number;
4608
4254
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4610,13 +4256,13 @@ declare function useUpdatePhoneSession(): {
4610
4256
  userId?: string;
4611
4257
  expire?: any;
4612
4258
  current?: boolean;
4613
- }, AppwriteException, Exact<{
4259
+ }, AppwriteException[], Exact<{
4614
4260
  userId: string;
4615
4261
  secret: string;
4616
4262
  }>, unknown>;
4617
4263
  } | {
4618
4264
  data: undefined;
4619
- error: AppwriteException;
4265
+ error: AppwriteException[];
4620
4266
  variables: Exact<{
4621
4267
  userId: string;
4622
4268
  secret: string;
@@ -4631,14 +4277,14 @@ declare function useUpdatePhoneSession(): {
4631
4277
  userId?: string;
4632
4278
  expire?: any;
4633
4279
  current?: boolean;
4634
- }, AppwriteException, Exact<{
4280
+ }, AppwriteException[], Exact<{
4635
4281
  userId: string;
4636
4282
  secret: string;
4637
4283
  }>, unknown>;
4638
4284
  reset: () => void;
4639
4285
  context: unknown;
4640
4286
  failureCount: number;
4641
- failureReason: AppwriteException;
4287
+ failureReason: AppwriteException[];
4642
4288
  isPaused: boolean;
4643
4289
  submittedAt: number;
4644
4290
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4646,7 +4292,7 @@ declare function useUpdatePhoneSession(): {
4646
4292
  userId?: string;
4647
4293
  expire?: any;
4648
4294
  current?: boolean;
4649
- }, AppwriteException, Exact<{
4295
+ }, AppwriteException[], Exact<{
4650
4296
  userId: string;
4651
4297
  secret: string;
4652
4298
  }>, unknown>;
@@ -4672,14 +4318,14 @@ declare function useUpdatePhoneSession(): {
4672
4318
  userId?: string;
4673
4319
  expire?: any;
4674
4320
  current?: boolean;
4675
- }, AppwriteException, Exact<{
4321
+ }, AppwriteException[], Exact<{
4676
4322
  userId: string;
4677
4323
  secret: string;
4678
4324
  }>, unknown>;
4679
4325
  reset: () => void;
4680
4326
  context: unknown;
4681
4327
  failureCount: number;
4682
- failureReason: AppwriteException;
4328
+ failureReason: AppwriteException[];
4683
4329
  isPaused: boolean;
4684
4330
  submittedAt: number;
4685
4331
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4687,7 +4333,7 @@ declare function useUpdatePhoneSession(): {
4687
4333
  userId?: string;
4688
4334
  expire?: any;
4689
4335
  current?: boolean;
4690
- }, AppwriteException, Exact<{
4336
+ }, AppwriteException[], Exact<{
4691
4337
  userId: string;
4692
4338
  secret: string;
4693
4339
  }>, unknown>;
@@ -4705,20 +4351,20 @@ declare function useUpdatePhoneVerification(): {
4705
4351
  mutate: _tanstack_react_query.UseMutateFunction<{
4706
4352
  __typename?: "Token";
4707
4353
  expire?: any;
4708
- }, AppwriteException, Exact<{
4354
+ }, AppwriteException[], Exact<{
4709
4355
  userId: string;
4710
4356
  secret: string;
4711
4357
  }>, unknown>;
4712
4358
  reset: () => void;
4713
4359
  context: unknown;
4714
4360
  failureCount: number;
4715
- failureReason: AppwriteException;
4361
+ failureReason: AppwriteException[];
4716
4362
  isPaused: boolean;
4717
4363
  submittedAt: number;
4718
4364
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4719
4365
  __typename?: "Token";
4720
4366
  expire?: any;
4721
- }, AppwriteException, Exact<{
4367
+ }, AppwriteException[], Exact<{
4722
4368
  userId: string;
4723
4369
  secret: string;
4724
4370
  }>, unknown>;
@@ -4737,26 +4383,26 @@ declare function useUpdatePhoneVerification(): {
4737
4383
  mutate: _tanstack_react_query.UseMutateFunction<{
4738
4384
  __typename?: "Token";
4739
4385
  expire?: any;
4740
- }, AppwriteException, Exact<{
4386
+ }, AppwriteException[], Exact<{
4741
4387
  userId: string;
4742
4388
  secret: string;
4743
4389
  }>, unknown>;
4744
4390
  reset: () => void;
4745
4391
  context: unknown;
4746
4392
  failureCount: number;
4747
- failureReason: AppwriteException;
4393
+ failureReason: AppwriteException[];
4748
4394
  isPaused: boolean;
4749
4395
  submittedAt: number;
4750
4396
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4751
4397
  __typename?: "Token";
4752
4398
  expire?: any;
4753
- }, AppwriteException, Exact<{
4399
+ }, AppwriteException[], Exact<{
4754
4400
  userId: string;
4755
4401
  secret: string;
4756
4402
  }>, unknown>;
4757
4403
  } | {
4758
4404
  data: undefined;
4759
- error: AppwriteException;
4405
+ error: AppwriteException[];
4760
4406
  variables: Exact<{
4761
4407
  userId: string;
4762
4408
  secret: string;
@@ -4769,20 +4415,20 @@ declare function useUpdatePhoneVerification(): {
4769
4415
  mutate: _tanstack_react_query.UseMutateFunction<{
4770
4416
  __typename?: "Token";
4771
4417
  expire?: any;
4772
- }, AppwriteException, Exact<{
4418
+ }, AppwriteException[], Exact<{
4773
4419
  userId: string;
4774
4420
  secret: string;
4775
4421
  }>, unknown>;
4776
4422
  reset: () => void;
4777
4423
  context: unknown;
4778
4424
  failureCount: number;
4779
- failureReason: AppwriteException;
4425
+ failureReason: AppwriteException[];
4780
4426
  isPaused: boolean;
4781
4427
  submittedAt: number;
4782
4428
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4783
4429
  __typename?: "Token";
4784
4430
  expire?: any;
4785
- }, AppwriteException, Exact<{
4431
+ }, AppwriteException[], Exact<{
4786
4432
  userId: string;
4787
4433
  secret: string;
4788
4434
  }>, unknown>;
@@ -4804,20 +4450,20 @@ declare function useUpdatePhoneVerification(): {
4804
4450
  mutate: _tanstack_react_query.UseMutateFunction<{
4805
4451
  __typename?: "Token";
4806
4452
  expire?: any;
4807
- }, AppwriteException, Exact<{
4453
+ }, AppwriteException[], Exact<{
4808
4454
  userId: string;
4809
4455
  secret: string;
4810
4456
  }>, unknown>;
4811
4457
  reset: () => void;
4812
4458
  context: unknown;
4813
4459
  failureCount: number;
4814
- failureReason: AppwriteException;
4460
+ failureReason: AppwriteException[];
4815
4461
  isPaused: boolean;
4816
4462
  submittedAt: number;
4817
4463
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4818
4464
  __typename?: "Token";
4819
4465
  expire?: any;
4820
- }, AppwriteException, Exact<{
4466
+ }, AppwriteException[], Exact<{
4821
4467
  userId: string;
4822
4468
  secret: string;
4823
4469
  }>, unknown>;
@@ -4838,13 +4484,13 @@ declare function useUpdatePrefs(): {
4838
4484
  __typename?: "Preferences";
4839
4485
  data?: any;
4840
4486
  };
4841
- }, AppwriteException, {
4487
+ }, AppwriteException[], {
4842
4488
  prefs: Record<string, string | number | boolean>;
4843
4489
  }, unknown>;
4844
4490
  reset: () => void;
4845
4491
  context: unknown;
4846
4492
  failureCount: number;
4847
- failureReason: AppwriteException;
4493
+ failureReason: AppwriteException[];
4848
4494
  isPaused: boolean;
4849
4495
  submittedAt: number;
4850
4496
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4853,7 +4499,7 @@ declare function useUpdatePrefs(): {
4853
4499
  __typename?: "Preferences";
4854
4500
  data?: any;
4855
4501
  };
4856
- }, AppwriteException, {
4502
+ }, AppwriteException[], {
4857
4503
  prefs: Record<string, string | number | boolean>;
4858
4504
  }, unknown>;
4859
4505
  } | {
@@ -4873,13 +4519,13 @@ declare function useUpdatePrefs(): {
4873
4519
  __typename?: "Preferences";
4874
4520
  data?: any;
4875
4521
  };
4876
- }, AppwriteException, {
4522
+ }, AppwriteException[], {
4877
4523
  prefs: Record<string, string | number | boolean>;
4878
4524
  }, unknown>;
4879
4525
  reset: () => void;
4880
4526
  context: unknown;
4881
4527
  failureCount: number;
4882
- failureReason: AppwriteException;
4528
+ failureReason: AppwriteException[];
4883
4529
  isPaused: boolean;
4884
4530
  submittedAt: number;
4885
4531
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4888,12 +4534,12 @@ declare function useUpdatePrefs(): {
4888
4534
  __typename?: "Preferences";
4889
4535
  data?: any;
4890
4536
  };
4891
- }, AppwriteException, {
4537
+ }, AppwriteException[], {
4892
4538
  prefs: Record<string, string | number | boolean>;
4893
4539
  }, unknown>;
4894
4540
  } | {
4895
4541
  data: undefined;
4896
- error: AppwriteException;
4542
+ error: AppwriteException[];
4897
4543
  variables: {
4898
4544
  prefs: Record<string, string | number | boolean>;
4899
4545
  };
@@ -4908,13 +4554,13 @@ declare function useUpdatePrefs(): {
4908
4554
  __typename?: "Preferences";
4909
4555
  data?: any;
4910
4556
  };
4911
- }, AppwriteException, {
4557
+ }, AppwriteException[], {
4912
4558
  prefs: Record<string, string | number | boolean>;
4913
4559
  }, unknown>;
4914
4560
  reset: () => void;
4915
4561
  context: unknown;
4916
4562
  failureCount: number;
4917
- failureReason: AppwriteException;
4563
+ failureReason: AppwriteException[];
4918
4564
  isPaused: boolean;
4919
4565
  submittedAt: number;
4920
4566
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4923,7 +4569,7 @@ declare function useUpdatePrefs(): {
4923
4569
  __typename?: "Preferences";
4924
4570
  data?: any;
4925
4571
  };
4926
- }, AppwriteException, {
4572
+ }, AppwriteException[], {
4927
4573
  prefs: Record<string, string | number | boolean>;
4928
4574
  }, unknown>;
4929
4575
  } | {
@@ -4949,13 +4595,13 @@ declare function useUpdatePrefs(): {
4949
4595
  __typename?: "Preferences";
4950
4596
  data?: any;
4951
4597
  };
4952
- }, AppwriteException, {
4598
+ }, AppwriteException[], {
4953
4599
  prefs: Record<string, string | number | boolean>;
4954
4600
  }, unknown>;
4955
4601
  reset: () => void;
4956
4602
  context: unknown;
4957
4603
  failureCount: number;
4958
- failureReason: AppwriteException;
4604
+ failureReason: AppwriteException[];
4959
4605
  isPaused: boolean;
4960
4606
  submittedAt: number;
4961
4607
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4964,7 +4610,7 @@ declare function useUpdatePrefs(): {
4964
4610
  __typename?: "Preferences";
4965
4611
  data?: any;
4966
4612
  };
4967
- }, AppwriteException, {
4613
+ }, AppwriteException[], {
4968
4614
  prefs: Record<string, string | number | boolean>;
4969
4615
  }, unknown>;
4970
4616
  };
@@ -4983,13 +4629,13 @@ declare function useUpdateSession(): {
4983
4629
  userId?: string;
4984
4630
  expire?: any;
4985
4631
  current?: boolean;
4986
- }, AppwriteException, Exact<{
4632
+ }, AppwriteException[], Exact<{
4987
4633
  sessionId: string;
4988
4634
  }>, unknown>;
4989
4635
  reset: () => void;
4990
4636
  context: unknown;
4991
4637
  failureCount: number;
4992
- failureReason: AppwriteException;
4638
+ failureReason: AppwriteException[];
4993
4639
  isPaused: boolean;
4994
4640
  submittedAt: number;
4995
4641
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4997,7 +4643,7 @@ declare function useUpdateSession(): {
4997
4643
  userId?: string;
4998
4644
  expire?: any;
4999
4645
  current?: boolean;
5000
- }, AppwriteException, Exact<{
4646
+ }, AppwriteException[], Exact<{
5001
4647
  sessionId: string;
5002
4648
  }>, unknown>;
5003
4649
  } | {
@@ -5016,13 +4662,13 @@ declare function useUpdateSession(): {
5016
4662
  userId?: string;
5017
4663
  expire?: any;
5018
4664
  current?: boolean;
5019
- }, AppwriteException, Exact<{
4665
+ }, AppwriteException[], Exact<{
5020
4666
  sessionId: string;
5021
4667
  }>, unknown>;
5022
4668
  reset: () => void;
5023
4669
  context: unknown;
5024
4670
  failureCount: number;
5025
- failureReason: AppwriteException;
4671
+ failureReason: AppwriteException[];
5026
4672
  isPaused: boolean;
5027
4673
  submittedAt: number;
5028
4674
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5030,12 +4676,12 @@ declare function useUpdateSession(): {
5030
4676
  userId?: string;
5031
4677
  expire?: any;
5032
4678
  current?: boolean;
5033
- }, AppwriteException, Exact<{
4679
+ }, AppwriteException[], Exact<{
5034
4680
  sessionId: string;
5035
4681
  }>, unknown>;
5036
4682
  } | {
5037
4683
  data: undefined;
5038
- error: AppwriteException;
4684
+ error: AppwriteException[];
5039
4685
  variables: Exact<{
5040
4686
  sessionId: string;
5041
4687
  }>;
@@ -5049,13 +4695,13 @@ declare function useUpdateSession(): {
5049
4695
  userId?: string;
5050
4696
  expire?: any;
5051
4697
  current?: boolean;
5052
- }, AppwriteException, Exact<{
4698
+ }, AppwriteException[], Exact<{
5053
4699
  sessionId: string;
5054
4700
  }>, unknown>;
5055
4701
  reset: () => void;
5056
4702
  context: unknown;
5057
4703
  failureCount: number;
5058
- failureReason: AppwriteException;
4704
+ failureReason: AppwriteException[];
5059
4705
  isPaused: boolean;
5060
4706
  submittedAt: number;
5061
4707
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5063,7 +4709,7 @@ declare function useUpdateSession(): {
5063
4709
  userId?: string;
5064
4710
  expire?: any;
5065
4711
  current?: boolean;
5066
- }, AppwriteException, Exact<{
4712
+ }, AppwriteException[], Exact<{
5067
4713
  sessionId: string;
5068
4714
  }>, unknown>;
5069
4715
  } | {
@@ -5087,13 +4733,13 @@ declare function useUpdateSession(): {
5087
4733
  userId?: string;
5088
4734
  expire?: any;
5089
4735
  current?: boolean;
5090
- }, AppwriteException, Exact<{
4736
+ }, AppwriteException[], Exact<{
5091
4737
  sessionId: string;
5092
4738
  }>, unknown>;
5093
4739
  reset: () => void;
5094
4740
  context: unknown;
5095
4741
  failureCount: number;
5096
- failureReason: AppwriteException;
4742
+ failureReason: AppwriteException[];
5097
4743
  isPaused: boolean;
5098
4744
  submittedAt: number;
5099
4745
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5101,7 +4747,7 @@ declare function useUpdateSession(): {
5101
4747
  userId?: string;
5102
4748
  expire?: any;
5103
4749
  current?: boolean;
5104
- }, AppwriteException, Exact<{
4750
+ }, AppwriteException[], Exact<{
5105
4751
  sessionId: string;
5106
4752
  }>, unknown>;
5107
4753
  };
@@ -5120,14 +4766,14 @@ declare function useVerification(): {
5120
4766
  secret?: string;
5121
4767
  expire?: any;
5122
4768
  userId?: string;
5123
- }, AppwriteException, Exact<{
4769
+ }, AppwriteException[], Exact<{
5124
4770
  userId: string;
5125
4771
  secret: string;
5126
4772
  }>, unknown>;
5127
4773
  reset: () => void;
5128
4774
  context: unknown;
5129
4775
  failureCount: number;
5130
- failureReason: AppwriteException;
4776
+ failureReason: AppwriteException[];
5131
4777
  isPaused: boolean;
5132
4778
  submittedAt: number;
5133
4779
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5135,7 +4781,7 @@ declare function useVerification(): {
5135
4781
  secret?: string;
5136
4782
  expire?: any;
5137
4783
  userId?: string;
5138
- }, AppwriteException, Exact<{
4784
+ }, AppwriteException[], Exact<{
5139
4785
  userId: string;
5140
4786
  secret: string;
5141
4787
  }>, unknown>;
@@ -5156,14 +4802,14 @@ declare function useVerification(): {
5156
4802
  secret?: string;
5157
4803
  expire?: any;
5158
4804
  userId?: string;
5159
- }, AppwriteException, Exact<{
4805
+ }, AppwriteException[], Exact<{
5160
4806
  userId: string;
5161
4807
  secret: string;
5162
4808
  }>, unknown>;
5163
4809
  reset: () => void;
5164
4810
  context: unknown;
5165
4811
  failureCount: number;
5166
- failureReason: AppwriteException;
4812
+ failureReason: AppwriteException[];
5167
4813
  isPaused: boolean;
5168
4814
  submittedAt: number;
5169
4815
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5171,13 +4817,13 @@ declare function useVerification(): {
5171
4817
  secret?: string;
5172
4818
  expire?: any;
5173
4819
  userId?: string;
5174
- }, AppwriteException, Exact<{
4820
+ }, AppwriteException[], Exact<{
5175
4821
  userId: string;
5176
4822
  secret: string;
5177
4823
  }>, unknown>;
5178
4824
  } | {
5179
4825
  data: undefined;
5180
- error: AppwriteException;
4826
+ error: AppwriteException[];
5181
4827
  variables: Exact<{
5182
4828
  userId: string;
5183
4829
  secret: string;
@@ -5192,14 +4838,14 @@ declare function useVerification(): {
5192
4838
  secret?: string;
5193
4839
  expire?: any;
5194
4840
  userId?: string;
5195
- }, AppwriteException, Exact<{
4841
+ }, AppwriteException[], Exact<{
5196
4842
  userId: string;
5197
4843
  secret: string;
5198
4844
  }>, unknown>;
5199
4845
  reset: () => void;
5200
4846
  context: unknown;
5201
4847
  failureCount: number;
5202
- failureReason: AppwriteException;
4848
+ failureReason: AppwriteException[];
5203
4849
  isPaused: boolean;
5204
4850
  submittedAt: number;
5205
4851
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5207,7 +4853,7 @@ declare function useVerification(): {
5207
4853
  secret?: string;
5208
4854
  expire?: any;
5209
4855
  userId?: string;
5210
- }, AppwriteException, Exact<{
4856
+ }, AppwriteException[], Exact<{
5211
4857
  userId: string;
5212
4858
  secret: string;
5213
4859
  }>, unknown>;
@@ -5233,14 +4879,14 @@ declare function useVerification(): {
5233
4879
  secret?: string;
5234
4880
  expire?: any;
5235
4881
  userId?: string;
5236
- }, AppwriteException, Exact<{
4882
+ }, AppwriteException[], Exact<{
5237
4883
  userId: string;
5238
4884
  secret: string;
5239
4885
  }>, unknown>;
5240
4886
  reset: () => void;
5241
4887
  context: unknown;
5242
4888
  failureCount: number;
5243
- failureReason: AppwriteException;
4889
+ failureReason: AppwriteException[];
5244
4890
  isPaused: boolean;
5245
4891
  submittedAt: number;
5246
4892
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5248,7 +4894,7 @@ declare function useVerification(): {
5248
4894
  secret?: string;
5249
4895
  expire?: any;
5250
4896
  userId?: string;
5251
- }, AppwriteException, Exact<{
4897
+ }, AppwriteException[], Exact<{
5252
4898
  userId: string;
5253
4899
  secret: string;
5254
4900
  }>, unknown>;
@@ -5257,15 +4903,16 @@ declare function useVerification(): {
5257
4903
  type Document<T> = T & Models.Document;
5258
4904
  type Collection<T> = Models.DocumentList<Document<T>>;
5259
4905
 
5260
- declare function useCollection<TDocument>({ databaseId, collectionId, queries, }: {
4906
+ declare function useCollection<TDocument>({ databaseId, collectionId, queries, subscribe, }: {
5261
4907
  databaseId: string;
5262
4908
  collectionId: string;
5263
4909
  queries: string[];
4910
+ subscribe?: boolean;
5264
4911
  }): {
5265
4912
  documents: Document<TDocument>[];
5266
4913
  total: number;
5267
4914
  data: Collection<TDocument>;
5268
- error: AppwriteException;
4915
+ error: AppwriteException[];
5269
4916
  isError: true;
5270
4917
  isPending: false;
5271
4918
  isLoading: false;
@@ -5276,7 +4923,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5276
4923
  dataUpdatedAt: number;
5277
4924
  errorUpdatedAt: number;
5278
4925
  failureCount: number;
5279
- failureReason: AppwriteException;
4926
+ failureReason: AppwriteException[];
5280
4927
  errorUpdateCount: number;
5281
4928
  isFetched: boolean;
5282
4929
  isFetchedAfterMount: boolean;
@@ -5286,7 +4933,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5286
4933
  isPlaceholderData: boolean;
5287
4934
  isRefetching: boolean;
5288
4935
  isStale: boolean;
5289
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
4936
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5290
4937
  fetchStatus: _tanstack_query_core.FetchStatus;
5291
4938
  } | {
5292
4939
  documents: Document<TDocument>[];
@@ -5303,7 +4950,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5303
4950
  dataUpdatedAt: number;
5304
4951
  errorUpdatedAt: number;
5305
4952
  failureCount: number;
5306
- failureReason: AppwriteException;
4953
+ failureReason: AppwriteException[];
5307
4954
  errorUpdateCount: number;
5308
4955
  isFetched: boolean;
5309
4956
  isFetchedAfterMount: boolean;
@@ -5313,13 +4960,13 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5313
4960
  isPlaceholderData: boolean;
5314
4961
  isRefetching: boolean;
5315
4962
  isStale: boolean;
5316
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
4963
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5317
4964
  fetchStatus: _tanstack_query_core.FetchStatus;
5318
4965
  } | {
5319
4966
  documents: Document<TDocument>[];
5320
4967
  total: number;
5321
4968
  data: undefined;
5322
- error: AppwriteException;
4969
+ error: AppwriteException[];
5323
4970
  isError: true;
5324
4971
  isPending: false;
5325
4972
  isLoading: false;
@@ -5330,7 +4977,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5330
4977
  dataUpdatedAt: number;
5331
4978
  errorUpdatedAt: number;
5332
4979
  failureCount: number;
5333
- failureReason: AppwriteException;
4980
+ failureReason: AppwriteException[];
5334
4981
  errorUpdateCount: number;
5335
4982
  isFetched: boolean;
5336
4983
  isFetchedAfterMount: boolean;
@@ -5340,7 +4987,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5340
4987
  isPlaceholderData: boolean;
5341
4988
  isRefetching: boolean;
5342
4989
  isStale: boolean;
5343
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
4990
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5344
4991
  fetchStatus: _tanstack_query_core.FetchStatus;
5345
4992
  } | {
5346
4993
  documents: Document<TDocument>[];
@@ -5357,7 +5004,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5357
5004
  dataUpdatedAt: number;
5358
5005
  errorUpdatedAt: number;
5359
5006
  failureCount: number;
5360
- failureReason: AppwriteException;
5007
+ failureReason: AppwriteException[];
5361
5008
  errorUpdateCount: number;
5362
5009
  isFetched: boolean;
5363
5010
  isFetchedAfterMount: boolean;
@@ -5367,7 +5014,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5367
5014
  isPlaceholderData: boolean;
5368
5015
  isRefetching: boolean;
5369
5016
  isStale: boolean;
5370
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
5017
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5371
5018
  fetchStatus: _tanstack_query_core.FetchStatus;
5372
5019
  } | {
5373
5020
  documents: Document<TDocument>[];
@@ -5383,7 +5030,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5383
5030
  dataUpdatedAt: number;
5384
5031
  errorUpdatedAt: number;
5385
5032
  failureCount: number;
5386
- failureReason: AppwriteException;
5033
+ failureReason: AppwriteException[];
5387
5034
  errorUpdateCount: number;
5388
5035
  isFetched: boolean;
5389
5036
  isFetchedAfterMount: boolean;
@@ -5394,24 +5041,25 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, }
5394
5041
  isPlaceholderData: boolean;
5395
5042
  isRefetching: boolean;
5396
5043
  isStale: boolean;
5397
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
5044
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5398
5045
  fetchStatus: _tanstack_query_core.FetchStatus;
5399
5046
  };
5400
- declare function useSuspenseCollection<TDocument>({ databaseId, collectionId, queries, }: {
5047
+ declare function useSuspenseCollection<TDocument>({ databaseId, collectionId, queries, subscribe, }: {
5401
5048
  databaseId: string;
5402
5049
  collectionId: string;
5403
5050
  queries: string[];
5051
+ subscribe?: boolean;
5404
5052
  }): {
5405
5053
  documents: Document<TDocument>[];
5406
5054
  total: number;
5407
5055
  data: Collection<TDocument>;
5408
5056
  status: "error" | "success";
5409
- error: AppwriteException;
5057
+ error: AppwriteException[];
5410
5058
  isError: boolean;
5411
5059
  isPending: false;
5412
5060
  isSuccess: boolean;
5413
5061
  failureCount: number;
5414
- failureReason: AppwriteException;
5062
+ failureReason: AppwriteException[];
5415
5063
  isPaused: boolean;
5416
5064
  isLoading: false;
5417
5065
  isLoadingError: false;
@@ -5425,14 +5073,14 @@ declare function useSuspenseCollection<TDocument>({ databaseId, collectionId, qu
5425
5073
  isInitialLoading: boolean;
5426
5074
  isRefetching: boolean;
5427
5075
  isStale: boolean;
5428
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
5076
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5429
5077
  fetchStatus: _tanstack_query_core.FetchStatus;
5430
5078
  };
5431
5079
 
5432
5080
  declare function useCreateDocument(): _tanstack_react_query.UseMutationResult<{
5433
5081
  __typename?: "Document";
5434
5082
  _id?: string;
5435
- }, AppwriteException, Omit<Exact<{
5083
+ }, AppwriteException[], Omit<Exact<{
5436
5084
  databaseId: string;
5437
5085
  collectionId: string;
5438
5086
  documentId: string;
@@ -5454,7 +5102,7 @@ declare function useDeleteDocument(): {
5454
5102
  mutate: _tanstack_react_query.UseMutateFunction<{
5455
5103
  __typename?: "Status";
5456
5104
  status?: boolean;
5457
- }, AppwriteException, Exact<{
5105
+ }, AppwriteException[], Exact<{
5458
5106
  databaseId: string;
5459
5107
  collectionId: string;
5460
5108
  documentId: string;
@@ -5462,13 +5110,13 @@ declare function useDeleteDocument(): {
5462
5110
  reset: () => void;
5463
5111
  context: unknown;
5464
5112
  failureCount: number;
5465
- failureReason: AppwriteException;
5113
+ failureReason: AppwriteException[];
5466
5114
  isPaused: boolean;
5467
5115
  submittedAt: number;
5468
5116
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
5469
5117
  __typename?: "Status";
5470
5118
  status?: boolean;
5471
- }, AppwriteException, Exact<{
5119
+ }, AppwriteException[], Exact<{
5472
5120
  databaseId: string;
5473
5121
  collectionId: string;
5474
5122
  documentId: string;
@@ -5489,7 +5137,7 @@ declare function useDeleteDocument(): {
5489
5137
  mutate: _tanstack_react_query.UseMutateFunction<{
5490
5138
  __typename?: "Status";
5491
5139
  status?: boolean;
5492
- }, AppwriteException, Exact<{
5140
+ }, AppwriteException[], Exact<{
5493
5141
  databaseId: string;
5494
5142
  collectionId: string;
5495
5143
  documentId: string;
@@ -5497,20 +5145,20 @@ declare function useDeleteDocument(): {
5497
5145
  reset: () => void;
5498
5146
  context: unknown;
5499
5147
  failureCount: number;
5500
- failureReason: AppwriteException;
5148
+ failureReason: AppwriteException[];
5501
5149
  isPaused: boolean;
5502
5150
  submittedAt: number;
5503
5151
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
5504
5152
  __typename?: "Status";
5505
5153
  status?: boolean;
5506
- }, AppwriteException, Exact<{
5154
+ }, AppwriteException[], Exact<{
5507
5155
  databaseId: string;
5508
5156
  collectionId: string;
5509
5157
  documentId: string;
5510
5158
  }>, unknown>;
5511
5159
  } | {
5512
5160
  data: undefined;
5513
- error: AppwriteException;
5161
+ error: AppwriteException[];
5514
5162
  variables: Exact<{
5515
5163
  databaseId: string;
5516
5164
  collectionId: string;
@@ -5524,7 +5172,7 @@ declare function useDeleteDocument(): {
5524
5172
  mutate: _tanstack_react_query.UseMutateFunction<{
5525
5173
  __typename?: "Status";
5526
5174
  status?: boolean;
5527
- }, AppwriteException, Exact<{
5175
+ }, AppwriteException[], Exact<{
5528
5176
  databaseId: string;
5529
5177
  collectionId: string;
5530
5178
  documentId: string;
@@ -5532,13 +5180,13 @@ declare function useDeleteDocument(): {
5532
5180
  reset: () => void;
5533
5181
  context: unknown;
5534
5182
  failureCount: number;
5535
- failureReason: AppwriteException;
5183
+ failureReason: AppwriteException[];
5536
5184
  isPaused: boolean;
5537
5185
  submittedAt: number;
5538
5186
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
5539
5187
  __typename?: "Status";
5540
5188
  status?: boolean;
5541
- }, AppwriteException, Exact<{
5189
+ }, AppwriteException[], Exact<{
5542
5190
  databaseId: string;
5543
5191
  collectionId: string;
5544
5192
  documentId: string;
@@ -5562,7 +5210,7 @@ declare function useDeleteDocument(): {
5562
5210
  mutate: _tanstack_react_query.UseMutateFunction<{
5563
5211
  __typename?: "Status";
5564
5212
  status?: boolean;
5565
- }, AppwriteException, Exact<{
5213
+ }, AppwriteException[], Exact<{
5566
5214
  databaseId: string;
5567
5215
  collectionId: string;
5568
5216
  documentId: string;
@@ -5570,13 +5218,13 @@ declare function useDeleteDocument(): {
5570
5218
  reset: () => void;
5571
5219
  context: unknown;
5572
5220
  failureCount: number;
5573
- failureReason: AppwriteException;
5221
+ failureReason: AppwriteException[];
5574
5222
  isPaused: boolean;
5575
5223
  submittedAt: number;
5576
5224
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
5577
5225
  __typename?: "Status";
5578
5226
  status?: boolean;
5579
- }, AppwriteException, Exact<{
5227
+ }, AppwriteException[], Exact<{
5580
5228
  databaseId: string;
5581
5229
  collectionId: string;
5582
5230
  documentId: string;
@@ -5585,7 +5233,7 @@ declare function useDeleteDocument(): {
5585
5233
 
5586
5234
  declare function useDocument<TDocument>({ databaseId, collectionId, documentId, }: GetDocumentQueryVariables): {
5587
5235
  data: Document<TDocument>;
5588
- error: AppwriteException;
5236
+ error: AppwriteException[];
5589
5237
  isError: true;
5590
5238
  isPending: false;
5591
5239
  isLoading: false;
@@ -5596,7 +5244,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5596
5244
  dataUpdatedAt: number;
5597
5245
  errorUpdatedAt: number;
5598
5246
  failureCount: number;
5599
- failureReason: AppwriteException;
5247
+ failureReason: AppwriteException[];
5600
5248
  errorUpdateCount: number;
5601
5249
  isFetched: boolean;
5602
5250
  isFetchedAfterMount: boolean;
@@ -5606,7 +5254,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5606
5254
  isPlaceholderData: boolean;
5607
5255
  isRefetching: boolean;
5608
5256
  isStale: boolean;
5609
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5257
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5610
5258
  fetchStatus: _tanstack_query_core.FetchStatus;
5611
5259
  } | {
5612
5260
  data: Document<TDocument>;
@@ -5621,7 +5269,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5621
5269
  dataUpdatedAt: number;
5622
5270
  errorUpdatedAt: number;
5623
5271
  failureCount: number;
5624
- failureReason: AppwriteException;
5272
+ failureReason: AppwriteException[];
5625
5273
  errorUpdateCount: number;
5626
5274
  isFetched: boolean;
5627
5275
  isFetchedAfterMount: boolean;
@@ -5631,11 +5279,11 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5631
5279
  isPlaceholderData: boolean;
5632
5280
  isRefetching: boolean;
5633
5281
  isStale: boolean;
5634
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5282
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5635
5283
  fetchStatus: _tanstack_query_core.FetchStatus;
5636
5284
  } | {
5637
5285
  data: undefined;
5638
- error: AppwriteException;
5286
+ error: AppwriteException[];
5639
5287
  isError: true;
5640
5288
  isPending: false;
5641
5289
  isLoading: false;
@@ -5646,7 +5294,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5646
5294
  dataUpdatedAt: number;
5647
5295
  errorUpdatedAt: number;
5648
5296
  failureCount: number;
5649
- failureReason: AppwriteException;
5297
+ failureReason: AppwriteException[];
5650
5298
  errorUpdateCount: number;
5651
5299
  isFetched: boolean;
5652
5300
  isFetchedAfterMount: boolean;
@@ -5656,7 +5304,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5656
5304
  isPlaceholderData: boolean;
5657
5305
  isRefetching: boolean;
5658
5306
  isStale: boolean;
5659
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5307
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5660
5308
  fetchStatus: _tanstack_query_core.FetchStatus;
5661
5309
  } | {
5662
5310
  data: undefined;
@@ -5671,7 +5319,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5671
5319
  dataUpdatedAt: number;
5672
5320
  errorUpdatedAt: number;
5673
5321
  failureCount: number;
5674
- failureReason: AppwriteException;
5322
+ failureReason: AppwriteException[];
5675
5323
  errorUpdateCount: number;
5676
5324
  isFetched: boolean;
5677
5325
  isFetchedAfterMount: boolean;
@@ -5681,7 +5329,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5681
5329
  isPlaceholderData: boolean;
5682
5330
  isRefetching: boolean;
5683
5331
  isStale: boolean;
5684
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5332
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5685
5333
  fetchStatus: _tanstack_query_core.FetchStatus;
5686
5334
  } | {
5687
5335
  data: undefined;
@@ -5695,7 +5343,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5695
5343
  dataUpdatedAt: number;
5696
5344
  errorUpdatedAt: number;
5697
5345
  failureCount: number;
5698
- failureReason: AppwriteException;
5346
+ failureReason: AppwriteException[];
5699
5347
  errorUpdateCount: number;
5700
5348
  isFetched: boolean;
5701
5349
  isFetchedAfterMount: boolean;
@@ -5706,7 +5354,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5706
5354
  isPlaceholderData: boolean;
5707
5355
  isRefetching: boolean;
5708
5356
  isStale: boolean;
5709
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5357
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5710
5358
  fetchStatus: _tanstack_query_core.FetchStatus;
5711
5359
  };
5712
5360
 
@@ -5719,7 +5367,7 @@ declare function useUpdateDocument<TDocument>(): {
5719
5367
  isPending: false;
5720
5368
  isSuccess: false;
5721
5369
  status: "idle";
5722
- mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5370
+ mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5723
5371
  databaseId: string;
5724
5372
  collectionId: string;
5725
5373
  documentId: string;
@@ -5731,10 +5379,10 @@ declare function useUpdateDocument<TDocument>(): {
5731
5379
  reset: () => void;
5732
5380
  context: unknown;
5733
5381
  failureCount: number;
5734
- failureReason: AppwriteException;
5382
+ failureReason: AppwriteException[];
5735
5383
  isPaused: boolean;
5736
5384
  submittedAt: number;
5737
- mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5385
+ mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5738
5386
  databaseId: string;
5739
5387
  collectionId: string;
5740
5388
  documentId: string;
@@ -5760,7 +5408,7 @@ declare function useUpdateDocument<TDocument>(): {
5760
5408
  isPending: true;
5761
5409
  isSuccess: false;
5762
5410
  status: "pending";
5763
- mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5411
+ mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5764
5412
  databaseId: string;
5765
5413
  collectionId: string;
5766
5414
  documentId: string;
@@ -5772,10 +5420,10 @@ declare function useUpdateDocument<TDocument>(): {
5772
5420
  reset: () => void;
5773
5421
  context: unknown;
5774
5422
  failureCount: number;
5775
- failureReason: AppwriteException;
5423
+ failureReason: AppwriteException[];
5776
5424
  isPaused: boolean;
5777
5425
  submittedAt: number;
5778
- mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5426
+ mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5779
5427
  databaseId: string;
5780
5428
  collectionId: string;
5781
5429
  documentId: string;
@@ -5786,7 +5434,7 @@ declare function useUpdateDocument<TDocument>(): {
5786
5434
  }, unknown>;
5787
5435
  } | {
5788
5436
  data: undefined;
5789
- error: AppwriteException;
5437
+ error: AppwriteException[];
5790
5438
  variables: Omit<Exact<{
5791
5439
  databaseId: string;
5792
5440
  collectionId: string;
@@ -5801,7 +5449,7 @@ declare function useUpdateDocument<TDocument>(): {
5801
5449
  isPending: false;
5802
5450
  isSuccess: false;
5803
5451
  status: "error";
5804
- mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5452
+ mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5805
5453
  databaseId: string;
5806
5454
  collectionId: string;
5807
5455
  documentId: string;
@@ -5813,10 +5461,10 @@ declare function useUpdateDocument<TDocument>(): {
5813
5461
  reset: () => void;
5814
5462
  context: unknown;
5815
5463
  failureCount: number;
5816
- failureReason: AppwriteException;
5464
+ failureReason: AppwriteException[];
5817
5465
  isPaused: boolean;
5818
5466
  submittedAt: number;
5819
- mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5467
+ mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5820
5468
  databaseId: string;
5821
5469
  collectionId: string;
5822
5470
  documentId: string;
@@ -5842,7 +5490,7 @@ declare function useUpdateDocument<TDocument>(): {
5842
5490
  isPending: false;
5843
5491
  isSuccess: true;
5844
5492
  status: "success";
5845
- mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5493
+ mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5846
5494
  databaseId: string;
5847
5495
  collectionId: string;
5848
5496
  documentId: string;
@@ -5854,10 +5502,10 @@ declare function useUpdateDocument<TDocument>(): {
5854
5502
  reset: () => void;
5855
5503
  context: unknown;
5856
5504
  failureCount: number;
5857
- failureReason: AppwriteException;
5505
+ failureReason: AppwriteException[];
5858
5506
  isPaused: boolean;
5859
5507
  submittedAt: number;
5860
- mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5508
+ mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5861
5509
  databaseId: string;
5862
5510
  collectionId: string;
5863
5511
  documentId: string;
@@ -5876,11 +5524,11 @@ type Props = {
5876
5524
  method?: string;
5877
5525
  };
5878
5526
  declare function useFunction(): {
5879
- executeFunction: _tanstack_react_query.UseMutationResult<Record<string, unknown>, Error, Props, unknown>;
5527
+ executeFunction: _tanstack_react_query.UseMutationResult<Record<string, unknown>, AppwriteException[], Props, unknown>;
5880
5528
  currentExecution: _tanstack_react_query.UseQueryResult<unknown, unknown>;
5881
5529
  };
5882
5530
  declare function useSuspenseFunction({ functionId, body, async, path, method, }: Props): {
5883
- executeFunction: _tanstack_react_query.UseSuspenseQueryResult<Record<string, unknown>, Error>;
5531
+ executeFunction: _tanstack_react_query.UseSuspenseQueryResult<Record<string, unknown>, AppwriteException[]>;
5884
5532
  currentExecution: _tanstack_react_query.UseQueryResult<unknown, unknown>;
5885
5533
  };
5886
5534