@zeroin.earth/appwrite-graphql 0.15.7 → 0.15.9

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 +587 -548
  2. package/dist/index.d.ts +587 -548
  3. package/dist/index.js +38 -38
  4. package/dist/index.js.map +1 -1
  5. package/dist/index.mjs +29 -29
  6. package/dist/index.mjs.map +1 -1
  7. package/package.json +1 -1
package/dist/index.d.mts CHANGED
@@ -111,7 +111,7 @@ declare function useAccount<Preferences extends Models.Preferences>(): _tanstack
111
111
  ' $fragmentRefs'?: {
112
112
  Account_UserFragment: Account_UserFragment;
113
113
  };
114
- }, AppwriteException>;
114
+ }, AppwriteException[]>;
115
115
 
116
116
  declare function useCreateAnonymousSession(): {
117
117
  data: undefined;
@@ -127,11 +127,11 @@ declare function useCreateAnonymousSession(): {
127
127
  _id?: string;
128
128
  expire?: any;
129
129
  current?: boolean;
130
- }, AppwriteException, void, unknown>;
130
+ }, AppwriteException[], void, unknown>;
131
131
  reset: () => void;
132
132
  context: unknown;
133
133
  failureCount: number;
134
- failureReason: AppwriteException;
134
+ failureReason: AppwriteException[];
135
135
  isPaused: boolean;
136
136
  submittedAt: number;
137
137
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -139,7 +139,7 @@ declare function useCreateAnonymousSession(): {
139
139
  _id?: string;
140
140
  expire?: any;
141
141
  current?: boolean;
142
- }, AppwriteException, void, unknown>;
142
+ }, AppwriteException[], void, unknown>;
143
143
  } | {
144
144
  data: undefined;
145
145
  variables: void;
@@ -154,11 +154,11 @@ declare function useCreateAnonymousSession(): {
154
154
  _id?: string;
155
155
  expire?: any;
156
156
  current?: boolean;
157
- }, AppwriteException, void, unknown>;
157
+ }, AppwriteException[], void, unknown>;
158
158
  reset: () => void;
159
159
  context: unknown;
160
160
  failureCount: number;
161
- failureReason: AppwriteException;
161
+ failureReason: AppwriteException[];
162
162
  isPaused: boolean;
163
163
  submittedAt: number;
164
164
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -166,10 +166,10 @@ declare function useCreateAnonymousSession(): {
166
166
  _id?: string;
167
167
  expire?: any;
168
168
  current?: boolean;
169
- }, AppwriteException, void, unknown>;
169
+ }, AppwriteException[], void, unknown>;
170
170
  } | {
171
171
  data: undefined;
172
- error: AppwriteException;
172
+ error: AppwriteException[];
173
173
  variables: void;
174
174
  isError: true;
175
175
  isIdle: false;
@@ -181,11 +181,11 @@ declare function useCreateAnonymousSession(): {
181
181
  _id?: string;
182
182
  expire?: any;
183
183
  current?: boolean;
184
- }, AppwriteException, void, unknown>;
184
+ }, AppwriteException[], void, unknown>;
185
185
  reset: () => void;
186
186
  context: unknown;
187
187
  failureCount: number;
188
- failureReason: AppwriteException;
188
+ failureReason: AppwriteException[];
189
189
  isPaused: boolean;
190
190
  submittedAt: number;
191
191
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -193,7 +193,7 @@ declare function useCreateAnonymousSession(): {
193
193
  _id?: string;
194
194
  expire?: any;
195
195
  current?: boolean;
196
- }, AppwriteException, void, unknown>;
196
+ }, AppwriteException[], void, unknown>;
197
197
  } | {
198
198
  data: {
199
199
  __typename?: "Session";
@@ -213,11 +213,11 @@ declare function useCreateAnonymousSession(): {
213
213
  _id?: string;
214
214
  expire?: any;
215
215
  current?: boolean;
216
- }, AppwriteException, void, unknown>;
216
+ }, AppwriteException[], void, unknown>;
217
217
  reset: () => void;
218
218
  context: unknown;
219
219
  failureCount: number;
220
- failureReason: AppwriteException;
220
+ failureReason: AppwriteException[];
221
221
  isPaused: boolean;
222
222
  submittedAt: number;
223
223
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -225,7 +225,7 @@ declare function useCreateAnonymousSession(): {
225
225
  _id?: string;
226
226
  expire?: any;
227
227
  current?: boolean;
228
- }, AppwriteException, void, unknown>;
228
+ }, AppwriteException[], void, unknown>;
229
229
  };
230
230
 
231
231
  declare function useCreateEmailToken(): {
@@ -240,7 +240,7 @@ declare function useCreateEmailToken(): {
240
240
  mutate: _tanstack_react_query.UseMutateFunction<{
241
241
  __typename?: "Token";
242
242
  expire?: any;
243
- }, AppwriteException, Exact<{
243
+ }, AppwriteException[], Exact<{
244
244
  userId: string;
245
245
  email: string;
246
246
  phrase?: boolean;
@@ -248,13 +248,13 @@ declare function useCreateEmailToken(): {
248
248
  reset: () => void;
249
249
  context: unknown;
250
250
  failureCount: number;
251
- failureReason: AppwriteException;
251
+ failureReason: AppwriteException[];
252
252
  isPaused: boolean;
253
253
  submittedAt: number;
254
254
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
255
255
  __typename?: "Token";
256
256
  expire?: any;
257
- }, AppwriteException, Exact<{
257
+ }, AppwriteException[], Exact<{
258
258
  userId: string;
259
259
  email: string;
260
260
  phrase?: boolean;
@@ -275,7 +275,7 @@ declare function useCreateEmailToken(): {
275
275
  mutate: _tanstack_react_query.UseMutateFunction<{
276
276
  __typename?: "Token";
277
277
  expire?: any;
278
- }, AppwriteException, Exact<{
278
+ }, AppwriteException[], Exact<{
279
279
  userId: string;
280
280
  email: string;
281
281
  phrase?: boolean;
@@ -283,20 +283,20 @@ declare function useCreateEmailToken(): {
283
283
  reset: () => void;
284
284
  context: unknown;
285
285
  failureCount: number;
286
- failureReason: AppwriteException;
286
+ failureReason: AppwriteException[];
287
287
  isPaused: boolean;
288
288
  submittedAt: number;
289
289
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
290
290
  __typename?: "Token";
291
291
  expire?: any;
292
- }, AppwriteException, Exact<{
292
+ }, AppwriteException[], Exact<{
293
293
  userId: string;
294
294
  email: string;
295
295
  phrase?: boolean;
296
296
  }>, unknown>;
297
297
  } | {
298
298
  data: undefined;
299
- error: AppwriteException;
299
+ error: AppwriteException[];
300
300
  variables: Exact<{
301
301
  userId: string;
302
302
  email: string;
@@ -310,7 +310,7 @@ declare function useCreateEmailToken(): {
310
310
  mutate: _tanstack_react_query.UseMutateFunction<{
311
311
  __typename?: "Token";
312
312
  expire?: any;
313
- }, AppwriteException, Exact<{
313
+ }, AppwriteException[], Exact<{
314
314
  userId: string;
315
315
  email: string;
316
316
  phrase?: boolean;
@@ -318,13 +318,13 @@ declare function useCreateEmailToken(): {
318
318
  reset: () => void;
319
319
  context: unknown;
320
320
  failureCount: number;
321
- failureReason: AppwriteException;
321
+ failureReason: AppwriteException[];
322
322
  isPaused: boolean;
323
323
  submittedAt: number;
324
324
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
325
325
  __typename?: "Token";
326
326
  expire?: any;
327
- }, AppwriteException, Exact<{
327
+ }, AppwriteException[], Exact<{
328
328
  userId: string;
329
329
  email: string;
330
330
  phrase?: boolean;
@@ -348,7 +348,7 @@ declare function useCreateEmailToken(): {
348
348
  mutate: _tanstack_react_query.UseMutateFunction<{
349
349
  __typename?: "Token";
350
350
  expire?: any;
351
- }, AppwriteException, Exact<{
351
+ }, AppwriteException[], Exact<{
352
352
  userId: string;
353
353
  email: string;
354
354
  phrase?: boolean;
@@ -356,13 +356,13 @@ declare function useCreateEmailToken(): {
356
356
  reset: () => void;
357
357
  context: unknown;
358
358
  failureCount: number;
359
- failureReason: AppwriteException;
359
+ failureReason: AppwriteException[];
360
360
  isPaused: boolean;
361
361
  submittedAt: number;
362
362
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
363
363
  __typename?: "Token";
364
364
  expire?: any;
365
- }, AppwriteException, Exact<{
365
+ }, AppwriteException[], Exact<{
366
366
  userId: string;
367
367
  email: string;
368
368
  phrase?: boolean;
@@ -383,17 +383,17 @@ declare function useCreateJWT({ gcTime }?: {
383
383
  mutate: _tanstack_react_query.UseMutateFunction<{
384
384
  __typename?: "JWT";
385
385
  jwt?: string;
386
- }, AppwriteException, void, unknown>;
386
+ }, AppwriteException[], void, unknown>;
387
387
  reset: () => void;
388
388
  context: unknown;
389
389
  failureCount: number;
390
- failureReason: AppwriteException;
390
+ failureReason: AppwriteException[];
391
391
  isPaused: boolean;
392
392
  submittedAt: number;
393
393
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
394
394
  __typename?: "JWT";
395
395
  jwt?: string;
396
- }, AppwriteException, void, unknown>;
396
+ }, AppwriteException[], void, unknown>;
397
397
  } | {
398
398
  data: undefined;
399
399
  variables: void;
@@ -406,20 +406,20 @@ declare function useCreateJWT({ gcTime }?: {
406
406
  mutate: _tanstack_react_query.UseMutateFunction<{
407
407
  __typename?: "JWT";
408
408
  jwt?: string;
409
- }, AppwriteException, void, unknown>;
409
+ }, AppwriteException[], void, unknown>;
410
410
  reset: () => void;
411
411
  context: unknown;
412
412
  failureCount: number;
413
- failureReason: AppwriteException;
413
+ failureReason: AppwriteException[];
414
414
  isPaused: boolean;
415
415
  submittedAt: number;
416
416
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
417
417
  __typename?: "JWT";
418
418
  jwt?: string;
419
- }, AppwriteException, void, unknown>;
419
+ }, AppwriteException[], void, unknown>;
420
420
  } | {
421
421
  data: undefined;
422
- error: AppwriteException;
422
+ error: AppwriteException[];
423
423
  variables: void;
424
424
  isError: true;
425
425
  isIdle: false;
@@ -429,17 +429,17 @@ declare function useCreateJWT({ gcTime }?: {
429
429
  mutate: _tanstack_react_query.UseMutateFunction<{
430
430
  __typename?: "JWT";
431
431
  jwt?: string;
432
- }, AppwriteException, void, unknown>;
432
+ }, AppwriteException[], void, unknown>;
433
433
  reset: () => void;
434
434
  context: unknown;
435
435
  failureCount: number;
436
- failureReason: AppwriteException;
436
+ failureReason: AppwriteException[];
437
437
  isPaused: boolean;
438
438
  submittedAt: number;
439
439
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
440
440
  __typename?: "JWT";
441
441
  jwt?: string;
442
- }, AppwriteException, void, unknown>;
442
+ }, AppwriteException[], void, unknown>;
443
443
  } | {
444
444
  data: {
445
445
  __typename?: "JWT";
@@ -455,17 +455,17 @@ declare function useCreateJWT({ gcTime }?: {
455
455
  mutate: _tanstack_react_query.UseMutateFunction<{
456
456
  __typename?: "JWT";
457
457
  jwt?: string;
458
- }, AppwriteException, void, unknown>;
458
+ }, AppwriteException[], void, unknown>;
459
459
  reset: () => void;
460
460
  context: unknown;
461
461
  failureCount: number;
462
- failureReason: AppwriteException;
462
+ failureReason: AppwriteException[];
463
463
  isPaused: boolean;
464
464
  submittedAt: number;
465
465
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
466
466
  __typename?: "JWT";
467
467
  jwt?: string;
468
- }, AppwriteException, void, unknown>;
468
+ }, AppwriteException[], void, unknown>;
469
469
  };
470
470
  declare function useSuspenseCreateJWT({ gcTime }?: {
471
471
  gcTime?: number;
@@ -475,12 +475,12 @@ declare function useSuspenseCreateJWT({ gcTime }?: {
475
475
  jwt?: string;
476
476
  };
477
477
  status: "error" | "success";
478
- error: AppwriteException;
478
+ error: AppwriteException[];
479
479
  isError: boolean;
480
480
  isPending: false;
481
481
  isSuccess: boolean;
482
482
  failureCount: number;
483
- failureReason: AppwriteException;
483
+ failureReason: AppwriteException[];
484
484
  isPaused: boolean;
485
485
  isLoading: false;
486
486
  isLoadingError: false;
@@ -497,7 +497,7 @@ declare function useSuspenseCreateJWT({ gcTime }?: {
497
497
  refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
498
498
  __typename?: "JWT";
499
499
  jwt?: string;
500
- }, AppwriteException>>;
500
+ }, AppwriteException[]>>;
501
501
  fetchStatus: _tanstack_query_core.FetchStatus;
502
502
  };
503
503
 
@@ -513,7 +513,7 @@ declare function useCreateMagicURLToken(): {
513
513
  mutate: _tanstack_react_query.UseMutateFunction<{
514
514
  __typename?: "Token";
515
515
  expire?: any;
516
- }, AppwriteException, Exact<{
516
+ }, AppwriteException[], Exact<{
517
517
  userId: string;
518
518
  email: string;
519
519
  url?: string;
@@ -522,13 +522,13 @@ declare function useCreateMagicURLToken(): {
522
522
  reset: () => void;
523
523
  context: unknown;
524
524
  failureCount: number;
525
- failureReason: AppwriteException;
525
+ failureReason: AppwriteException[];
526
526
  isPaused: boolean;
527
527
  submittedAt: number;
528
528
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
529
529
  __typename?: "Token";
530
530
  expire?: any;
531
- }, AppwriteException, Exact<{
531
+ }, AppwriteException[], Exact<{
532
532
  userId: string;
533
533
  email: string;
534
534
  url?: string;
@@ -551,7 +551,7 @@ declare function useCreateMagicURLToken(): {
551
551
  mutate: _tanstack_react_query.UseMutateFunction<{
552
552
  __typename?: "Token";
553
553
  expire?: any;
554
- }, AppwriteException, Exact<{
554
+ }, AppwriteException[], Exact<{
555
555
  userId: string;
556
556
  email: string;
557
557
  url?: string;
@@ -560,13 +560,13 @@ declare function useCreateMagicURLToken(): {
560
560
  reset: () => void;
561
561
  context: unknown;
562
562
  failureCount: number;
563
- failureReason: AppwriteException;
563
+ failureReason: AppwriteException[];
564
564
  isPaused: boolean;
565
565
  submittedAt: number;
566
566
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
567
567
  __typename?: "Token";
568
568
  expire?: any;
569
- }, AppwriteException, Exact<{
569
+ }, AppwriteException[], Exact<{
570
570
  userId: string;
571
571
  email: string;
572
572
  url?: string;
@@ -574,7 +574,7 @@ declare function useCreateMagicURLToken(): {
574
574
  }>, unknown>;
575
575
  } | {
576
576
  data: undefined;
577
- error: AppwriteException;
577
+ error: AppwriteException[];
578
578
  variables: Exact<{
579
579
  userId: string;
580
580
  email: string;
@@ -589,7 +589,7 @@ declare function useCreateMagicURLToken(): {
589
589
  mutate: _tanstack_react_query.UseMutateFunction<{
590
590
  __typename?: "Token";
591
591
  expire?: any;
592
- }, AppwriteException, Exact<{
592
+ }, AppwriteException[], Exact<{
593
593
  userId: string;
594
594
  email: string;
595
595
  url?: string;
@@ -598,13 +598,13 @@ declare function useCreateMagicURLToken(): {
598
598
  reset: () => void;
599
599
  context: unknown;
600
600
  failureCount: number;
601
- failureReason: AppwriteException;
601
+ failureReason: AppwriteException[];
602
602
  isPaused: boolean;
603
603
  submittedAt: number;
604
604
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
605
605
  __typename?: "Token";
606
606
  expire?: any;
607
- }, AppwriteException, Exact<{
607
+ }, AppwriteException[], Exact<{
608
608
  userId: string;
609
609
  email: string;
610
610
  url?: string;
@@ -630,7 +630,7 @@ declare function useCreateMagicURLToken(): {
630
630
  mutate: _tanstack_react_query.UseMutateFunction<{
631
631
  __typename?: "Token";
632
632
  expire?: any;
633
- }, AppwriteException, Exact<{
633
+ }, AppwriteException[], Exact<{
634
634
  userId: string;
635
635
  email: string;
636
636
  url?: string;
@@ -639,13 +639,13 @@ declare function useCreateMagicURLToken(): {
639
639
  reset: () => void;
640
640
  context: unknown;
641
641
  failureCount: number;
642
- failureReason: AppwriteException;
642
+ failureReason: AppwriteException[];
643
643
  isPaused: boolean;
644
644
  submittedAt: number;
645
645
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
646
646
  __typename?: "Token";
647
647
  expire?: any;
648
- }, AppwriteException, Exact<{
648
+ }, AppwriteException[], Exact<{
649
649
  userId: string;
650
650
  email: string;
651
651
  url?: string;
@@ -666,20 +666,20 @@ declare function useCreateMfaAuthenticator(): {
666
666
  __typename?: "MFAType";
667
667
  secret?: string;
668
668
  uri?: string;
669
- }, AppwriteException, Exact<{
669
+ }, AppwriteException[], Exact<{
670
670
  type: string;
671
671
  }>, unknown>;
672
672
  reset: () => void;
673
673
  context: unknown;
674
674
  failureCount: number;
675
- failureReason: AppwriteException;
675
+ failureReason: AppwriteException[];
676
676
  isPaused: boolean;
677
677
  submittedAt: number;
678
678
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
679
679
  __typename?: "MFAType";
680
680
  secret?: string;
681
681
  uri?: string;
682
- }, AppwriteException, Exact<{
682
+ }, AppwriteException[], Exact<{
683
683
  type: string;
684
684
  }>, unknown>;
685
685
  } | {
@@ -697,25 +697,25 @@ declare function useCreateMfaAuthenticator(): {
697
697
  __typename?: "MFAType";
698
698
  secret?: string;
699
699
  uri?: string;
700
- }, AppwriteException, Exact<{
700
+ }, AppwriteException[], Exact<{
701
701
  type: string;
702
702
  }>, unknown>;
703
703
  reset: () => void;
704
704
  context: unknown;
705
705
  failureCount: number;
706
- failureReason: AppwriteException;
706
+ failureReason: AppwriteException[];
707
707
  isPaused: boolean;
708
708
  submittedAt: number;
709
709
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
710
710
  __typename?: "MFAType";
711
711
  secret?: string;
712
712
  uri?: string;
713
- }, AppwriteException, Exact<{
713
+ }, AppwriteException[], Exact<{
714
714
  type: string;
715
715
  }>, unknown>;
716
716
  } | {
717
717
  data: undefined;
718
- error: AppwriteException;
718
+ error: AppwriteException[];
719
719
  variables: Exact<{
720
720
  type: string;
721
721
  }>;
@@ -728,20 +728,20 @@ declare function useCreateMfaAuthenticator(): {
728
728
  __typename?: "MFAType";
729
729
  secret?: string;
730
730
  uri?: string;
731
- }, AppwriteException, Exact<{
731
+ }, AppwriteException[], Exact<{
732
732
  type: string;
733
733
  }>, unknown>;
734
734
  reset: () => void;
735
735
  context: unknown;
736
736
  failureCount: number;
737
- failureReason: AppwriteException;
737
+ failureReason: AppwriteException[];
738
738
  isPaused: boolean;
739
739
  submittedAt: number;
740
740
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
741
741
  __typename?: "MFAType";
742
742
  secret?: string;
743
743
  uri?: string;
744
- }, AppwriteException, Exact<{
744
+ }, AppwriteException[], Exact<{
745
745
  type: string;
746
746
  }>, unknown>;
747
747
  } | {
@@ -763,20 +763,20 @@ declare function useCreateMfaAuthenticator(): {
763
763
  __typename?: "MFAType";
764
764
  secret?: string;
765
765
  uri?: string;
766
- }, AppwriteException, Exact<{
766
+ }, AppwriteException[], Exact<{
767
767
  type: string;
768
768
  }>, unknown>;
769
769
  reset: () => void;
770
770
  context: unknown;
771
771
  failureCount: number;
772
- failureReason: AppwriteException;
772
+ failureReason: AppwriteException[];
773
773
  isPaused: boolean;
774
774
  submittedAt: number;
775
775
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
776
776
  __typename?: "MFAType";
777
777
  secret?: string;
778
778
  uri?: string;
779
- }, AppwriteException, Exact<{
779
+ }, AppwriteException[], Exact<{
780
780
  type: string;
781
781
  }>, unknown>;
782
782
  };
@@ -794,20 +794,20 @@ declare function useCreateMfaChallenge(): {
794
794
  __typename?: "MFAChallenge";
795
795
  userId?: string;
796
796
  expire?: any;
797
- }, AppwriteException, {
797
+ }, AppwriteException[], {
798
798
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
799
799
  }, unknown>;
800
800
  reset: () => void;
801
801
  context: unknown;
802
802
  failureCount: number;
803
- failureReason: AppwriteException;
803
+ failureReason: AppwriteException[];
804
804
  isPaused: boolean;
805
805
  submittedAt: number;
806
806
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
807
807
  __typename?: "MFAChallenge";
808
808
  userId?: string;
809
809
  expire?: any;
810
- }, AppwriteException, {
810
+ }, AppwriteException[], {
811
811
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
812
812
  }, unknown>;
813
813
  } | {
@@ -825,25 +825,25 @@ declare function useCreateMfaChallenge(): {
825
825
  __typename?: "MFAChallenge";
826
826
  userId?: string;
827
827
  expire?: any;
828
- }, AppwriteException, {
828
+ }, AppwriteException[], {
829
829
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
830
830
  }, unknown>;
831
831
  reset: () => void;
832
832
  context: unknown;
833
833
  failureCount: number;
834
- failureReason: AppwriteException;
834
+ failureReason: AppwriteException[];
835
835
  isPaused: boolean;
836
836
  submittedAt: number;
837
837
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
838
838
  __typename?: "MFAChallenge";
839
839
  userId?: string;
840
840
  expire?: any;
841
- }, AppwriteException, {
841
+ }, AppwriteException[], {
842
842
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
843
843
  }, unknown>;
844
844
  } | {
845
845
  data: undefined;
846
- error: AppwriteException;
846
+ error: AppwriteException[];
847
847
  variables: {
848
848
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
849
849
  };
@@ -856,20 +856,20 @@ declare function useCreateMfaChallenge(): {
856
856
  __typename?: "MFAChallenge";
857
857
  userId?: string;
858
858
  expire?: any;
859
- }, AppwriteException, {
859
+ }, AppwriteException[], {
860
860
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
861
861
  }, unknown>;
862
862
  reset: () => void;
863
863
  context: unknown;
864
864
  failureCount: number;
865
- failureReason: AppwriteException;
865
+ failureReason: AppwriteException[];
866
866
  isPaused: boolean;
867
867
  submittedAt: number;
868
868
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
869
869
  __typename?: "MFAChallenge";
870
870
  userId?: string;
871
871
  expire?: any;
872
- }, AppwriteException, {
872
+ }, AppwriteException[], {
873
873
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
874
874
  }, unknown>;
875
875
  } | {
@@ -891,20 +891,20 @@ declare function useCreateMfaChallenge(): {
891
891
  __typename?: "MFAChallenge";
892
892
  userId?: string;
893
893
  expire?: any;
894
- }, AppwriteException, {
894
+ }, AppwriteException[], {
895
895
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
896
896
  }, unknown>;
897
897
  reset: () => void;
898
898
  context: unknown;
899
899
  failureCount: number;
900
- failureReason: AppwriteException;
900
+ failureReason: AppwriteException[];
901
901
  isPaused: boolean;
902
902
  submittedAt: number;
903
903
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
904
904
  __typename?: "MFAChallenge";
905
905
  userId?: string;
906
906
  expire?: any;
907
- }, AppwriteException, {
907
+ }, AppwriteException[], {
908
908
  factor: 'email' | 'phone' | 'totp' | 'recoveryCode';
909
909
  }, unknown>;
910
910
  };
@@ -921,17 +921,17 @@ declare function useCreateMfaRecoveryCodes(): {
921
921
  mutate: _tanstack_react_query.UseMutateFunction<{
922
922
  __typename?: "MFARecoveryCodes";
923
923
  recoveryCodes: string[];
924
- }, AppwriteException, void, unknown>;
924
+ }, AppwriteException[], void, unknown>;
925
925
  reset: () => void;
926
926
  context: unknown;
927
927
  failureCount: number;
928
- failureReason: AppwriteException;
928
+ failureReason: AppwriteException[];
929
929
  isPaused: boolean;
930
930
  submittedAt: number;
931
931
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
932
932
  __typename?: "MFARecoveryCodes";
933
933
  recoveryCodes: string[];
934
- }, AppwriteException, void, unknown>;
934
+ }, AppwriteException[], void, unknown>;
935
935
  } | {
936
936
  data: undefined;
937
937
  variables: void;
@@ -944,20 +944,20 @@ declare function useCreateMfaRecoveryCodes(): {
944
944
  mutate: _tanstack_react_query.UseMutateFunction<{
945
945
  __typename?: "MFARecoveryCodes";
946
946
  recoveryCodes: string[];
947
- }, AppwriteException, void, unknown>;
947
+ }, AppwriteException[], void, unknown>;
948
948
  reset: () => void;
949
949
  context: unknown;
950
950
  failureCount: number;
951
- failureReason: AppwriteException;
951
+ failureReason: AppwriteException[];
952
952
  isPaused: boolean;
953
953
  submittedAt: number;
954
954
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
955
955
  __typename?: "MFARecoveryCodes";
956
956
  recoveryCodes: string[];
957
- }, AppwriteException, void, unknown>;
957
+ }, AppwriteException[], void, unknown>;
958
958
  } | {
959
959
  data: undefined;
960
- error: AppwriteException;
960
+ error: AppwriteException[];
961
961
  variables: void;
962
962
  isError: true;
963
963
  isIdle: false;
@@ -967,17 +967,17 @@ declare function useCreateMfaRecoveryCodes(): {
967
967
  mutate: _tanstack_react_query.UseMutateFunction<{
968
968
  __typename?: "MFARecoveryCodes";
969
969
  recoveryCodes: string[];
970
- }, AppwriteException, void, unknown>;
970
+ }, AppwriteException[], void, unknown>;
971
971
  reset: () => void;
972
972
  context: unknown;
973
973
  failureCount: number;
974
- failureReason: AppwriteException;
974
+ failureReason: AppwriteException[];
975
975
  isPaused: boolean;
976
976
  submittedAt: number;
977
977
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
978
978
  __typename?: "MFARecoveryCodes";
979
979
  recoveryCodes: string[];
980
- }, AppwriteException, void, unknown>;
980
+ }, AppwriteException[], void, unknown>;
981
981
  } | {
982
982
  data: {
983
983
  __typename?: "MFARecoveryCodes";
@@ -993,17 +993,17 @@ declare function useCreateMfaRecoveryCodes(): {
993
993
  mutate: _tanstack_react_query.UseMutateFunction<{
994
994
  __typename?: "MFARecoveryCodes";
995
995
  recoveryCodes: string[];
996
- }, AppwriteException, void, unknown>;
996
+ }, AppwriteException[], void, unknown>;
997
997
  reset: () => void;
998
998
  context: unknown;
999
999
  failureCount: number;
1000
- failureReason: AppwriteException;
1000
+ failureReason: AppwriteException[];
1001
1001
  isPaused: boolean;
1002
1002
  submittedAt: number;
1003
1003
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1004
1004
  __typename?: "MFARecoveryCodes";
1005
1005
  recoveryCodes: string[];
1006
- }, AppwriteException, void, unknown>;
1006
+ }, AppwriteException[], void, unknown>;
1007
1007
  };
1008
1008
 
1009
1009
  declare function useCreatePhoneToken(): {
@@ -1018,20 +1018,20 @@ declare function useCreatePhoneToken(): {
1018
1018
  mutate: _tanstack_react_query.UseMutateFunction<{
1019
1019
  __typename?: "Token";
1020
1020
  expire?: any;
1021
- }, AppwriteException, Exact<{
1021
+ }, AppwriteException[], Exact<{
1022
1022
  userId: string;
1023
1023
  phone: string;
1024
1024
  }>, unknown>;
1025
1025
  reset: () => void;
1026
1026
  context: unknown;
1027
1027
  failureCount: number;
1028
- failureReason: AppwriteException;
1028
+ failureReason: AppwriteException[];
1029
1029
  isPaused: boolean;
1030
1030
  submittedAt: number;
1031
1031
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1032
1032
  __typename?: "Token";
1033
1033
  expire?: any;
1034
- }, AppwriteException, Exact<{
1034
+ }, AppwriteException[], Exact<{
1035
1035
  userId: string;
1036
1036
  phone: string;
1037
1037
  }>, unknown>;
@@ -1050,26 +1050,26 @@ declare function useCreatePhoneToken(): {
1050
1050
  mutate: _tanstack_react_query.UseMutateFunction<{
1051
1051
  __typename?: "Token";
1052
1052
  expire?: any;
1053
- }, AppwriteException, Exact<{
1053
+ }, AppwriteException[], Exact<{
1054
1054
  userId: string;
1055
1055
  phone: string;
1056
1056
  }>, unknown>;
1057
1057
  reset: () => void;
1058
1058
  context: unknown;
1059
1059
  failureCount: number;
1060
- failureReason: AppwriteException;
1060
+ failureReason: AppwriteException[];
1061
1061
  isPaused: boolean;
1062
1062
  submittedAt: number;
1063
1063
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1064
1064
  __typename?: "Token";
1065
1065
  expire?: any;
1066
- }, AppwriteException, Exact<{
1066
+ }, AppwriteException[], Exact<{
1067
1067
  userId: string;
1068
1068
  phone: string;
1069
1069
  }>, unknown>;
1070
1070
  } | {
1071
1071
  data: undefined;
1072
- error: AppwriteException;
1072
+ error: AppwriteException[];
1073
1073
  variables: Exact<{
1074
1074
  userId: string;
1075
1075
  phone: string;
@@ -1082,20 +1082,20 @@ declare function useCreatePhoneToken(): {
1082
1082
  mutate: _tanstack_react_query.UseMutateFunction<{
1083
1083
  __typename?: "Token";
1084
1084
  expire?: any;
1085
- }, AppwriteException, Exact<{
1085
+ }, AppwriteException[], Exact<{
1086
1086
  userId: string;
1087
1087
  phone: string;
1088
1088
  }>, unknown>;
1089
1089
  reset: () => void;
1090
1090
  context: unknown;
1091
1091
  failureCount: number;
1092
- failureReason: AppwriteException;
1092
+ failureReason: AppwriteException[];
1093
1093
  isPaused: boolean;
1094
1094
  submittedAt: number;
1095
1095
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1096
1096
  __typename?: "Token";
1097
1097
  expire?: any;
1098
- }, AppwriteException, Exact<{
1098
+ }, AppwriteException[], Exact<{
1099
1099
  userId: string;
1100
1100
  phone: string;
1101
1101
  }>, unknown>;
@@ -1117,20 +1117,20 @@ declare function useCreatePhoneToken(): {
1117
1117
  mutate: _tanstack_react_query.UseMutateFunction<{
1118
1118
  __typename?: "Token";
1119
1119
  expire?: any;
1120
- }, AppwriteException, Exact<{
1120
+ }, AppwriteException[], Exact<{
1121
1121
  userId: string;
1122
1122
  phone: string;
1123
1123
  }>, unknown>;
1124
1124
  reset: () => void;
1125
1125
  context: unknown;
1126
1126
  failureCount: number;
1127
- failureReason: AppwriteException;
1127
+ failureReason: AppwriteException[];
1128
1128
  isPaused: boolean;
1129
1129
  submittedAt: number;
1130
1130
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1131
1131
  __typename?: "Token";
1132
1132
  expire?: any;
1133
- }, AppwriteException, Exact<{
1133
+ }, AppwriteException[], Exact<{
1134
1134
  userId: string;
1135
1135
  phone: string;
1136
1136
  }>, unknown>;
@@ -1148,17 +1148,17 @@ declare function useCreatePhoneVerification(): {
1148
1148
  mutate: _tanstack_react_query.UseMutateFunction<{
1149
1149
  __typename?: "Token";
1150
1150
  expire?: any;
1151
- }, AppwriteException, void, unknown>;
1151
+ }, AppwriteException[], void, unknown>;
1152
1152
  reset: () => void;
1153
1153
  context: unknown;
1154
1154
  failureCount: number;
1155
- failureReason: AppwriteException;
1155
+ failureReason: AppwriteException[];
1156
1156
  isPaused: boolean;
1157
1157
  submittedAt: number;
1158
1158
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1159
1159
  __typename?: "Token";
1160
1160
  expire?: any;
1161
- }, AppwriteException, void, unknown>;
1161
+ }, AppwriteException[], void, unknown>;
1162
1162
  } | {
1163
1163
  data: undefined;
1164
1164
  variables: void;
@@ -1171,20 +1171,20 @@ declare function useCreatePhoneVerification(): {
1171
1171
  mutate: _tanstack_react_query.UseMutateFunction<{
1172
1172
  __typename?: "Token";
1173
1173
  expire?: any;
1174
- }, AppwriteException, void, unknown>;
1174
+ }, AppwriteException[], void, unknown>;
1175
1175
  reset: () => void;
1176
1176
  context: unknown;
1177
1177
  failureCount: number;
1178
- failureReason: AppwriteException;
1178
+ failureReason: AppwriteException[];
1179
1179
  isPaused: boolean;
1180
1180
  submittedAt: number;
1181
1181
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1182
1182
  __typename?: "Token";
1183
1183
  expire?: any;
1184
- }, AppwriteException, void, unknown>;
1184
+ }, AppwriteException[], void, unknown>;
1185
1185
  } | {
1186
1186
  data: undefined;
1187
- error: AppwriteException;
1187
+ error: AppwriteException[];
1188
1188
  variables: void;
1189
1189
  isError: true;
1190
1190
  isIdle: false;
@@ -1194,17 +1194,17 @@ declare function useCreatePhoneVerification(): {
1194
1194
  mutate: _tanstack_react_query.UseMutateFunction<{
1195
1195
  __typename?: "Token";
1196
1196
  expire?: any;
1197
- }, AppwriteException, void, unknown>;
1197
+ }, AppwriteException[], void, unknown>;
1198
1198
  reset: () => void;
1199
1199
  context: unknown;
1200
1200
  failureCount: number;
1201
- failureReason: AppwriteException;
1201
+ failureReason: AppwriteException[];
1202
1202
  isPaused: boolean;
1203
1203
  submittedAt: number;
1204
1204
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1205
1205
  __typename?: "Token";
1206
1206
  expire?: any;
1207
- }, AppwriteException, void, unknown>;
1207
+ }, AppwriteException[], void, unknown>;
1208
1208
  } | {
1209
1209
  data: {
1210
1210
  __typename?: "Token";
@@ -1220,17 +1220,17 @@ declare function useCreatePhoneVerification(): {
1220
1220
  mutate: _tanstack_react_query.UseMutateFunction<{
1221
1221
  __typename?: "Token";
1222
1222
  expire?: any;
1223
- }, AppwriteException, void, unknown>;
1223
+ }, AppwriteException[], void, unknown>;
1224
1224
  reset: () => void;
1225
1225
  context: unknown;
1226
1226
  failureCount: number;
1227
- failureReason: AppwriteException;
1227
+ failureReason: AppwriteException[];
1228
1228
  isPaused: boolean;
1229
1229
  submittedAt: number;
1230
1230
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1231
1231
  __typename?: "Token";
1232
1232
  expire?: any;
1233
- }, AppwriteException, void, unknown>;
1233
+ }, AppwriteException[], void, unknown>;
1234
1234
  };
