frontend/generated/graphql.tsx (view raw)
1import { gql } from '@apollo/client';
2import * as Apollo from '@apollo/client';
3export type Maybe<T> = T | null;
4export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
5export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
6export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
7/** All built-in and custom scalars, mapped to their actual values */
8export type Scalars = {
9 ID: string;
10 String: string;
11 Boolean: boolean;
12 Int: number;
13 Float: number;
14 /** A date string, such as 2007-12-03, compliant with the `full-date` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
15 Date: any;
16 /** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
17 DateTime: any;
18 /** A string used to identify an i18n locale */
19 I18NLocaleCode: any;
20 /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
21 JSON: any;
22 /** The `Upload` scalar type represents a file upload. */
23 Upload: any;
24};
25
26export type BooleanFilterInput = {
27 and?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
28 or?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
29 not?: Maybe<BooleanFilterInput>;
30 eq?: Maybe<Scalars['Boolean']>;
31 eqi?: Maybe<Scalars['Boolean']>;
32 ne?: Maybe<Scalars['Boolean']>;
33 startsWith?: Maybe<Scalars['Boolean']>;
34 endsWith?: Maybe<Scalars['Boolean']>;
35 contains?: Maybe<Scalars['Boolean']>;
36 notContains?: Maybe<Scalars['Boolean']>;
37 containsi?: Maybe<Scalars['Boolean']>;
38 notContainsi?: Maybe<Scalars['Boolean']>;
39 gt?: Maybe<Scalars['Boolean']>;
40 gte?: Maybe<Scalars['Boolean']>;
41 lt?: Maybe<Scalars['Boolean']>;
42 lte?: Maybe<Scalars['Boolean']>;
43 null?: Maybe<Scalars['Boolean']>;
44 notNull?: Maybe<Scalars['Boolean']>;
45 in?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
46 notIn?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
47 between?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
48};
49
50
51export type DateFilterInput = {
52 and?: Maybe<Array<Maybe<Scalars['Date']>>>;
53 or?: Maybe<Array<Maybe<Scalars['Date']>>>;
54 not?: Maybe<DateFilterInput>;
55 eq?: Maybe<Scalars['Date']>;
56 eqi?: Maybe<Scalars['Date']>;
57 ne?: Maybe<Scalars['Date']>;
58 startsWith?: Maybe<Scalars['Date']>;
59 endsWith?: Maybe<Scalars['Date']>;
60 contains?: Maybe<Scalars['Date']>;
61 notContains?: Maybe<Scalars['Date']>;
62 containsi?: Maybe<Scalars['Date']>;
63 notContainsi?: Maybe<Scalars['Date']>;
64 gt?: Maybe<Scalars['Date']>;
65 gte?: Maybe<Scalars['Date']>;
66 lt?: Maybe<Scalars['Date']>;
67 lte?: Maybe<Scalars['Date']>;
68 null?: Maybe<Scalars['Boolean']>;
69 notNull?: Maybe<Scalars['Boolean']>;
70 in?: Maybe<Array<Maybe<Scalars['Date']>>>;
71 notIn?: Maybe<Array<Maybe<Scalars['Date']>>>;
72 between?: Maybe<Array<Maybe<Scalars['Date']>>>;
73};
74
75
76export type DateTimeFilterInput = {
77 and?: Maybe<Array<Maybe<Scalars['DateTime']>>>;
78 or?: Maybe<Array<Maybe<Scalars['DateTime']>>>;
79 not?: Maybe<DateTimeFilterInput>;
80 eq?: Maybe<Scalars['DateTime']>;
81 eqi?: Maybe<Scalars['DateTime']>;
82 ne?: Maybe<Scalars['DateTime']>;
83 startsWith?: Maybe<Scalars['DateTime']>;
84 endsWith?: Maybe<Scalars['DateTime']>;
85 contains?: Maybe<Scalars['DateTime']>;
86 notContains?: Maybe<Scalars['DateTime']>;
87 containsi?: Maybe<Scalars['DateTime']>;
88 notContainsi?: Maybe<Scalars['DateTime']>;
89 gt?: Maybe<Scalars['DateTime']>;
90 gte?: Maybe<Scalars['DateTime']>;
91 lt?: Maybe<Scalars['DateTime']>;
92 lte?: Maybe<Scalars['DateTime']>;
93 null?: Maybe<Scalars['Boolean']>;
94 notNull?: Maybe<Scalars['Boolean']>;
95 in?: Maybe<Array<Maybe<Scalars['DateTime']>>>;
96 notIn?: Maybe<Array<Maybe<Scalars['DateTime']>>>;
97 between?: Maybe<Array<Maybe<Scalars['DateTime']>>>;
98};
99
100export enum Enum_Page_Type {
101 Tos = 'tos'
102}
103
104export enum Enum_Userspermissionsuser_Lang {
105 Fr = 'FR',
106 En = 'EN'
107}
108
109export type EmailDesignerEmailTemplate = {
110 __typename?: 'EmailDesignerEmailTemplate';
111 templateReferenceId?: Maybe<Scalars['Int']>;
112 design?: Maybe<Scalars['JSON']>;
113 name?: Maybe<Scalars['String']>;
114 subject?: Maybe<Scalars['String']>;
115 bodyHtml?: Maybe<Scalars['String']>;
116 bodyText?: Maybe<Scalars['String']>;
117 enabled?: Maybe<Scalars['Boolean']>;
118 tags?: Maybe<Scalars['JSON']>;
119 createdAt?: Maybe<Scalars['DateTime']>;
120 updatedAt?: Maybe<Scalars['DateTime']>;
121};
122
123export type EmailDesignerEmailTemplateEntity = {
124 __typename?: 'EmailDesignerEmailTemplateEntity';
125 id?: Maybe<Scalars['ID']>;
126 attributes?: Maybe<EmailDesignerEmailTemplate>;
127};
128
129export type EmailDesignerEmailTemplateEntityResponse = {
130 __typename?: 'EmailDesignerEmailTemplateEntityResponse';
131 data?: Maybe<EmailDesignerEmailTemplateEntity>;
132};
133
134export type EmailDesignerEmailTemplateEntityResponseCollection = {
135 __typename?: 'EmailDesignerEmailTemplateEntityResponseCollection';
136 data: Array<EmailDesignerEmailTemplateEntity>;
137 meta: ResponseCollectionMeta;
138};
139
140export type EmailDesignerEmailTemplateFiltersInput = {
141 id?: Maybe<IdFilterInput>;
142 templateReferenceId?: Maybe<IntFilterInput>;
143 design?: Maybe<JsonFilterInput>;
144 name?: Maybe<StringFilterInput>;
145 subject?: Maybe<StringFilterInput>;
146 bodyHtml?: Maybe<StringFilterInput>;
147 bodyText?: Maybe<StringFilterInput>;
148 enabled?: Maybe<BooleanFilterInput>;
149 tags?: Maybe<JsonFilterInput>;
150 createdAt?: Maybe<DateTimeFilterInput>;
151 updatedAt?: Maybe<DateTimeFilterInput>;
152 and?: Maybe<Array<Maybe<EmailDesignerEmailTemplateFiltersInput>>>;
153 or?: Maybe<Array<Maybe<EmailDesignerEmailTemplateFiltersInput>>>;
154 not?: Maybe<EmailDesignerEmailTemplateFiltersInput>;
155};
156
157export type EmailDesignerEmailTemplateInput = {
158 templateReferenceId?: Maybe<Scalars['Int']>;
159 design?: Maybe<Scalars['JSON']>;
160 name?: Maybe<Scalars['String']>;
161 subject?: Maybe<Scalars['String']>;
162 bodyHtml?: Maybe<Scalars['String']>;
163 bodyText?: Maybe<Scalars['String']>;
164 enabled?: Maybe<Scalars['Boolean']>;
165 tags?: Maybe<Scalars['JSON']>;
166};
167
168export type Event = {
169 __typename?: 'Event';
170 name: Scalars['String'];
171 email: Scalars['String'];
172 date?: Maybe<Scalars['Date']>;
173 address?: Maybe<Scalars['String']>;
174 position?: Maybe<Scalars['JSON']>;
175 uuid?: Maybe<Scalars['String']>;
176 description?: Maybe<Scalars['String']>;
177 travels?: Maybe<TravelRelationResponseCollection>;
178 waitingPassengers?: Maybe<PassengerRelationResponseCollection>;
179 createdAt?: Maybe<Scalars['DateTime']>;
180 updatedAt?: Maybe<Scalars['DateTime']>;
181};
182
183
184export type EventTravelsArgs = {
185 filters?: Maybe<TravelFiltersInput>;
186 pagination?: Maybe<PaginationArg>;
187 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
188};
189
190
191export type EventWaitingPassengersArgs = {
192 filters?: Maybe<PassengerFiltersInput>;
193 pagination?: Maybe<PaginationArg>;
194 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
195};
196
197export type EventEntity = {
198 __typename?: 'EventEntity';
199 id?: Maybe<Scalars['ID']>;
200 attributes?: Maybe<Event>;
201};
202
203export type EventEntityResponse = {
204 __typename?: 'EventEntityResponse';
205 data?: Maybe<EventEntity>;
206};
207
208export type EventFiltersInput = {
209 id?: Maybe<IdFilterInput>;
210 name?: Maybe<StringFilterInput>;
211 email?: Maybe<StringFilterInput>;
212 date?: Maybe<DateFilterInput>;
213 address?: Maybe<StringFilterInput>;
214 position?: Maybe<JsonFilterInput>;
215 uuid?: Maybe<StringFilterInput>;
216 description?: Maybe<StringFilterInput>;
217 newsletter?: Maybe<BooleanFilterInput>;
218 users?: Maybe<UsersPermissionsUserFiltersInput>;
219 travels?: Maybe<TravelFiltersInput>;
220 waitingPassengers?: Maybe<PassengerFiltersInput>;
221 createdAt?: Maybe<DateTimeFilterInput>;
222 updatedAt?: Maybe<DateTimeFilterInput>;
223 and?: Maybe<Array<Maybe<EventFiltersInput>>>;
224 or?: Maybe<Array<Maybe<EventFiltersInput>>>;
225 not?: Maybe<EventFiltersInput>;
226};
227
228export type EventInput = {
229 name?: Maybe<Scalars['String']>;
230 email?: Maybe<Scalars['String']>;
231 date?: Maybe<Scalars['Date']>;
232 address?: Maybe<Scalars['String']>;
233 position?: Maybe<Scalars['JSON']>;
234 uuid?: Maybe<Scalars['String']>;
235 description?: Maybe<Scalars['String']>;
236 newsletter?: Maybe<Scalars['Boolean']>;
237 users?: Maybe<Array<Maybe<Scalars['ID']>>>;
238 travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
239 waitingPassengers?: Maybe<Array<Maybe<Scalars['ID']>>>;
240};
241
242export type EventRelationResponseCollection = {
243 __typename?: 'EventRelationResponseCollection';
244 data: Array<EventEntity>;
245};
246
247export type FileInfoInput = {
248 name?: Maybe<Scalars['String']>;
249 alternativeText?: Maybe<Scalars['String']>;
250 caption?: Maybe<Scalars['String']>;
251};
252
253export type FloatFilterInput = {
254 and?: Maybe<Array<Maybe<Scalars['Float']>>>;
255 or?: Maybe<Array<Maybe<Scalars['Float']>>>;
256 not?: Maybe<FloatFilterInput>;
257 eq?: Maybe<Scalars['Float']>;
258 eqi?: Maybe<Scalars['Float']>;
259 ne?: Maybe<Scalars['Float']>;
260 startsWith?: Maybe<Scalars['Float']>;
261 endsWith?: Maybe<Scalars['Float']>;
262 contains?: Maybe<Scalars['Float']>;
263 notContains?: Maybe<Scalars['Float']>;
264 containsi?: Maybe<Scalars['Float']>;
265 notContainsi?: Maybe<Scalars['Float']>;
266 gt?: Maybe<Scalars['Float']>;
267 gte?: Maybe<Scalars['Float']>;
268 lt?: Maybe<Scalars['Float']>;
269 lte?: Maybe<Scalars['Float']>;
270 null?: Maybe<Scalars['Boolean']>;
271 notNull?: Maybe<Scalars['Boolean']>;
272 in?: Maybe<Array<Maybe<Scalars['Float']>>>;
273 notIn?: Maybe<Array<Maybe<Scalars['Float']>>>;
274 between?: Maybe<Array<Maybe<Scalars['Float']>>>;
275};
276
277export type GenericMorph = UploadFile | UploadFolder | I18NLocale | UsersPermissionsPermission | UsersPermissionsRole | UsersPermissionsUser | EmailDesignerEmailTemplate | Event | Page | Passenger | Setting | Travel | Vehicle;
278
279export type I18NLocale = {
280 __typename?: 'I18NLocale';
281 name?: Maybe<Scalars['String']>;
282 code?: Maybe<Scalars['String']>;
283 createdAt?: Maybe<Scalars['DateTime']>;
284 updatedAt?: Maybe<Scalars['DateTime']>;
285};
286
287
288export type I18NLocaleEntity = {
289 __typename?: 'I18NLocaleEntity';
290 id?: Maybe<Scalars['ID']>;
291 attributes?: Maybe<I18NLocale>;
292};
293
294export type I18NLocaleEntityResponse = {
295 __typename?: 'I18NLocaleEntityResponse';
296 data?: Maybe<I18NLocaleEntity>;
297};
298
299export type I18NLocaleEntityResponseCollection = {
300 __typename?: 'I18NLocaleEntityResponseCollection';
301 data: Array<I18NLocaleEntity>;
302 meta: ResponseCollectionMeta;
303};
304
305export type I18NLocaleFiltersInput = {
306 id?: Maybe<IdFilterInput>;
307 name?: Maybe<StringFilterInput>;
308 code?: Maybe<StringFilterInput>;
309 createdAt?: Maybe<DateTimeFilterInput>;
310 updatedAt?: Maybe<DateTimeFilterInput>;
311 and?: Maybe<Array<Maybe<I18NLocaleFiltersInput>>>;
312 or?: Maybe<Array<Maybe<I18NLocaleFiltersInput>>>;
313 not?: Maybe<I18NLocaleFiltersInput>;
314};
315
316export type IdFilterInput = {
317 and?: Maybe<Array<Maybe<Scalars['ID']>>>;
318 or?: Maybe<Array<Maybe<Scalars['ID']>>>;
319 not?: Maybe<IdFilterInput>;
320 eq?: Maybe<Scalars['ID']>;
321 eqi?: Maybe<Scalars['ID']>;
322 ne?: Maybe<Scalars['ID']>;
323 startsWith?: Maybe<Scalars['ID']>;
324 endsWith?: Maybe<Scalars['ID']>;
325 contains?: Maybe<Scalars['ID']>;
326 notContains?: Maybe<Scalars['ID']>;
327 containsi?: Maybe<Scalars['ID']>;
328 notContainsi?: Maybe<Scalars['ID']>;
329 gt?: Maybe<Scalars['ID']>;
330 gte?: Maybe<Scalars['ID']>;
331 lt?: Maybe<Scalars['ID']>;
332 lte?: Maybe<Scalars['ID']>;
333 null?: Maybe<Scalars['Boolean']>;
334 notNull?: Maybe<Scalars['Boolean']>;
335 in?: Maybe<Array<Maybe<Scalars['ID']>>>;
336 notIn?: Maybe<Array<Maybe<Scalars['ID']>>>;
337 between?: Maybe<Array<Maybe<Scalars['ID']>>>;
338};
339
340export type IntFilterInput = {
341 and?: Maybe<Array<Maybe<Scalars['Int']>>>;
342 or?: Maybe<Array<Maybe<Scalars['Int']>>>;
343 not?: Maybe<IntFilterInput>;
344 eq?: Maybe<Scalars['Int']>;
345 eqi?: Maybe<Scalars['Int']>;
346 ne?: Maybe<Scalars['Int']>;
347 startsWith?: Maybe<Scalars['Int']>;
348 endsWith?: Maybe<Scalars['Int']>;
349 contains?: Maybe<Scalars['Int']>;
350 notContains?: Maybe<Scalars['Int']>;
351 containsi?: Maybe<Scalars['Int']>;
352 notContainsi?: Maybe<Scalars['Int']>;
353 gt?: Maybe<Scalars['Int']>;
354 gte?: Maybe<Scalars['Int']>;
355 lt?: Maybe<Scalars['Int']>;
356 lte?: Maybe<Scalars['Int']>;
357 null?: Maybe<Scalars['Boolean']>;
358 notNull?: Maybe<Scalars['Boolean']>;
359 in?: Maybe<Array<Maybe<Scalars['Int']>>>;
360 notIn?: Maybe<Array<Maybe<Scalars['Int']>>>;
361 between?: Maybe<Array<Maybe<Scalars['Int']>>>;
362};
363
364
365export type JsonFilterInput = {
366 and?: Maybe<Array<Maybe<Scalars['JSON']>>>;
367 or?: Maybe<Array<Maybe<Scalars['JSON']>>>;
368 not?: Maybe<JsonFilterInput>;
369 eq?: Maybe<Scalars['JSON']>;
370 eqi?: Maybe<Scalars['JSON']>;
371 ne?: Maybe<Scalars['JSON']>;
372 startsWith?: Maybe<Scalars['JSON']>;
373 endsWith?: Maybe<Scalars['JSON']>;
374 contains?: Maybe<Scalars['JSON']>;
375 notContains?: Maybe<Scalars['JSON']>;
376 containsi?: Maybe<Scalars['JSON']>;
377 notContainsi?: Maybe<Scalars['JSON']>;
378 gt?: Maybe<Scalars['JSON']>;
379 gte?: Maybe<Scalars['JSON']>;
380 lt?: Maybe<Scalars['JSON']>;
381 lte?: Maybe<Scalars['JSON']>;
382 null?: Maybe<Scalars['Boolean']>;
383 notNull?: Maybe<Scalars['Boolean']>;
384 in?: Maybe<Array<Maybe<Scalars['JSON']>>>;
385 notIn?: Maybe<Array<Maybe<Scalars['JSON']>>>;
386 between?: Maybe<Array<Maybe<Scalars['JSON']>>>;
387};
388
389export type Mutation = {
390 __typename?: 'Mutation';
391 createUploadFile?: Maybe<UploadFileEntityResponse>;
392 updateUploadFile?: Maybe<UploadFileEntityResponse>;
393 deleteUploadFile?: Maybe<UploadFileEntityResponse>;
394 createUploadFolder?: Maybe<UploadFolderEntityResponse>;
395 updateUploadFolder?: Maybe<UploadFolderEntityResponse>;
396 deleteUploadFolder?: Maybe<UploadFolderEntityResponse>;
397 createEmailDesignerEmailTemplate?: Maybe<EmailDesignerEmailTemplateEntityResponse>;
398 updateEmailDesignerEmailTemplate?: Maybe<EmailDesignerEmailTemplateEntityResponse>;
399 deleteEmailDesignerEmailTemplate?: Maybe<EmailDesignerEmailTemplateEntityResponse>;
400 createEvent?: Maybe<EventEntityResponse>;
401 updateEvent?: Maybe<EventEntityResponse>;
402 deleteEvent?: Maybe<EventEntityResponse>;
403 createPage?: Maybe<PageEntityResponse>;
404 updatePage?: Maybe<PageEntityResponse>;
405 deletePage?: Maybe<PageEntityResponse>;
406 createPassenger?: Maybe<PassengerEntityResponse>;
407 updatePassenger?: Maybe<PassengerEntityResponse>;
408 deletePassenger?: Maybe<PassengerEntityResponse>;
409 updateSetting?: Maybe<SettingEntityResponse>;
410 deleteSetting?: Maybe<SettingEntityResponse>;
411 createTravel?: Maybe<TravelEntityResponse>;
412 updateTravel?: Maybe<TravelEntityResponse>;
413 deleteTravel?: Maybe<TravelEntityResponse>;
414 createVehicle?: Maybe<VehicleEntityResponse>;
415 updateVehicle?: Maybe<VehicleEntityResponse>;
416 deleteVehicle?: Maybe<VehicleEntityResponse>;
417 upload: UploadFileEntityResponse;
418 multipleUpload: Array<Maybe<UploadFileEntityResponse>>;
419 updateFileInfo: UploadFileEntityResponse;
420 removeFile?: Maybe<UploadFileEntityResponse>;
421 createSettingLocalization?: Maybe<SettingEntityResponse>;
422 /** Create a new role */
423 createUsersPermissionsRole?: Maybe<UsersPermissionsCreateRolePayload>;
424 /** Update an existing role */
425 updateUsersPermissionsRole?: Maybe<UsersPermissionsUpdateRolePayload>;
426 /** Delete an existing role */
427 deleteUsersPermissionsRole?: Maybe<UsersPermissionsDeleteRolePayload>;
428 /** Create a new user */
429 createUsersPermissionsUser: UsersPermissionsUserEntityResponse;
430 /** Update an existing user */
431 updateUsersPermissionsUser: UsersPermissionsUserEntityResponse;
432 /** Delete an existing user */
433 deleteUsersPermissionsUser: UsersPermissionsUserEntityResponse;
434 login: UsersPermissionsLoginPayload;
435 /** Register a user */
436 register: UsersPermissionsLoginPayload;
437 /** Request a reset password token */
438 forgotPassword?: Maybe<UsersPermissionsPasswordPayload>;
439 /** Reset user password. Confirm with a code (resetToken from forgotPassword) */
440 resetPassword?: Maybe<UsersPermissionsLoginPayload>;
441 /** Change user password. Confirm with the current password. */
442 changePassword?: Maybe<UsersPermissionsLoginPayload>;
443 /** Confirm an email users email address */
444 emailConfirmation?: Maybe<UsersPermissionsLoginPayload>;
445 /** Update an event using its UUID */
446 updateEventByUUID?: Maybe<EventEntityResponse>;
447 updateMe: UsersPermissionsUserEntityResponse;
448};
449
450
451export type MutationCreateUploadFileArgs = {
452 data: UploadFileInput;
453};
454
455
456export type MutationUpdateUploadFileArgs = {
457 id: Scalars['ID'];
458 data: UploadFileInput;
459};
460
461
462export type MutationDeleteUploadFileArgs = {
463 id: Scalars['ID'];
464};
465
466
467export type MutationCreateUploadFolderArgs = {
468 data: UploadFolderInput;
469};
470
471
472export type MutationUpdateUploadFolderArgs = {
473 id: Scalars['ID'];
474 data: UploadFolderInput;
475};
476
477
478export type MutationDeleteUploadFolderArgs = {
479 id: Scalars['ID'];
480};
481
482
483export type MutationCreateEmailDesignerEmailTemplateArgs = {
484 data: EmailDesignerEmailTemplateInput;
485};
486
487
488export type MutationUpdateEmailDesignerEmailTemplateArgs = {
489 id: Scalars['ID'];
490 data: EmailDesignerEmailTemplateInput;
491};
492
493
494export type MutationDeleteEmailDesignerEmailTemplateArgs = {
495 id: Scalars['ID'];
496};
497
498
499export type MutationCreateEventArgs = {
500 data: EventInput;
501};
502
503
504export type MutationUpdateEventArgs = {
505 id: Scalars['ID'];
506 data: EventInput;
507};
508
509
510export type MutationDeleteEventArgs = {
511 id: Scalars['ID'];
512};
513
514
515export type MutationCreatePageArgs = {
516 data: PageInput;
517};
518
519
520export type MutationUpdatePageArgs = {
521 id: Scalars['ID'];
522 data: PageInput;
523};
524
525
526export type MutationDeletePageArgs = {
527 id: Scalars['ID'];
528};
529
530
531export type MutationCreatePassengerArgs = {
532 data: PassengerInput;
533};
534
535
536export type MutationUpdatePassengerArgs = {
537 id: Scalars['ID'];
538 data: PassengerInput;
539};
540
541
542export type MutationDeletePassengerArgs = {
543 id: Scalars['ID'];
544};
545
546
547export type MutationUpdateSettingArgs = {
548 data: SettingInput;
549 locale?: Maybe<Scalars['I18NLocaleCode']>;
550};
551
552
553export type MutationDeleteSettingArgs = {
554 locale?: Maybe<Scalars['I18NLocaleCode']>;
555};
556
557
558export type MutationCreateTravelArgs = {
559 data: TravelInput;
560 createVehicle?: Maybe<Scalars['Boolean']>;
561};
562
563
564export type MutationUpdateTravelArgs = {
565 id: Scalars['ID'];
566 data: TravelInput;
567};
568
569
570export type MutationDeleteTravelArgs = {
571 id: Scalars['ID'];
572};
573
574
575export type MutationCreateVehicleArgs = {
576 data: VehicleInput;
577};
578
579
580export type MutationUpdateVehicleArgs = {
581 id: Scalars['ID'];
582 data: VehicleInput;
583};
584
585
586export type MutationDeleteVehicleArgs = {
587 id: Scalars['ID'];
588};
589
590
591export type MutationUploadArgs = {
592 refId?: Maybe<Scalars['ID']>;
593 ref?: Maybe<Scalars['String']>;
594 field?: Maybe<Scalars['String']>;
595 info?: Maybe<FileInfoInput>;
596 file: Scalars['Upload'];
597};
598
599
600export type MutationMultipleUploadArgs = {
601 refId?: Maybe<Scalars['ID']>;
602 ref?: Maybe<Scalars['String']>;
603 field?: Maybe<Scalars['String']>;
604 files: Array<Maybe<Scalars['Upload']>>;
605};
606
607
608export type MutationUpdateFileInfoArgs = {
609 id: Scalars['ID'];
610 info?: Maybe<FileInfoInput>;
611};
612
613
614export type MutationRemoveFileArgs = {
615 id: Scalars['ID'];
616};
617
618
619export type MutationCreateSettingLocalizationArgs = {
620 id?: Maybe<Scalars['ID']>;
621 data?: Maybe<SettingInput>;
622 locale?: Maybe<Scalars['I18NLocaleCode']>;
623};
624
625
626export type MutationCreateUsersPermissionsRoleArgs = {
627 data: UsersPermissionsRoleInput;
628};
629
630
631export type MutationUpdateUsersPermissionsRoleArgs = {
632 id: Scalars['ID'];
633 data: UsersPermissionsRoleInput;
634};
635
636
637export type MutationDeleteUsersPermissionsRoleArgs = {
638 id: Scalars['ID'];
639};
640
641
642export type MutationCreateUsersPermissionsUserArgs = {
643 data: UsersPermissionsUserInput;
644};
645
646
647export type MutationUpdateUsersPermissionsUserArgs = {
648 id: Scalars['ID'];
649 data: UsersPermissionsUserInput;
650};
651
652
653export type MutationDeleteUsersPermissionsUserArgs = {
654 id: Scalars['ID'];
655};
656
657
658export type MutationLoginArgs = {
659 input: UsersPermissionsLoginInput;
660};
661
662
663export type MutationRegisterArgs = {
664 input: UsersPermissionsRegisterInput;
665};
666
667
668export type MutationForgotPasswordArgs = {
669 email: Scalars['String'];
670};
671
672
673export type MutationResetPasswordArgs = {
674 password: Scalars['String'];
675 passwordConfirmation: Scalars['String'];
676 code: Scalars['String'];
677};
678
679
680export type MutationChangePasswordArgs = {
681 currentPassword: Scalars['String'];
682 password: Scalars['String'];
683 passwordConfirmation: Scalars['String'];
684};
685
686
687export type MutationEmailConfirmationArgs = {
688 confirmation: Scalars['String'];
689};
690
691
692export type MutationUpdateEventByUuidArgs = {
693 uuid: Scalars['String'];
694 data: EventInput;
695};
696
697
698export type MutationUpdateMeArgs = {
699 data: UsersPermissionsUserInput;
700};
701
702export type Page = {
703 __typename?: 'Page';
704 name: Scalars['String'];
705 content?: Maybe<Scalars['String']>;
706 type?: Maybe<Enum_Page_Type>;
707 createdAt?: Maybe<Scalars['DateTime']>;
708 updatedAt?: Maybe<Scalars['DateTime']>;
709};
710
711export type PageEntity = {
712 __typename?: 'PageEntity';
713 id?: Maybe<Scalars['ID']>;
714 attributes?: Maybe<Page>;
715};
716
717export type PageEntityResponse = {
718 __typename?: 'PageEntityResponse';
719 data?: Maybe<PageEntity>;
720};
721
722export type PageEntityResponseCollection = {
723 __typename?: 'PageEntityResponseCollection';
724 data: Array<PageEntity>;
725 meta: ResponseCollectionMeta;
726};
727
728export type PageFiltersInput = {
729 id?: Maybe<IdFilterInput>;
730 name?: Maybe<StringFilterInput>;
731 content?: Maybe<StringFilterInput>;
732 type?: Maybe<StringFilterInput>;
733 createdAt?: Maybe<DateTimeFilterInput>;
734 updatedAt?: Maybe<DateTimeFilterInput>;
735 and?: Maybe<Array<Maybe<PageFiltersInput>>>;
736 or?: Maybe<Array<Maybe<PageFiltersInput>>>;
737 not?: Maybe<PageFiltersInput>;
738};
739
740export type PageInput = {
741 name?: Maybe<Scalars['String']>;
742 content?: Maybe<Scalars['String']>;
743 type?: Maybe<Enum_Page_Type>;
744};
745
746export type Pagination = {
747 __typename?: 'Pagination';
748 total: Scalars['Int'];
749 page: Scalars['Int'];
750 pageSize: Scalars['Int'];
751 pageCount: Scalars['Int'];
752};
753
754export type PaginationArg = {
755 page?: Maybe<Scalars['Int']>;
756 pageSize?: Maybe<Scalars['Int']>;
757 start?: Maybe<Scalars['Int']>;
758 limit?: Maybe<Scalars['Int']>;
759};
760
761export type Passenger = {
762 __typename?: 'Passenger';
763 name: Scalars['String'];
764 email?: Maybe<Scalars['String']>;
765 location?: Maybe<Scalars['String']>;
766 event?: Maybe<EventEntityResponse>;
767 user?: Maybe<UsersPermissionsUserEntityResponse>;
768 travel?: Maybe<TravelEntityResponse>;
769 createdAt?: Maybe<Scalars['DateTime']>;
770 updatedAt?: Maybe<Scalars['DateTime']>;
771};
772
773export type PassengerEntity = {
774 __typename?: 'PassengerEntity';
775 id?: Maybe<Scalars['ID']>;
776 attributes?: Maybe<Passenger>;
777};
778
779export type PassengerEntityResponse = {
780 __typename?: 'PassengerEntityResponse';
781 data?: Maybe<PassengerEntity>;
782};
783
784export type PassengerFiltersInput = {
785 id?: Maybe<IdFilterInput>;
786 name?: Maybe<StringFilterInput>;
787 email?: Maybe<StringFilterInput>;
788 location?: Maybe<StringFilterInput>;
789 event?: Maybe<EventFiltersInput>;
790 user?: Maybe<UsersPermissionsUserFiltersInput>;
791 travel?: Maybe<TravelFiltersInput>;
792 createdAt?: Maybe<DateTimeFilterInput>;
793 updatedAt?: Maybe<DateTimeFilterInput>;
794 and?: Maybe<Array<Maybe<PassengerFiltersInput>>>;
795 or?: Maybe<Array<Maybe<PassengerFiltersInput>>>;
796 not?: Maybe<PassengerFiltersInput>;
797};
798
799export type PassengerInput = {
800 name?: Maybe<Scalars['String']>;
801 email?: Maybe<Scalars['String']>;
802 location?: Maybe<Scalars['String']>;
803 event?: Maybe<Scalars['ID']>;
804 user?: Maybe<Scalars['ID']>;
805 travel?: Maybe<Scalars['ID']>;
806};
807
808export type PassengerRelationResponseCollection = {
809 __typename?: 'PassengerRelationResponseCollection';
810 data: Array<PassengerEntity>;
811};
812
813export type Query = {
814 __typename?: 'Query';
815 uploadFile?: Maybe<UploadFileEntityResponse>;
816 uploadFiles?: Maybe<UploadFileEntityResponseCollection>;
817 uploadFolder?: Maybe<UploadFolderEntityResponse>;
818 uploadFolders?: Maybe<UploadFolderEntityResponseCollection>;
819 i18NLocale?: Maybe<I18NLocaleEntityResponse>;
820 i18NLocales?: Maybe<I18NLocaleEntityResponseCollection>;
821 usersPermissionsRole?: Maybe<UsersPermissionsRoleEntityResponse>;
822 usersPermissionsRoles?: Maybe<UsersPermissionsRoleEntityResponseCollection>;
823 usersPermissionsUser?: Maybe<UsersPermissionsUserEntityResponse>;
824 emailDesignerEmailTemplate?: Maybe<EmailDesignerEmailTemplateEntityResponse>;
825 emailDesignerEmailTemplates?: Maybe<EmailDesignerEmailTemplateEntityResponseCollection>;
826 event?: Maybe<EventEntityResponse>;
827 page?: Maybe<PageEntityResponse>;
828 pages?: Maybe<PageEntityResponseCollection>;
829 passenger?: Maybe<PassengerEntityResponse>;
830 setting?: Maybe<SettingEntityResponse>;
831 travel?: Maybe<TravelEntityResponse>;
832 vehicle?: Maybe<VehicleEntityResponse>;
833 me?: Maybe<UsersPermissionsMe>;
834 /** Retrieve an event using its UUID */
835 eventByUUID?: Maybe<EventEntityResponse>;
836};
837
838
839export type QueryUploadFileArgs = {
840 id?: Maybe<Scalars['ID']>;
841};
842
843
844export type QueryUploadFilesArgs = {
845 filters?: Maybe<UploadFileFiltersInput>;
846 pagination?: Maybe<PaginationArg>;
847 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
848};
849
850
851export type QueryUploadFolderArgs = {
852 id?: Maybe<Scalars['ID']>;
853};
854
855
856export type QueryUploadFoldersArgs = {
857 filters?: Maybe<UploadFolderFiltersInput>;
858 pagination?: Maybe<PaginationArg>;
859 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
860};
861
862
863export type QueryI18NLocaleArgs = {
864 id?: Maybe<Scalars['ID']>;
865};
866
867
868export type QueryI18NLocalesArgs = {
869 filters?: Maybe<I18NLocaleFiltersInput>;
870 pagination?: Maybe<PaginationArg>;
871 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
872};
873
874
875export type QueryUsersPermissionsRoleArgs = {
876 id?: Maybe<Scalars['ID']>;
877};
878
879
880export type QueryUsersPermissionsRolesArgs = {
881 filters?: Maybe<UsersPermissionsRoleFiltersInput>;
882 pagination?: Maybe<PaginationArg>;
883 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
884};
885
886
887export type QueryUsersPermissionsUserArgs = {
888 id?: Maybe<Scalars['ID']>;
889};
890
891
892export type QueryEmailDesignerEmailTemplateArgs = {
893 id?: Maybe<Scalars['ID']>;
894};
895
896
897export type QueryEmailDesignerEmailTemplatesArgs = {
898 filters?: Maybe<EmailDesignerEmailTemplateFiltersInput>;
899 pagination?: Maybe<PaginationArg>;
900 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
901};
902
903
904export type QueryEventArgs = {
905 id?: Maybe<Scalars['ID']>;
906};
907
908
909export type QueryPageArgs = {
910 id?: Maybe<Scalars['ID']>;
911};
912
913
914export type QueryPagesArgs = {
915 filters?: Maybe<PageFiltersInput>;
916 pagination?: Maybe<PaginationArg>;
917 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
918};
919
920
921export type QueryPassengerArgs = {
922 id?: Maybe<Scalars['ID']>;
923};
924
925
926export type QuerySettingArgs = {
927 locale?: Maybe<Scalars['I18NLocaleCode']>;
928};
929
930
931export type QueryTravelArgs = {
932 id?: Maybe<Scalars['ID']>;
933};
934
935
936export type QueryVehicleArgs = {
937 id?: Maybe<Scalars['ID']>;
938};
939
940
941export type QueryEventByUuidArgs = {
942 uuid: Scalars['String'];
943};
944
945export type ResponseCollectionMeta = {
946 __typename?: 'ResponseCollectionMeta';
947 pagination: Pagination;
948};
949
950export type Setting = {
951 __typename?: 'Setting';
952 gtm_id?: Maybe<Scalars['String']>;
953 about_link?: Maybe<Scalars['String']>;
954 faq_link?: Maybe<Scalars['String']>;
955 announcement?: Maybe<Scalars['String']>;
956 createdAt?: Maybe<Scalars['DateTime']>;
957 updatedAt?: Maybe<Scalars['DateTime']>;
958 localizations?: Maybe<SettingRelationResponseCollection>;
959 locale?: Maybe<Scalars['String']>;
960};
961
962export type SettingEntity = {
963 __typename?: 'SettingEntity';
964 id?: Maybe<Scalars['ID']>;
965 attributes?: Maybe<Setting>;
966};
967
968export type SettingEntityResponse = {
969 __typename?: 'SettingEntityResponse';
970 data?: Maybe<SettingEntity>;
971};
972
973export type SettingInput = {
974 gtm_id?: Maybe<Scalars['String']>;
975 about_link?: Maybe<Scalars['String']>;
976 faq_link?: Maybe<Scalars['String']>;
977 announcement?: Maybe<Scalars['String']>;
978};
979
980export type SettingRelationResponseCollection = {
981 __typename?: 'SettingRelationResponseCollection';
982 data: Array<SettingEntity>;
983};
984
985export type StringFilterInput = {
986 and?: Maybe<Array<Maybe<Scalars['String']>>>;
987 or?: Maybe<Array<Maybe<Scalars['String']>>>;
988 not?: Maybe<StringFilterInput>;
989 eq?: Maybe<Scalars['String']>;
990 eqi?: Maybe<Scalars['String']>;
991 ne?: Maybe<Scalars['String']>;
992 startsWith?: Maybe<Scalars['String']>;
993 endsWith?: Maybe<Scalars['String']>;
994 contains?: Maybe<Scalars['String']>;
995 notContains?: Maybe<Scalars['String']>;
996 containsi?: Maybe<Scalars['String']>;
997 notContainsi?: Maybe<Scalars['String']>;
998 gt?: Maybe<Scalars['String']>;
999 gte?: Maybe<Scalars['String']>;
1000 lt?: Maybe<Scalars['String']>;
1001 lte?: Maybe<Scalars['String']>;
1002 null?: Maybe<Scalars['Boolean']>;
1003 notNull?: Maybe<Scalars['Boolean']>;
1004 in?: Maybe<Array<Maybe<Scalars['String']>>>;
1005 notIn?: Maybe<Array<Maybe<Scalars['String']>>>;
1006 between?: Maybe<Array<Maybe<Scalars['String']>>>;
1007};
1008
1009export type Travel = {
1010 __typename?: 'Travel';
1011 meeting?: Maybe<Scalars['String']>;
1012 departure?: Maybe<Scalars['DateTime']>;
1013 details?: Maybe<Scalars['String']>;
1014 vehicleName?: Maybe<Scalars['String']>;
1015 seats?: Maybe<Scalars['Int']>;
1016 phone_number?: Maybe<Scalars['String']>;
1017 event?: Maybe<EventEntityResponse>;
1018 passengers?: Maybe<PassengerRelationResponseCollection>;
1019 createdAt?: Maybe<Scalars['DateTime']>;
1020 updatedAt?: Maybe<Scalars['DateTime']>;
1021};
1022
1023
1024export type TravelPassengersArgs = {
1025 filters?: Maybe<PassengerFiltersInput>;
1026 pagination?: Maybe<PaginationArg>;
1027 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1028};
1029
1030export type TravelEntity = {
1031 __typename?: 'TravelEntity';
1032 id?: Maybe<Scalars['ID']>;
1033 attributes?: Maybe<Travel>;
1034};
1035
1036export type TravelEntityResponse = {
1037 __typename?: 'TravelEntityResponse';
1038 data?: Maybe<TravelEntity>;
1039};
1040
1041export type TravelFiltersInput = {
1042 id?: Maybe<IdFilterInput>;
1043 meeting?: Maybe<StringFilterInput>;
1044 departure?: Maybe<DateTimeFilterInput>;
1045 details?: Maybe<StringFilterInput>;
1046 vehicleName?: Maybe<StringFilterInput>;
1047 seats?: Maybe<IntFilterInput>;
1048 phone_number?: Maybe<StringFilterInput>;
1049 event?: Maybe<EventFiltersInput>;
1050 passengers?: Maybe<PassengerFiltersInput>;
1051 createdAt?: Maybe<DateTimeFilterInput>;
1052 updatedAt?: Maybe<DateTimeFilterInput>;
1053 and?: Maybe<Array<Maybe<TravelFiltersInput>>>;
1054 or?: Maybe<Array<Maybe<TravelFiltersInput>>>;
1055 not?: Maybe<TravelFiltersInput>;
1056};
1057
1058export type TravelInput = {
1059 meeting?: Maybe<Scalars['String']>;
1060 departure?: Maybe<Scalars['DateTime']>;
1061 details?: Maybe<Scalars['String']>;
1062 vehicleName?: Maybe<Scalars['String']>;
1063 seats?: Maybe<Scalars['Int']>;
1064 phone_number?: Maybe<Scalars['String']>;
1065 event?: Maybe<Scalars['ID']>;
1066 passengers?: Maybe<Array<Maybe<Scalars['ID']>>>;
1067};
1068
1069export type TravelRelationResponseCollection = {
1070 __typename?: 'TravelRelationResponseCollection';
1071 data: Array<TravelEntity>;
1072};
1073
1074
1075export type UploadFile = {
1076 __typename?: 'UploadFile';
1077 name: Scalars['String'];
1078 alternativeText?: Maybe<Scalars['String']>;
1079 caption?: Maybe<Scalars['String']>;
1080 width?: Maybe<Scalars['Int']>;
1081 height?: Maybe<Scalars['Int']>;
1082 formats?: Maybe<Scalars['JSON']>;
1083 hash: Scalars['String'];
1084 ext?: Maybe<Scalars['String']>;
1085 mime: Scalars['String'];
1086 size: Scalars['Float'];
1087 url: Scalars['String'];
1088 previewUrl?: Maybe<Scalars['String']>;
1089 provider: Scalars['String'];
1090 provider_metadata?: Maybe<Scalars['JSON']>;
1091 related?: Maybe<Array<Maybe<GenericMorph>>>;
1092 createdAt?: Maybe<Scalars['DateTime']>;
1093 updatedAt?: Maybe<Scalars['DateTime']>;
1094};
1095
1096export type UploadFileEntity = {
1097 __typename?: 'UploadFileEntity';
1098 id?: Maybe<Scalars['ID']>;
1099 attributes?: Maybe<UploadFile>;
1100};
1101
1102export type UploadFileEntityResponse = {
1103 __typename?: 'UploadFileEntityResponse';
1104 data?: Maybe<UploadFileEntity>;
1105};
1106
1107export type UploadFileEntityResponseCollection = {
1108 __typename?: 'UploadFileEntityResponseCollection';
1109 data: Array<UploadFileEntity>;
1110 meta: ResponseCollectionMeta;
1111};
1112
1113export type UploadFileFiltersInput = {
1114 id?: Maybe<IdFilterInput>;
1115 name?: Maybe<StringFilterInput>;
1116 alternativeText?: Maybe<StringFilterInput>;
1117 caption?: Maybe<StringFilterInput>;
1118 width?: Maybe<IntFilterInput>;
1119 height?: Maybe<IntFilterInput>;
1120 formats?: Maybe<JsonFilterInput>;
1121 hash?: Maybe<StringFilterInput>;
1122 ext?: Maybe<StringFilterInput>;
1123 mime?: Maybe<StringFilterInput>;
1124 size?: Maybe<FloatFilterInput>;
1125 url?: Maybe<StringFilterInput>;
1126 previewUrl?: Maybe<StringFilterInput>;
1127 provider?: Maybe<StringFilterInput>;
1128 provider_metadata?: Maybe<JsonFilterInput>;
1129 folder?: Maybe<UploadFolderFiltersInput>;
1130 folderPath?: Maybe<StringFilterInput>;
1131 createdAt?: Maybe<DateTimeFilterInput>;
1132 updatedAt?: Maybe<DateTimeFilterInput>;
1133 and?: Maybe<Array<Maybe<UploadFileFiltersInput>>>;
1134 or?: Maybe<Array<Maybe<UploadFileFiltersInput>>>;
1135 not?: Maybe<UploadFileFiltersInput>;
1136};
1137
1138export type UploadFileInput = {
1139 name?: Maybe<Scalars['String']>;
1140 alternativeText?: Maybe<Scalars['String']>;
1141 caption?: Maybe<Scalars['String']>;
1142 width?: Maybe<Scalars['Int']>;
1143 height?: Maybe<Scalars['Int']>;
1144 formats?: Maybe<Scalars['JSON']>;
1145 hash?: Maybe<Scalars['String']>;
1146 ext?: Maybe<Scalars['String']>;
1147 mime?: Maybe<Scalars['String']>;
1148 size?: Maybe<Scalars['Float']>;
1149 url?: Maybe<Scalars['String']>;
1150 previewUrl?: Maybe<Scalars['String']>;
1151 provider?: Maybe<Scalars['String']>;
1152 provider_metadata?: Maybe<Scalars['JSON']>;
1153 folder?: Maybe<Scalars['ID']>;
1154 folderPath?: Maybe<Scalars['String']>;
1155};
1156
1157export type UploadFileRelationResponseCollection = {
1158 __typename?: 'UploadFileRelationResponseCollection';
1159 data: Array<UploadFileEntity>;
1160};
1161
1162export type UploadFolder = {
1163 __typename?: 'UploadFolder';
1164 name: Scalars['String'];
1165 pathId: Scalars['Int'];
1166 parent?: Maybe<UploadFolderEntityResponse>;
1167 children?: Maybe<UploadFolderRelationResponseCollection>;
1168 files?: Maybe<UploadFileRelationResponseCollection>;
1169 path: Scalars['String'];
1170 createdAt?: Maybe<Scalars['DateTime']>;
1171 updatedAt?: Maybe<Scalars['DateTime']>;
1172};
1173
1174
1175export type UploadFolderChildrenArgs = {
1176 filters?: Maybe<UploadFolderFiltersInput>;
1177 pagination?: Maybe<PaginationArg>;
1178 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1179};
1180
1181
1182export type UploadFolderFilesArgs = {
1183 filters?: Maybe<UploadFileFiltersInput>;
1184 pagination?: Maybe<PaginationArg>;
1185 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1186};
1187
1188export type UploadFolderEntity = {
1189 __typename?: 'UploadFolderEntity';
1190 id?: Maybe<Scalars['ID']>;
1191 attributes?: Maybe<UploadFolder>;
1192};
1193
1194export type UploadFolderEntityResponse = {
1195 __typename?: 'UploadFolderEntityResponse';
1196 data?: Maybe<UploadFolderEntity>;
1197};
1198
1199export type UploadFolderEntityResponseCollection = {
1200 __typename?: 'UploadFolderEntityResponseCollection';
1201 data: Array<UploadFolderEntity>;
1202 meta: ResponseCollectionMeta;
1203};
1204
1205export type UploadFolderFiltersInput = {
1206 id?: Maybe<IdFilterInput>;
1207 name?: Maybe<StringFilterInput>;
1208 pathId?: Maybe<IntFilterInput>;
1209 parent?: Maybe<UploadFolderFiltersInput>;
1210 children?: Maybe<UploadFolderFiltersInput>;
1211 files?: Maybe<UploadFileFiltersInput>;
1212 path?: Maybe<StringFilterInput>;
1213 createdAt?: Maybe<DateTimeFilterInput>;
1214 updatedAt?: Maybe<DateTimeFilterInput>;
1215 and?: Maybe<Array<Maybe<UploadFolderFiltersInput>>>;
1216 or?: Maybe<Array<Maybe<UploadFolderFiltersInput>>>;
1217 not?: Maybe<UploadFolderFiltersInput>;
1218};
1219
1220export type UploadFolderInput = {
1221 name?: Maybe<Scalars['String']>;
1222 pathId?: Maybe<Scalars['Int']>;
1223 parent?: Maybe<Scalars['ID']>;
1224 children?: Maybe<Array<Maybe<Scalars['ID']>>>;
1225 files?: Maybe<Array<Maybe<Scalars['ID']>>>;
1226 path?: Maybe<Scalars['String']>;
1227};
1228
1229export type UploadFolderRelationResponseCollection = {
1230 __typename?: 'UploadFolderRelationResponseCollection';
1231 data: Array<UploadFolderEntity>;
1232};
1233
1234export type UsersPermissionsCreateRolePayload = {
1235 __typename?: 'UsersPermissionsCreateRolePayload';
1236 ok: Scalars['Boolean'];
1237};
1238
1239export type UsersPermissionsDeleteRolePayload = {
1240 __typename?: 'UsersPermissionsDeleteRolePayload';
1241 ok: Scalars['Boolean'];
1242};
1243
1244export type UsersPermissionsLoginInput = {
1245 identifier: Scalars['String'];
1246 password: Scalars['String'];
1247 provider?: Scalars['String'];
1248};
1249
1250export type UsersPermissionsLoginPayload = {
1251 __typename?: 'UsersPermissionsLoginPayload';
1252 jwt?: Maybe<Scalars['String']>;
1253 user: UsersPermissionsMe;
1254};
1255
1256export type UsersPermissionsMe = {
1257 __typename?: 'UsersPermissionsMe';
1258 id: Scalars['ID'];
1259 username: Scalars['String'];
1260 email?: Maybe<Scalars['String']>;
1261 confirmed?: Maybe<Scalars['Boolean']>;
1262 blocked?: Maybe<Scalars['Boolean']>;
1263 role?: Maybe<UsersPermissionsMeRole>;
1264 profile?: Maybe<UsersPermissionsUser>;
1265};
1266
1267export type UsersPermissionsMeRole = {
1268 __typename?: 'UsersPermissionsMeRole';
1269 id: Scalars['ID'];
1270 name: Scalars['String'];
1271 description?: Maybe<Scalars['String']>;
1272 type?: Maybe<Scalars['String']>;
1273};
1274
1275export type UsersPermissionsPasswordPayload = {
1276 __typename?: 'UsersPermissionsPasswordPayload';
1277 ok: Scalars['Boolean'];
1278};
1279
1280export type UsersPermissionsPermission = {
1281 __typename?: 'UsersPermissionsPermission';
1282 action: Scalars['String'];
1283 role?: Maybe<UsersPermissionsRoleEntityResponse>;
1284 createdAt?: Maybe<Scalars['DateTime']>;
1285 updatedAt?: Maybe<Scalars['DateTime']>;
1286};
1287
1288export type UsersPermissionsPermissionEntity = {
1289 __typename?: 'UsersPermissionsPermissionEntity';
1290 id?: Maybe<Scalars['ID']>;
1291 attributes?: Maybe<UsersPermissionsPermission>;
1292};
1293
1294export type UsersPermissionsPermissionFiltersInput = {
1295 id?: Maybe<IdFilterInput>;
1296 action?: Maybe<StringFilterInput>;
1297 role?: Maybe<UsersPermissionsRoleFiltersInput>;
1298 createdAt?: Maybe<DateTimeFilterInput>;
1299 updatedAt?: Maybe<DateTimeFilterInput>;
1300 and?: Maybe<Array<Maybe<UsersPermissionsPermissionFiltersInput>>>;
1301 or?: Maybe<Array<Maybe<UsersPermissionsPermissionFiltersInput>>>;
1302 not?: Maybe<UsersPermissionsPermissionFiltersInput>;
1303};
1304
1305export type UsersPermissionsPermissionRelationResponseCollection = {
1306 __typename?: 'UsersPermissionsPermissionRelationResponseCollection';
1307 data: Array<UsersPermissionsPermissionEntity>;
1308};
1309
1310export type UsersPermissionsRegisterInput = {
1311 username: Scalars['String'];
1312 email: Scalars['String'];
1313 password: Scalars['String'];
1314 firstName?: Maybe<Scalars['String']>;
1315 lastName?: Maybe<Scalars['String']>;
1316 lang?: Maybe<Scalars['String']>;
1317};
1318
1319export type UsersPermissionsRole = {
1320 __typename?: 'UsersPermissionsRole';
1321 name: Scalars['String'];
1322 description?: Maybe<Scalars['String']>;
1323 type?: Maybe<Scalars['String']>;
1324 permissions?: Maybe<UsersPermissionsPermissionRelationResponseCollection>;
1325 users?: Maybe<UsersPermissionsUserRelationResponseCollection>;
1326 createdAt?: Maybe<Scalars['DateTime']>;
1327 updatedAt?: Maybe<Scalars['DateTime']>;
1328};
1329
1330
1331export type UsersPermissionsRolePermissionsArgs = {
1332 filters?: Maybe<UsersPermissionsPermissionFiltersInput>;
1333 pagination?: Maybe<PaginationArg>;
1334 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1335};
1336
1337
1338export type UsersPermissionsRoleUsersArgs = {
1339 filters?: Maybe<UsersPermissionsUserFiltersInput>;
1340 pagination?: Maybe<PaginationArg>;
1341 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1342};
1343
1344export type UsersPermissionsRoleEntity = {
1345 __typename?: 'UsersPermissionsRoleEntity';
1346 id?: Maybe<Scalars['ID']>;
1347 attributes?: Maybe<UsersPermissionsRole>;
1348};
1349
1350export type UsersPermissionsRoleEntityResponse = {
1351 __typename?: 'UsersPermissionsRoleEntityResponse';
1352 data?: Maybe<UsersPermissionsRoleEntity>;
1353};
1354
1355export type UsersPermissionsRoleEntityResponseCollection = {
1356 __typename?: 'UsersPermissionsRoleEntityResponseCollection';
1357 data: Array<UsersPermissionsRoleEntity>;
1358 meta: ResponseCollectionMeta;
1359};
1360
1361export type UsersPermissionsRoleFiltersInput = {
1362 id?: Maybe<IdFilterInput>;
1363 name?: Maybe<StringFilterInput>;
1364 description?: Maybe<StringFilterInput>;
1365 type?: Maybe<StringFilterInput>;
1366 permissions?: Maybe<UsersPermissionsPermissionFiltersInput>;
1367 users?: Maybe<UsersPermissionsUserFiltersInput>;
1368 createdAt?: Maybe<DateTimeFilterInput>;
1369 updatedAt?: Maybe<DateTimeFilterInput>;
1370 and?: Maybe<Array<Maybe<UsersPermissionsRoleFiltersInput>>>;
1371 or?: Maybe<Array<Maybe<UsersPermissionsRoleFiltersInput>>>;
1372 not?: Maybe<UsersPermissionsRoleFiltersInput>;
1373};
1374
1375export type UsersPermissionsRoleInput = {
1376 name?: Maybe<Scalars['String']>;
1377 description?: Maybe<Scalars['String']>;
1378 type?: Maybe<Scalars['String']>;
1379 permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
1380 users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1381};
1382
1383export type UsersPermissionsUpdateRolePayload = {
1384 __typename?: 'UsersPermissionsUpdateRolePayload';
1385 ok: Scalars['Boolean'];
1386};
1387
1388export type UsersPermissionsUser = {
1389 __typename?: 'UsersPermissionsUser';
1390 username: Scalars['String'];
1391 email: Scalars['String'];
1392 confirmed?: Maybe<Scalars['Boolean']>;
1393 role?: Maybe<UsersPermissionsRoleEntityResponse>;
1394 events?: Maybe<EventRelationResponseCollection>;
1395 vehicles?: Maybe<VehicleRelationResponseCollection>;
1396 firstName?: Maybe<Scalars['String']>;
1397 lastName?: Maybe<Scalars['String']>;
1398 onboardingUser?: Maybe<Scalars['Boolean']>;
1399 onboardingCreator?: Maybe<Scalars['Boolean']>;
1400 lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1401 createdAt?: Maybe<Scalars['DateTime']>;
1402 updatedAt?: Maybe<Scalars['DateTime']>;
1403};
1404
1405
1406export type UsersPermissionsUserEventsArgs = {
1407 filters?: Maybe<EventFiltersInput>;
1408 pagination?: Maybe<PaginationArg>;
1409 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1410};
1411
1412
1413export type UsersPermissionsUserVehiclesArgs = {
1414 filters?: Maybe<VehicleFiltersInput>;
1415 pagination?: Maybe<PaginationArg>;
1416 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1417};
1418
1419export type UsersPermissionsUserEntity = {
1420 __typename?: 'UsersPermissionsUserEntity';
1421 id?: Maybe<Scalars['ID']>;
1422 attributes?: Maybe<UsersPermissionsUser>;
1423};
1424
1425export type UsersPermissionsUserEntityResponse = {
1426 __typename?: 'UsersPermissionsUserEntityResponse';
1427 data?: Maybe<UsersPermissionsUserEntity>;
1428};
1429
1430export type UsersPermissionsUserFiltersInput = {
1431 id?: Maybe<IdFilterInput>;
1432 username?: Maybe<StringFilterInput>;
1433 email?: Maybe<StringFilterInput>;
1434 provider?: Maybe<StringFilterInput>;
1435 password?: Maybe<StringFilterInput>;
1436 resetPasswordToken?: Maybe<StringFilterInput>;
1437 confirmationToken?: Maybe<StringFilterInput>;
1438 confirmed?: Maybe<BooleanFilterInput>;
1439 blocked?: Maybe<BooleanFilterInput>;
1440 role?: Maybe<UsersPermissionsRoleFiltersInput>;
1441 events?: Maybe<EventFiltersInput>;
1442 passengers?: Maybe<PassengerFiltersInput>;
1443 vehicles?: Maybe<VehicleFiltersInput>;
1444 firstName?: Maybe<StringFilterInput>;
1445 lastName?: Maybe<StringFilterInput>;
1446 onboardingUser?: Maybe<BooleanFilterInput>;
1447 onboardingCreator?: Maybe<BooleanFilterInput>;
1448 lang?: Maybe<StringFilterInput>;
1449 createdAt?: Maybe<DateTimeFilterInput>;
1450 updatedAt?: Maybe<DateTimeFilterInput>;
1451 and?: Maybe<Array<Maybe<UsersPermissionsUserFiltersInput>>>;
1452 or?: Maybe<Array<Maybe<UsersPermissionsUserFiltersInput>>>;
1453 not?: Maybe<UsersPermissionsUserFiltersInput>;
1454};
1455
1456export type UsersPermissionsUserInput = {
1457 username?: Maybe<Scalars['String']>;
1458 email?: Maybe<Scalars['String']>;
1459 provider?: Maybe<Scalars['String']>;
1460 password?: Maybe<Scalars['String']>;
1461 resetPasswordToken?: Maybe<Scalars['String']>;
1462 confirmationToken?: Maybe<Scalars['String']>;
1463 confirmed?: Maybe<Scalars['Boolean']>;
1464 blocked?: Maybe<Scalars['Boolean']>;
1465 role?: Maybe<Scalars['ID']>;
1466 events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1467 passengers?: Maybe<Array<Maybe<Scalars['ID']>>>;
1468 vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1469 firstName?: Maybe<Scalars['String']>;
1470 lastName?: Maybe<Scalars['String']>;
1471 onboardingUser?: Maybe<Scalars['Boolean']>;
1472 onboardingCreator?: Maybe<Scalars['Boolean']>;
1473 lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1474 oldPassword?: Maybe<Scalars['String']>;
1475};
1476
1477export type UsersPermissionsUserRelationResponseCollection = {
1478 __typename?: 'UsersPermissionsUserRelationResponseCollection';
1479 data: Array<UsersPermissionsUserEntity>;
1480};
1481
1482export type Vehicle = {
1483 __typename?: 'Vehicle';
1484 name: Scalars['String'];
1485 seats?: Maybe<Scalars['Int']>;
1486 phone_number?: Maybe<Scalars['String']>;
1487 user?: Maybe<UsersPermissionsUserEntityResponse>;
1488 createdAt?: Maybe<Scalars['DateTime']>;
1489 updatedAt?: Maybe<Scalars['DateTime']>;
1490};
1491
1492export type VehicleEntity = {
1493 __typename?: 'VehicleEntity';
1494 id?: Maybe<Scalars['ID']>;
1495 attributes?: Maybe<Vehicle>;
1496};
1497
1498export type VehicleEntityResponse = {
1499 __typename?: 'VehicleEntityResponse';
1500 data?: Maybe<VehicleEntity>;
1501};
1502
1503export type VehicleFiltersInput = {
1504 id?: Maybe<IdFilterInput>;
1505 name?: Maybe<StringFilterInput>;
1506 seats?: Maybe<IntFilterInput>;
1507 phone_number?: Maybe<StringFilterInput>;
1508 user?: Maybe<UsersPermissionsUserFiltersInput>;
1509 createdAt?: Maybe<DateTimeFilterInput>;
1510 updatedAt?: Maybe<DateTimeFilterInput>;
1511 and?: Maybe<Array<Maybe<VehicleFiltersInput>>>;
1512 or?: Maybe<Array<Maybe<VehicleFiltersInput>>>;
1513 not?: Maybe<VehicleFiltersInput>;
1514};
1515
1516export type VehicleInput = {
1517 name?: Maybe<Scalars['String']>;
1518 seats?: Maybe<Scalars['Int']>;
1519 phone_number?: Maybe<Scalars['String']>;
1520 user?: Maybe<Scalars['ID']>;
1521};
1522
1523export type VehicleRelationResponseCollection = {
1524 __typename?: 'VehicleRelationResponseCollection';
1525 data: Array<VehicleEntity>;
1526};
1527
1528export type MeFieldsFragment = (
1529 { __typename?: 'UsersPermissionsMe' }
1530 & Pick<UsersPermissionsMe, 'id' | 'username' | 'email' | 'confirmed'>
1531);
1532
1533export type RegisterMutationVariables = Exact<{
1534 user: UsersPermissionsRegisterInput;
1535}>;
1536
1537
1538export type RegisterMutation = (
1539 { __typename?: 'Mutation' }
1540 & { register: (
1541 { __typename?: 'UsersPermissionsLoginPayload' }
1542 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1543 & { user: (
1544 { __typename?: 'UsersPermissionsMe' }
1545 & MeFieldsFragment
1546 ) }
1547 ) }
1548);
1549
1550export type LoginMutationVariables = Exact<{
1551 identifier: Scalars['String'];
1552 password: Scalars['String'];
1553}>;
1554
1555
1556export type LoginMutation = (
1557 { __typename?: 'Mutation' }
1558 & { login: (
1559 { __typename?: 'UsersPermissionsLoginPayload' }
1560 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1561 & { user: (
1562 { __typename?: 'UsersPermissionsMe' }
1563 & MeFieldsFragment
1564 ) }
1565 ) }
1566);
1567
1568export type ForgotPasswordMutationVariables = Exact<{
1569 email: Scalars['String'];
1570}>;
1571
1572
1573export type ForgotPasswordMutation = (
1574 { __typename?: 'Mutation' }
1575 & { forgotPassword?: Maybe<(
1576 { __typename?: 'UsersPermissionsPasswordPayload' }
1577 & Pick<UsersPermissionsPasswordPayload, 'ok'>
1578 )> }
1579);
1580
1581export type ResetPasswordMutationVariables = Exact<{
1582 password: Scalars['String'];
1583 passwordConfirmation: Scalars['String'];
1584 code: Scalars['String'];
1585}>;
1586
1587
1588export type ResetPasswordMutation = (
1589 { __typename?: 'Mutation' }
1590 & { resetPassword?: Maybe<(
1591 { __typename?: 'UsersPermissionsLoginPayload' }
1592 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1593 & { user: (
1594 { __typename?: 'UsersPermissionsMe' }
1595 & MeFieldsFragment
1596 ) }
1597 )> }
1598);
1599
1600export type EventFieldsFragment = (
1601 { __typename?: 'EventEntity' }
1602 & Pick<EventEntity, 'id'>
1603 & { attributes?: Maybe<(
1604 { __typename?: 'Event' }
1605 & Pick<Event, 'uuid' | 'name' | 'description' | 'email' | 'date' | 'address' | 'position'>
1606 & { waitingPassengers?: Maybe<(
1607 { __typename?: 'PassengerRelationResponseCollection' }
1608 & { data: Array<(
1609 { __typename?: 'PassengerEntity' }
1610 & Pick<PassengerEntity, 'id'>
1611 & { attributes?: Maybe<(
1612 { __typename?: 'Passenger' }
1613 & Pick<Passenger, 'name' | 'email' | 'location'>
1614 & { user?: Maybe<(
1615 { __typename?: 'UsersPermissionsUserEntityResponse' }
1616 & { data?: Maybe<(
1617 { __typename?: 'UsersPermissionsUserEntity' }
1618 & Pick<UsersPermissionsUserEntity, 'id'>
1619 & { attributes?: Maybe<(
1620 { __typename?: 'UsersPermissionsUser' }
1621 & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1622 )> }
1623 )> }
1624 )> }
1625 )> }
1626 )> }
1627 )>, travels?: Maybe<(
1628 { __typename?: 'TravelRelationResponseCollection' }
1629 & { data: Array<(
1630 { __typename?: 'TravelEntity' }
1631 & Pick<TravelEntity, 'id'>
1632 & { attributes?: Maybe<(
1633 { __typename?: 'Travel' }
1634 & Pick<Travel, 'meeting' | 'departure' | 'details' | 'vehicleName' | 'phone_number' | 'seats'>
1635 & { passengers?: Maybe<(
1636 { __typename?: 'PassengerRelationResponseCollection' }
1637 & { data: Array<(
1638 { __typename?: 'PassengerEntity' }
1639 & Pick<PassengerEntity, 'id'>
1640 & { attributes?: Maybe<(
1641 { __typename?: 'Passenger' }
1642 & Pick<Passenger, 'name' | 'location'>
1643 & { user?: Maybe<(
1644 { __typename?: 'UsersPermissionsUserEntityResponse' }
1645 & { data?: Maybe<(
1646 { __typename?: 'UsersPermissionsUserEntity' }
1647 & Pick<UsersPermissionsUserEntity, 'id'>
1648 & { attributes?: Maybe<(
1649 { __typename?: 'UsersPermissionsUser' }
1650 & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1651 )> }
1652 )> }
1653 )> }
1654 )> }
1655 )> }
1656 )> }
1657 )> }
1658 )> }
1659 )> }
1660 )> }
1661);
1662
1663export type CreateEventMutationVariables = Exact<{
1664 name: Scalars['String'];
1665 email: Scalars['String'];
1666 date?: Maybe<Scalars['Date']>;
1667 address?: Maybe<Scalars['String']>;
1668 description?: Maybe<Scalars['String']>;
1669 newsletter?: Maybe<Scalars['Boolean']>;
1670}>;
1671
1672
1673export type CreateEventMutation = (
1674 { __typename?: 'Mutation' }
1675 & { createEvent?: Maybe<(
1676 { __typename?: 'EventEntityResponse' }
1677 & { data?: Maybe<(
1678 { __typename?: 'EventEntity' }
1679 & EventFieldsFragment
1680 )> }
1681 )> }
1682);
1683
1684export type UpdateEventMutationVariables = Exact<{
1685 uuid: Scalars['String'];
1686 eventUpdate: EventInput;
1687}>;
1688
1689
1690export type UpdateEventMutation = (
1691 { __typename?: 'Mutation' }
1692 & { updateEventByUUID?: Maybe<(
1693 { __typename?: 'EventEntityResponse' }
1694 & { data?: Maybe<(
1695 { __typename?: 'EventEntity' }
1696 & EventFieldsFragment
1697 )> }
1698 )> }
1699);
1700
1701export type EventByUuidQueryVariables = Exact<{
1702 uuid: Scalars['String'];
1703}>;
1704
1705
1706export type EventByUuidQuery = (
1707 { __typename?: 'Query' }
1708 & { eventByUUID?: Maybe<(
1709 { __typename?: 'EventEntityResponse' }
1710 & { data?: Maybe<(
1711 { __typename?: 'EventEntity' }
1712 & EventFieldsFragment
1713 )> }
1714 )> }
1715);
1716
1717export type PassengerFieldsFragment = (
1718 { __typename?: 'PassengerEntity' }
1719 & Pick<PassengerEntity, 'id'>
1720 & { attributes?: Maybe<(
1721 { __typename?: 'Passenger' }
1722 & Pick<Passenger, 'name' | 'location' | 'email'>
1723 & { user?: Maybe<(
1724 { __typename?: 'UsersPermissionsUserEntityResponse' }
1725 & { data?: Maybe<(
1726 { __typename?: 'UsersPermissionsUserEntity' }
1727 & Pick<UsersPermissionsUserEntity, 'id'>
1728 & { attributes?: Maybe<(
1729 { __typename?: 'UsersPermissionsUser' }
1730 & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1731 )> }
1732 )> }
1733 )> }
1734 )> }
1735);
1736
1737export type CreatePassengerMutationVariables = Exact<{
1738 passenger: PassengerInput;
1739}>;
1740
1741
1742export type CreatePassengerMutation = (
1743 { __typename?: 'Mutation' }
1744 & { createPassenger?: Maybe<(
1745 { __typename?: 'PassengerEntityResponse' }
1746 & { data?: Maybe<(
1747 { __typename?: 'PassengerEntity' }
1748 & PassengerFieldsFragment
1749 )> }
1750 )> }
1751);
1752
1753export type UpdatePassengerMutationVariables = Exact<{
1754 id: Scalars['ID'];
1755 passengerUpdate: PassengerInput;
1756}>;
1757
1758
1759export type UpdatePassengerMutation = (
1760 { __typename?: 'Mutation' }
1761 & { updatePassenger?: Maybe<(
1762 { __typename?: 'PassengerEntityResponse' }
1763 & { data?: Maybe<(
1764 { __typename?: 'PassengerEntity' }
1765 & PassengerFieldsFragment
1766 )> }
1767 )> }
1768);
1769
1770export type DeletePassengerMutationVariables = Exact<{
1771 id: Scalars['ID'];
1772}>;
1773
1774
1775export type DeletePassengerMutation = (
1776 { __typename?: 'Mutation' }
1777 & { deletePassenger?: Maybe<(
1778 { __typename?: 'PassengerEntityResponse' }
1779 & { data?: Maybe<(
1780 { __typename?: 'PassengerEntity' }
1781 & Pick<PassengerEntity, 'id'>
1782 )> }
1783 )> }
1784);
1785
1786export type SettingQueryVariables = Exact<{
1787 locale: Scalars['I18NLocaleCode'];
1788}>;
1789
1790
1791export type SettingQuery = (
1792 { __typename?: 'Query' }
1793 & { setting?: Maybe<(
1794 { __typename?: 'SettingEntityResponse' }
1795 & { data?: Maybe<(
1796 { __typename?: 'SettingEntity' }
1797 & Pick<SettingEntity, 'id'>
1798 & { attributes?: Maybe<(
1799 { __typename?: 'Setting' }
1800 & Pick<Setting, 'gtm_id' | 'about_link' | 'faq_link' | 'announcement'>
1801 )> }
1802 )> }
1803 )> }
1804);
1805
1806export type TravelFieldsFragment = (
1807 { __typename?: 'TravelEntity' }
1808 & Pick<TravelEntity, 'id'>
1809 & { attributes?: Maybe<(
1810 { __typename?: 'Travel' }
1811 & Pick<Travel, 'meeting' | 'departure' | 'details' | 'vehicleName' | 'phone_number' | 'seats'>
1812 & { passengers?: Maybe<(
1813 { __typename?: 'PassengerRelationResponseCollection' }
1814 & { data: Array<(
1815 { __typename?: 'PassengerEntity' }
1816 & Pick<PassengerEntity, 'id'>
1817 & { attributes?: Maybe<(
1818 { __typename?: 'Passenger' }
1819 & Pick<Passenger, 'name' | 'location'>
1820 & { user?: Maybe<(
1821 { __typename?: 'UsersPermissionsUserEntityResponse' }
1822 & { data?: Maybe<(
1823 { __typename?: 'UsersPermissionsUserEntity' }
1824 & Pick<UsersPermissionsUserEntity, 'id'>
1825 & { attributes?: Maybe<(
1826 { __typename?: 'UsersPermissionsUser' }
1827 & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1828 )> }
1829 )> }
1830 )> }
1831 )> }
1832 )> }
1833 )> }
1834 )> }
1835);
1836
1837export type CreateTravelMutationVariables = Exact<{
1838 travel: TravelInput;
1839 createVehicle?: Maybe<Scalars['Boolean']>;
1840}>;
1841
1842
1843export type CreateTravelMutation = (
1844 { __typename?: 'Mutation' }
1845 & { createTravel?: Maybe<(
1846 { __typename?: 'TravelEntityResponse' }
1847 & { data?: Maybe<(
1848 { __typename?: 'TravelEntity' }
1849 & TravelFieldsFragment
1850 )> }
1851 )> }
1852);
1853
1854export type UpdateTravelMutationVariables = Exact<{
1855 id: Scalars['ID'];
1856 travelUpdate: TravelInput;
1857}>;
1858
1859
1860export type UpdateTravelMutation = (
1861 { __typename?: 'Mutation' }
1862 & { updateTravel?: Maybe<(
1863 { __typename?: 'TravelEntityResponse' }
1864 & { data?: Maybe<(
1865 { __typename?: 'TravelEntity' }
1866 & TravelFieldsFragment
1867 )> }
1868 )> }
1869);
1870
1871export type DeleteTravelMutationVariables = Exact<{
1872 id: Scalars['ID'];
1873}>;
1874
1875
1876export type DeleteTravelMutation = (
1877 { __typename?: 'Mutation' }
1878 & { deleteTravel?: Maybe<(
1879 { __typename?: 'TravelEntityResponse' }
1880 & { data?: Maybe<(
1881 { __typename?: 'TravelEntity' }
1882 & Pick<TravelEntity, 'id'>
1883 )> }
1884 )> }
1885);
1886
1887export type UserFieldsFragment = (
1888 { __typename?: 'UsersPermissionsUser' }
1889 & Pick<UsersPermissionsUser, 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName' | 'lang' | 'onboardingUser' | 'onboardingCreator'>
1890 & { events?: Maybe<(
1891 { __typename?: 'EventRelationResponseCollection' }
1892 & { data: Array<(
1893 { __typename?: 'EventEntity' }
1894 & Pick<EventEntity, 'id'>
1895 & { attributes?: Maybe<(
1896 { __typename?: 'Event' }
1897 & Pick<Event, 'uuid' | 'name' | 'date' | 'address'>
1898 )> }
1899 )> }
1900 )> }
1901);
1902
1903export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
1904
1905
1906export type ProfileQuery = (
1907 { __typename?: 'Query' }
1908 & { me?: Maybe<(
1909 { __typename?: 'UsersPermissionsMe' }
1910 & Pick<UsersPermissionsMe, 'id' | 'username'>
1911 & { profile?: Maybe<(
1912 { __typename?: 'UsersPermissionsUser' }
1913 & UserFieldsFragment
1914 )> }
1915 )> }
1916);
1917
1918export type UpdateMeMutationVariables = Exact<{
1919 userUpdate: UsersPermissionsUserInput;
1920}>;
1921
1922
1923export type UpdateMeMutation = (
1924 { __typename?: 'Mutation' }
1925 & { updateMe: (
1926 { __typename?: 'UsersPermissionsUserEntityResponse' }
1927 & { data?: Maybe<(
1928 { __typename?: 'UsersPermissionsUserEntity' }
1929 & Pick<UsersPermissionsUserEntity, 'id'>
1930 & { attributes?: Maybe<(
1931 { __typename?: 'UsersPermissionsUser' }
1932 & UserFieldsFragment
1933 )> }
1934 )> }
1935 ) }
1936);
1937
1938export type VehicleFieldsFragment = (
1939 { __typename?: 'VehicleEntity' }
1940 & Pick<VehicleEntity, 'id'>
1941 & { attributes?: Maybe<(
1942 { __typename?: 'Vehicle' }
1943 & Pick<Vehicle, 'name' | 'seats' | 'phone_number'>
1944 )> }
1945);
1946
1947export type FindUserVehiclesQueryVariables = Exact<{ [key: string]: never; }>;
1948
1949
1950export type FindUserVehiclesQuery = (
1951 { __typename?: 'Query' }
1952 & { me?: Maybe<(
1953 { __typename?: 'UsersPermissionsMe' }
1954 & Pick<UsersPermissionsMe, 'id' | 'username'>
1955 & { profile?: Maybe<(
1956 { __typename?: 'UsersPermissionsUser' }
1957 & { vehicles?: Maybe<(
1958 { __typename?: 'VehicleRelationResponseCollection' }
1959 & { data: Array<(
1960 { __typename?: 'VehicleEntity' }
1961 & VehicleFieldsFragment
1962 )> }
1963 )> }
1964 )> }
1965 )> }
1966);
1967
1968export type DeleteVehicleMutationVariables = Exact<{
1969 id: Scalars['ID'];
1970}>;
1971
1972
1973export type DeleteVehicleMutation = (
1974 { __typename?: 'Mutation' }
1975 & { deleteVehicle?: Maybe<(
1976 { __typename?: 'VehicleEntityResponse' }
1977 & { data?: Maybe<(
1978 { __typename?: 'VehicleEntity' }
1979 & Pick<VehicleEntity, 'id'>
1980 & { attributes?: Maybe<(
1981 { __typename?: 'Vehicle' }
1982 & Pick<Vehicle, 'name'>
1983 )> }
1984 )> }
1985 )> }
1986);
1987
1988export const MeFieldsFragmentDoc = gql`
1989 fragment MeFields on UsersPermissionsMe {
1990 id
1991 username
1992 email
1993 confirmed
1994}
1995 `;
1996export const EventFieldsFragmentDoc = gql`
1997 fragment EventFields on EventEntity {
1998 id
1999 attributes {
2000 uuid
2001 name
2002 description
2003 email
2004 date
2005 address
2006 position
2007 waitingPassengers {
2008 data {
2009 id
2010 attributes {
2011 name
2012 email
2013 location
2014 user {
2015 data {
2016 id
2017 attributes {
2018 firstName
2019 lastName
2020 }
2021 }
2022 }
2023 }
2024 }
2025 }
2026 travels {
2027 data {
2028 id
2029 attributes {
2030 meeting
2031 departure
2032 details
2033 vehicleName
2034 phone_number
2035 seats
2036 passengers {
2037 data {
2038 id
2039 attributes {
2040 name
2041 location
2042 user {
2043 data {
2044 id
2045 attributes {
2046 firstName
2047 lastName
2048 }
2049 }
2050 }
2051 }
2052 }
2053 }
2054 }
2055 }
2056 }
2057 }
2058}
2059 `;
2060export const PassengerFieldsFragmentDoc = gql`
2061 fragment PassengerFields on PassengerEntity {
2062 id
2063 attributes {
2064 name
2065 location
2066 email
2067 user {
2068 data {
2069 id
2070 attributes {
2071 firstName
2072 lastName
2073 }
2074 }
2075 }
2076 }
2077}
2078 `;
2079export const TravelFieldsFragmentDoc = gql`
2080 fragment TravelFields on TravelEntity {
2081 id
2082 attributes {
2083 meeting
2084 departure
2085 details
2086 vehicleName
2087 phone_number
2088 seats
2089 passengers {
2090 data {
2091 id
2092 attributes {
2093 name
2094 location
2095 user {
2096 data {
2097 id
2098 attributes {
2099 firstName
2100 lastName
2101 }
2102 }
2103 }
2104 }
2105 }
2106 }
2107 }
2108}
2109 `;
2110export const UserFieldsFragmentDoc = gql`
2111 fragment UserFields on UsersPermissionsUser {
2112 username
2113 email
2114 confirmed
2115 lastName
2116 firstName
2117 lang
2118 onboardingUser
2119 onboardingCreator
2120 events {
2121 data {
2122 id
2123 attributes {
2124 uuid
2125 name
2126 date
2127 address
2128 }
2129 }
2130 }
2131}
2132 `;
2133export const VehicleFieldsFragmentDoc = gql`
2134 fragment VehicleFields on VehicleEntity {
2135 id
2136 attributes {
2137 name
2138 seats
2139 phone_number
2140 }
2141}
2142 `;
2143export const RegisterDocument = gql`
2144 mutation register($user: UsersPermissionsRegisterInput!) {
2145 register(input: $user) {
2146 jwt
2147 user {
2148 ...MeFields
2149 }
2150 }
2151}
2152 ${MeFieldsFragmentDoc}`;
2153export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
2154
2155/**
2156 * __useRegisterMutation__
2157 *
2158 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
2159 * When your component renders, `useRegisterMutation` returns a tuple that includes:
2160 * - A mutate function that you can call at any time to execute the mutation
2161 * - An object with fields that represent the current status of the mutation's execution
2162 *
2163 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2164 *
2165 * @example
2166 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
2167 * variables: {
2168 * user: // value for 'user'
2169 * },
2170 * });
2171 */
2172export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
2173 return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
2174 }
2175export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
2176export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
2177export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
2178export const LoginDocument = gql`
2179 mutation login($identifier: String!, $password: String!) {
2180 login(input: {identifier: $identifier, password: $password}) {
2181 jwt
2182 user {
2183 ...MeFields
2184 }
2185 }
2186}
2187 ${MeFieldsFragmentDoc}`;
2188export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
2189
2190/**
2191 * __useLoginMutation__
2192 *
2193 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
2194 * When your component renders, `useLoginMutation` returns a tuple that includes:
2195 * - A mutate function that you can call at any time to execute the mutation
2196 * - An object with fields that represent the current status of the mutation's execution
2197 *
2198 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2199 *
2200 * @example
2201 * const [loginMutation, { data, loading, error }] = useLoginMutation({
2202 * variables: {
2203 * identifier: // value for 'identifier'
2204 * password: // value for 'password'
2205 * },
2206 * });
2207 */
2208export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
2209 return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
2210 }
2211export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
2212export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
2213export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
2214export const ForgotPasswordDocument = gql`
2215 mutation forgotPassword($email: String!) {
2216 forgotPassword(email: $email) {
2217 ok
2218 }
2219}
2220 `;
2221export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2222
2223/**
2224 * __useForgotPasswordMutation__
2225 *
2226 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
2227 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
2228 * - A mutate function that you can call at any time to execute the mutation
2229 * - An object with fields that represent the current status of the mutation's execution
2230 *
2231 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2232 *
2233 * @example
2234 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
2235 * variables: {
2236 * email: // value for 'email'
2237 * },
2238 * });
2239 */
2240export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
2241 return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
2242 }
2243export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
2244export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
2245export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2246export const ResetPasswordDocument = gql`
2247 mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
2248 resetPassword(
2249 password: $password
2250 passwordConfirmation: $passwordConfirmation
2251 code: $code
2252 ) {
2253 jwt
2254 user {
2255 ...MeFields
2256 }
2257 }
2258}
2259 ${MeFieldsFragmentDoc}`;
2260export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
2261
2262/**
2263 * __useResetPasswordMutation__
2264 *
2265 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
2266 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
2267 * - A mutate function that you can call at any time to execute the mutation
2268 * - An object with fields that represent the current status of the mutation's execution
2269 *
2270 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2271 *
2272 * @example
2273 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
2274 * variables: {
2275 * password: // value for 'password'
2276 * passwordConfirmation: // value for 'passwordConfirmation'
2277 * code: // value for 'code'
2278 * },
2279 * });
2280 */
2281export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
2282 return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
2283 }
2284export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
2285export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
2286export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
2287export const CreateEventDocument = gql`
2288 mutation createEvent($name: String!, $email: String!, $date: Date, $address: String, $description: String, $newsletter: Boolean) {
2289 createEvent(
2290 data: {name: $name, email: $email, date: $date, address: $address, description: $description, newsletter: $newsletter}
2291 ) {
2292 data {
2293 ...EventFields
2294 }
2295 }
2296}
2297 ${EventFieldsFragmentDoc}`;
2298export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2299
2300/**
2301 * __useCreateEventMutation__
2302 *
2303 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2304 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2305 * - A mutate function that you can call at any time to execute the mutation
2306 * - An object with fields that represent the current status of the mutation's execution
2307 *
2308 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2309 *
2310 * @example
2311 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2312 * variables: {
2313 * name: // value for 'name'
2314 * email: // value for 'email'
2315 * date: // value for 'date'
2316 * address: // value for 'address'
2317 * description: // value for 'description'
2318 * newsletter: // value for 'newsletter'
2319 * },
2320 * });
2321 */
2322export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2323 return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2324 }
2325export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2326export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2327export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2328export const UpdateEventDocument = gql`
2329 mutation updateEvent($uuid: String!, $eventUpdate: EventInput!) {
2330 updateEventByUUID(uuid: $uuid, data: $eventUpdate) {
2331 data {
2332 ...EventFields
2333 }
2334 }
2335}
2336 ${EventFieldsFragmentDoc}`;
2337export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2338
2339/**
2340 * __useUpdateEventMutation__
2341 *
2342 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2343 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2344 * - A mutate function that you can call at any time to execute the mutation
2345 * - An object with fields that represent the current status of the mutation's execution
2346 *
2347 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2348 *
2349 * @example
2350 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2351 * variables: {
2352 * uuid: // value for 'uuid'
2353 * eventUpdate: // value for 'eventUpdate'
2354 * },
2355 * });
2356 */
2357export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2358 return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2359 }
2360export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2361export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2362export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2363export const EventByUuidDocument = gql`
2364 query eventByUUID($uuid: String!) {
2365 eventByUUID(uuid: $uuid) {
2366 data {
2367 ...EventFields
2368 }
2369 }
2370}
2371 ${EventFieldsFragmentDoc}`;
2372
2373/**
2374 * __useEventByUuidQuery__
2375 *
2376 * To run a query within a React component, call `useEventByUuidQuery` and pass it any options that fit your needs.
2377 * When your component renders, `useEventByUuidQuery` returns an object from Apollo Client that contains loading, error, and data properties
2378 * you can use to render your UI.
2379 *
2380 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
2381 *
2382 * @example
2383 * const { data, loading, error } = useEventByUuidQuery({
2384 * variables: {
2385 * uuid: // value for 'uuid'
2386 * },
2387 * });
2388 */
2389export function useEventByUuidQuery(baseOptions: Apollo.QueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2390 return Apollo.useQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2391 }
2392export function useEventByUuidLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2393 return Apollo.useLazyQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2394 }
2395export type EventByUuidQueryHookResult = ReturnType<typeof useEventByUuidQuery>;
2396export type EventByUuidLazyQueryHookResult = ReturnType<typeof useEventByUuidLazyQuery>;
2397export type EventByUuidQueryResult = Apollo.QueryResult<EventByUuidQuery, EventByUuidQueryVariables>;
2398export const CreatePassengerDocument = gql`
2399 mutation createPassenger($passenger: PassengerInput!) {
2400 createPassenger(data: $passenger) {
2401 data {
2402 ...PassengerFields
2403 }
2404 }
2405}
2406 ${PassengerFieldsFragmentDoc}`;
2407export type CreatePassengerMutationFn = Apollo.MutationFunction<CreatePassengerMutation, CreatePassengerMutationVariables>;
2408
2409/**
2410 * __useCreatePassengerMutation__
2411 *
2412 * To run a mutation, you first call `useCreatePassengerMutation` within a React component and pass it any options that fit your needs.
2413 * When your component renders, `useCreatePassengerMutation` returns a tuple that includes:
2414 * - A mutate function that you can call at any time to execute the mutation
2415 * - An object with fields that represent the current status of the mutation's execution
2416 *
2417 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2418 *
2419 * @example
2420 * const [createPassengerMutation, { data, loading, error }] = useCreatePassengerMutation({
2421 * variables: {
2422 * passenger: // value for 'passenger'
2423 * },
2424 * });
2425 */
2426export function useCreatePassengerMutation(baseOptions?: Apollo.MutationHookOptions<CreatePassengerMutation, CreatePassengerMutationVariables>) {
2427 return Apollo.useMutation<CreatePassengerMutation, CreatePassengerMutationVariables>(CreatePassengerDocument, baseOptions);
2428 }
2429export type CreatePassengerMutationHookResult = ReturnType<typeof useCreatePassengerMutation>;
2430export type CreatePassengerMutationResult = Apollo.MutationResult<CreatePassengerMutation>;
2431export type CreatePassengerMutationOptions = Apollo.BaseMutationOptions<CreatePassengerMutation, CreatePassengerMutationVariables>;
2432export const UpdatePassengerDocument = gql`
2433 mutation updatePassenger($id: ID!, $passengerUpdate: PassengerInput!) {
2434 updatePassenger(id: $id, data: $passengerUpdate) {
2435 data {
2436 ...PassengerFields
2437 }
2438 }
2439}
2440 ${PassengerFieldsFragmentDoc}`;
2441export type UpdatePassengerMutationFn = Apollo.MutationFunction<UpdatePassengerMutation, UpdatePassengerMutationVariables>;
2442
2443/**
2444 * __useUpdatePassengerMutation__
2445 *
2446 * To run a mutation, you first call `useUpdatePassengerMutation` within a React component and pass it any options that fit your needs.
2447 * When your component renders, `useUpdatePassengerMutation` returns a tuple that includes:
2448 * - A mutate function that you can call at any time to execute the mutation
2449 * - An object with fields that represent the current status of the mutation's execution
2450 *
2451 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2452 *
2453 * @example
2454 * const [updatePassengerMutation, { data, loading, error }] = useUpdatePassengerMutation({
2455 * variables: {
2456 * id: // value for 'id'
2457 * passengerUpdate: // value for 'passengerUpdate'
2458 * },
2459 * });
2460 */
2461export function useUpdatePassengerMutation(baseOptions?: Apollo.MutationHookOptions<UpdatePassengerMutation, UpdatePassengerMutationVariables>) {
2462 return Apollo.useMutation<UpdatePassengerMutation, UpdatePassengerMutationVariables>(UpdatePassengerDocument, baseOptions);
2463 }
2464export type UpdatePassengerMutationHookResult = ReturnType<typeof useUpdatePassengerMutation>;
2465export type UpdatePassengerMutationResult = Apollo.MutationResult<UpdatePassengerMutation>;
2466export type UpdatePassengerMutationOptions = Apollo.BaseMutationOptions<UpdatePassengerMutation, UpdatePassengerMutationVariables>;
2467export const DeletePassengerDocument = gql`
2468 mutation deletePassenger($id: ID!) {
2469 deletePassenger(id: $id) {
2470 data {
2471 id
2472 }
2473 }
2474}
2475 `;
2476export type DeletePassengerMutationFn = Apollo.MutationFunction<DeletePassengerMutation, DeletePassengerMutationVariables>;
2477
2478/**
2479 * __useDeletePassengerMutation__
2480 *
2481 * To run a mutation, you first call `useDeletePassengerMutation` within a React component and pass it any options that fit your needs.
2482 * When your component renders, `useDeletePassengerMutation` returns a tuple that includes:
2483 * - A mutate function that you can call at any time to execute the mutation
2484 * - An object with fields that represent the current status of the mutation's execution
2485 *
2486 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2487 *
2488 * @example
2489 * const [deletePassengerMutation, { data, loading, error }] = useDeletePassengerMutation({
2490 * variables: {
2491 * id: // value for 'id'
2492 * },
2493 * });
2494 */
2495export function useDeletePassengerMutation(baseOptions?: Apollo.MutationHookOptions<DeletePassengerMutation, DeletePassengerMutationVariables>) {
2496 return Apollo.useMutation<DeletePassengerMutation, DeletePassengerMutationVariables>(DeletePassengerDocument, baseOptions);
2497 }
2498export type DeletePassengerMutationHookResult = ReturnType<typeof useDeletePassengerMutation>;
2499export type DeletePassengerMutationResult = Apollo.MutationResult<DeletePassengerMutation>;
2500export type DeletePassengerMutationOptions = Apollo.BaseMutationOptions<DeletePassengerMutation, DeletePassengerMutationVariables>;
2501export const SettingDocument = gql`
2502 query setting($locale: I18NLocaleCode!) {
2503 setting(locale: $locale) {
2504 data {
2505 id
2506 attributes {
2507 gtm_id
2508 about_link
2509 faq_link
2510 announcement
2511 }
2512 }
2513 }
2514}
2515 `;
2516
2517/**
2518 * __useSettingQuery__
2519 *
2520 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2521 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2522 * you can use to render your UI.
2523 *
2524 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
2525 *
2526 * @example
2527 * const { data, loading, error } = useSettingQuery({
2528 * variables: {
2529 * locale: // value for 'locale'
2530 * },
2531 * });
2532 */
2533export function useSettingQuery(baseOptions: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2534 return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2535 }
2536export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2537 return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2538 }
2539export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2540export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2541export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2542export const CreateTravelDocument = gql`
2543 mutation createTravel($travel: TravelInput!, $createVehicle: Boolean) {
2544 createTravel(data: $travel, createVehicle: $createVehicle) {
2545 data {
2546 ...TravelFields
2547 }
2548 }
2549}
2550 ${TravelFieldsFragmentDoc}`;
2551export type CreateTravelMutationFn = Apollo.MutationFunction<CreateTravelMutation, CreateTravelMutationVariables>;
2552
2553/**
2554 * __useCreateTravelMutation__
2555 *
2556 * To run a mutation, you first call `useCreateTravelMutation` within a React component and pass it any options that fit your needs.
2557 * When your component renders, `useCreateTravelMutation` returns a tuple that includes:
2558 * - A mutate function that you can call at any time to execute the mutation
2559 * - An object with fields that represent the current status of the mutation's execution
2560 *
2561 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2562 *
2563 * @example
2564 * const [createTravelMutation, { data, loading, error }] = useCreateTravelMutation({
2565 * variables: {
2566 * travel: // value for 'travel'
2567 * createVehicle: // value for 'createVehicle'
2568 * },
2569 * });
2570 */
2571export function useCreateTravelMutation(baseOptions?: Apollo.MutationHookOptions<CreateTravelMutation, CreateTravelMutationVariables>) {
2572 return Apollo.useMutation<CreateTravelMutation, CreateTravelMutationVariables>(CreateTravelDocument, baseOptions);
2573 }
2574export type CreateTravelMutationHookResult = ReturnType<typeof useCreateTravelMutation>;
2575export type CreateTravelMutationResult = Apollo.MutationResult<CreateTravelMutation>;
2576export type CreateTravelMutationOptions = Apollo.BaseMutationOptions<CreateTravelMutation, CreateTravelMutationVariables>;
2577export const UpdateTravelDocument = gql`
2578 mutation updateTravel($id: ID!, $travelUpdate: TravelInput!) {
2579 updateTravel(id: $id, data: $travelUpdate) {
2580 data {
2581 ...TravelFields
2582 }
2583 }
2584}
2585 ${TravelFieldsFragmentDoc}`;
2586export type UpdateTravelMutationFn = Apollo.MutationFunction<UpdateTravelMutation, UpdateTravelMutationVariables>;
2587
2588/**
2589 * __useUpdateTravelMutation__
2590 *
2591 * To run a mutation, you first call `useUpdateTravelMutation` within a React component and pass it any options that fit your needs.
2592 * When your component renders, `useUpdateTravelMutation` returns a tuple that includes:
2593 * - A mutate function that you can call at any time to execute the mutation
2594 * - An object with fields that represent the current status of the mutation's execution
2595 *
2596 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2597 *
2598 * @example
2599 * const [updateTravelMutation, { data, loading, error }] = useUpdateTravelMutation({
2600 * variables: {
2601 * id: // value for 'id'
2602 * travelUpdate: // value for 'travelUpdate'
2603 * },
2604 * });
2605 */
2606export function useUpdateTravelMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTravelMutation, UpdateTravelMutationVariables>) {
2607 return Apollo.useMutation<UpdateTravelMutation, UpdateTravelMutationVariables>(UpdateTravelDocument, baseOptions);
2608 }
2609export type UpdateTravelMutationHookResult = ReturnType<typeof useUpdateTravelMutation>;
2610export type UpdateTravelMutationResult = Apollo.MutationResult<UpdateTravelMutation>;
2611export type UpdateTravelMutationOptions = Apollo.BaseMutationOptions<UpdateTravelMutation, UpdateTravelMutationVariables>;
2612export const DeleteTravelDocument = gql`
2613 mutation deleteTravel($id: ID!) {
2614 deleteTravel(id: $id) {
2615 data {
2616 id
2617 }
2618 }
2619}
2620 `;
2621export type DeleteTravelMutationFn = Apollo.MutationFunction<DeleteTravelMutation, DeleteTravelMutationVariables>;
2622
2623/**
2624 * __useDeleteTravelMutation__
2625 *
2626 * To run a mutation, you first call `useDeleteTravelMutation` within a React component and pass it any options that fit your needs.
2627 * When your component renders, `useDeleteTravelMutation` returns a tuple that includes:
2628 * - A mutate function that you can call at any time to execute the mutation
2629 * - An object with fields that represent the current status of the mutation's execution
2630 *
2631 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2632 *
2633 * @example
2634 * const [deleteTravelMutation, { data, loading, error }] = useDeleteTravelMutation({
2635 * variables: {
2636 * id: // value for 'id'
2637 * },
2638 * });
2639 */
2640export function useDeleteTravelMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTravelMutation, DeleteTravelMutationVariables>) {
2641 return Apollo.useMutation<DeleteTravelMutation, DeleteTravelMutationVariables>(DeleteTravelDocument, baseOptions);
2642 }
2643export type DeleteTravelMutationHookResult = ReturnType<typeof useDeleteTravelMutation>;
2644export type DeleteTravelMutationResult = Apollo.MutationResult<DeleteTravelMutation>;
2645export type DeleteTravelMutationOptions = Apollo.BaseMutationOptions<DeleteTravelMutation, DeleteTravelMutationVariables>;
2646export const ProfileDocument = gql`
2647 query profile {
2648 me {
2649 id
2650 username
2651 profile {
2652 ...UserFields
2653 }
2654 }
2655}
2656 ${UserFieldsFragmentDoc}`;
2657
2658/**
2659 * __useProfileQuery__
2660 *
2661 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2662 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2663 * you can use to render your UI.
2664 *
2665 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
2666 *
2667 * @example
2668 * const { data, loading, error } = useProfileQuery({
2669 * variables: {
2670 * },
2671 * });
2672 */
2673export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2674 return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2675 }
2676export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2677 return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2678 }
2679export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2680export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2681export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2682export const UpdateMeDocument = gql`
2683 mutation updateMe($userUpdate: UsersPermissionsUserInput!) {
2684 updateMe(data: $userUpdate) {
2685 data {
2686 id
2687 attributes {
2688 ...UserFields
2689 }
2690 }
2691 }
2692}
2693 ${UserFieldsFragmentDoc}`;
2694export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2695
2696/**
2697 * __useUpdateMeMutation__
2698 *
2699 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2700 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2701 * - A mutate function that you can call at any time to execute the mutation
2702 * - An object with fields that represent the current status of the mutation's execution
2703 *
2704 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2705 *
2706 * @example
2707 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2708 * variables: {
2709 * userUpdate: // value for 'userUpdate'
2710 * },
2711 * });
2712 */
2713export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2714 return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2715 }
2716export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2717export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2718export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;
2719export const FindUserVehiclesDocument = gql`
2720 query findUserVehicles {
2721 me {
2722 id
2723 username
2724 profile {
2725 vehicles {
2726 data {
2727 ...VehicleFields
2728 }
2729 }
2730 }
2731 }
2732}
2733 ${VehicleFieldsFragmentDoc}`;
2734
2735/**
2736 * __useFindUserVehiclesQuery__
2737 *
2738 * To run a query within a React component, call `useFindUserVehiclesQuery` and pass it any options that fit your needs.
2739 * When your component renders, `useFindUserVehiclesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2740 * you can use to render your UI.
2741 *
2742 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
2743 *
2744 * @example
2745 * const { data, loading, error } = useFindUserVehiclesQuery({
2746 * variables: {
2747 * },
2748 * });
2749 */
2750export function useFindUserVehiclesQuery(baseOptions?: Apollo.QueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
2751 return Apollo.useQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
2752 }
2753export function useFindUserVehiclesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
2754 return Apollo.useLazyQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
2755 }
2756export type FindUserVehiclesQueryHookResult = ReturnType<typeof useFindUserVehiclesQuery>;
2757export type FindUserVehiclesLazyQueryHookResult = ReturnType<typeof useFindUserVehiclesLazyQuery>;
2758export type FindUserVehiclesQueryResult = Apollo.QueryResult<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>;
2759export const DeleteVehicleDocument = gql`
2760 mutation deleteVehicle($id: ID!) {
2761 deleteVehicle(id: $id) {
2762 data {
2763 id
2764 attributes {
2765 name
2766 }
2767 }
2768 }
2769}
2770 `;
2771export type DeleteVehicleMutationFn = Apollo.MutationFunction<DeleteVehicleMutation, DeleteVehicleMutationVariables>;
2772
2773/**
2774 * __useDeleteVehicleMutation__
2775 *
2776 * To run a mutation, you first call `useDeleteVehicleMutation` within a React component and pass it any options that fit your needs.
2777 * When your component renders, `useDeleteVehicleMutation` returns a tuple that includes:
2778 * - A mutate function that you can call at any time to execute the mutation
2779 * - An object with fields that represent the current status of the mutation's execution
2780 *
2781 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2782 *
2783 * @example
2784 * const [deleteVehicleMutation, { data, loading, error }] = useDeleteVehicleMutation({
2785 * variables: {
2786 * id: // value for 'id'
2787 * },
2788 * });
2789 */
2790export function useDeleteVehicleMutation(baseOptions?: Apollo.MutationHookOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>) {
2791 return Apollo.useMutation<DeleteVehicleMutation, DeleteVehicleMutationVariables>(DeleteVehicleDocument, baseOptions);
2792 }
2793export type DeleteVehicleMutationHookResult = ReturnType<typeof useDeleteVehicleMutation>;
2794export type DeleteVehicleMutationResult = Apollo.MutationResult<DeleteVehicleMutation>;
2795export type DeleteVehicleMutationOptions = Apollo.BaseMutationOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>;