1235
1235
 
1236
1236
  declare function useCreateSession(): {
@@ -1247,14 +1247,14 @@ declare function useCreateSession(): {
1247
1247
  userId?: string;
1248
1248
  expire?: any;
1249
1249
  current?: boolean;
1250
- }, AppwriteException, Exact<{
1250
+ }, AppwriteException[], Exact<{
1251
1251
  userId: string;
1252
1252
  secret: string;
1253
1253
  }>, unknown>;
1254
1254
  reset: () => void;
1255
1255
  context: unknown;
1256
1256
  failureCount: number;
1257
- failureReason: AppwriteException;
1257
+ failureReason: AppwriteException[];
1258
1258
  isPaused: boolean;
1259
1259
  submittedAt: number;
1260
1260
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -1262,7 +1262,7 @@ declare function useCreateSession(): {
1262
1262
  userId?: string;
1263
1263
  expire?: any;
1264
1264
  current?: boolean;
1265
- }, AppwriteException, Exact<{
1265
+ }, AppwriteException[], Exact<{
1266
1266
  userId: string;
1267
1267
  secret: string;
1268
1268
  }>, unknown>;
@@ -1283,14 +1283,14 @@ declare function useCreateSession(): {
1283
1283
  userId?: string;
1284
1284
  expire?: any;
1285
1285
  current?: boolean;
1286
- }, AppwriteException, Exact<{
1286
+ }, AppwriteException[], Exact<{
1287
1287
  userId: string;
1288
1288
  secret: string;
1289
1289
  }>, unknown>;
1290
1290
  reset: () => void;
1291
1291
  context: unknown;
1292
1292
  failureCount: number;
1293
- failureReason: AppwriteException;
1293
+ failureReason: AppwriteException[];
1294
1294
  isPaused: boolean;
1295
1295
  submittedAt: number;
1296
1296
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -1298,13 +1298,13 @@ declare function useCreateSession(): {
1298
1298
  userId?: string;
1299
1299
  expire?: any;
1300
1300
  current?: boolean;
1301
- }, AppwriteException, Exact<{
1301
+ }, AppwriteException[], Exact<{
1302
1302
  userId: string;
1303
1303
  secret: string;
1304
1304
  }>, unknown>;
1305
1305
  } | {
1306
1306
  data: undefined;
1307
- error: AppwriteException;
1307
+ error: AppwriteException[];
1308
1308
  variables: Exact<{
1309
1309
  userId: string;
1310
1310
  secret: string;
@@ -1319,14 +1319,14 @@ declare function useCreateSession(): {
1319
1319
  userId?: string;
1320
1320
  expire?: any;
1321
1321
  current?: boolean;
1322
- }, AppwriteException, Exact<{
1322
+ }, AppwriteException[], Exact<{
1323
1323
  userId: string;
1324
1324
  secret: string;
1325
1325
  }>, unknown>;
1326
1326
  reset: () => void;
1327
1327
  context: unknown;
1328
1328
  failureCount: number;
1329
- failureReason: AppwriteException;
1329
+ failureReason: AppwriteException[];
1330
1330
  isPaused: boolean;
1331
1331
  submittedAt: number;
1332
1332
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -1334,7 +1334,7 @@ declare function useCreateSession(): {
1334
1334
  userId?: string;
1335
1335
  expire?: any;
1336
1336
  current?: boolean;
1337
- }, AppwriteException, Exact<{
1337
+ }, AppwriteException[], Exact<{
1338
1338
  userId: string;
1339
1339
  secret: string;
1340
1340
  }>, unknown>;
@@ -1360,14 +1360,14 @@ declare function useCreateSession(): {
1360
1360
  userId?: string;
1361
1361
  expire?: any;
1362
1362
  current?: boolean;
1363
- }, AppwriteException, Exact<{
1363
+ }, AppwriteException[], Exact<{
1364
1364
  userId: string;
1365
1365
  secret: string;
1366
1366
  }>, unknown>;
1367
1367
  reset: () => void;
1368
1368
  context: unknown;
1369
1369
  failureCount: number;
1370
- failureReason: AppwriteException;
1370
+ failureReason: AppwriteException[];
1371
1371
  isPaused: boolean;
1372
1372
  submittedAt: number;
1373
1373
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -1375,7 +1375,7 @@ declare function useCreateSession(): {
1375
1375
  userId?: string;
1376
1376
  expire?: any;
1377
1377
  current?: boolean;
1378
- }, AppwriteException, Exact<{
1378
+ }, AppwriteException[], Exact<{
1379
1379
  userId: string;
1380
1380
  secret: string;
1381
1381
  }>, unknown>;
@@ -1393,19 +1393,19 @@ declare function useDeleteIdentity(): {
1393
1393
  mutate: _tanstack_react_query.UseMutateFunction<{
1394
1394
  __typename?: "Status";
1395
1395
  status?: boolean;
1396
- }, AppwriteException, Exact<{
1396
+ }, AppwriteException[], Exact<{
1397
1397
  identityId: string;
1398
1398
  }>, unknown>;
1399
1399
  reset: () => void;
1400
1400
  context: unknown;
1401
1401
  failureCount: number;
1402
- failureReason: AppwriteException;
1402
+ failureReason: AppwriteException[];
1403
1403
  isPaused: boolean;
1404
1404
  submittedAt: number;
1405
1405
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1406
1406
  __typename?: "Status";
1407
1407
  status?: boolean;
1408
- }, AppwriteException, Exact<{
1408
+ }, AppwriteException[], Exact<{
1409
1409
  identityId: string;
1410
1410
  }>, unknown>;
1411
1411
  } | {
@@ -1422,24 +1422,24 @@ declare function useDeleteIdentity(): {
1422
1422
  mutate: _tanstack_react_query.UseMutateFunction<{
1423
1423
  __typename?: "Status";
1424
1424
  status?: boolean;
1425
- }, AppwriteException, Exact<{
1425
+ }, AppwriteException[], Exact<{
1426
1426
  identityId: string;
1427
1427
  }>, unknown>;
1428
1428
  reset: () => void;
1429
1429
  context: unknown;
1430
1430
  failureCount: number;
1431
- failureReason: AppwriteException;
1431
+ failureReason: AppwriteException[];
1432
1432
  isPaused: boolean;
1433
1433
  submittedAt: number;
1434
1434
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1435
1435
  __typename?: "Status";
1436
1436
  status?: boolean;
1437
- }, AppwriteException, Exact<{
1437
+ }, AppwriteException[], Exact<{
1438
1438
  identityId: string;
1439
1439
  }>, unknown>;
1440
1440
  } | {
1441
1441
  data: undefined;
1442
- error: AppwriteException;
1442
+ error: AppwriteException[];
1443
1443
  variables: Exact<{
1444
1444
  identityId: string;
1445
1445
  }>;
@@ -1451,19 +1451,19 @@ declare function useDeleteIdentity(): {
1451
1451
  mutate: _tanstack_react_query.UseMutateFunction<{
1452
1452
  __typename?: "Status";
1453
1453
  status?: boolean;
1454
- }, AppwriteException, Exact<{
1454
+ }, AppwriteException[], Exact<{
1455
1455
  identityId: string;
1456
1456
  }>, unknown>;
1457
1457
  reset: () => void;
1458
1458
  context: unknown;
1459
1459
  failureCount: number;
1460
- failureReason: AppwriteException;
1460
+ failureReason: AppwriteException[];
1461
1461
  isPaused: boolean;
1462
1462
  submittedAt: number;
1463
1463
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1464
1464
  __typename?: "Status";
1465
1465
  status?: boolean;
1466
- }, AppwriteException, Exact<{
1466
+ }, AppwriteException[], Exact<{
1467
1467
  identityId: string;
1468
1468
  }>, unknown>;
1469
1469
  } | {
@@ -1483,19 +1483,19 @@ declare function useDeleteIdentity(): {
1483
1483
  mutate: _tanstack_react_query.UseMutateFunction<{
1484
1484
  __typename?: "Status";
1485
1485
  status?: boolean;
1486
- }, AppwriteException, Exact<{
1486
+ }, AppwriteException[], Exact<{
1487
1487
  identityId: string;
1488
1488
  }>, unknown>;
1489
1489
  reset: () => void;
1490
1490
  context: unknown;
1491
1491
  failureCount: number;
1492
- failureReason: AppwriteException;
1492
+ failureReason: AppwriteException[];
1493
1493
  isPaused: boolean;
1494
1494
  submittedAt: number;
1495
1495
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1496
1496
  __typename?: "Status";
1497
1497
  status?: boolean;
1498
- }, AppwriteException, Exact<{
1498
+ }, AppwriteException[], Exact<{
1499
1499
  identityId: string;
1500
1500
  }>, unknown>;
1501
1501
  };
@@ -1512,20 +1512,20 @@ declare function useDeleteMfaAuthenticator(): {
1512
1512
  mutate: _tanstack_react_query.UseMutateFunction<{
1513
1513
  __typename?: "User";
1514
1514
  mfa?: boolean;
1515
- }, AppwriteException, Exact<{
1515
+ }, AppwriteException[], Exact<{
1516
1516
  type: string;
1517
1517
  otp: string;
1518
1518
  }>, unknown>;
1519
1519
  reset: () => void;
1520
1520
  context: unknown;
1521
1521
  failureCount: number;
1522
- failureReason: AppwriteException;
1522
+ failureReason: AppwriteException[];
1523
1523
  isPaused: boolean;
1524
1524
  submittedAt: number;
1525
1525
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1526
1526
  __typename?: "User";
1527
1527
  mfa?: boolean;
1528
- }, AppwriteException, Exact<{
1528
+ }, AppwriteException[], Exact<{
1529
1529
  type: string;
1530
1530
  otp: string;
1531
1531
  }>, unknown>;
@@ -1544,26 +1544,26 @@ declare function useDeleteMfaAuthenticator(): {
1544
1544
  mutate: _tanstack_react_query.UseMutateFunction<{
1545
1545
  __typename?: "User";
1546
1546
  mfa?: boolean;
1547
- }, AppwriteException, Exact<{
1547
+ }, AppwriteException[], Exact<{
1548
1548
  type: string;
1549
1549
  otp: string;
1550
1550
  }>, unknown>;
1551
1551
  reset: () => void;
1552
1552
  context: unknown;
1553
1553
  failureCount: number;
1554
- failureReason: AppwriteException;
1554
+ failureReason: AppwriteException[];
1555
1555
  isPaused: boolean;
1556
1556
  submittedAt: number;
1557
1557
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1558
1558
  __typename?: "User";
1559
1559
  mfa?: boolean;
1560
- }, AppwriteException, Exact<{
1560
+ }, AppwriteException[], Exact<{
1561
1561
  type: string;
1562
1562
  otp: string;
1563
1563
  }>, unknown>;
1564
1564
  } | {
1565
1565
  data: undefined;
1566
- error: AppwriteException;
1566
+ error: AppwriteException[];
1567
1567
  variables: Exact<{
1568
1568
  type: string;
1569
1569
  otp: string;
@@ -1576,20 +1576,20 @@ declare function useDeleteMfaAuthenticator(): {
1576
1576
  mutate: _tanstack_react_query.UseMutateFunction<{
1577
1577
  __typename?: "User";
1578
1578
  mfa?: boolean;
1579
- }, AppwriteException, Exact<{
1579
+ }, AppwriteException[], Exact<{
1580
1580
  type: string;
1581
1581
  otp: string;
1582
1582
  }>, unknown>;
1583
1583
  reset: () => void;
1584
1584
  context: unknown;
1585
1585
  failureCount: number;
1586
- failureReason: AppwriteException;
1586
+ failureReason: AppwriteException[];
1587
1587
  isPaused: boolean;
1588
1588
  submittedAt: number;
1589
1589
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1590
1590
  __typename?: "User";
1591
1591
  mfa?: boolean;
1592
- }, AppwriteException, Exact<{
1592
+ }, AppwriteException[], Exact<{
1593
1593
  type: string;
1594
1594
  otp: string;
1595
1595
  }>, unknown>;
@@ -1611,20 +1611,20 @@ declare function useDeleteMfaAuthenticator(): {
1611
1611
  mutate: _tanstack_react_query.UseMutateFunction<{
1612
1612
  __typename?: "User";
1613
1613
  mfa?: boolean;
1614
- }, AppwriteException, Exact<{
1614
+ }, AppwriteException[], Exact<{
1615
1615
  type: string;
1616
1616
  otp: string;
1617
1617
  }>, unknown>;
1618
1618
  reset: () => void;
1619
1619
  context: unknown;
1620
1620
  failureCount: number;
1621
- failureReason: AppwriteException;
1621
+ failureReason: AppwriteException[];
1622
1622
  isPaused: boolean;
1623
1623
  submittedAt: number;
1624
1624
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1625
1625
  __typename?: "User";
1626
1626
  mfa?: boolean;
1627
- }, AppwriteException, Exact<{
1627
+ }, AppwriteException[], Exact<{
1628
1628
  type: string;
1629
1629
  otp: string;
1630
1630
  }>, unknown>;
@@ -1642,19 +1642,19 @@ declare function useDeleteSession(): {
1642
1642
  mutate: _tanstack_react_query.UseMutateFunction<{
1643
1643
  __typename?: "Status";
1644
1644
  status?: boolean;
1645
- }, AppwriteException, Exact<{
1645
+ }, AppwriteException[], Exact<{
1646
1646
  sessionId: string;
1647
1647
  }>, unknown>;
1648
1648
  reset: () => void;
1649
1649
  context: unknown;
1650
1650
  failureCount: number;
1651
- failureReason: AppwriteException;
1651
+ failureReason: AppwriteException[];
1652
1652
  isPaused: boolean;
1653
1653
  submittedAt: number;
1654
1654
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1655
1655
  __typename?: "Status";
1656
1656
  status?: boolean;
1657
- }, AppwriteException, Exact<{
1657
+ }, AppwriteException[], Exact<{
1658
1658
  sessionId: string;
1659
1659
  }>, unknown>;
1660
1660
  } | {
@@ -1671,24 +1671,24 @@ declare function useDeleteSession(): {
1671
1671
  mutate: _tanstack_react_query.UseMutateFunction<{
1672
1672
  __typename?: "Status";
1673
1673
  status?: boolean;
1674
- }, AppwriteException, Exact<{
1674
+ }, AppwriteException[], Exact<{
1675
1675
  sessionId: string;
1676
1676
  }>, unknown>;
1677
1677
  reset: () => void;
1678
1678
  context: unknown;
1679
1679
  failureCount: number;
1680
- failureReason: AppwriteException;
1680
+ failureReason: AppwriteException[];
1681
1681
  isPaused: boolean;
1682
1682
  submittedAt: number;
1683
1683
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1684
1684
  __typename?: "Status";
1685
1685
  status?: boolean;
1686
- }, AppwriteException, Exact<{
1686
+ }, AppwriteException[], Exact<{
1687
1687
  sessionId: string;
1688
1688
  }>, unknown>;
1689
1689
  } | {
1690
1690
  data: undefined;
1691
- error: AppwriteException;
1691
+ error: AppwriteException[];
1692
1692
  variables: Exact<{
1693
1693
  sessionId: string;
1694
1694
  }>;
@@ -1700,19 +1700,19 @@ declare function useDeleteSession(): {
1700
1700
  mutate: _tanstack_react_query.UseMutateFunction<{
1701
1701
  __typename?: "Status";
1702
1702
  status?: boolean;
1703
- }, AppwriteException, Exact<{
1703
+ }, AppwriteException[], Exact<{
1704
1704
  sessionId: string;
1705
1705
  }>, unknown>;
1706
1706
  reset: () => void;
1707
1707
  context: unknown;
1708
1708
  failureCount: number;
1709
- failureReason: AppwriteException;
1709
+ failureReason: AppwriteException[];
1710
1710
  isPaused: boolean;
1711
1711
  submittedAt: number;
1712
1712
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1713
1713
  __typename?: "Status";
1714
1714
  status?: boolean;
1715
- }, AppwriteException, Exact<{
1715
+ }, AppwriteException[], Exact<{
1716
1716
  sessionId: string;
1717
1717
  }>, unknown>;
1718
1718
  } | {
@@ -1732,19 +1732,19 @@ declare function useDeleteSession(): {
1732
1732
  mutate: _tanstack_react_query.UseMutateFunction<{
1733
1733
  __typename?: "Status";
1734
1734
  status?: boolean;
1735
- }, AppwriteException, Exact<{
1735
+ }, AppwriteException[], Exact<{
1736
1736
  sessionId: string;
1737
1737
  }>, unknown>;
1738
1738
  reset: () => void;
1739
1739
  context: unknown;
1740
1740
  failureCount: number;
1741
- failureReason: AppwriteException;
1741
+ failureReason: AppwriteException[];
1742
1742
  isPaused: boolean;
1743
1743
  submittedAt: number;
1744
1744
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1745
1745
  __typename?: "Status";
1746
1746
  status?: boolean;
1747
- }, AppwriteException, Exact<{
1747
+ }, AppwriteException[], Exact<{
1748
1748
  sessionId: string;
1749
1749
  }>, unknown>;
1750
1750
  };
@@ -1761,17 +1761,17 @@ declare function useDeleteSessions(): {
1761
1761
  mutate: _tanstack_react_query.UseMutateFunction<{
1762
1762
  __typename?: "Status";
1763
1763
  status?: boolean;
1764
- }, AppwriteException, void, unknown>;
1764
+ }, AppwriteException[], void, unknown>;
1765
1765
  reset: () => void;
1766
1766
  context: unknown;
1767
1767
  failureCount: number;
1768
- failureReason: AppwriteException;
1768
+ failureReason: AppwriteException[];
1769
1769
  isPaused: boolean;
1770
1770
  submittedAt: number;
1771
1771
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1772
1772
  __typename?: "Status";
1773
1773
  status?: boolean;
1774
- }, AppwriteException, void, unknown>;
1774
+ }, AppwriteException[], void, unknown>;
1775
1775
  } | {
1776
1776
  data: undefined;
1777
1777
  variables: void;
@@ -1784,20 +1784,20 @@ declare function useDeleteSessions(): {
1784
1784
  mutate: _tanstack_react_query.UseMutateFunction<{
1785
1785
  __typename?: "Status";
1786
1786
  status?: boolean;
1787
- }, AppwriteException, void, unknown>;
1787
+ }, AppwriteException[], void, unknown>;
1788
1788
  reset: () => void;
1789
1789
  context: unknown;
1790
1790
  failureCount: number;
1791
- failureReason: AppwriteException;
1791
+ failureReason: AppwriteException[];
1792
1792
  isPaused: boolean;
1793
1793
  submittedAt: number;
1794
1794
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1795
1795
  __typename?: "Status";
1796
1796
  status?: boolean;
1797
- }, AppwriteException, void, unknown>;
1797
+ }, AppwriteException[], void, unknown>;
1798
1798
  } | {
1799
1799
  data: undefined;
1800
- error: AppwriteException;
1800
+ error: AppwriteException[];
1801
1801
  variables: void;
1802
1802
  isError: true;
1803
1803
  isIdle: false;
@@ -1807,17 +1807,17 @@ declare function useDeleteSessions(): {
1807
1807
  mutate: _tanstack_react_query.UseMutateFunction<{
1808
1808
  __typename?: "Status";
1809
1809
  status?: boolean;
1810
- }, AppwriteException, void, unknown>;
1810
+ }, AppwriteException[], void, unknown>;
1811
1811
  reset: () => void;
1812
1812
  context: unknown;
1813
1813
  failureCount: number;
1814
- failureReason: AppwriteException;
1814
+ failureReason: AppwriteException[];
1815
1815
  isPaused: boolean;
1816
1816
  submittedAt: number;
1817
1817
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1818
1818
  __typename?: "Status";
1819
1819
  status?: boolean;
1820
- }, AppwriteException, void, unknown>;
1820
+ }, AppwriteException[], void, unknown>;
1821
1821
  } | {
1822
1822
  data: {
1823
1823
  __typename?: "Status";
@@ -1833,22 +1833,25 @@ declare function useDeleteSessions(): {
1833
1833
  mutate: _tanstack_react_query.UseMutateFunction<{
1834
1834
  __typename?: "Status";
1835
1835
  status?: boolean;
1836
- }, AppwriteException, void, unknown>;
1836
+ }, AppwriteException[], void, unknown>;
1837
1837
  reset: () => void;
1838
1838
  context: unknown;
1839
1839
  failureCount: number;
1840
- failureReason: AppwriteException;
1840
+ failureReason: AppwriteException[];
1841
1841
  isPaused: boolean;
1842
1842
  submittedAt: number;
1843
1843
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
1844
1844
  __typename?: "Status";
1845
1845
  status?: boolean;
1846
- }, AppwriteException, void, unknown>;
1846
+ }, AppwriteException[], void, unknown>;
1847
1847
  };
1848
1848
 
1849
1849
  declare function useGetMfaRecoveryCodes(): {
1850
- data: void;
1851
- error: AppwriteException;
1850
+ data: {
1851
+ __typename?: "MFARecoveryCodes";
1852
+ recoveryCodes: string[];
1853
+ };
1854
+ error: AppwriteException[];
1852
1855
  isError: true;
1853
1856
  isPending: false;
1854
1857
  isLoading: false;
@@ -1859,7 +1862,7 @@ declare function useGetMfaRecoveryCodes(): {
1859
1862
  dataUpdatedAt: number;
1860
1863
  errorUpdatedAt: number;
1861
1864
  failureCount: number;
1862
- failureReason: AppwriteException;
1865
+ failureReason: AppwriteException[];
1863
1866
  errorUpdateCount: number;
1864
1867
  isFetched: boolean;
1865
1868
  isFetchedAfterMount: boolean;
@@ -1869,10 +1872,16 @@ declare function useGetMfaRecoveryCodes(): {
1869
1872
  isPlaceholderData: boolean;
1870
1873
  isRefetching: boolean;
1871
1874
  isStale: boolean;
1872
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1875
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
1876
+ __typename?: "MFARecoveryCodes";
1877
+ recoveryCodes: string[];
1878
+ }, AppwriteException[]>>;
1873
1879
  fetchStatus: _tanstack_query_core.FetchStatus;
1874
1880
  } | {
1875
- data: void;
1881
+ data: {
1882
+ __typename?: "MFARecoveryCodes";
1883
+ recoveryCodes: string[];
1884
+ };
1876
1885
  error: null;
1877
1886
  isError: false;
1878
1887
  isPending: false;
@@ -1884,7 +1893,7 @@ declare function useGetMfaRecoveryCodes(): {
1884
1893
  dataUpdatedAt: number;
1885
1894
  errorUpdatedAt: number;
1886
1895
  failureCount: number;
1887
- failureReason: AppwriteException;
1896
+ failureReason: AppwriteException[];
1888
1897
  errorUpdateCount: number;
1889
1898
  isFetched: boolean;
1890
1899
  isFetchedAfterMount: boolean;
@@ -1894,11 +1903,14 @@ declare function useGetMfaRecoveryCodes(): {
1894
1903
  isPlaceholderData: boolean;
1895
1904
  isRefetching: boolean;
1896
1905
  isStale: boolean;
1897
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1906
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
1907
+ __typename?: "MFARecoveryCodes";
1908
+ recoveryCodes: string[];
1909
+ }, AppwriteException[]>>;
1898
1910
  fetchStatus: _tanstack_query_core.FetchStatus;
1899
1911
  } | {
1900
1912
  data: undefined;
1901
- error: AppwriteException;
1913
+ error: AppwriteException[];
1902
1914
  isError: true;
1903
1915
  isPending: false;
1904
1916
  isLoading: false;
@@ -1909,7 +1921,7 @@ declare function useGetMfaRecoveryCodes(): {
1909
1921
  dataUpdatedAt: number;
1910
1922
  errorUpdatedAt: number;
1911
1923
  failureCount: number;
1912
- failureReason: AppwriteException;
1924
+ failureReason: AppwriteException[];
1913
1925
  errorUpdateCount: number;
1914
1926
  isFetched: boolean;
1915
1927
  isFetchedAfterMount: boolean;
@@ -1919,7 +1931,10 @@ declare function useGetMfaRecoveryCodes(): {
1919
1931
  isPlaceholderData: boolean;
1920
1932
  isRefetching: boolean;
1921
1933
  isStale: boolean;
1922
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1934
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
1935
+ __typename?: "MFARecoveryCodes";
1936
+ recoveryCodes: string[];
1937
+ }, AppwriteException[]>>;
1923
1938
  fetchStatus: _tanstack_query_core.FetchStatus;
1924
1939
  } | {
1925
1940
  data: undefined;
@@ -1934,7 +1949,7 @@ declare function useGetMfaRecoveryCodes(): {
1934
1949
  dataUpdatedAt: number;
1935
1950
  errorUpdatedAt: number;
1936
1951
  failureCount: number;
1937
- failureReason: AppwriteException;
1952
+ failureReason: AppwriteException[];
1938
1953
  errorUpdateCount: number;
1939
1954
  isFetched: boolean;
1940
1955
  isFetchedAfterMount: boolean;
@@ -1944,7 +1959,10 @@ declare function useGetMfaRecoveryCodes(): {
1944
1959
  isPlaceholderData: boolean;
1945
1960
  isRefetching: boolean;
1946
1961
  isStale: boolean;
1947
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1962
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
1963
+ __typename?: "MFARecoveryCodes";
1964
+ recoveryCodes: string[];
1965
+ }, AppwriteException[]>>;
1948
1966
  fetchStatus: _tanstack_query_core.FetchStatus;
1949
1967
  } | {
1950
1968
  data: undefined;
@@ -1958,7 +1976,7 @@ declare function useGetMfaRecoveryCodes(): {
1958
1976
  dataUpdatedAt: number;
1959
1977
  errorUpdatedAt: number;
1960
1978
  failureCount: number;
1961
- failureReason: AppwriteException;
1979
+ failureReason: AppwriteException[];
1962
1980
  errorUpdateCount: number;
1963
1981
  isFetched: boolean;
1964
1982
  isFetchedAfterMount: boolean;
@@ -1969,13 +1987,19 @@ declare function useGetMfaRecoveryCodes(): {
1969
1987
  isPlaceholderData: boolean;
1970
1988
  isRefetching: boolean;
1971
1989
  isStale: boolean;
1972
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
1990
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
1991
+ __typename?: "MFARecoveryCodes";
1992
+ recoveryCodes: string[];
1993
+ }, AppwriteException[]>>;
1973
1994
  fetchStatus: _tanstack_query_core.FetchStatus;
1974
1995
  };
1975
1996
 
1976
1997
  declare function useGetPrefs(): {
1977
- data: void;
1978
- error: AppwriteException;
1998
+ data: {
1999
+ __typename?: "Preferences";
2000
+ data?: any;
2001
+ };
2002
+ error: AppwriteException[];
1979
2003
  isError: true;
1980
2004
  isPending: false;
1981
2005
  isLoading: false;
@@ -1986,7 +2010,7 @@ declare function useGetPrefs(): {
1986
2010
  dataUpdatedAt: number;
1987
2011
  errorUpdatedAt: number;
1988
2012
  failureCount: number;
1989
- failureReason: AppwriteException;
2013
+ failureReason: AppwriteException[];
1990
2014
  errorUpdateCount: number;
1991
2015
  isFetched: boolean;
1992
2016
  isFetchedAfterMount: boolean;
@@ -1996,10 +2020,16 @@ declare function useGetPrefs(): {
1996
2020
  isPlaceholderData: boolean;
1997
2021
  isRefetching: boolean;
1998
2022
  isStale: boolean;
1999
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
2023
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2024
+ __typename?: "Preferences";
2025
+ data?: any;
2026
+ }, AppwriteException[]>>;
2000
2027
  fetchStatus: _tanstack_query_core.FetchStatus;
2001
2028
  } | {
2002
- data: void;
2029
+ data: {
2030
+ __typename?: "Preferences";
2031
+ data?: any;
2032
+ };
2003
2033
  error: null;
2004
2034
  isError: false;
2005
2035
  isPending: false;
@@ -2011,7 +2041,7 @@ declare function useGetPrefs(): {
2011
2041
  dataUpdatedAt: number;
2012
2042
  errorUpdatedAt: number;
2013
2043
  failureCount: number;
2014
- failureReason: AppwriteException;
2044
+ failureReason: AppwriteException[];
2015
2045
  errorUpdateCount: number;
2016
2046
  isFetched: boolean;
2017
2047
  isFetchedAfterMount: boolean;
@@ -2021,11 +2051,14 @@ declare function useGetPrefs(): {
2021
2051
  isPlaceholderData: boolean;
2022
2052
  isRefetching: boolean;
2023
2053
  isStale: boolean;
2024
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
2054
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2055
+ __typename?: "Preferences";
2056
+ data?: any;
2057
+ }, AppwriteException[]>>;
2025
2058
  fetchStatus: _tanstack_query_core.FetchStatus;
2026
2059
  } | {
2027
2060
  data: undefined;
2028
- error: AppwriteException;
2061
+ error: AppwriteException[];
2029
2062
  isError: true;
2030
2063
  isPending: false;
2031
2064
  isLoading: false;
@@ -2036,7 +2069,7 @@ declare function useGetPrefs(): {
2036
2069
  dataUpdatedAt: number;
2037
2070
  errorUpdatedAt: number;
2038
2071
  failureCount: number;
2039
- failureReason: AppwriteException;
2072
+ failureReason: AppwriteException[];
2040
2073
  errorUpdateCount: number;
2041
2074
  isFetched: boolean;
2042
2075
  isFetchedAfterMount: boolean;
@@ -2046,7 +2079,10 @@ declare function useGetPrefs(): {
2046
2079
  isPlaceholderData: boolean;
2047
2080
  isRefetching: boolean;
2048
2081
  isStale: boolean;
2049
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
2082
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2083
+ __typename?: "Preferences";
2084
+ data?: any;
2085
+ }, AppwriteException[]>>;
2050
2086
  fetchStatus: _tanstack_query_core.FetchStatus;
2051
2087
  } | {
2052
2088
  data: undefined;
@@ -2061,7 +2097,7 @@ declare function useGetPrefs(): {
2061
2097
  dataUpdatedAt: number;
2062
2098
  errorUpdatedAt: number;
2063
2099
  failureCount: number;
2064
- failureReason: AppwriteException;
2100
+ failureReason: AppwriteException[];
2065
2101
  errorUpdateCount: number;
2066
2102
  isFetched: boolean;
2067
2103
  isFetchedAfterMount: boolean;
@@ -2071,7 +2107,10 @@ declare function useGetPrefs(): {
2071
2107
  isPlaceholderData: boolean;
2072
2108
  isRefetching: boolean;
2073
2109
  isStale: boolean;
2074
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
2110
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2111
+ __typename?: "Preferences";
2112
+ data?: any;
2113
+ }, AppwriteException[]>>;
2075
2114
  fetchStatus: _tanstack_query_core.FetchStatus;
2076
2115
  } | {
2077
2116
  data: undefined;
@@ -2085,7 +2124,7 @@ declare function useGetPrefs(): {
2085
2124
  dataUpdatedAt: number;
2086
2125
  errorUpdatedAt: number;
2087
2126
  failureCount: number;
2088
- failureReason: AppwriteException;
2127
+ failureReason: AppwriteException[];
2089
2128
  errorUpdateCount: number;
2090
2129
  isFetched: boolean;
2091
2130
  isFetchedAfterMount: boolean;
@@ -2096,16 +2135,16 @@ declare function useGetPrefs(): {
2096
2135
  isPlaceholderData: boolean;
2097
2136
  isRefetching: boolean;
2098
2137
  isStale: boolean;
2099
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<void, AppwriteException>>;
2138
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<{
2139
+ __typename?: "Preferences";
2140
+ data?: any;
2141
+ }, AppwriteException[]>>;
2100
2142
  fetchStatus: _tanstack_query_core.FetchStatus;
2101
2143
  };
2102
2144
 
2103
- declare function useGetSession({ sessionId }: GetSessionQueryVariables): _tanstack_react_query.UseQueryResult<{
2104
- __typename?: "Session";
2105
- userId?: string;
2106
- expire?: any;
2107
- current?: boolean;
2108
- }, AppwriteException>;
2145
+ declare function useGetSession({ sessionId }: GetSessionQueryVariables): _tanstack_react_query.UseQueryResult<Exact<{
2146
+ sessionId: string;
2147
+ }>, AppwriteException[]>;
2109
2148
 
2110
2149
  declare function useListIdentities(): {
2111
2150
  data: {
@@ -2119,7 +2158,7 @@ declare function useListIdentities(): {
2119
2158
  };
2120
2159
  })[];
2121
2160
  };
2122
- error: AppwriteException;
2161
+ error: AppwriteException[];
2123
2162
  isError: true;
2124
2163
  isPending: false;
2125
2164
  isLoading: false;
@@ -2130,7 +2169,7 @@ declare function useListIdentities(): {
2130
2169
  dataUpdatedAt: number;
2131
2170
  errorUpdatedAt: number;
2132
2171
  failureCount: number;
2133
- failureReason: AppwriteException;
2172
+ failureReason: AppwriteException[];
2134
2173
  errorUpdateCount: number;
2135
2174
  isFetched: boolean;
2136
2175
  isFetchedAfterMount: boolean;
@@ -2150,7 +2189,7 @@ declare function useListIdentities(): {
2150
2189
  Identity_ProviderFragment: Identity_ProviderFragment;
2151
2190
  };
2152
2191
  })[];
2153
- }, AppwriteException>>;
2192
+ }, AppwriteException[]>>;
2154
2193
  fetchStatus: _tanstack_query_core.FetchStatus;
2155
2194
  } | {
2156
2195
  data: {
@@ -2175,7 +2214,7 @@ declare function useListIdentities(): {
2175
2214
  dataUpdatedAt: number;
2176
2215
  errorUpdatedAt: number;
2177
2216
  failureCount: number;
2178
- failureReason: AppwriteException;
2217
+ failureReason: AppwriteException[];
2179
2218
  errorUpdateCount: number;
2180
2219
  isFetched: boolean;
2181
2220
  isFetchedAfterMount: boolean;
@@ -2195,11 +2234,11 @@ declare function useListIdentities(): {
2195
2234
  Identity_ProviderFragment: Identity_ProviderFragment;
2196
2235
  };
2197
2236
  })[];
2198
- }, AppwriteException>>;
2237
+ }, AppwriteException[]>>;
2199
2238
  fetchStatus: _tanstack_query_core.FetchStatus;
2200
2239
  } | {
2201
2240
  data: undefined;
2202
- error: AppwriteException;
2241
+ error: AppwriteException[];
2203
2242
  isError: true;
2204
2243
  isPending: false;
2205
2244
  isLoading: false;
@@ -2210,7 +2249,7 @@ declare function useListIdentities(): {
2210
2249
  dataUpdatedAt: number;
2211
2250
  errorUpdatedAt: number;
2212
2251
  failureCount: number;
2213
- failureReason: AppwriteException;
2252
+ failureReason: AppwriteException[];
2214
2253
  errorUpdateCount: number;
2215
2254
  isFetched: boolean;
2216
2255
  isFetchedAfterMount: boolean;
@@ -2230,7 +2269,7 @@ declare function useListIdentities(): {
2230
2269
  Identity_ProviderFragment: Identity_ProviderFragment;
2231
2270
  };
2232
2271
  })[];
2233
- }, AppwriteException>>;
2272
+ }, AppwriteException[]>>;
2234
2273
  fetchStatus: _tanstack_query_core.FetchStatus;
2235
2274
  } | {
2236
2275
  data: undefined;
@@ -2245,7 +2284,7 @@ declare function useListIdentities(): {
2245
2284
  dataUpdatedAt: number;
2246
2285
  errorUpdatedAt: number;
2247
2286
  failureCount: number;
2248
- failureReason: AppwriteException;
2287
+ failureReason: AppwriteException[];
2249
2288
  errorUpdateCount: number;
2250
2289
  isFetched: boolean;
2251
2290
  isFetchedAfterMount: boolean;
@@ -2265,7 +2304,7 @@ declare function useListIdentities(): {
2265
2304
  Identity_ProviderFragment: Identity_ProviderFragment;
2266
2305
  };
2267
2306
  })[];
2268
- }, AppwriteException>>;
2307
+ }, AppwriteException[]>>;
2269
2308
  fetchStatus: _tanstack_query_core.FetchStatus;
2270
2309
  } | {
2271
2310
  data: undefined;
@@ -2279,7 +2318,7 @@ declare function useListIdentities(): {
2279
2318
  dataUpdatedAt: number;
2280
2319
  errorUpdatedAt: number;
2281
2320
  failureCount: number;
2282
- failureReason: AppwriteException;
2321
+ failureReason: AppwriteException[];
2283
2322
  errorUpdateCount: number;
2284
2323
  isFetched: boolean;
2285
2324
  isFetchedAfterMount: boolean;
@@ -2300,7 +2339,7 @@ declare function useListIdentities(): {
2300
2339
  Identity_ProviderFragment: Identity_ProviderFragment;
2301
2340
  };
2302
2341
  })[];
2303
- }, AppwriteException>>;
2342
+ }, AppwriteException[]>>;
2304
2343
  fetchStatus: _tanstack_query_core.FetchStatus;
2305
2344
  };
2306
2345
 
@@ -2311,7 +2350,7 @@ declare function useListMfaFactors(): {
2311
2350
  phone?: boolean;
2312
2351
  email?: boolean;
2313
2352
  };
2314
- error: AppwriteException;
2353
+ error: AppwriteException[];
2315
2354
  isError: true;
2316
2355
  isPending: false;
2317
2356
  isLoading: false;
@@ -2322,7 +2361,7 @@ declare function useListMfaFactors(): {
2322
2361
  dataUpdatedAt: number;
2323
2362
  errorUpdatedAt: number;
2324
2363
  failureCount: number;
2325
- failureReason: AppwriteException;
2364
+ failureReason: AppwriteException[];
2326
2365
  errorUpdateCount: number;
2327
2366
  isFetched: boolean;
2328
2367
  isFetchedAfterMount: boolean;
@@ -2337,7 +2376,7 @@ declare function useListMfaFactors(): {
2337
2376
  totp?: boolean;
2338
2377
  phone?: boolean;
2339
2378
  email?: boolean;
2340
- }, AppwriteException>>;
2379
+ }, AppwriteException[]>>;
2341
2380
  fetchStatus: _tanstack_query_core.FetchStatus;
2342
2381
  } | {
2343
2382
  data: {
@@ -2357,7 +2396,7 @@ declare function useListMfaFactors(): {
2357
2396
  dataUpdatedAt: number;
2358
2397
  errorUpdatedAt: number;
2359
2398
  failureCount: number;
2360
- failureReason: AppwriteException;
2399
+ failureReason: AppwriteException[];
2361
2400
  errorUpdateCount: number;
2362
2401
  isFetched: boolean;
2363
2402
  isFetchedAfterMount: boolean;
@@ -2372,11 +2411,11 @@ declare function useListMfaFactors(): {
2372
2411
  totp?: boolean;
2373
2412
  phone?: boolean;
2374
2413
  email?: boolean;
2375
- }, AppwriteException>>;
2414
+ }, AppwriteException[]>>;
2376
2415
  fetchStatus: _tanstack_query_core.FetchStatus;
2377
2416
  } | {
2378
2417
  data: undefined;
2379
- error: AppwriteException;
2418
+ error: AppwriteException[];
2380
2419
  isError: true;
2381
2420
  isPending: false;
2382
2421
  isLoading: false;
@@ -2387,7 +2426,7 @@ declare function useListMfaFactors(): {
2387
2426
  dataUpdatedAt: number;
2388
2427
  errorUpdatedAt: number;
2389
2428
  failureCount: number;
2390
- failureReason: AppwriteException;
2429
+ failureReason: AppwriteException[];
2391
2430
  errorUpdateCount: number;
2392
2431
  isFetched: boolean;
2393
2432
  isFetchedAfterMount: boolean;
@@ -2402,7 +2441,7 @@ declare function useListMfaFactors(): {
2402
2441
  totp?: boolean;
2403
2442
  phone?: boolean;
2404
2443
  email?: boolean;
2405
- }, AppwriteException>>;
2444
+ }, AppwriteException[]>>;
2406
2445
  fetchStatus: _tanstack_query_core.FetchStatus;
2407
2446
  } | {
2408
2447
  data: undefined;
@@ -2417,7 +2456,7 @@ declare function useListMfaFactors(): {
2417
2456
  dataUpdatedAt: number;
2418
2457
  errorUpdatedAt: number;
2419
2458
  failureCount: number;
2420
- failureReason: AppwriteException;
2459
+ failureReason: AppwriteException[];
2421
2460
  errorUpdateCount: number;
2422
2461
  isFetched: boolean;
2423
2462
  isFetchedAfterMount: boolean;
@@ -2432,7 +2471,7 @@ declare function useListMfaFactors(): {
2432
2471
  totp?: boolean;
2433
2472
  phone?: boolean;
2434
2473
  email?: boolean;
2435
- }, AppwriteException>>;
2474
+ }, AppwriteException[]>>;
2436
2475
  fetchStatus: _tanstack_query_core.FetchStatus;
2437
2476
  } | {
2438
2477
  data: undefined;
@@ -2446,7 +2485,7 @@ declare function useListMfaFactors(): {
2446
2485
  dataUpdatedAt: number;
2447
2486
  errorUpdatedAt: number;
2448
2487
  failureCount: number;
2449
- failureReason: AppwriteException;
2488
+ failureReason: AppwriteException[];
2450
2489
  errorUpdateCount: number;
2451
2490
  isFetched: boolean;
2452
2491
  isFetchedAfterMount: boolean;
@@ -2462,7 +2501,7 @@ declare function useListMfaFactors(): {
2462
2501
  totp?: boolean;
2463
2502
  phone?: boolean;
2464
2503
  email?: boolean;
2465
- }, AppwriteException>>;
2504
+ }, AppwriteException[]>>;
2466
2505
  fetchStatus: _tanstack_query_core.FetchStatus;
2467
2506
  };
2468
2507
 
@@ -2477,7 +2516,7 @@ declare function useListSessions(): {
2477
2516
  clientName?: string;
2478
2517
  }[];
2479
2518
  };
2480
- error: AppwriteException;
2519
+ error: AppwriteException[];
2481
2520
  isError: true;
2482
2521
  isPending: false;
2483
2522
  isLoading: false;
@@ -2488,7 +2527,7 @@ declare function useListSessions(): {
2488
2527
  dataUpdatedAt: number;
2489
2528
  errorUpdatedAt: number;
2490
2529
  failureCount: number;
2491
- failureReason: AppwriteException;
2530
+ failureReason: AppwriteException[];
2492
2531
  errorUpdateCount: number;
2493
2532
  isFetched: boolean;
2494
2533
  isFetchedAfterMount: boolean;
@@ -2507,7 +2546,7 @@ declare function useListSessions(): {
2507
2546
  osName?: string;
2508
2547
  clientName?: string;
2509
2548
  }[];
2510
- }, AppwriteException>>;
2549
+ }, AppwriteException[]>>;
2511
2550
  fetchStatus: _tanstack_query_core.FetchStatus;
2512
2551
  } | {
2513
2552
  data: {
@@ -2531,7 +2570,7 @@ declare function useListSessions(): {
2531
2570
  dataUpdatedAt: number;
2532
2571
  errorUpdatedAt: number;
2533
2572
  failureCount: number;
2534
- failureReason: AppwriteException;
2573
+ failureReason: AppwriteException[];
2535
2574
  errorUpdateCount: number;
2536
2575
  isFetched: boolean;
2537
2576
  isFetchedAfterMount: boolean;
@@ -2550,11 +2589,11 @@ declare function useListSessions(): {
2550
2589
  osName?: string;
2551
2590
  clientName?: string;
2552
2591
  }[];
2553
- }, AppwriteException>>;
2592
+ }, AppwriteException[]>>;
2554
2593
  fetchStatus: _tanstack_query_core.FetchStatus;
2555
2594
  } | {
2556
2595
  data: undefined;
2557
- error: AppwriteException;
2596
+ error: AppwriteException[];
2558
2597
  isError: true;
2559
2598
  isPending: false;
2560
2599
  isLoading: false;
@@ -2565,7 +2604,7 @@ declare function useListSessions(): {
2565
2604
  dataUpdatedAt: number;
2566
2605
  errorUpdatedAt: number;
2567
2606
  failureCount: number;
2568
- failureReason: AppwriteException;
2607
+ failureReason: AppwriteException[];
2569
2608
  errorUpdateCount: number;
2570
2609
  isFetched: boolean;
2571
2610
  isFetchedAfterMount: boolean;
@@ -2584,7 +2623,7 @@ declare function useListSessions(): {
2584
2623
  osName?: string;
2585
2624
  clientName?: string;
2586
2625
  }[];
2587
- }, AppwriteException>>;
2626
+ }, AppwriteException[]>>;
2588
2627
  fetchStatus: _tanstack_query_core.FetchStatus;
2589
2628
  } | {
2590
2629
  data: undefined;
@@ -2599,7 +2638,7 @@ declare function useListSessions(): {
2599
2638
  dataUpdatedAt: number;
2600
2639
  errorUpdatedAt: number;
2601
2640
  failureCount: number;
2602
- failureReason: AppwriteException;
2641
+ failureReason: AppwriteException[];
2603
2642
  errorUpdateCount: number;
2604
2643
  isFetched: boolean;
2605
2644
  isFetchedAfterMount: boolean;
@@ -2618,7 +2657,7 @@ declare function useListSessions(): {
2618
2657
  osName?: string;
2619
2658
  clientName?: string;
2620
2659
  }[];
2621
- }, AppwriteException>>;
2660
+ }, AppwriteException[]>>;
2622
2661
  fetchStatus: _tanstack_query_core.FetchStatus;
2623
2662
  } | {
2624
2663
  data: undefined;
@@ -2632,7 +2671,7 @@ declare function useListSessions(): {
2632
2671
  dataUpdatedAt: number;
2633
2672
  errorUpdatedAt: number;
2634
2673
  failureCount: number;
2635
- failureReason: AppwriteException;
2674
+ failureReason: AppwriteException[];
2636
2675
  errorUpdateCount: number;
2637
2676
  isFetched: boolean;
2638
2677
  isFetchedAfterMount: boolean;
@@ -2652,7 +2691,7 @@ declare function useListSessions(): {
2652
2691
  osName?: string;
2653
2692
  clientName?: string;
2654
2693
  }[];
2655
- }, AppwriteException>>;
2694
+ }, AppwriteException[]>>;
2656
2695
  fetchStatus: _tanstack_query_core.FetchStatus;
2657
2696
  };
2658
2697
 
@@ -2667,18 +2706,18 @@ declare function useLogin(): {
2667
2706
  userId?: string;
2668
2707
  expire?: any;
2669
2708
  current?: boolean;
2670
- }, AppwriteException, Exact<{
2709
+ }, AppwriteException[], Exact<{
2671
2710
  email: string;
2672
2711
  password: string;
2673
2712
  }>, unknown>;
2674
- oAuthLogin: _tanstack_react_query.UseMutationResult<void | URL, AppwriteException, OAuthLoginProps, unknown>;
2713
+ oAuthLogin: _tanstack_react_query.UseMutationResult<void | URL, AppwriteException[], OAuthLoginProps, unknown>;
2675
2714
  };
2676
2715
 
2677
2716
  declare function useLogout(): {
2678
2717
  mutate: _tanstack_react_query.UseMutateFunction<{
2679
2718
  __typename?: "Status";
2680
2719
  status?: boolean;
2681
- }, AppwriteException, Exact<{
2720
+ }, AppwriteException[], Exact<{
2682
2721
  sessionId: string;
2683
2722
  }>, unknown>;
2684
2723
  data: undefined;
@@ -2692,20 +2731,20 @@ declare function useLogout(): {
2692
2731
  reset: () => void;
2693
2732
  context: unknown;
2694
2733
  failureCount: number;
2695
- failureReason: AppwriteException;
2734
+ failureReason: AppwriteException[];
2696
2735
  isPaused: boolean;
2697
2736
  submittedAt: number;
2698
2737
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
2699
2738
  __typename?: "Status";
2700
2739
  status?: boolean;
2701
- }, AppwriteException, Exact<{
2740
+ }, AppwriteException[], Exact<{
2702
2741
  sessionId: string;
2703
2742
  }>, unknown>;
2704
2743
  } | {
2705
2744
  mutate: _tanstack_react_query.UseMutateFunction<{
2706
2745
  __typename?: "Status";
2707
2746
  status?: boolean;
2708
- }, AppwriteException, Exact<{
2747
+ }, AppwriteException[], Exact<{
2709
2748
  sessionId: string;
2710
2749
  }>, unknown>;
2711
2750
  data: undefined;
@@ -2721,24 +2760,24 @@ declare function useLogout(): {
2721
2760
  reset: () => void;
2722
2761
  context: unknown;
2723
2762
  failureCount: number;
2724
- failureReason: AppwriteException;
2763
+ failureReason: AppwriteException[];
2725
2764
  isPaused: boolean;
2726
2765
  submittedAt: number;
2727
2766
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
2728
2767
  __typename?: "Status";
2729
2768
  status?: boolean;
2730
- }, AppwriteException, Exact<{
2769
+ }, AppwriteException[], Exact<{
2731
2770
  sessionId: string;
2732
2771
  }>, unknown>;
2733
2772
  } | {
2734
2773
  mutate: _tanstack_react_query.UseMutateFunction<{
2735
2774
  __typename?: "Status";
2736
2775
  status?: boolean;
2737
- }, AppwriteException, Exact<{
2776
+ }, AppwriteException[], Exact<{
2738
2777
  sessionId: string;
2739
2778
  }>, unknown>;
2740
2779
  data: undefined;
2741
- error: AppwriteException;
2780
+ error: AppwriteException[];
2742
2781
  variables: Exact<{
2743
2782
  sessionId: string;
2744
2783
  }>;
@@ -2750,20 +2789,20 @@ declare function useLogout(): {
2750
2789
  reset: () => void;
2751
2790
  context: unknown;
2752
2791
  failureCount: number;
2753
- failureReason: AppwriteException;
2792
+ failureReason: AppwriteException[];
2754
2793
  isPaused: boolean;
2755
2794
  submittedAt: number;
2756
2795
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
2757
2796
  __typename?: "Status";
2758
2797
  status?: boolean;
2759
- }, AppwriteException, Exact<{
2798
+ }, AppwriteException[], Exact<{
2760
2799
  sessionId: string;
2761
2800
  }>, unknown>;
2762
2801
  } | {
2763
2802
  mutate: _tanstack_react_query.UseMutateFunction<{
2764
2803
  __typename?: "Status";
2765
2804
  status?: boolean;
2766
- }, AppwriteException, Exact<{
2805
+ }, AppwriteException[], Exact<{
2767
2806
  sessionId: string;
2768
2807
  }>, unknown>;
2769
2808
  data: {
@@ -2782,13 +2821,13 @@ declare function useLogout(): {
2782
2821
  reset: () => void;
2783
2822
  context: unknown;
2784
2823
  failureCount: number;
2785
- failureReason: AppwriteException;
2824
+ failureReason: AppwriteException[];
2786
2825
  isPaused: boolean;
2787
2826
  submittedAt: number;
2788
2827
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
2789
2828
  __typename?: "Status";
2790
2829
  status?: boolean;
2791
- }, AppwriteException, Exact<{
2830
+ }, AppwriteException[], Exact<{
2792
2831
  sessionId: string;
2793
2832
  }>, unknown>;
2794
2833
  };
@@ -2822,7 +2861,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2822
2861
  countryName?: string;
2823
2862
  }[];
2824
2863
  };
2825
- error: AppwriteException;
2864
+ error: AppwriteException[];
2826
2865
  isError: true;
2827
2866
  isPending: false;
2828
2867
  isLoading: false;
@@ -2833,7 +2872,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2833
2872
  dataUpdatedAt: number;
2834
2873
  errorUpdatedAt: number;
2835
2874
  failureCount: number;
2836
- failureReason: AppwriteException;
2875
+ failureReason: AppwriteException[];
2837
2876
  errorUpdateCount: number;
2838
2877
  isFetched: boolean;
2839
2878
  isFetchedAfterMount: boolean;
@@ -2870,7 +2909,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2870
2909
  countryCode?: string;
2871
2910
  countryName?: string;
2872
2911
  }[];
2873
- }, AppwriteException>>;
2912
+ }, AppwriteException[]>>;
2874
2913
  fetchStatus: _tanstack_react_query.FetchStatus;
2875
2914
  } | {
2876
2915
  data: {
@@ -2912,7 +2951,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2912
2951
  dataUpdatedAt: number;
2913
2952
  errorUpdatedAt: number;
2914
2953
  failureCount: number;
2915
- failureReason: AppwriteException;
2954
+ failureReason: AppwriteException[];
2916
2955
  errorUpdateCount: number;
2917
2956
  isFetched: boolean;
2918
2957
  isFetchedAfterMount: boolean;
@@ -2949,11 +2988,11 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2949
2988
  countryCode?: string;
2950
2989
  countryName?: string;
2951
2990
  }[];
2952
- }, AppwriteException>>;
2991
+ }, AppwriteException[]>>;
2953
2992
  fetchStatus: _tanstack_react_query.FetchStatus;
2954
2993
  } | {
2955
2994
  data: undefined;
2956
- error: AppwriteException;
2995
+ error: AppwriteException[];
2957
2996
  isError: true;
2958
2997
  isPending: false;
2959
2998
  isLoading: false;
@@ -2964,7 +3003,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
2964
3003
  dataUpdatedAt: number;
2965
3004
  errorUpdatedAt: number;
2966
3005
  failureCount: number;
2967
- failureReason: AppwriteException;
3006
+ failureReason: AppwriteException[];
2968
3007
  errorUpdateCount: number;
2969
3008
  isFetched: boolean;
2970
3009
  isFetchedAfterMount: boolean;
@@ -3001,7 +3040,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
3001
3040
  countryCode?: string;
3002
3041
  countryName?: string;
3003
3042
  }[];
3004
- }, AppwriteException>>;
3043
+ }, AppwriteException[]>>;
3005
3044
  fetchStatus: _tanstack_react_query.FetchStatus;
3006
3045
  } | {
3007
3046
  data: undefined;
@@ -3016,7 +3055,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
3016
3055
  dataUpdatedAt: number;
3017
3056
  errorUpdatedAt: number;
3018
3057
  failureCount: number;
3019
- failureReason: AppwriteException;
3058
+ failureReason: AppwriteException[];
3020
3059
  errorUpdateCount: number;
3021
3060
  isFetched: boolean;
3022
3061
  isFetchedAfterMount: boolean;
@@ -3053,7 +3092,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
3053
3092
  countryCode?: string;
3054
3093
  countryName?: string;
3055
3094
  }[];
3056
- }, AppwriteException>>;
3095
+ }, AppwriteException[]>>;
3057
3096
  fetchStatus: _tanstack_react_query.FetchStatus;
3058
3097
  } | {
3059
3098
  data: undefined;
@@ -3067,7 +3106,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
3067
3106
  dataUpdatedAt: number;
3068
3107
  errorUpdatedAt: number;
3069
3108
  failureCount: number;
3070
- failureReason: AppwriteException;
3109
+ failureReason: AppwriteException[];
3071
3110
  errorUpdateCount: number;
3072
3111
  isFetched: boolean;
3073
3112
  isFetchedAfterMount: boolean;
@@ -3105,7 +3144,7 @@ declare function useLogs({ queries }: ListLogsQueryVariables): {
3105
3144
  countryCode?: string;
3106
3145
  countryName?: string;
3107
3146
  }[];
3108
- }, AppwriteException>>;
3147
+ }, AppwriteException[]>>;
3109
3148
  fetchStatus: _tanstack_react_query.FetchStatus;
3110
3149
  };
3111
3150
 
@@ -3124,20 +3163,20 @@ declare function usePasswordRecovery(): {
3124
3163
  mutate: _tanstack_react_query.UseMutateFunction<{
3125
3164
  __typename?: "Token";
3126
3165
  expire?: any;
3127
- }, AppwriteException, Exact<{
3166
+ }, AppwriteException[], Exact<{
3128
3167
  email: string;
3129
3168
  url: string;
3130
3169
  }>, unknown>;
3131
3170
  reset: () => void;
3132
3171
  context: unknown;
3133
3172
  failureCount: number;
3134
- failureReason: AppwriteException;
3173
+ failureReason: AppwriteException[];
3135
3174
  isPaused: boolean;
3136
3175
  submittedAt: number;
3137
3176
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3138
3177
  __typename?: "Token";
3139
3178
  expire?: any;
3140
- }, AppwriteException, Exact<{
3179
+ }, AppwriteException[], Exact<{
3141
3180
  email: string;
3142
3181
  url: string;
3143
3182
  }>, unknown>;
@@ -3156,26 +3195,26 @@ declare function usePasswordRecovery(): {
3156
3195
  mutate: _tanstack_react_query.UseMutateFunction<{
3157
3196
  __typename?: "Token";
3158
3197
  expire?: any;
3159
- }, AppwriteException, Exact<{
3198
+ }, AppwriteException[], Exact<{
3160
3199
  email: string;
3161
3200
  url: string;
3162
3201
  }>, unknown>;
3163
3202
  reset: () => void;
3164
3203
  context: unknown;
3165
3204
  failureCount: number;
3166
- failureReason: AppwriteException;
3205
+ failureReason: AppwriteException[];
3167
3206
  isPaused: boolean;
3168
3207
  submittedAt: number;
3169
3208
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3170
3209
  __typename?: "Token";
3171
3210
  expire?: any;
3172
- }, AppwriteException, Exact<{
3211
+ }, AppwriteException[], Exact<{
3173
3212
  email: string;
3174
3213
  url: string;
3175
3214
  }>, unknown>;
3176
3215
  } | {
3177
3216
  data: undefined;
3178
- error: AppwriteException;
3217
+ error: AppwriteException[];
3179
3218
  variables: Exact<{
3180
3219
  email: string;
3181
3220
  url: string;
@@ -3188,20 +3227,20 @@ declare function usePasswordRecovery(): {
3188
3227
  mutate: _tanstack_react_query.UseMutateFunction<{
3189
3228
  __typename?: "Token";
3190
3229
  expire?: any;
3191
- }, AppwriteException, Exact<{
3230
+ }, AppwriteException[], Exact<{
3192
3231
  email: string;
3193
3232
  url: string;
3194
3233
  }>, unknown>;
3195
3234
  reset: () => void;
3196
3235
  context: unknown;
3197
3236
  failureCount: number;
3198
- failureReason: AppwriteException;
3237
+ failureReason: AppwriteException[];
3199
3238
  isPaused: boolean;
3200
3239
  submittedAt: number;
3201
3240
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3202
3241
  __typename?: "Token";
3203
3242
  expire?: any;
3204
- }, AppwriteException, Exact<{
3243
+ }, AppwriteException[], Exact<{
3205
3244
  email: string;
3206
3245
  url: string;
3207
3246
  }>, unknown>;
@@ -3223,20 +3262,20 @@ declare function usePasswordRecovery(): {
3223
3262
  mutate: _tanstack_react_query.UseMutateFunction<{
3224
3263
  __typename?: "Token";
3225
3264
  expire?: any;
3226
- }, AppwriteException, Exact<{
3265
+ }, AppwriteException[], Exact<{
3227
3266
  email: string;
3228
3267
  url: string;
3229
3268
  }>, unknown>;
3230
3269
  reset: () => void;
3231
3270
  context: unknown;
3232
3271
  failureCount: number;
3233
- failureReason: AppwriteException;
3272
+ failureReason: AppwriteException[];
3234
3273
  isPaused: boolean;
3235
3274
  submittedAt: number;
3236
3275
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3237
3276
  __typename?: "Token";
3238
3277
  expire?: any;
3239
- }, AppwriteException, Exact<{
3278
+ }, AppwriteException[], Exact<{
3240
3279
  email: string;
3241
3280
  url: string;
3242
3281
  }>, unknown>;
@@ -3254,7 +3293,7 @@ declare function useResetPassword(): {
3254
3293
  mutate: _tanstack_react_query.UseMutateFunction<{
3255
3294
  __typename?: "Token";
3256
3295
  expire?: any;
3257
- }, AppwriteException, Exact<{
3296
+ }, AppwriteException[], Exact<{
3258
3297
  userId: string;
3259
3298
  secret: string;
3260
3299
  password: string;
@@ -3262,13 +3301,13 @@ declare function useResetPassword(): {
3262
3301
  reset: () => void;
3263
3302
  context: unknown;
3264
3303
  failureCount: number;
3265
- failureReason: AppwriteException;
3304
+ failureReason: AppwriteException[];
3266
3305
  isPaused: boolean;
3267
3306
  submittedAt: number;
3268
3307
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3269
3308
  __typename?: "Token";
3270
3309
  expire?: any;
3271
- }, AppwriteException, Exact<{
3310
+ }, AppwriteException[], Exact<{
3272
3311
  userId: string;
3273
3312
  secret: string;
3274
3313
  password: string;
@@ -3289,7 +3328,7 @@ declare function useResetPassword(): {
3289
3328
  mutate: _tanstack_react_query.UseMutateFunction<{
3290
3329
  __typename?: "Token";
3291
3330
  expire?: any;
3292
- }, AppwriteException, Exact<{
3331
+ }, AppwriteException[], Exact<{
3293
3332
  userId: string;
3294
3333
  secret: string;
3295
3334
  password: string;
@@ -3297,20 +3336,20 @@ declare function useResetPassword(): {
3297
3336
  reset: () => void;
3298
3337
  context: unknown;
3299
3338
  failureCount: number;
3300
- failureReason: AppwriteException;
3339
+ failureReason: AppwriteException[];
3301
3340
  isPaused: boolean;
3302
3341
  submittedAt: number;
3303
3342
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3304
3343
  __typename?: "Token";
3305
3344
  expire?: any;
3306
- }, AppwriteException, Exact<{
3345
+ }, AppwriteException[], Exact<{
3307
3346
  userId: string;
3308
3347
  secret: string;
3309
3348
  password: string;
3310
3349
  }>, unknown>;
3311
3350
  } | {
3312
3351
  data: undefined;
3313
- error: AppwriteException;
3352
+ error: AppwriteException[];
3314
3353
  variables: Exact<{
3315
3354
  userId: string;
3316
3355
  secret: string;
@@ -3324,7 +3363,7 @@ declare function useResetPassword(): {
3324
3363
  mutate: _tanstack_react_query.UseMutateFunction<{
3325
3364
  __typename?: "Token";
3326
3365
  expire?: any;
3327
- }, AppwriteException, Exact<{
3366
+ }, AppwriteException[], Exact<{
3328
3367
  userId: string;
3329
3368
  secret: string;
3330
3369
  password: string;
@@ -3332,13 +3371,13 @@ declare function useResetPassword(): {
3332
3371
  reset: () => void;
3333
3372
  context: unknown;
3334
3373
  failureCount: number;
3335
- failureReason: AppwriteException;
3374
+ failureReason: AppwriteException[];
3336
3375
  isPaused: boolean;
3337
3376
  submittedAt: number;
3338
3377
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3339
3378
  __typename?: "Token";
3340
3379
  expire?: any;
3341
- }, AppwriteException, Exact<{
3380
+ }, AppwriteException[], Exact<{
3342
3381
  userId: string;
3343
3382
  secret: string;
3344
3383
  password: string;
@@ -3362,7 +3401,7 @@ declare function useResetPassword(): {
3362
3401
  mutate: _tanstack_react_query.UseMutateFunction<{
3363
3402
  __typename?: "Token";
3364
3403
  expire?: any;
3365
- }, AppwriteException, Exact<{
3404
+ }, AppwriteException[], Exact<{
3366
3405
  userId: string;
3367
3406
  secret: string;
3368
3407
  password: string;
@@ -3370,13 +3409,13 @@ declare function useResetPassword(): {
3370
3409
  reset: () => void;
3371
3410
  context: unknown;
3372
3411
  failureCount: number;
3373
- failureReason: AppwriteException;
3412
+ failureReason: AppwriteException[];
3374
3413
  isPaused: boolean;
3375
3414
  submittedAt: number;
3376
3415
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3377
3416
  __typename?: "Token";
3378
3417
  expire?: any;
3379
- }, AppwriteException, Exact<{
3418
+ }, AppwriteException[], Exact<{
3380
3419
  userId: string;
3381
3420
  secret: string;
3382
3421
  password: string;
@@ -3391,7 +3430,7 @@ declare function useSignUp(): {
3391
3430
  __typename?: "User";
3392
3431
  name?: string;
3393
3432
  email?: string;
3394
- }, Error, Exact<{
3433
+ }, AppwriteException[], Exact<{
3395
3434
  userId: string;
3396
3435
  name?: string;
3397
3436
  email: string;
@@ -3416,21 +3455,21 @@ declare function useUpdateEmail(): {
3416
3455
  __typename?: "User";
3417
3456
  name?: string;
3418
3457
  email?: string;
3419
- }, AppwriteException, Exact<{
3458
+ }, AppwriteException[], Exact<{
3420
3459
  email: string;
3421
3460
  password: string;
3422
3461
  }>, unknown>;
3423
3462
  reset: () => void;
3424
3463
  context: unknown;
3425
3464
  failureCount: number;
3426
- failureReason: AppwriteException;
3465
+ failureReason: AppwriteException[];
3427
3466
  isPaused: boolean;
3428
3467
  submittedAt: number;
3429
3468
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3430
3469
  __typename?: "User";
3431
3470
  name?: string;
3432
3471
  email?: string;
3433
- }, AppwriteException, Exact<{
3472
+ }, AppwriteException[], Exact<{
3434
3473
  email: string;
3435
3474
  password: string;
3436
3475
  }>, unknown>;
@@ -3450,27 +3489,27 @@ declare function useUpdateEmail(): {
3450
3489
  __typename?: "User";
3451
3490
  name?: string;
3452
3491
  email?: string;
3453
- }, AppwriteException, Exact<{
3492
+ }, AppwriteException[], Exact<{
3454
3493
  email: string;
3455
3494
  password: string;
3456
3495
  }>, unknown>;
3457
3496
  reset: () => void;
3458
3497
  context: unknown;
3459
3498
  failureCount: number;
3460
- failureReason: AppwriteException;
3499
+ failureReason: AppwriteException[];
3461
3500
  isPaused: boolean;
3462
3501
  submittedAt: number;
3463
3502
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3464
3503
  __typename?: "User";
3465
3504
  name?: string;
3466
3505
  email?: string;
3467
- }, AppwriteException, Exact<{
3506
+ }, AppwriteException[], Exact<{
3468
3507
  email: string;
3469
3508
  password: string;
3470
3509
  }>, unknown>;
3471
3510
  } | {
3472
3511
  data: undefined;
3473
- error: AppwriteException;
3512
+ error: AppwriteException[];
3474
3513
  variables: Exact<{
3475
3514
  email: string;
3476
3515
  password: string;
@@ -3484,21 +3523,21 @@ declare function useUpdateEmail(): {
3484
3523
  __typename?: "User";
3485
3524
  name?: string;
3486
3525
  email?: string;
3487
- }, AppwriteException, Exact<{
3526
+ }, AppwriteException[], Exact<{
3488
3527
  email: string;
3489
3528
  password: string;
3490
3529
  }>, unknown>;
3491
3530
  reset: () => void;
3492
3531
  context: unknown;
3493
3532
  failureCount: number;
3494
- failureReason: AppwriteException;
3533
+ failureReason: AppwriteException[];
3495
3534
  isPaused: boolean;
3496
3535
  submittedAt: number;
3497
3536
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3498
3537
  __typename?: "User";
3499
3538
  name?: string;
3500
3539
  email?: string;
3501
- }, AppwriteException, Exact<{
3540
+ }, AppwriteException[], Exact<{
3502
3541
  email: string;
3503
3542
  password: string;
3504
3543
  }>, unknown>;
@@ -3522,21 +3561,21 @@ declare function useUpdateEmail(): {
3522
3561
  __typename?: "User";
3523
3562
  name?: string;
3524
3563
  email?: string;
3525
- }, AppwriteException, Exact<{
3564
+ }, AppwriteException[], Exact<{
3526
3565
  email: string;
3527
3566
  password: string;
3528
3567
  }>, unknown>;
3529
3568
  reset: () => void;
3530
3569
  context: unknown;
3531
3570
  failureCount: number;
3532
- failureReason: AppwriteException;
3571
+ failureReason: AppwriteException[];
3533
3572
  isPaused: boolean;
3534
3573
  submittedAt: number;
3535
3574
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3536
3575
  __typename?: "User";
3537
3576
  name?: string;
3538
3577
  email?: string;
3539
- }, AppwriteException, Exact<{
3578
+ }, AppwriteException[], Exact<{
3540
3579
  email: string;
3541
3580
  password: string;
3542
3581
  }>, unknown>;
@@ -3556,14 +3595,14 @@ declare function useUpdateMagicURLSession(): {
3556
3595
  userId?: string;
3557
3596
  expire?: any;
3558
3597
  current?: boolean;
3559
- }, AppwriteException, Exact<{
3598
+ }, AppwriteException[], Exact<{
3560
3599
  userId: string;
3561
3600
  secret: string;
3562
3601
  }>, unknown>;
3563
3602
  reset: () => void;
3564
3603
  context: unknown;
3565
3604
  failureCount: number;
3566
- failureReason: AppwriteException;
3605
+ failureReason: AppwriteException[];
3567
3606
  isPaused: boolean;
3568
3607
  submittedAt: number;
3569
3608
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -3571,7 +3610,7 @@ declare function useUpdateMagicURLSession(): {
3571
3610
  userId?: string;
3572
3611
  expire?: any;
3573
3612
  current?: boolean;
3574
- }, AppwriteException, Exact<{
3613
+ }, AppwriteException[], Exact<{
3575
3614
  userId: string;
3576
3615
  secret: string;
3577
3616
  }>, unknown>;
@@ -3592,14 +3631,14 @@ declare function useUpdateMagicURLSession(): {
3592
3631
  userId?: string;
3593
3632
  expire?: any;
3594
3633
  current?: boolean;
3595
- }, AppwriteException, Exact<{
3634
+ }, AppwriteException[], Exact<{
3596
3635
  userId: string;
3597
3636
  secret: string;
3598
3637
  }>, unknown>;
3599
3638
  reset: () => void;
3600
3639
  context: unknown;
3601
3640
  failureCount: number;
3602
- failureReason: AppwriteException;
3641
+ failureReason: AppwriteException[];
3603
3642
  isPaused: boolean;
3604
3643
  submittedAt: number;
3605
3644
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -3607,13 +3646,13 @@ declare function useUpdateMagicURLSession(): {
3607
3646
  userId?: string;
3608
3647
  expire?: any;
3609
3648
  current?: boolean;
3610
- }, AppwriteException, Exact<{
3649
+ }, AppwriteException[], Exact<{
3611
3650
  userId: string;
3612
3651
  secret: string;
3613
3652
  }>, unknown>;
3614
3653
  } | {
3615
3654
  data: undefined;
3616
- error: AppwriteException;
3655
+ error: AppwriteException[];
3617
3656
  variables: Exact<{
3618
3657
  userId: string;
3619
3658
  secret: string;
@@ -3628,14 +3667,14 @@ declare function useUpdateMagicURLSession(): {
3628
3667
  userId?: string;
3629
3668
  expire?: any;
3630
3669
  current?: boolean;
3631
- }, AppwriteException, Exact<{
3670
+ }, AppwriteException[], Exact<{
3632
3671
  userId: string;
3633
3672
  secret: string;
3634
3673
  }>, unknown>;
3635
3674
  reset: () => void;
3636
3675
  context: unknown;
3637
3676
  failureCount: number;
3638
- failureReason: AppwriteException;
3677
+ failureReason: AppwriteException[];
3639
3678
  isPaused: boolean;
3640
3679
  submittedAt: number;
3641
3680
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -3643,7 +3682,7 @@ declare function useUpdateMagicURLSession(): {
3643
3682
  userId?: string;
3644
3683
  expire?: any;
3645
3684
  current?: boolean;
3646
- }, AppwriteException, Exact<{
3685
+ }, AppwriteException[], Exact<{
3647
3686
  userId: string;
3648
3687
  secret: string;
3649
3688
  }>, unknown>;
@@ -3669,14 +3708,14 @@ declare function useUpdateMagicURLSession(): {
3669
3708
  userId?: string;
3670
3709
  expire?: any;
3671
3710
  current?: boolean;
3672
- }, AppwriteException, Exact<{
3711
+ }, AppwriteException[], Exact<{
3673
3712
  userId: string;
3674
3713
  secret: string;
3675
3714
  }>, unknown>;
3676
3715
  reset: () => void;
3677
3716
  context: unknown;
3678
3717
  failureCount: number;
3679
- failureReason: AppwriteException;
3718
+ failureReason: AppwriteException[];
3680
3719
  isPaused: boolean;
3681
3720
  submittedAt: number;
3682
3721
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -3684,7 +3723,7 @@ declare function useUpdateMagicURLSession(): {
3684
3723
  userId?: string;
3685
3724
  expire?: any;
3686
3725
  current?: boolean;
3687
- }, AppwriteException, Exact<{
3726
+ }, AppwriteException[], Exact<{
3688
3727
  userId: string;
3689
3728
  secret: string;
3690
3729
  }>, unknown>;
@@ -3702,19 +3741,19 @@ declare function useUpdateMfa(): {
3702
3741
  mutate: _tanstack_react_query.UseMutateFunction<{
3703
3742
  __typename?: "User";
3704
3743
  mfa?: boolean;
3705
- }, AppwriteException, Exact<{
3744
+ }, AppwriteException[], Exact<{
3706
3745
  mfa: boolean;
3707
3746
  }>, unknown>;
3708
3747
  reset: () => void;
3709
3748
  context: unknown;
3710
3749
  failureCount: number;
3711
- failureReason: AppwriteException;
3750
+ failureReason: AppwriteException[];
3712
3751
  isPaused: boolean;
3713
3752
  submittedAt: number;
3714
3753
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3715
3754
  __typename?: "User";
3716
3755
  mfa?: boolean;
3717
- }, AppwriteException, Exact<{
3756
+ }, AppwriteException[], Exact<{
3718
3757
  mfa: boolean;
3719
3758
  }>, unknown>;
3720
3759
  } | {
@@ -3731,24 +3770,24 @@ declare function useUpdateMfa(): {
3731
3770
  mutate: _tanstack_react_query.UseMutateFunction<{
3732
3771
  __typename?: "User";
3733
3772
  mfa?: boolean;
3734
- }, AppwriteException, Exact<{
3773
+ }, AppwriteException[], Exact<{
3735
3774
  mfa: boolean;
3736
3775
  }>, unknown>;
3737
3776
  reset: () => void;
3738
3777
  context: unknown;
3739
3778
  failureCount: number;
3740
- failureReason: AppwriteException;
3779
+ failureReason: AppwriteException[];
3741
3780
  isPaused: boolean;
3742
3781
  submittedAt: number;
3743
3782
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3744
3783
  __typename?: "User";
3745
3784
  mfa?: boolean;
3746
- }, AppwriteException, Exact<{
3785
+ }, AppwriteException[], Exact<{
3747
3786
  mfa: boolean;
3748
3787
  }>, unknown>;
3749
3788
  } | {
3750
3789
  data: undefined;
3751
- error: AppwriteException;
3790
+ error: AppwriteException[];
3752
3791
  variables: Exact<{
3753
3792
  mfa: boolean;
3754
3793
  }>;
@@ -3760,19 +3799,19 @@ declare function useUpdateMfa(): {
3760
3799
  mutate: _tanstack_react_query.UseMutateFunction<{
3761
3800
  __typename?: "User";
3762
3801
  mfa?: boolean;
3763
- }, AppwriteException, Exact<{
3802
+ }, AppwriteException[], Exact<{
3764
3803
  mfa: boolean;
3765
3804
  }>, unknown>;
3766
3805
  reset: () => void;
3767
3806
  context: unknown;
3768
3807
  failureCount: number;
3769
- failureReason: AppwriteException;
3808
+ failureReason: AppwriteException[];
3770
3809
  isPaused: boolean;
3771
3810
  submittedAt: number;
3772
3811
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3773
3812
  __typename?: "User";
3774
3813
  mfa?: boolean;
3775
- }, AppwriteException, Exact<{
3814
+ }, AppwriteException[], Exact<{
3776
3815
  mfa: boolean;
3777
3816
  }>, unknown>;
3778
3817
  } | {
@@ -3792,19 +3831,19 @@ declare function useUpdateMfa(): {
3792
3831
  mutate: _tanstack_react_query.UseMutateFunction<{
3793
3832
  __typename?: "User";
3794
3833
  mfa?: boolean;
3795
- }, AppwriteException, Exact<{
3834
+ }, AppwriteException[], Exact<{
3796
3835
  mfa: boolean;
3797
3836
  }>, unknown>;
3798
3837
  reset: () => void;
3799
3838
  context: unknown;
3800
3839
  failureCount: number;
3801
- failureReason: AppwriteException;
3840
+ failureReason: AppwriteException[];
3802
3841
  isPaused: boolean;
3803
3842
  submittedAt: number;
3804
3843
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3805
3844
  __typename?: "User";
3806
3845
  mfa?: boolean;
3807
- }, AppwriteException, Exact<{
3846
+ }, AppwriteException[], Exact<{
3808
3847
  mfa: boolean;
3809
3848
  }>, unknown>;
3810
3849
  };
@@ -3821,20 +3860,20 @@ declare function useUpdateMfaAuthenticator(): {
3821
3860
  mutate: _tanstack_react_query.UseMutateFunction<{
3822
3861
  __typename?: "User";
3823
3862
  mfa?: boolean;
3824
- }, AppwriteException, Exact<{
3863
+ }, AppwriteException[], Exact<{
3825
3864
  type: string;
3826
3865
  otp: string;
3827
3866
  }>, unknown>;
3828
3867
  reset: () => void;
3829
3868
  context: unknown;
3830
3869
  failureCount: number;
3831
- failureReason: AppwriteException;
3870
+ failureReason: AppwriteException[];
3832
3871
  isPaused: boolean;
3833
3872
  submittedAt: number;
3834
3873
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3835
3874
  __typename?: "User";
3836
3875
  mfa?: boolean;
3837
- }, AppwriteException, Exact<{
3876
+ }, AppwriteException[], Exact<{
3838
3877
  type: string;
3839
3878
  otp: string;
3840
3879
  }>, unknown>;
@@ -3853,26 +3892,26 @@ declare function useUpdateMfaAuthenticator(): {
3853
3892
  mutate: _tanstack_react_query.UseMutateFunction<{
3854
3893
  __typename?: "User";
3855
3894
  mfa?: boolean;
3856
- }, AppwriteException, Exact<{
3895
+ }, AppwriteException[], Exact<{
3857
3896
  type: string;
3858
3897
  otp: string;
3859
3898
  }>, unknown>;
3860
3899
  reset: () => void;
3861
3900
  context: unknown;
3862
3901
  failureCount: number;
3863
- failureReason: AppwriteException;
3902
+ failureReason: AppwriteException[];
3864
3903
  isPaused: boolean;
3865
3904
  submittedAt: number;
3866
3905
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3867
3906
  __typename?: "User";
3868
3907
  mfa?: boolean;
3869
- }, AppwriteException, Exact<{
3908
+ }, AppwriteException[], Exact<{
3870
3909
  type: string;
3871
3910
  otp: string;
3872
3911
  }>, unknown>;
3873
3912
  } | {
3874
3913
  data: undefined;
3875
- error: AppwriteException;
3914
+ error: AppwriteException[];
3876
3915
  variables: Exact<{
3877
3916
  type: string;
3878
3917
  otp: string;
@@ -3885,20 +3924,20 @@ declare function useUpdateMfaAuthenticator(): {
3885
3924
  mutate: _tanstack_react_query.UseMutateFunction<{
3886
3925
  __typename?: "User";
3887
3926
  mfa?: boolean;
3888
- }, AppwriteException, Exact<{
3927
+ }, AppwriteException[], Exact<{
3889
3928
  type: string;
3890
3929
  otp: string;
3891
3930
  }>, unknown>;
3892
3931
  reset: () => void;
3893
3932
  context: unknown;
3894
3933
  failureCount: number;
3895
- failureReason: AppwriteException;
3934
+ failureReason: AppwriteException[];
3896
3935
  isPaused: boolean;
3897
3936
  submittedAt: number;
3898
3937
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3899
3938
  __typename?: "User";
3900
3939
  mfa?: boolean;
3901
- }, AppwriteException, Exact<{
3940
+ }, AppwriteException[], Exact<{
3902
3941
  type: string;
3903
3942
  otp: string;
3904
3943
  }>, unknown>;
@@ -3920,20 +3959,20 @@ declare function useUpdateMfaAuthenticator(): {
3920
3959
  mutate: _tanstack_react_query.UseMutateFunction<{
3921
3960
  __typename?: "User";
3922
3961
  mfa?: boolean;
3923
- }, AppwriteException, Exact<{
3962
+ }, AppwriteException[], Exact<{
3924
3963
  type: string;
3925
3964
  otp: string;
3926
3965
  }>, unknown>;
3927
3966
  reset: () => void;
3928
3967
  context: unknown;
3929
3968
  failureCount: number;
3930
- failureReason: AppwriteException;
3969
+ failureReason: AppwriteException[];
3931
3970
  isPaused: boolean;
3932
3971
  submittedAt: number;
3933
3972
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3934
3973
  __typename?: "User";
3935
3974
  mfa?: boolean;
3936
- }, AppwriteException, Exact<{
3975
+ }, AppwriteException[], Exact<{
3937
3976
  type: string;
3938
3977
  otp: string;
3939
3978
  }>, unknown>;
@@ -3951,20 +3990,20 @@ declare function useUpdateMfaChallenge(): {
3951
3990
  mutate: _tanstack_react_query.UseMutateFunction<{
3952
3991
  __typename?: "Status";
3953
3992
  status?: boolean;
3954
- }, AppwriteException, Exact<{
3993
+ }, AppwriteException[], Exact<{
3955
3994
  challengeId: string;
3956
3995
  otp: string;
3957
3996
  }>, unknown>;
3958
3997
  reset: () => void;
3959
3998
  context: unknown;
3960
3999
  failureCount: number;
3961
- failureReason: AppwriteException;
4000
+ failureReason: AppwriteException[];
3962
4001
  isPaused: boolean;
3963
4002
  submittedAt: number;
3964
4003
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3965
4004
  __typename?: "Status";
3966
4005
  status?: boolean;
3967
- }, AppwriteException, Exact<{
4006
+ }, AppwriteException[], Exact<{
3968
4007
  challengeId: string;
3969
4008
  otp: string;
3970
4009
  }>, unknown>;
@@ -3983,26 +4022,26 @@ declare function useUpdateMfaChallenge(): {
3983
4022
  mutate: _tanstack_react_query.UseMutateFunction<{
3984
4023
  __typename?: "Status";
3985
4024
  status?: boolean;
3986
- }, AppwriteException, Exact<{
4025
+ }, AppwriteException[], Exact<{
3987
4026
  challengeId: string;
3988
4027
  otp: string;
3989
4028
  }>, unknown>;
3990
4029
  reset: () => void;
3991
4030
  context: unknown;
3992
4031
  failureCount: number;
3993
- failureReason: AppwriteException;
4032
+ failureReason: AppwriteException[];
3994
4033
  isPaused: boolean;
3995
4034
  submittedAt: number;
3996
4035
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
3997
4036
  __typename?: "Status";
3998
4037
  status?: boolean;
3999
- }, AppwriteException, Exact<{
4038
+ }, AppwriteException[], Exact<{
4000
4039
  challengeId: string;
4001
4040
  otp: string;
4002
4041
  }>, unknown>;
4003
4042
  } | {
4004
4043
  data: undefined;
4005
- error: AppwriteException;
4044
+ error: AppwriteException[];
4006
4045
  variables: Exact<{
4007
4046
  challengeId: string;
4008
4047
  otp: string;
@@ -4015,20 +4054,20 @@ declare function useUpdateMfaChallenge(): {
4015
4054
  mutate: _tanstack_react_query.UseMutateFunction<{
4016
4055
  __typename?: "Status";
4017
4056
  status?: boolean;
4018
- }, AppwriteException, Exact<{
4057
+ }, AppwriteException[], Exact<{
4019
4058
  challengeId: string;
4020
4059
  otp: string;
4021
4060
  }>, unknown>;
4022
4061
  reset: () => void;
4023
4062
  context: unknown;
4024
4063
  failureCount: number;
4025
- failureReason: AppwriteException;
4064
+ failureReason: AppwriteException[];
4026
4065
  isPaused: boolean;
4027
4066
  submittedAt: number;
4028
4067
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4029
4068
  __typename?: "Status";
4030
4069
  status?: boolean;
4031
- }, AppwriteException, Exact<{
4070
+ }, AppwriteException[], Exact<{
4032
4071
  challengeId: string;
4033
4072
  otp: string;
4034
4073
  }>, unknown>;
@@ -4050,20 +4089,20 @@ declare function useUpdateMfaChallenge(): {
4050
4089
  mutate: _tanstack_react_query.UseMutateFunction<{
4051
4090
  __typename?: "Status";
4052
4091
  status?: boolean;
4053
- }, AppwriteException, Exact<{
4092
+ }, AppwriteException[], Exact<{
4054
4093
  challengeId: string;
4055
4094
  otp: string;
4056
4095
  }>, unknown>;
4057
4096
  reset: () => void;
4058
4097
  context: unknown;
4059
4098
  failureCount: number;
4060
- failureReason: AppwriteException;
4099
+ failureReason: AppwriteException[];
4061
4100
  isPaused: boolean;
4062
4101
  submittedAt: number;
4063
4102
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4064
4103
  __typename?: "Status";
4065
4104
  status?: boolean;
4066
- }, AppwriteException, Exact<{
4105
+ }, AppwriteException[], Exact<{
4067
4106
  challengeId: string;
4068
4107
  otp: string;
4069
4108
  }>, unknown>;
@@ -4081,17 +4120,17 @@ declare function useUpdateMfaRecoveryCodes(): {
4081
4120
  mutate: _tanstack_react_query.UseMutateFunction<{
4082
4121
  __typename?: "MFARecoveryCodes";
4083
4122
  recoveryCodes: string[];
4084
- }, AppwriteException, void, unknown>;
4123
+ }, AppwriteException[], void, unknown>;
4085
4124
  reset: () => void;
4086
4125
  context: unknown;
4087
4126
  failureCount: number;
4088
- failureReason: AppwriteException;
4127
+ failureReason: AppwriteException[];
4089
4128
  isPaused: boolean;
4090
4129
  submittedAt: number;
4091
4130
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4092
4131
  __typename?: "MFARecoveryCodes";
4093
4132
  recoveryCodes: string[];
4094
- }, AppwriteException, void, unknown>;
4133
+ }, AppwriteException[], void, unknown>;
4095
4134
  } | {
4096
4135
  data: undefined;
4097
4136
  variables: void;
@@ -4104,20 +4143,20 @@ declare function useUpdateMfaRecoveryCodes(): {
4104
4143
  mutate: _tanstack_react_query.UseMutateFunction<{
4105
4144
  __typename?: "MFARecoveryCodes";
4106
4145
  recoveryCodes: string[];
4107
- }, AppwriteException, void, unknown>;
4146
+ }, AppwriteException[], void, unknown>;
4108
4147
  reset: () => void;
4109
4148
  context: unknown;
4110
4149
  failureCount: number;
4111
- failureReason: AppwriteException;
4150
+ failureReason: AppwriteException[];
4112
4151
  isPaused: boolean;
4113
4152
  submittedAt: number;
4114
4153
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4115
4154
  __typename?: "MFARecoveryCodes";
4116
4155
  recoveryCodes: string[];
4117
- }, AppwriteException, void, unknown>;
4156
+ }, AppwriteException[], void, unknown>;
4118
4157
  } | {
4119
4158
  data: undefined;
4120
- error: AppwriteException;
4159
+ error: AppwriteException[];
4121
4160
  variables: void;
4122
4161
  isError: true;
4123
4162
  isIdle: false;
@@ -4127,17 +4166,17 @@ declare function useUpdateMfaRecoveryCodes(): {
4127
4166
  mutate: _tanstack_react_query.UseMutateFunction<{
4128
4167
  __typename?: "MFARecoveryCodes";
4129
4168
  recoveryCodes: string[];
4130
- }, AppwriteException, void, unknown>;
4169
+ }, AppwriteException[], void, unknown>;
4131
4170
  reset: () => void;
4132
4171
  context: unknown;
4133
4172
  failureCount: number;
4134
- failureReason: AppwriteException;
4173
+ failureReason: AppwriteException[];
4135
4174
  isPaused: boolean;
4136
4175
  submittedAt: number;
4137
4176
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4138
4177
  __typename?: "MFARecoveryCodes";
4139
4178
  recoveryCodes: string[];
4140
- }, AppwriteException, void, unknown>;
4179
+ }, AppwriteException[], void, unknown>;
4141
4180
  } | {
4142
4181
  data: {
4143
4182
  __typename?: "MFARecoveryCodes";
@@ -4153,17 +4192,17 @@ declare function useUpdateMfaRecoveryCodes(): {
4153
4192
  mutate: _tanstack_react_query.UseMutateFunction<{
4154
4193
  __typename?: "MFARecoveryCodes";
4155
4194
  recoveryCodes: string[];
4156
- }, AppwriteException, void, unknown>;
4195
+ }, AppwriteException[], void, unknown>;
4157
4196
  reset: () => void;
4158
4197
  context: unknown;
4159
4198
  failureCount: number;
4160
- failureReason: AppwriteException;
4199
+ failureReason: AppwriteException[];
4161
4200
  isPaused: boolean;
4162
4201
  submittedAt: number;
4163
4202
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4164
4203
  __typename?: "MFARecoveryCodes";
4165
4204
  recoveryCodes: string[];
4166
- }, AppwriteException, void, unknown>;
4205
+ }, AppwriteException[], void, unknown>;
4167
4206
  };
4168
4207
 
4169
4208
  declare function useUpdateName(): {
@@ -4178,19 +4217,19 @@ declare function useUpdateName(): {
4178
4217
  mutate: _tanstack_react_query.UseMutateFunction<{
4179
4218
  __typename?: "User";
4180
4219
  name?: string;
4181
- }, AppwriteException, Exact<{
4220
+ }, AppwriteException[], Exact<{
4182
4221
  name: string;
4183
4222
  }>, unknown>;
4184
4223
  reset: () => void;
4185
4224
  context: unknown;
4186
4225
  failureCount: number;
4187
- failureReason: AppwriteException;
4226
+ failureReason: AppwriteException[];
4188
4227
  isPaused: boolean;
4189
4228
  submittedAt: number;
4190
4229
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4191
4230
  __typename?: "User";
4192
4231
  name?: string;
4193
- }, AppwriteException, Exact<{
4232
+ }, AppwriteException[], Exact<{
4194
4233
  name: string;
4195
4234
  }>, unknown>;
4196
4235
  } | {
@@ -4207,24 +4246,24 @@ declare function useUpdateName(): {
4207
4246
  mutate: _tanstack_react_query.UseMutateFunction<{
4208
4247
  __typename?: "User";
4209
4248
  name?: string;
4210
- }, AppwriteException, Exact<{
4249
+ }, AppwriteException[], Exact<{
4211
4250
  name: string;
4212
4251
  }>, unknown>;
4213
4252
  reset: () => void;
4214
4253
  context: unknown;
4215
4254
  failureCount: number;
4216
- failureReason: AppwriteException;
4255
+ failureReason: AppwriteException[];
4217
4256
  isPaused: boolean;
4218
4257
  submittedAt: number;
4219
4258
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4220
4259
  __typename?: "User";
4221
4260
  name?: string;
4222
- }, AppwriteException, Exact<{
4261
+ }, AppwriteException[], Exact<{
4223
4262
  name: string;
4224
4263
  }>, unknown>;
4225
4264
  } | {
4226
4265
  data: undefined;
4227
- error: AppwriteException;
4266
+ error: AppwriteException[];
4228
4267
  variables: Exact<{
4229
4268
  name: string;
4230
4269
  }>;
@@ -4236,19 +4275,19 @@ declare function useUpdateName(): {
4236
4275
  mutate: _tanstack_react_query.UseMutateFunction<{
4237
4276
  __typename?: "User";
4238
4277
  name?: string;
4239
- }, AppwriteException, Exact<{
4278
+ }, AppwriteException[], Exact<{
4240
4279
  name: string;
4241
4280
  }>, unknown>;
4242
4281
  reset: () => void;
4243
4282
  context: unknown;
4244
4283
  failureCount: number;
4245
- failureReason: AppwriteException;
4284
+ failureReason: AppwriteException[];
4246
4285
  isPaused: boolean;
4247
4286
  submittedAt: number;
4248
4287
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4249
4288
  __typename?: "User";
4250
4289
  name?: string;
4251
- }, AppwriteException, Exact<{
4290
+ }, AppwriteException[], Exact<{
4252
4291
  name: string;
4253
4292
  }>, unknown>;
4254
4293
  } | {
@@ -4268,19 +4307,19 @@ declare function useUpdateName(): {
4268
4307
  mutate: _tanstack_react_query.UseMutateFunction<{
4269
4308
  __typename?: "User";
4270
4309
  name?: string;
4271
- }, AppwriteException, Exact<{
4310
+ }, AppwriteException[], Exact<{
4272
4311
  name: string;
4273
4312
  }>, unknown>;
4274
4313
  reset: () => void;
4275
4314
  context: unknown;
4276
4315
  failureCount: number;
4277
- failureReason: AppwriteException;
4316
+ failureReason: AppwriteException[];
4278
4317
  isPaused: boolean;
4279
4318
  submittedAt: number;
4280
4319
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4281
4320
  __typename?: "User";
4282
4321
  name?: string;
4283
- }, AppwriteException, Exact<{
4322
+ }, AppwriteException[], Exact<{
4284
4323
  name: string;
4285
4324
  }>, unknown>;
4286
4325
  };
@@ -4297,20 +4336,20 @@ declare function useUpdatePassword(): {
4297
4336
  mutate: _tanstack_react_query.UseMutateFunction<{
4298
4337
  __typename?: "User";
4299
4338
  status?: string;
4300
- }, AppwriteException, Exact<{
4339
+ }, AppwriteException[], Exact<{
4301
4340
  password: string;
4302
4341
  oldPassword: string;
4303
4342
  }>, unknown>;
4304
4343
  reset: () => void;
4305
4344
  context: unknown;
4306
4345
  failureCount: number;
4307
- failureReason: AppwriteException;
4346
+ failureReason: AppwriteException[];
4308
4347
  isPaused: boolean;
4309
4348
  submittedAt: number;
4310
4349
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4311
4350
  __typename?: "User";
4312
4351
  status?: string;
4313
- }, AppwriteException, Exact<{
4352
+ }, AppwriteException[], Exact<{
4314
4353
  password: string;
4315
4354
  oldPassword: string;
4316
4355
  }>, unknown>;
@@ -4329,26 +4368,26 @@ declare function useUpdatePassword(): {
4329
4368
  mutate: _tanstack_react_query.UseMutateFunction<{
4330
4369
  __typename?: "User";
4331
4370
  status?: string;
4332
- }, AppwriteException, Exact<{
4371
+ }, AppwriteException[], Exact<{
4333
4372
  password: string;
4334
4373
  oldPassword: string;
4335
4374
  }>, unknown>;
4336
4375
  reset: () => void;
4337
4376
  context: unknown;
4338
4377
  failureCount: number;
4339
- failureReason: AppwriteException;
4378
+ failureReason: AppwriteException[];
4340
4379
  isPaused: boolean;
4341
4380
  submittedAt: number;
4342
4381
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4343
4382
  __typename?: "User";
4344
4383
  status?: string;
4345
- }, AppwriteException, Exact<{
4384
+ }, AppwriteException[], Exact<{
4346
4385
  password: string;
4347
4386
  oldPassword: string;
4348
4387
  }>, unknown>;
4349
4388
  } | {
4350
4389
  data: undefined;
4351
- error: AppwriteException;
4390
+ error: AppwriteException[];
4352
4391
  variables: Exact<{
4353
4392
  password: string;
4354
4393
  oldPassword: string;
@@ -4361,20 +4400,20 @@ declare function useUpdatePassword(): {
4361
4400
  mutate: _tanstack_react_query.UseMutateFunction<{
4362
4401
  __typename?: "User";
4363
4402
  status?: string;
4364
- }, AppwriteException, Exact<{
4403
+ }, AppwriteException[], Exact<{
4365
4404
  password: string;
4366
4405
  oldPassword: string;
4367
4406
  }>, unknown>;
4368
4407
  reset: () => void;
4369
4408
  context: unknown;
4370
4409
  failureCount: number;
4371
- failureReason: AppwriteException;
4410
+ failureReason: AppwriteException[];
4372
4411
  isPaused: boolean;
4373
4412
  submittedAt: number;
4374
4413
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4375
4414
  __typename?: "User";
4376
4415
  status?: string;
4377
- }, AppwriteException, Exact<{
4416
+ }, AppwriteException[], Exact<{
4378
4417
  password: string;
4379
4418
  oldPassword: string;
4380
4419
  }>, unknown>;
@@ -4396,20 +4435,20 @@ declare function useUpdatePassword(): {
4396
4435
  mutate: _tanstack_react_query.UseMutateFunction<{
4397
4436
  __typename?: "User";
4398
4437
  status?: string;
4399
- }, AppwriteException, Exact<{
4438
+ }, AppwriteException[], Exact<{
4400
4439
  password: string;
4401
4440
  oldPassword: string;
4402
4441
  }>, unknown>;
4403
4442
  reset: () => void;
4404
4443
  context: unknown;
4405
4444
  failureCount: number;
4406
- failureReason: AppwriteException;
4445
+ failureReason: AppwriteException[];
4407
4446
  isPaused: boolean;
4408
4447
  submittedAt: number;
4409
4448
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4410
4449
  __typename?: "User";
4411
4450
  status?: string;
4412
- }, AppwriteException, Exact<{
4451
+ }, AppwriteException[], Exact<{
4413
4452
  password: string;
4414
4453
  oldPassword: string;
4415
4454
  }>, unknown>;
@@ -4427,20 +4466,20 @@ declare function useUpdatePhone(): {
4427
4466
  mutate: _tanstack_react_query.UseMutateFunction<{
4428
4467
  __typename?: "User";
4429
4468
  phone?: string;
4430
- }, AppwriteException, Exact<{
4469
+ }, AppwriteException[], Exact<{
4431
4470
  phone: string;
4432
4471
  password: string;
4433
4472
  }>, unknown>;
4434
4473
  reset: () => void;
4435
4474
  context: unknown;
4436
4475
  failureCount: number;
4437
- failureReason: AppwriteException;
4476
+ failureReason: AppwriteException[];
4438
4477
  isPaused: boolean;
4439
4478
  submittedAt: number;
4440
4479
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4441
4480
  __typename?: "User";
4442
4481
  phone?: string;
4443
- }, AppwriteException, Exact<{
4482
+ }, AppwriteException[], Exact<{
4444
4483
  phone: string;
4445
4484
  password: string;
4446
4485
  }>, unknown>;
@@ -4459,26 +4498,26 @@ declare function useUpdatePhone(): {
4459
4498
  mutate: _tanstack_react_query.UseMutateFunction<{
4460
4499
  __typename?: "User";
4461
4500
  phone?: string;
4462
- }, AppwriteException, Exact<{
4501
+ }, AppwriteException[], Exact<{
4463
4502
  phone: string;
4464
4503
  password: string;
4465
4504
  }>, unknown>;
4466
4505
  reset: () => void;
4467
4506
  context: unknown;
4468
4507
  failureCount: number;
4469
- failureReason: AppwriteException;
4508
+ failureReason: AppwriteException[];
4470
4509
  isPaused: boolean;
4471
4510
  submittedAt: number;
4472
4511
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4473
4512
  __typename?: "User";
4474
4513
  phone?: string;
4475
- }, AppwriteException, Exact<{
4514
+ }, AppwriteException[], Exact<{
4476
4515
  phone: string;
4477
4516
  password: string;
4478
4517
  }>, unknown>;
4479
4518
  } | {
4480
4519
  data: undefined;
4481
- error: AppwriteException;
4520
+ error: AppwriteException[];
4482
4521
  variables: Exact<{
4483
4522
  phone: string;
4484
4523
  password: string;
@@ -4491,20 +4530,20 @@ declare function useUpdatePhone(): {
4491
4530
  mutate: _tanstack_react_query.UseMutateFunction<{
4492
4531
  __typename?: "User";
4493
4532
  phone?: string;
4494
- }, AppwriteException, Exact<{
4533
+ }, AppwriteException[], Exact<{
4495
4534
  phone: string;
4496
4535
  password: string;
4497
4536
  }>, unknown>;
4498
4537
  reset: () => void;
4499
4538
  context: unknown;
4500
4539
  failureCount: number;
4501
- failureReason: AppwriteException;
4540
+ failureReason: AppwriteException[];
4502
4541
  isPaused: boolean;
4503
4542
  submittedAt: number;
4504
4543
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4505
4544
  __typename?: "User";
4506
4545
  phone?: string;
4507
- }, AppwriteException, Exact<{
4546
+ }, AppwriteException[], Exact<{
4508
4547
  phone: string;
4509
4548
  password: string;
4510
4549
  }>, unknown>;
@@ -4526,20 +4565,20 @@ declare function useUpdatePhone(): {
4526
4565
  mutate: _tanstack_react_query.UseMutateFunction<{
4527
4566
  __typename?: "User";
4528
4567
  phone?: string;
4529
- }, AppwriteException, Exact<{
4568
+ }, AppwriteException[], Exact<{
4530
4569
  phone: string;
4531
4570
  password: string;
4532
4571
  }>, unknown>;
4533
4572
  reset: () => void;
4534
4573
  context: unknown;
4535
4574
  failureCount: number;
4536
- failureReason: AppwriteException;
4575
+ failureReason: AppwriteException[];
4537
4576
  isPaused: boolean;
4538
4577
  submittedAt: number;
4539
4578
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4540
4579
  __typename?: "User";
4541
4580
  phone?: string;
4542
- }, AppwriteException, Exact<{
4581
+ }, AppwriteException[], Exact<{
4543
4582
  phone: string;
4544
4583
  password: string;
4545
4584
  }>, unknown>;
@@ -4559,14 +4598,14 @@ declare function useUpdatePhoneSession(): {
4559
4598
  userId?: string;
4560
4599
  expire?: any;
4561
4600
  current?: boolean;
4562
- }, AppwriteException, Exact<{
4601
+ }, AppwriteException[], Exact<{
4563
4602
  userId: string;
4564
4603
  secret: string;
4565
4604
  }>, unknown>;
4566
4605
  reset: () => void;
4567
4606
  context: unknown;
4568
4607
  failureCount: number;
4569
- failureReason: AppwriteException;
4608
+ failureReason: AppwriteException[];
4570
4609
  isPaused: boolean;
4571
4610
  submittedAt: number;
4572
4611
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4574,7 +4613,7 @@ declare function useUpdatePhoneSession(): {
4574
4613
  userId?: string;
4575
4614
  expire?: any;
4576
4615
  current?: boolean;
4577
- }, AppwriteException, Exact<{
4616
+ }, AppwriteException[], Exact<{
4578
4617
  userId: string;
4579
4618
  secret: string;
4580
4619
  }>, unknown>;
@@ -4595,14 +4634,14 @@ declare function useUpdatePhoneSession(): {
4595
4634
  userId?: string;
4596
4635
  expire?: any;
4597
4636
  current?: boolean;
4598
- }, AppwriteException, Exact<{
4637
+ }, AppwriteException[], Exact<{
4599
4638
  userId: string;
4600
4639
  secret: string;
4601
4640
  }>, unknown>;
4602
4641
  reset: () => void;
4603
4642
  context: unknown;
4604
4643
  failureCount: number;
4605
- failureReason: AppwriteException;
4644
+ failureReason: AppwriteException[];
4606
4645
  isPaused: boolean;
4607
4646
  submittedAt: number;
4608
4647
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4610,13 +4649,13 @@ declare function useUpdatePhoneSession(): {
4610
4649
  userId?: string;
4611
4650
  expire?: any;
4612
4651
  current?: boolean;
4613
- }, AppwriteException, Exact<{
4652
+ }, AppwriteException[], Exact<{
4614
4653
  userId: string;
4615
4654
  secret: string;
4616
4655
  }>, unknown>;
4617
4656
  } | {
4618
4657
  data: undefined;
4619
- error: AppwriteException;
4658
+ error: AppwriteException[];
4620
4659
  variables: Exact<{
4621
4660
  userId: string;
4622
4661
  secret: string;
@@ -4631,14 +4670,14 @@ declare function useUpdatePhoneSession(): {
4631
4670
  userId?: string;
4632
4671
  expire?: any;
4633
4672
  current?: boolean;
4634
- }, AppwriteException, Exact<{
4673
+ }, AppwriteException[], Exact<{
4635
4674
  userId: string;
4636
4675
  secret: string;
4637
4676
  }>, unknown>;
4638
4677
  reset: () => void;
4639
4678
  context: unknown;
4640
4679
  failureCount: number;
4641
- failureReason: AppwriteException;
4680
+ failureReason: AppwriteException[];
4642
4681
  isPaused: boolean;
4643
4682
  submittedAt: number;
4644
4683
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4646,7 +4685,7 @@ declare function useUpdatePhoneSession(): {
4646
4685
  userId?: string;
4647
4686
  expire?: any;
4648
4687
  current?: boolean;
4649
- }, AppwriteException, Exact<{
4688
+ }, AppwriteException[], Exact<{
4650
4689
  userId: string;
4651
4690
  secret: string;
4652
4691
  }>, unknown>;
@@ -4672,14 +4711,14 @@ declare function useUpdatePhoneSession(): {
4672
4711
  userId?: string;
4673
4712
  expire?: any;
4674
4713
  current?: boolean;
4675
- }, AppwriteException, Exact<{
4714
+ }, AppwriteException[], Exact<{
4676
4715
  userId: string;
4677
4716
  secret: string;
4678
4717
  }>, unknown>;
4679
4718
  reset: () => void;
4680
4719
  context: unknown;
4681
4720
  failureCount: number;
4682
- failureReason: AppwriteException;
4721
+ failureReason: AppwriteException[];
4683
4722
  isPaused: boolean;
4684
4723
  submittedAt: number;
4685
4724
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4687,7 +4726,7 @@ declare function useUpdatePhoneSession(): {
4687
4726
  userId?: string;
4688
4727
  expire?: any;
4689
4728
  current?: boolean;
4690
- }, AppwriteException, Exact<{
4729
+ }, AppwriteException[], Exact<{
4691
4730
  userId: string;
4692
4731
  secret: string;
4693
4732
  }>, unknown>;
@@ -4705,20 +4744,20 @@ declare function useUpdatePhoneVerification(): {
4705
4744
  mutate: _tanstack_react_query.UseMutateFunction<{
4706
4745
  __typename?: "Token";
4707
4746
  expire?: any;
4708
- }, AppwriteException, Exact<{
4747
+ }, AppwriteException[], Exact<{
4709
4748
  userId: string;
4710
4749
  secret: string;
4711
4750
  }>, unknown>;
4712
4751
  reset: () => void;
4713
4752
  context: unknown;
4714
4753
  failureCount: number;
4715
- failureReason: AppwriteException;
4754
+ failureReason: AppwriteException[];
4716
4755
  isPaused: boolean;
4717
4756
  submittedAt: number;
4718
4757
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4719
4758
  __typename?: "Token";
4720
4759
  expire?: any;
4721
- }, AppwriteException, Exact<{
4760
+ }, AppwriteException[], Exact<{
4722
4761
  userId: string;
4723
4762
  secret: string;
4724
4763
  }>, unknown>;
@@ -4737,26 +4776,26 @@ declare function useUpdatePhoneVerification(): {
4737
4776
  mutate: _tanstack_react_query.UseMutateFunction<{
4738
4777
  __typename?: "Token";
4739
4778
  expire?: any;
4740
- }, AppwriteException, Exact<{
4779
+ }, AppwriteException[], Exact<{
4741
4780
  userId: string;
4742
4781
  secret: string;
4743
4782
  }>, unknown>;
4744
4783
  reset: () => void;
4745
4784
  context: unknown;
4746
4785
  failureCount: number;
4747
- failureReason: AppwriteException;
4786
+ failureReason: AppwriteException[];
4748
4787
  isPaused: boolean;
4749
4788
  submittedAt: number;
4750
4789
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4751
4790
  __typename?: "Token";
4752
4791
  expire?: any;
4753
- }, AppwriteException, Exact<{
4792
+ }, AppwriteException[], Exact<{
4754
4793
  userId: string;
4755
4794
  secret: string;
4756
4795
  }>, unknown>;
4757
4796
  } | {
4758
4797
  data: undefined;
4759
- error: AppwriteException;
4798
+ error: AppwriteException[];
4760
4799
  variables: Exact<{
4761
4800
  userId: string;
4762
4801
  secret: string;
@@ -4769,20 +4808,20 @@ declare function useUpdatePhoneVerification(): {
4769
4808
  mutate: _tanstack_react_query.UseMutateFunction<{
4770
4809
  __typename?: "Token";
4771
4810
  expire?: any;
4772
- }, AppwriteException, Exact<{
4811
+ }, AppwriteException[], Exact<{
4773
4812
  userId: string;
4774
4813
  secret: string;
4775
4814
  }>, unknown>;
4776
4815
  reset: () => void;
4777
4816
  context: unknown;
4778
4817
  failureCount: number;
4779
- failureReason: AppwriteException;
4818
+ failureReason: AppwriteException[];
4780
4819
  isPaused: boolean;
4781
4820
  submittedAt: number;
4782
4821
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4783
4822
  __typename?: "Token";
4784
4823
  expire?: any;
4785
- }, AppwriteException, Exact<{
4824
+ }, AppwriteException[], Exact<{
4786
4825
  userId: string;
4787
4826
  secret: string;
4788
4827
  }>, unknown>;
@@ -4804,20 +4843,20 @@ declare function useUpdatePhoneVerification(): {
4804
4843
  mutate: _tanstack_react_query.UseMutateFunction<{
4805
4844
  __typename?: "Token";
4806
4845
  expire?: any;
4807
- }, AppwriteException, Exact<{
4846
+ }, AppwriteException[], Exact<{
4808
4847
  userId: string;
4809
4848
  secret: string;
4810
4849
  }>, unknown>;
4811
4850
  reset: () => void;
4812
4851
  context: unknown;
4813
4852
  failureCount: number;
4814
- failureReason: AppwriteException;
4853
+ failureReason: AppwriteException[];
4815
4854
  isPaused: boolean;
4816
4855
  submittedAt: number;
4817
4856
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
4818
4857
  __typename?: "Token";
4819
4858
  expire?: any;
4820
- }, AppwriteException, Exact<{
4859
+ }, AppwriteException[], Exact<{
4821
4860
  userId: string;
4822
4861
  secret: string;
4823
4862
  }>, unknown>;
@@ -4838,13 +4877,13 @@ declare function useUpdatePrefs(): {
4838
4877
  __typename?: "Preferences";
4839
4878
  data?: any;
4840
4879
  };
4841
- }, AppwriteException, {
4880
+ }, AppwriteException[], {
4842
4881
  prefs: Record<string, string | number | boolean>;
4843
4882
  }, unknown>;
4844
4883
  reset: () => void;
4845
4884
  context: unknown;
4846
4885
  failureCount: number;
4847
- failureReason: AppwriteException;
4886
+ failureReason: AppwriteException[];
4848
4887
  isPaused: boolean;
4849
4888
  submittedAt: number;
4850
4889
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4853,7 +4892,7 @@ declare function useUpdatePrefs(): {
4853
4892
  __typename?: "Preferences";
4854
4893
  data?: any;
4855
4894
  };
4856
- }, AppwriteException, {
4895
+ }, AppwriteException[], {
4857
4896
  prefs: Record<string, string | number | boolean>;
4858
4897
  }, unknown>;
4859
4898
  } | {
@@ -4873,13 +4912,13 @@ declare function useUpdatePrefs(): {
4873
4912
  __typename?: "Preferences";
4874
4913
  data?: any;
4875
4914
  };
4876
- }, AppwriteException, {
4915
+ }, AppwriteException[], {
4877
4916
  prefs: Record<string, string | number | boolean>;
4878
4917
  }, unknown>;
4879
4918
  reset: () => void;
4880
4919
  context: unknown;
4881
4920
  failureCount: number;
4882
- failureReason: AppwriteException;
4921
+ failureReason: AppwriteException[];
4883
4922
  isPaused: boolean;
4884
4923
  submittedAt: number;
4885
4924
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4888,12 +4927,12 @@ declare function useUpdatePrefs(): {
4888
4927
  __typename?: "Preferences";
4889
4928
  data?: any;
4890
4929
  };
4891
- }, AppwriteException, {
4930
+ }, AppwriteException[], {
4892
4931
  prefs: Record<string, string | number | boolean>;
4893
4932
  }, unknown>;
4894
4933
  } | {
4895
4934
  data: undefined;
4896
- error: AppwriteException;
4935
+ error: AppwriteException[];
4897
4936
  variables: {
4898
4937
  prefs: Record<string, string | number | boolean>;
4899
4938
  };
@@ -4908,13 +4947,13 @@ declare function useUpdatePrefs(): {
4908
4947
  __typename?: "Preferences";
4909
4948
  data?: any;
4910
4949
  };
4911
- }, AppwriteException, {
4950
+ }, AppwriteException[], {
4912
4951
  prefs: Record<string, string | number | boolean>;
4913
4952
  }, unknown>;
4914
4953
  reset: () => void;
4915
4954
  context: unknown;
4916
4955
  failureCount: number;
4917
- failureReason: AppwriteException;
4956
+ failureReason: AppwriteException[];
4918
4957
  isPaused: boolean;
4919
4958
  submittedAt: number;
4920
4959
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4923,7 +4962,7 @@ declare function useUpdatePrefs(): {
4923
4962
  __typename?: "Preferences";
4924
4963
  data?: any;
4925
4964
  };
4926
- }, AppwriteException, {
4965
+ }, AppwriteException[], {
4927
4966
  prefs: Record<string, string | number | boolean>;
4928
4967
  }, unknown>;
4929
4968
  } | {
@@ -4949,13 +4988,13 @@ declare function useUpdatePrefs(): {
4949
4988
  __typename?: "Preferences";
4950
4989
  data?: any;
4951
4990
  };
4952
- }, AppwriteException, {
4991
+ }, AppwriteException[], {
4953
4992
  prefs: Record<string, string | number | boolean>;
4954
4993
  }, unknown>;
4955
4994
  reset: () => void;
4956
4995
  context: unknown;
4957
4996
  failureCount: number;
4958
- failureReason: AppwriteException;
4997
+ failureReason: AppwriteException[];
4959
4998
  isPaused: boolean;
4960
4999
  submittedAt: number;
4961
5000
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4964,7 +5003,7 @@ declare function useUpdatePrefs(): {
4964
5003
  __typename?: "Preferences";
4965
5004
  data?: any;
4966
5005
  };
4967
- }, AppwriteException, {
5006
+ }, AppwriteException[], {
4968
5007
  prefs: Record<string, string | number | boolean>;
4969
5008
  }, unknown>;
4970
5009
  };
@@ -4983,13 +5022,13 @@ declare function useUpdateSession(): {
4983
5022
  userId?: string;
4984
5023
  expire?: any;
4985
5024
  current?: boolean;
4986
- }, AppwriteException, Exact<{
5025
+ }, AppwriteException[], Exact<{
4987
5026
  sessionId: string;
4988
5027
  }>, unknown>;
4989
5028
  reset: () => void;
4990
5029
  context: unknown;
4991
5030
  failureCount: number;
4992
- failureReason: AppwriteException;
5031
+ failureReason: AppwriteException[];
4993
5032
  isPaused: boolean;
4994
5033
  submittedAt: number;
4995
5034
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -4997,7 +5036,7 @@ declare function useUpdateSession(): {
4997
5036
  userId?: string;
4998
5037
  expire?: any;
4999
5038
  current?: boolean;
5000
- }, AppwriteException, Exact<{
5039
+ }, AppwriteException[], Exact<{
5001
5040
  sessionId: string;
5002
5041
  }>, unknown>;
5003
5042
  } | {
@@ -5016,13 +5055,13 @@ declare function useUpdateSession(): {
5016
5055
  userId?: string;
5017
5056
  expire?: any;
5018
5057
  current?: boolean;
5019
- }, AppwriteException, Exact<{
5058
+ }, AppwriteException[], Exact<{
5020
5059
  sessionId: string;
5021
5060
  }>, unknown>;
5022
5061
  reset: () => void;
5023
5062
  context: unknown;
5024
5063
  failureCount: number;
5025
- failureReason: AppwriteException;
5064
+ failureReason: AppwriteException[];
5026
5065
  isPaused: boolean;
5027
5066
  submittedAt: number;
5028
5067
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5030,12 +5069,12 @@ declare function useUpdateSession(): {
5030
5069
  userId?: string;
5031
5070
  expire?: any;
5032
5071
  current?: boolean;
5033
- }, AppwriteException, Exact<{
5072
+ }, AppwriteException[], Exact<{
5034
5073
  sessionId: string;
5035
5074
  }>, unknown>;
5036
5075
  } | {
5037
5076
  data: undefined;
5038
- error: AppwriteException;
5077
+ error: AppwriteException[];
5039
5078
  variables: Exact<{
5040
5079
  sessionId: string;
5041
5080
  }>;
@@ -5049,13 +5088,13 @@ declare function useUpdateSession(): {
5049
5088
  userId?: string;
5050
5089
  expire?: any;
5051
5090
  current?: boolean;
5052
- }, AppwriteException, Exact<{
5091
+ }, AppwriteException[], Exact<{
5053
5092
  sessionId: string;
5054
5093
  }>, unknown>;
5055
5094
  reset: () => void;
5056
5095
  context: unknown;
5057
5096
  failureCount: number;
5058
- failureReason: AppwriteException;
5097
+ failureReason: AppwriteException[];
5059
5098
  isPaused: boolean;
5060
5099
  submittedAt: number;
5061
5100
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5063,7 +5102,7 @@ declare function useUpdateSession(): {
5063
5102
  userId?: string;
5064
5103
  expire?: any;
5065
5104
  current?: boolean;
5066
- }, AppwriteException, Exact<{
5105
+ }, AppwriteException[], Exact<{
5067
5106
  sessionId: string;
5068
5107
  }>, unknown>;
5069
5108
  } | {
@@ -5087,13 +5126,13 @@ declare function useUpdateSession(): {
5087
5126
  userId?: string;
5088
5127
  expire?: any;
5089
5128
  current?: boolean;
5090
- }, AppwriteException, Exact<{
5129
+ }, AppwriteException[], Exact<{
5091
5130
  sessionId: string;
5092
5131
  }>, unknown>;
5093
5132
  reset: () => void;
5094
5133
  context: unknown;
5095
5134
  failureCount: number;
5096
- failureReason: AppwriteException;
5135
+ failureReason: AppwriteException[];
5097
5136
  isPaused: boolean;
5098
5137
  submittedAt: number;
5099
5138
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5101,7 +5140,7 @@ declare function useUpdateSession(): {
5101
5140
  userId?: string;
5102
5141
  expire?: any;
5103
5142
  current?: boolean;
5104
- }, AppwriteException, Exact<{
5143
+ }, AppwriteException[], Exact<{
5105
5144
  sessionId: string;
5106
5145
  }>, unknown>;
5107
5146
  };
@@ -5120,14 +5159,14 @@ declare function useVerification(): {
5120
5159
  secret?: string;
5121
5160
  expire?: any;
5122
5161
  userId?: string;
5123
- }, AppwriteException, Exact<{
5162
+ }, AppwriteException[], Exact<{
5124
5163
  userId: string;
5125
5164
  secret: string;
5126
5165
  }>, unknown>;
5127
5166
  reset: () => void;
5128
5167
  context: unknown;
5129
5168
  failureCount: number;
5130
- failureReason: AppwriteException;
5169
+ failureReason: AppwriteException[];
5131
5170
  isPaused: boolean;
5132
5171
  submittedAt: number;
5133
5172
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5135,7 +5174,7 @@ declare function useVerification(): {
5135
5174
  secret?: string;
5136
5175
  expire?: any;
5137
5176
  userId?: string;
5138
- }, AppwriteException, Exact<{
5177
+ }, AppwriteException[], Exact<{
5139
5178
  userId: string;
5140
5179
  secret: string;
5141
5180
  }>, unknown>;
@@ -5156,14 +5195,14 @@ declare function useVerification(): {
5156
5195
  secret?: string;
5157
5196
  expire?: any;
5158
5197
  userId?: string;
5159
- }, AppwriteException, Exact<{
5198
+ }, AppwriteException[], Exact<{
5160
5199
  userId: string;
5161
5200
  secret: string;
5162
5201
  }>, unknown>;
5163
5202
  reset: () => void;
5164
5203
  context: unknown;
5165
5204
  failureCount: number;
5166
- failureReason: AppwriteException;
5205
+ failureReason: AppwriteException[];
5167
5206
  isPaused: boolean;
5168
5207
  submittedAt: number;
5169
5208
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5171,13 +5210,13 @@ declare function useVerification(): {
5171
5210
  secret?: string;
5172
5211
  expire?: any;
5173
5212
  userId?: string;
5174
- }, AppwriteException, Exact<{
5213
+ }, AppwriteException[], Exact<{
5175
5214
  userId: string;
5176
5215
  secret: string;
5177
5216
  }>, unknown>;
5178
5217
  } | {
5179
5218
  data: undefined;
5180
- error: AppwriteException;
5219
+ error: AppwriteException[];
5181
5220
  variables: Exact<{
5182
5221
  userId: string;
5183
5222
  secret: string;
@@ -5192,14 +5231,14 @@ declare function useVerification(): {
5192
5231
  secret?: string;
5193
5232
  expire?: any;
5194
5233
  userId?: string;
5195
- }, AppwriteException, Exact<{
5234
+ }, AppwriteException[], Exact<{
5196
5235
  userId: string;
5197
5236
  secret: string;
5198
5237
  }>, unknown>;
5199
5238
  reset: () => void;
5200
5239
  context: unknown;
5201
5240
  failureCount: number;
5202
- failureReason: AppwriteException;
5241
+ failureReason: AppwriteException[];
5203
5242
  isPaused: boolean;
5204
5243
  submittedAt: number;
5205
5244
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5207,7 +5246,7 @@ declare function useVerification(): {
5207
5246
  secret?: string;
5208
5247
  expire?: any;
5209
5248
  userId?: string;
5210
- }, AppwriteException, Exact<{
5249
+ }, AppwriteException[], Exact<{
5211
5250
  userId: string;
5212
5251
  secret: string;
5213
5252
  }>, unknown>;
@@ -5233,14 +5272,14 @@ declare function useVerification(): {
5233
5272
  secret?: string;
5234
5273
  expire?: any;
5235
5274
  userId?: string;
5236
- }, AppwriteException, Exact<{
5275
+ }, AppwriteException[], Exact<{
5237
5276
  userId: string;
5238
5277
  secret: string;
5239
5278
  }>, unknown>;
5240
5279
  reset: () => void;
5241
5280
  context: unknown;
5242
5281
  failureCount: number;
5243
- failureReason: AppwriteException;
5282
+ failureReason: AppwriteException[];
5244
5283
  isPaused: boolean;
5245
5284
  submittedAt: number;
5246
5285
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
@@ -5248,7 +5287,7 @@ declare function useVerification(): {
5248
5287
  secret?: string;
5249
5288
  expire?: any;
5250
5289
  userId?: string;
5251
- }, AppwriteException, Exact<{
5290
+ }, AppwriteException[], Exact<{
5252
5291
  userId: string;
5253
5292
  secret: string;
5254
5293
  }>, unknown>;
@@ -5266,7 +5305,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5266
5305
  documents: Document<TDocument>[];
5267
5306
  total: number;
5268
5307
  data: Collection<TDocument>;
5269
- error: AppwriteException;
5308
+ error: AppwriteException[];
5270
5309
  isError: true;
5271
5310
  isPending: false;
5272
5311
  isLoading: false;
@@ -5277,7 +5316,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5277
5316
  dataUpdatedAt: number;
5278
5317
  errorUpdatedAt: number;
5279
5318
  failureCount: number;
5280
- failureReason: AppwriteException;
5319
+ failureReason: AppwriteException[];
5281
5320
  errorUpdateCount: number;
5282
5321
  isFetched: boolean;
5283
5322
  isFetchedAfterMount: boolean;
@@ -5287,7 +5326,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5287
5326
  isPlaceholderData: boolean;
5288
5327
  isRefetching: boolean;
5289
5328
  isStale: boolean;
5290
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
5329
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5291
5330
  fetchStatus: _tanstack_query_core.FetchStatus;
5292
5331
  } | {
5293
5332
  documents: Document<TDocument>[];
@@ -5304,7 +5343,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5304
5343
  dataUpdatedAt: number;
5305
5344
  errorUpdatedAt: number;
5306
5345
  failureCount: number;
5307
- failureReason: AppwriteException;
5346
+ failureReason: AppwriteException[];
5308
5347
  errorUpdateCount: number;
5309
5348
  isFetched: boolean;
5310
5349
  isFetchedAfterMount: boolean;
@@ -5314,13 +5353,13 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5314
5353
  isPlaceholderData: boolean;
5315
5354
  isRefetching: boolean;
5316
5355
  isStale: boolean;
5317
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
5356
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5318
5357
  fetchStatus: _tanstack_query_core.FetchStatus;
5319
5358
  } | {
5320
5359
  documents: Document<TDocument>[];
5321
5360
  total: number;
5322
5361
  data: undefined;
5323
- error: AppwriteException;
5362
+ error: AppwriteException[];
5324
5363
  isError: true;
5325
5364
  isPending: false;
5326
5365
  isLoading: false;
@@ -5331,7 +5370,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5331
5370
  dataUpdatedAt: number;
5332
5371
  errorUpdatedAt: number;
5333
5372
  failureCount: number;
5334
- failureReason: AppwriteException;
5373
+ failureReason: AppwriteException[];
5335
5374
  errorUpdateCount: number;
5336
5375
  isFetched: boolean;
5337
5376
  isFetchedAfterMount: boolean;
@@ -5341,7 +5380,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5341
5380
  isPlaceholderData: boolean;
5342
5381
  isRefetching: boolean;
5343
5382
  isStale: boolean;
5344
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
5383
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5345
5384
  fetchStatus: _tanstack_query_core.FetchStatus;
5346
5385
  } | {
5347
5386
  documents: Document<TDocument>[];
@@ -5358,7 +5397,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5358
5397
  dataUpdatedAt: number;
5359
5398
  errorUpdatedAt: number;
5360
5399
  failureCount: number;
5361
- failureReason: AppwriteException;
5400
+ failureReason: AppwriteException[];
5362
5401
  errorUpdateCount: number;
5363
5402
  isFetched: boolean;
5364
5403
  isFetchedAfterMount: boolean;
@@ -5368,7 +5407,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5368
5407
  isPlaceholderData: boolean;
5369
5408
  isRefetching: boolean;
5370
5409
  isStale: boolean;
5371
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
5410
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5372
5411
  fetchStatus: _tanstack_query_core.FetchStatus;
5373
5412
  } | {
5374
5413
  documents: Document<TDocument>[];
@@ -5384,7 +5423,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5384
5423
  dataUpdatedAt: number;
5385
5424
  errorUpdatedAt: number;
5386
5425
  failureCount: number;
5387
- failureReason: AppwriteException;
5426
+ failureReason: AppwriteException[];
5388
5427
  errorUpdateCount: number;
5389
5428
  isFetched: boolean;
5390
5429
  isFetchedAfterMount: boolean;
@@ -5395,7 +5434,7 @@ declare function useCollection<TDocument>({ databaseId, collectionId, queries, s
5395
5434
  isPlaceholderData: boolean;
5396
5435
  isRefetching: boolean;
5397
5436
  isStale: boolean;
5398
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
5437
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5399
5438
  fetchStatus: _tanstack_query_core.FetchStatus;
5400
5439
  };
5401
5440
  declare function useSuspenseCollection<TDocument>({ databaseId, collectionId, queries, subscribe, }: {
@@ -5408,12 +5447,12 @@ declare function useSuspenseCollection<TDocument>({ databaseId, collectionId, qu
5408
5447
  total: number;
5409
5448
  data: Collection<TDocument>;
5410
5449
  status: "error" | "success";
5411
- error: AppwriteException;
5450
+ error: AppwriteException[];
5412
5451
  isError: boolean;
5413
5452
  isPending: false;
5414
5453
  isSuccess: boolean;
5415
5454
  failureCount: number;
5416
- failureReason: AppwriteException;
5455
+ failureReason: AppwriteException[];
5417
5456
  isPaused: boolean;
5418
5457
  isLoading: false;
5419
5458
  isLoadingError: false;
@@ -5427,14 +5466,14 @@ declare function useSuspenseCollection<TDocument>({ databaseId, collectionId, qu
5427
5466
  isInitialLoading: boolean;
5428
5467
  isRefetching: boolean;
5429
5468
  isStale: boolean;
5430
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException>>;
5469
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Collection<TDocument>, AppwriteException[]>>;
5431
5470
  fetchStatus: _tanstack_query_core.FetchStatus;
5432
5471
  };
5433
5472
 
5434
5473
  declare function useCreateDocument(): _tanstack_react_query.UseMutationResult<{
5435
5474
  __typename?: "Document";
5436
5475
  _id?: string;
5437
- }, AppwriteException, Omit<Exact<{
5476
+ }, AppwriteException[], Omit<Exact<{
5438
5477
  databaseId: string;
5439
5478
  collectionId: string;
5440
5479
  documentId: string;
@@ -5456,7 +5495,7 @@ declare function useDeleteDocument(): {
5456
5495
  mutate: _tanstack_react_query.UseMutateFunction<{
5457
5496
  __typename?: "Status";
5458
5497
  status?: boolean;
5459
- }, AppwriteException, Exact<{
5498
+ }, AppwriteException[], Exact<{
5460
5499
  databaseId: string;
5461
5500
  collectionId: string;
5462
5501
  documentId: string;
@@ -5464,13 +5503,13 @@ declare function useDeleteDocument(): {
5464
5503
  reset: () => void;
5465
5504
  context: unknown;
5466
5505
  failureCount: number;
5467
- failureReason: AppwriteException;
5506
+ failureReason: AppwriteException[];
5468
5507
  isPaused: boolean;
5469
5508
  submittedAt: number;
5470
5509
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
5471
5510
  __typename?: "Status";
5472
5511
  status?: boolean;
5473
- }, AppwriteException, Exact<{
5512
+ }, AppwriteException[], Exact<{
5474
5513
  databaseId: string;
5475
5514
  collectionId: string;
5476
5515
  documentId: string;
@@ -5491,7 +5530,7 @@ declare function useDeleteDocument(): {
5491
5530
  mutate: _tanstack_react_query.UseMutateFunction<{
5492
5531
  __typename?: "Status";
5493
5532
  status?: boolean;
5494
- }, AppwriteException, Exact<{
5533
+ }, AppwriteException[], Exact<{
5495
5534
  databaseId: string;
5496
5535
  collectionId: string;
5497
5536
  documentId: string;
@@ -5499,20 +5538,20 @@ declare function useDeleteDocument(): {
5499
5538
  reset: () => void;
5500
5539
  context: unknown;
5501
5540
  failureCount: number;
5502
- failureReason: AppwriteException;
5541
+ failureReason: AppwriteException[];
5503
5542
  isPaused: boolean;
5504
5543
  submittedAt: number;
5505
5544
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
5506
5545
  __typename?: "Status";
5507
5546
  status?: boolean;
5508
- }, AppwriteException, Exact<{
5547
+ }, AppwriteException[], Exact<{
5509
5548
  databaseId: string;
5510
5549
  collectionId: string;
5511
5550
  documentId: string;
5512
5551
  }>, unknown>;
5513
5552
  } | {
5514
5553
  data: undefined;
5515
- error: AppwriteException;
5554
+ error: AppwriteException[];
5516
5555
  variables: Exact<{
5517
5556
  databaseId: string;
5518
5557
  collectionId: string;
@@ -5526,7 +5565,7 @@ declare function useDeleteDocument(): {
5526
5565
  mutate: _tanstack_react_query.UseMutateFunction<{
5527
5566
  __typename?: "Status";
5528
5567
  status?: boolean;
5529
- }, AppwriteException, Exact<{
5568
+ }, AppwriteException[], Exact<{
5530
5569
  databaseId: string;
5531
5570
  collectionId: string;
5532
5571
  documentId: string;
@@ -5534,13 +5573,13 @@ declare function useDeleteDocument(): {
5534
5573
  reset: () => void;
5535
5574
  context: unknown;
5536
5575
  failureCount: number;
5537
- failureReason: AppwriteException;
5576
+ failureReason: AppwriteException[];
5538
5577
  isPaused: boolean;
5539
5578
  submittedAt: number;
5540
5579
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
5541
5580
  __typename?: "Status";
5542
5581
  status?: boolean;
5543
- }, AppwriteException, Exact<{
5582
+ }, AppwriteException[], Exact<{
5544
5583
  databaseId: string;
5545
5584
  collectionId: string;
5546
5585
  documentId: string;
@@ -5564,7 +5603,7 @@ declare function useDeleteDocument(): {
5564
5603
  mutate: _tanstack_react_query.UseMutateFunction<{
5565
5604
  __typename?: "Status";
5566
5605
  status?: boolean;
5567
- }, AppwriteException, Exact<{
5606
+ }, AppwriteException[], Exact<{
5568
5607
  databaseId: string;
5569
5608
  collectionId: string;
5570
5609
  documentId: string;
@@ -5572,13 +5611,13 @@ declare function useDeleteDocument(): {
5572
5611
  reset: () => void;
5573
5612
  context: unknown;
5574
5613
  failureCount: number;
5575
- failureReason: AppwriteException;
5614
+ failureReason: AppwriteException[];
5576
5615
  isPaused: boolean;
5577
5616
  submittedAt: number;
5578
5617
  mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<{
5579
5618
  __typename?: "Status";
5580
5619
  status?: boolean;
5581
- }, AppwriteException, Exact<{
5620
+ }, AppwriteException[], Exact<{
5582
5621
  databaseId: string;
5583
5622
  collectionId: string;
5584
5623
  documentId: string;
@@ -5587,7 +5626,7 @@ declare function useDeleteDocument(): {
5587
5626
 
5588
5627
  declare function useDocument<TDocument>({ databaseId, collectionId, documentId, }: GetDocumentQueryVariables): {
5589
5628
  data: Document<TDocument>;
5590
- error: AppwriteException;
5629
+ error: AppwriteException[];
5591
5630
  isError: true;
5592
5631
  isPending: false;
5593
5632
  isLoading: false;
@@ -5598,7 +5637,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5598
5637
  dataUpdatedAt: number;
5599
5638
  errorUpdatedAt: number;
5600
5639
  failureCount: number;
5601
- failureReason: AppwriteException;
5640
+ failureReason: AppwriteException[];
5602
5641
  errorUpdateCount: number;
5603
5642
  isFetched: boolean;
5604
5643
  isFetchedAfterMount: boolean;
@@ -5608,7 +5647,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5608
5647
  isPlaceholderData: boolean;
5609
5648
  isRefetching: boolean;
5610
5649
  isStale: boolean;
5611
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5650
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5612
5651
  fetchStatus: _tanstack_query_core.FetchStatus;
5613
5652
  } | {
5614
5653
  data: Document<TDocument>;
@@ -5623,7 +5662,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5623
5662
  dataUpdatedAt: number;
5624
5663
  errorUpdatedAt: number;
5625
5664
  failureCount: number;
5626
- failureReason: AppwriteException;
5665
+ failureReason: AppwriteException[];
5627
5666
  errorUpdateCount: number;
5628
5667
  isFetched: boolean;
5629
5668
  isFetchedAfterMount: boolean;
@@ -5633,11 +5672,11 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5633
5672
  isPlaceholderData: boolean;
5634
5673
  isRefetching: boolean;
5635
5674
  isStale: boolean;
5636
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5675
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5637
5676
  fetchStatus: _tanstack_query_core.FetchStatus;
5638
5677
  } | {
5639
5678
  data: undefined;
5640
- error: AppwriteException;
5679
+ error: AppwriteException[];
5641
5680
  isError: true;
5642
5681
  isPending: false;
5643
5682
  isLoading: false;
@@ -5648,7 +5687,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5648
5687
  dataUpdatedAt: number;
5649
5688
  errorUpdatedAt: number;
5650
5689
  failureCount: number;
5651
- failureReason: AppwriteException;
5690
+ failureReason: AppwriteException[];
5652
5691
  errorUpdateCount: number;
5653
5692
  isFetched: boolean;
5654
5693
  isFetchedAfterMount: boolean;
@@ -5658,7 +5697,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5658
5697
  isPlaceholderData: boolean;
5659
5698
  isRefetching: boolean;
5660
5699
  isStale: boolean;
5661
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5700
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5662
5701
  fetchStatus: _tanstack_query_core.FetchStatus;
5663
5702
  } | {
5664
5703
  data: undefined;
@@ -5673,7 +5712,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5673
5712
  dataUpdatedAt: number;
5674
5713
  errorUpdatedAt: number;
5675
5714
  failureCount: number;
5676
- failureReason: AppwriteException;
5715
+ failureReason: AppwriteException[];
5677
5716
  errorUpdateCount: number;
5678
5717
  isFetched: boolean;
5679
5718
  isFetchedAfterMount: boolean;
@@ -5683,7 +5722,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5683
5722
  isPlaceholderData: boolean;
5684
5723
  isRefetching: boolean;
5685
5724
  isStale: boolean;
5686
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5725
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5687
5726
  fetchStatus: _tanstack_query_core.FetchStatus;
5688
5727
  } | {
5689
5728
  data: undefined;
@@ -5697,7 +5736,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5697
5736
  dataUpdatedAt: number;
5698
5737
  errorUpdatedAt: number;
5699
5738
  failureCount: number;
5700
- failureReason: AppwriteException;
5739
+ failureReason: AppwriteException[];
5701
5740
  errorUpdateCount: number;
5702
5741
  isFetched: boolean;
5703
5742
  isFetchedAfterMount: boolean;
@@ -5708,7 +5747,7 @@ declare function useDocument<TDocument>({ databaseId, collectionId, documentId,
5708
5747
  isPlaceholderData: boolean;
5709
5748
  isRefetching: boolean;
5710
5749
  isStale: boolean;
5711
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException>>;
5750
+ refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Document<TDocument>, AppwriteException[]>>;
5712
5751
  fetchStatus: _tanstack_query_core.FetchStatus;
5713
5752
  };
5714
5753
 
@@ -5721,7 +5760,7 @@ declare function useUpdateDocument<TDocument>(): {
5721
5760
  isPending: false;
5722
5761
  isSuccess: false;
5723
5762
  status: "idle";
5724
- mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5763
+ mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5725
5764
  databaseId: string;
5726
5765
  collectionId: string;
5727
5766
  documentId: string;
@@ -5733,10 +5772,10 @@ declare function useUpdateDocument<TDocument>(): {
5733
5772
  reset: () => void;
5734
5773
  context: unknown;
5735
5774
  failureCount: number;
5736
- failureReason: AppwriteException;
5775
+ failureReason: AppwriteException[];
5737
5776
  isPaused: boolean;
5738
5777
  submittedAt: number;
5739
- mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5778
+ mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5740
5779
  databaseId: string;
5741
5780
  collectionId: string;
5742
5781
  documentId: string;
@@ -5762,7 +5801,7 @@ declare function useUpdateDocument<TDocument>(): {
5762
5801
  isPending: true;
5763
5802
  isSuccess: false;
5764
5803
  status: "pending";
5765
- mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5804
+ mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5766
5805
  databaseId: string;
5767
5806
  collectionId: string;
5768
5807
  documentId: string;
@@ -5774,10 +5813,10 @@ declare function useUpdateDocument<TDocument>(): {
5774
5813
  reset: () => void;
5775
5814
  context: unknown;
5776
5815
  failureCount: number;
5777
- failureReason: AppwriteException;
5816
+ failureReason: AppwriteException[];
5778
5817
  isPaused: boolean;
5779
5818
  submittedAt: number;
5780
- mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5819
+ mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5781
5820
  databaseId: string;
5782
5821
  collectionId: string;
5783
5822
  documentId: string;
@@ -5788,7 +5827,7 @@ declare function useUpdateDocument<TDocument>(): {
5788
5827
  }, unknown>;
5789
5828
  } | {
5790
5829
  data: undefined;
5791
- error: AppwriteException;
5830
+ error: AppwriteException[];
5792
5831
  variables: Omit<Exact<{
5793
5832
  databaseId: string;
5794
5833
  collectionId: string;
@@ -5803,7 +5842,7 @@ declare function useUpdateDocument<TDocument>(): {
5803
5842
  isPending: false;
5804
5843
  isSuccess: false;
5805
5844
  status: "error";
5806
- mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5845
+ mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5807
5846
  databaseId: string;
5808
5847
  collectionId: string;
5809
5848
  documentId: string;
@@ -5815,10 +5854,10 @@ declare function useUpdateDocument<TDocument>(): {
5815
5854
  reset: () => void;
5816
5855
  context: unknown;
5817
5856
  failureCount: number;
5818
- failureReason: AppwriteException;
5857
+ failureReason: AppwriteException[];
5819
5858
  isPaused: boolean;
5820
5859
  submittedAt: number;
5821
- mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5860
+ mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5822
5861
  databaseId: string;
5823
5862
  collectionId: string;
5824
5863
  documentId: string;
@@ -5844,7 +5883,7 @@ declare function useUpdateDocument<TDocument>(): {
5844
5883
  isPending: false;
5845
5884
  isSuccess: true;
5846
5885
  status: "success";
5847
- mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5886
+ mutate: _tanstack_react_query.UseMutateFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5848
5887
  databaseId: string;
5849
5888
  collectionId: string;
5850
5889
  documentId: string;
@@ -5856,10 +5895,10 @@ declare function useUpdateDocument<TDocument>(): {
5856
5895
  reset: () => void;
5857
5896
  context: unknown;
5858
5897
  failureCount: number;
5859
- failureReason: AppwriteException;
5898
+ failureReason: AppwriteException[];
5860
5899
  isPaused: boolean;
5861
5900
  submittedAt: number;
5862
- mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException, Omit<Exact<{
5901
+ mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<Document<TDocument>, AppwriteException[], Omit<Exact<{
5863
5902
  databaseId: string;
5864
5903
  collectionId: string;
5865
5904
  documentId: string;
@@ -5878,11 +5917,11 @@ type Props = {
5878
5917
  method?: string;
5879
5918
  };
5880
5919
  declare function useFunction(): {
5881
- executeFunction: _tanstack_react_query.UseMutationResult<Record<string, unknown>, Error, Props, unknown>;
5920
+ executeFunction: _tanstack_react_query.UseMutationResult<Record<string, unknown>, AppwriteException[], Props, unknown>;
5882
5921
  currentExecution: _tanstack_react_query.UseQueryResult<unknown, unknown>;
5883
5922
  };
5884
5923
  declare function useSuspenseFunction({ functionId, body, async, path, method, }: Props): {
5885
- executeFunction: _tanstack_react_query.UseSuspenseQueryResult<Record<string, unknown>, Error>;
5924
+ executeFunction: _tanstack_react_query.UseSuspenseQueryResult<Record<string, unknown>, AppwriteException[]>;
5886
5925
  currentExecution: _tanstack_react_query.UseQueryResult<unknown, unknown>;
5887
5926
  };
5888
5927