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 matomo_script_url?: Maybe<Scalars['String']>;
957 createdAt?: Maybe<Scalars['DateTime']>;
958 updatedAt?: Maybe<Scalars['DateTime']>;
959 localizations?: Maybe<SettingRelationResponseCollection>;
960 locale?: Maybe<Scalars['String']>;
961};
962
963export type SettingEntity = {
964 __typename?: 'SettingEntity';
965 id?: Maybe<Scalars['ID']>;
966 attributes?: Maybe<Setting>;
967};
968
969export type SettingEntityResponse = {
970 __typename?: 'SettingEntityResponse';
971 data?: Maybe<SettingEntity>;
972};
973
974export type SettingInput = {
975 gtm_id?: Maybe<Scalars['String']>;
976 about_link?: Maybe<Scalars['String']>;
977 faq_link?: Maybe<Scalars['String']>;
978 announcement?: Maybe<Scalars['String']>;
979 matomo_script_url?: Maybe<Scalars['String']>;
980};
981
982export type SettingRelationResponseCollection = {
983 __typename?: 'SettingRelationResponseCollection';
984 data: Array<SettingEntity>;
985};
986
987export type StringFilterInput = {
988 and?: Maybe<Array<Maybe<Scalars['String']>>>;
989 or?: Maybe<Array<Maybe<Scalars['String']>>>;
990 not?: Maybe<StringFilterInput>;
991 eq?: Maybe<Scalars['String']>;
992 eqi?: Maybe<Scalars['String']>;
993 ne?: Maybe<Scalars['String']>;
994 startsWith?: Maybe<Scalars['String']>;
995 endsWith?: Maybe<Scalars['String']>;
996 contains?: Maybe<Scalars['String']>;
997 notContains?: Maybe<Scalars['String']>;
998 containsi?: Maybe<Scalars['String']>;
999 notContainsi?: Maybe<Scalars['String']>;
1000 gt?: Maybe<Scalars['String']>;
1001 gte?: Maybe<Scalars['String']>;
1002 lt?: Maybe<Scalars['String']>;
1003 lte?: Maybe<Scalars['String']>;
1004 null?: Maybe<Scalars['Boolean']>;
1005 notNull?: Maybe<Scalars['Boolean']>;
1006 in?: Maybe<Array<Maybe<Scalars['String']>>>;
1007 notIn?: Maybe<Array<Maybe<Scalars['String']>>>;
1008 between?: Maybe<Array<Maybe<Scalars['String']>>>;
1009};
1010
1011export type Travel = {
1012 __typename?: 'Travel';
1013 meeting?: Maybe<Scalars['String']>;
1014 departure?: Maybe<Scalars['DateTime']>;
1015 details?: Maybe<Scalars['String']>;
1016 vehicleName?: Maybe<Scalars['String']>;
1017 seats?: Maybe<Scalars['Int']>;
1018 phone_number?: Maybe<Scalars['String']>;
1019 event?: Maybe<EventEntityResponse>;
1020 passengers?: Maybe<PassengerRelationResponseCollection>;
1021 createdAt?: Maybe<Scalars['DateTime']>;
1022 updatedAt?: Maybe<Scalars['DateTime']>;
1023};
1024
1025
1026export type TravelPassengersArgs = {
1027 filters?: Maybe<PassengerFiltersInput>;
1028 pagination?: Maybe<PaginationArg>;
1029 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1030};
1031
1032export type TravelEntity = {
1033 __typename?: 'TravelEntity';
1034 id?: Maybe<Scalars['ID']>;
1035 attributes?: Maybe<Travel>;
1036};
1037
1038export type TravelEntityResponse = {
1039 __typename?: 'TravelEntityResponse';
1040 data?: Maybe<TravelEntity>;
1041};
1042
1043export type TravelFiltersInput = {
1044 id?: Maybe<IdFilterInput>;
1045 meeting?: Maybe<StringFilterInput>;
1046 departure?: Maybe<DateTimeFilterInput>;
1047 details?: Maybe<StringFilterInput>;
1048 vehicleName?: Maybe<StringFilterInput>;
1049 seats?: Maybe<IntFilterInput>;
1050 phone_number?: Maybe<StringFilterInput>;
1051 event?: Maybe<EventFiltersInput>;
1052 passengers?: Maybe<PassengerFiltersInput>;
1053 createdAt?: Maybe<DateTimeFilterInput>;
1054 updatedAt?: Maybe<DateTimeFilterInput>;
1055 and?: Maybe<Array<Maybe<TravelFiltersInput>>>;
1056 or?: Maybe<Array<Maybe<TravelFiltersInput>>>;
1057 not?: Maybe<TravelFiltersInput>;
1058};
1059
1060export type TravelInput = {
1061 meeting?: Maybe<Scalars['String']>;
1062 departure?: Maybe<Scalars['DateTime']>;
1063 details?: Maybe<Scalars['String']>;
1064 vehicleName?: Maybe<Scalars['String']>;
1065 seats?: Maybe<Scalars['Int']>;
1066 phone_number?: Maybe<Scalars['String']>;
1067 event?: Maybe<Scalars['ID']>;
1068 passengers?: Maybe<Array<Maybe<Scalars['ID']>>>;
1069};
1070
1071export type TravelRelationResponseCollection = {
1072 __typename?: 'TravelRelationResponseCollection';
1073 data: Array<TravelEntity>;
1074};
1075
1076
1077export type UploadFile = {
1078 __typename?: 'UploadFile';
1079 name: Scalars['String'];
1080 alternativeText?: Maybe<Scalars['String']>;
1081 caption?: Maybe<Scalars['String']>;
1082 width?: Maybe<Scalars['Int']>;
1083 height?: Maybe<Scalars['Int']>;
1084 formats?: Maybe<Scalars['JSON']>;
1085 hash: Scalars['String'];
1086 ext?: Maybe<Scalars['String']>;
1087 mime: Scalars['String'];
1088 size: Scalars['Float'];
1089 url: Scalars['String'];
1090 previewUrl?: Maybe<Scalars['String']>;
1091 provider: Scalars['String'];
1092 provider_metadata?: Maybe<Scalars['JSON']>;
1093 related?: Maybe<Array<Maybe<GenericMorph>>>;
1094 createdAt?: Maybe<Scalars['DateTime']>;
1095 updatedAt?: Maybe<Scalars['DateTime']>;
1096};
1097
1098export type UploadFileEntity = {
1099 __typename?: 'UploadFileEntity';
1100 id?: Maybe<Scalars['ID']>;
1101 attributes?: Maybe<UploadFile>;
1102};
1103
1104export type UploadFileEntityResponse = {
1105 __typename?: 'UploadFileEntityResponse';
1106 data?: Maybe<UploadFileEntity>;
1107};
1108
1109export type UploadFileEntityResponseCollection = {
1110 __typename?: 'UploadFileEntityResponseCollection';
1111 data: Array<UploadFileEntity>;
1112 meta: ResponseCollectionMeta;
1113};
1114
1115export type UploadFileFiltersInput = {
1116 id?: Maybe<IdFilterInput>;
1117 name?: Maybe<StringFilterInput>;
1118 alternativeText?: Maybe<StringFilterInput>;
1119 caption?: Maybe<StringFilterInput>;
1120 width?: Maybe<IntFilterInput>;
1121 height?: Maybe<IntFilterInput>;
1122 formats?: Maybe<JsonFilterInput>;
1123 hash?: Maybe<StringFilterInput>;
1124 ext?: Maybe<StringFilterInput>;
1125 mime?: Maybe<StringFilterInput>;
1126 size?: Maybe<FloatFilterInput>;
1127 url?: Maybe<StringFilterInput>;
1128 previewUrl?: Maybe<StringFilterInput>;
1129 provider?: Maybe<StringFilterInput>;
1130 provider_metadata?: Maybe<JsonFilterInput>;
1131 folder?: Maybe<UploadFolderFiltersInput>;
1132 folderPath?: Maybe<StringFilterInput>;
1133 createdAt?: Maybe<DateTimeFilterInput>;
1134 updatedAt?: Maybe<DateTimeFilterInput>;
1135 and?: Maybe<Array<Maybe<UploadFileFiltersInput>>>;
1136 or?: Maybe<Array<Maybe<UploadFileFiltersInput>>>;
1137 not?: Maybe<UploadFileFiltersInput>;
1138};
1139
1140export type UploadFileInput = {
1141 name?: Maybe<Scalars['String']>;
1142 alternativeText?: Maybe<Scalars['String']>;
1143 caption?: Maybe<Scalars['String']>;
1144 width?: Maybe<Scalars['Int']>;
1145 height?: Maybe<Scalars['Int']>;
1146 formats?: Maybe<Scalars['JSON']>;
1147 hash?: Maybe<Scalars['String']>;
1148 ext?: Maybe<Scalars['String']>;
1149 mime?: Maybe<Scalars['String']>;
1150 size?: Maybe<Scalars['Float']>;
1151 url?: Maybe<Scalars['String']>;
1152 previewUrl?: Maybe<Scalars['String']>;
1153 provider?: Maybe<Scalars['String']>;
1154 provider_metadata?: Maybe<Scalars['JSON']>;
1155 folder?: Maybe<Scalars['ID']>;
1156 folderPath?: Maybe<Scalars['String']>;
1157};
1158
1159export type UploadFileRelationResponseCollection = {
1160 __typename?: 'UploadFileRelationResponseCollection';
1161 data: Array<UploadFileEntity>;
1162};
1163
1164export type UploadFolder = {
1165 __typename?: 'UploadFolder';
1166 name: Scalars['String'];
1167 pathId: Scalars['Int'];
1168 parent?: Maybe<UploadFolderEntityResponse>;
1169 children?: Maybe<UploadFolderRelationResponseCollection>;
1170 files?: Maybe<UploadFileRelationResponseCollection>;
1171 path: Scalars['String'];
1172 createdAt?: Maybe<Scalars['DateTime']>;
1173 updatedAt?: Maybe<Scalars['DateTime']>;
1174};
1175
1176
1177export type UploadFolderChildrenArgs = {
1178 filters?: Maybe<UploadFolderFiltersInput>;
1179 pagination?: Maybe<PaginationArg>;
1180 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1181};
1182
1183
1184export type UploadFolderFilesArgs = {
1185 filters?: Maybe<UploadFileFiltersInput>;
1186 pagination?: Maybe<PaginationArg>;
1187 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1188};
1189
1190export type UploadFolderEntity = {
1191 __typename?: 'UploadFolderEntity';
1192 id?: Maybe<Scalars['ID']>;
1193 attributes?: Maybe<UploadFolder>;
1194};
1195
1196export type UploadFolderEntityResponse = {
1197 __typename?: 'UploadFolderEntityResponse';
1198 data?: Maybe<UploadFolderEntity>;
1199};
1200
1201export type UploadFolderEntityResponseCollection = {
1202 __typename?: 'UploadFolderEntityResponseCollection';
1203 data: Array<UploadFolderEntity>;
1204 meta: ResponseCollectionMeta;
1205};
1206
1207export type UploadFolderFiltersInput = {
1208 id?: Maybe<IdFilterInput>;
1209 name?: Maybe<StringFilterInput>;
1210 pathId?: Maybe<IntFilterInput>;
1211 parent?: Maybe<UploadFolderFiltersInput>;
1212 children?: Maybe<UploadFolderFiltersInput>;
1213 files?: Maybe<UploadFileFiltersInput>;
1214 path?: Maybe<StringFilterInput>;
1215 createdAt?: Maybe<DateTimeFilterInput>;
1216 updatedAt?: Maybe<DateTimeFilterInput>;
1217 and?: Maybe<Array<Maybe<UploadFolderFiltersInput>>>;
1218 or?: Maybe<Array<Maybe<UploadFolderFiltersInput>>>;
1219 not?: Maybe<UploadFolderFiltersInput>;
1220};
1221
1222export type UploadFolderInput = {
1223 name?: Maybe<Scalars['String']>;
1224 pathId?: Maybe<Scalars['Int']>;
1225 parent?: Maybe<Scalars['ID']>;
1226 children?: Maybe<Array<Maybe<Scalars['ID']>>>;
1227 files?: Maybe<Array<Maybe<Scalars['ID']>>>;
1228 path?: Maybe<Scalars['String']>;
1229};
1230
1231export type UploadFolderRelationResponseCollection = {
1232 __typename?: 'UploadFolderRelationResponseCollection';
1233 data: Array<UploadFolderEntity>;
1234};
1235
1236export type UsersPermissionsCreateRolePayload = {
1237 __typename?: 'UsersPermissionsCreateRolePayload';
1238 ok: Scalars['Boolean'];
1239};
1240
1241export type UsersPermissionsDeleteRolePayload = {
1242 __typename?: 'UsersPermissionsDeleteRolePayload';
1243 ok: Scalars['Boolean'];
1244};
1245
1246export type UsersPermissionsLoginInput = {
1247 identifier: Scalars['String'];
1248 password: Scalars['String'];
1249 provider?: Scalars['String'];
1250};
1251
1252export type UsersPermissionsLoginPayload = {
1253 __typename?: 'UsersPermissionsLoginPayload';
1254 jwt?: Maybe<Scalars['String']>;
1255 user: UsersPermissionsMe;
1256};
1257
1258export type UsersPermissionsMe = {
1259 __typename?: 'UsersPermissionsMe';
1260 id: Scalars['ID'];
1261 username: Scalars['String'];
1262 email?: Maybe<Scalars['String']>;
1263 confirmed?: Maybe<Scalars['Boolean']>;
1264 blocked?: Maybe<Scalars['Boolean']>;
1265 role?: Maybe<UsersPermissionsMeRole>;
1266 profile?: Maybe<UsersPermissionsUser>;
1267};
1268
1269export type UsersPermissionsMeRole = {
1270 __typename?: 'UsersPermissionsMeRole';
1271 id: Scalars['ID'];
1272 name: Scalars['String'];
1273 description?: Maybe<Scalars['String']>;
1274 type?: Maybe<Scalars['String']>;
1275};
1276
1277export type UsersPermissionsPasswordPayload = {
1278 __typename?: 'UsersPermissionsPasswordPayload';
1279 ok: Scalars['Boolean'];
1280};
1281
1282export type UsersPermissionsPermission = {
1283 __typename?: 'UsersPermissionsPermission';
1284 action: Scalars['String'];
1285 role?: Maybe<UsersPermissionsRoleEntityResponse>;
1286 createdAt?: Maybe<Scalars['DateTime']>;
1287 updatedAt?: Maybe<Scalars['DateTime']>;
1288};
1289
1290export type UsersPermissionsPermissionEntity = {
1291 __typename?: 'UsersPermissionsPermissionEntity';
1292 id?: Maybe<Scalars['ID']>;
1293 attributes?: Maybe<UsersPermissionsPermission>;
1294};
1295
1296export type UsersPermissionsPermissionFiltersInput = {
1297 id?: Maybe<IdFilterInput>;
1298 action?: Maybe<StringFilterInput>;
1299 role?: Maybe<UsersPermissionsRoleFiltersInput>;
1300 createdAt?: Maybe<DateTimeFilterInput>;
1301 updatedAt?: Maybe<DateTimeFilterInput>;
1302 and?: Maybe<Array<Maybe<UsersPermissionsPermissionFiltersInput>>>;
1303 or?: Maybe<Array<Maybe<UsersPermissionsPermissionFiltersInput>>>;
1304 not?: Maybe<UsersPermissionsPermissionFiltersInput>;
1305};
1306
1307export type UsersPermissionsPermissionRelationResponseCollection = {
1308 __typename?: 'UsersPermissionsPermissionRelationResponseCollection';
1309 data: Array<UsersPermissionsPermissionEntity>;
1310};
1311
1312export type UsersPermissionsRegisterInput = {
1313 username: Scalars['String'];
1314 email: Scalars['String'];
1315 password: Scalars['String'];
1316 firstName?: Maybe<Scalars['String']>;
1317 lastName?: Maybe<Scalars['String']>;
1318 lang?: Maybe<Scalars['String']>;
1319};
1320
1321export type UsersPermissionsRole = {
1322 __typename?: 'UsersPermissionsRole';
1323 name: Scalars['String'];
1324 description?: Maybe<Scalars['String']>;
1325 type?: Maybe<Scalars['String']>;
1326 permissions?: Maybe<UsersPermissionsPermissionRelationResponseCollection>;
1327 users?: Maybe<UsersPermissionsUserRelationResponseCollection>;
1328 createdAt?: Maybe<Scalars['DateTime']>;
1329 updatedAt?: Maybe<Scalars['DateTime']>;
1330};
1331
1332
1333export type UsersPermissionsRolePermissionsArgs = {
1334 filters?: Maybe<UsersPermissionsPermissionFiltersInput>;
1335 pagination?: Maybe<PaginationArg>;
1336 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1337};
1338
1339
1340export type UsersPermissionsRoleUsersArgs = {
1341 filters?: Maybe<UsersPermissionsUserFiltersInput>;
1342 pagination?: Maybe<PaginationArg>;
1343 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1344};
1345
1346export type UsersPermissionsRoleEntity = {
1347 __typename?: 'UsersPermissionsRoleEntity';
1348 id?: Maybe<Scalars['ID']>;
1349 attributes?: Maybe<UsersPermissionsRole>;
1350};
1351
1352export type UsersPermissionsRoleEntityResponse = {
1353 __typename?: 'UsersPermissionsRoleEntityResponse';
1354 data?: Maybe<UsersPermissionsRoleEntity>;
1355};
1356
1357export type UsersPermissionsRoleEntityResponseCollection = {
1358 __typename?: 'UsersPermissionsRoleEntityResponseCollection';
1359 data: Array<UsersPermissionsRoleEntity>;
1360 meta: ResponseCollectionMeta;
1361};
1362
1363export type UsersPermissionsRoleFiltersInput = {
1364 id?: Maybe<IdFilterInput>;
1365 name?: Maybe<StringFilterInput>;
1366 description?: Maybe<StringFilterInput>;
1367 type?: Maybe<StringFilterInput>;
1368 permissions?: Maybe<UsersPermissionsPermissionFiltersInput>;
1369 users?: Maybe<UsersPermissionsUserFiltersInput>;
1370 createdAt?: Maybe<DateTimeFilterInput>;
1371 updatedAt?: Maybe<DateTimeFilterInput>;
1372 and?: Maybe<Array<Maybe<UsersPermissionsRoleFiltersInput>>>;
1373 or?: Maybe<Array<Maybe<UsersPermissionsRoleFiltersInput>>>;
1374 not?: Maybe<UsersPermissionsRoleFiltersInput>;
1375};
1376
1377export type UsersPermissionsRoleInput = {
1378 name?: Maybe<Scalars['String']>;
1379 description?: Maybe<Scalars['String']>;
1380 type?: Maybe<Scalars['String']>;
1381 permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
1382 users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1383};
1384
1385export type UsersPermissionsUpdateRolePayload = {
1386 __typename?: 'UsersPermissionsUpdateRolePayload';
1387 ok: Scalars['Boolean'];
1388};
1389
1390export type UsersPermissionsUser = {
1391 __typename?: 'UsersPermissionsUser';
1392 username: Scalars['String'];
1393 email: Scalars['String'];
1394 confirmed?: Maybe<Scalars['Boolean']>;
1395 role?: Maybe<UsersPermissionsRoleEntityResponse>;
1396 events?: Maybe<EventRelationResponseCollection>;
1397 vehicles?: Maybe<VehicleRelationResponseCollection>;
1398 firstName?: Maybe<Scalars['String']>;
1399 lastName?: Maybe<Scalars['String']>;
1400 onboardingUser?: Maybe<Scalars['Boolean']>;
1401 onboardingCreator?: Maybe<Scalars['Boolean']>;
1402 lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1403 createdAt?: Maybe<Scalars['DateTime']>;
1404 updatedAt?: Maybe<Scalars['DateTime']>;
1405};
1406
1407
1408export type UsersPermissionsUserEventsArgs = {
1409 filters?: Maybe<EventFiltersInput>;
1410 pagination?: Maybe<PaginationArg>;
1411 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1412};
1413
1414
1415export type UsersPermissionsUserVehiclesArgs = {
1416 filters?: Maybe<VehicleFiltersInput>;
1417 pagination?: Maybe<PaginationArg>;
1418 sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1419};
1420
1421export type UsersPermissionsUserEntity = {
1422 __typename?: 'UsersPermissionsUserEntity';
1423 id?: Maybe<Scalars['ID']>;
1424 attributes?: Maybe<UsersPermissionsUser>;
1425};
1426
1427export type UsersPermissionsUserEntityResponse = {
1428 __typename?: 'UsersPermissionsUserEntityResponse';
1429 data?: Maybe<UsersPermissionsUserEntity>;
1430};
1431
1432export type UsersPermissionsUserFiltersInput = {
1433 id?: Maybe<IdFilterInput>;
1434 username?: Maybe<StringFilterInput>;
1435 email?: Maybe<StringFilterInput>;
1436 provider?: Maybe<StringFilterInput>;
1437 password?: Maybe<StringFilterInput>;
1438 resetPasswordToken?: Maybe<StringFilterInput>;
1439 confirmationToken?: Maybe<StringFilterInput>;
1440 confirmed?: Maybe<BooleanFilterInput>;
1441 blocked?: Maybe<BooleanFilterInput>;
1442 role?: Maybe<UsersPermissionsRoleFiltersInput>;
1443 events?: Maybe<EventFiltersInput>;
1444 passengers?: Maybe<PassengerFiltersInput>;
1445 vehicles?: Maybe<VehicleFiltersInput>;
1446 firstName?: Maybe<StringFilterInput>;
1447 lastName?: Maybe<StringFilterInput>;
1448 onboardingUser?: Maybe<BooleanFilterInput>;
1449 onboardingCreator?: Maybe<BooleanFilterInput>;
1450 lang?: Maybe<StringFilterInput>;
1451 createdAt?: Maybe<DateTimeFilterInput>;
1452 updatedAt?: Maybe<DateTimeFilterInput>;
1453 and?: Maybe<Array<Maybe<UsersPermissionsUserFiltersInput>>>;
1454 or?: Maybe<Array<Maybe<UsersPermissionsUserFiltersInput>>>;
1455 not?: Maybe<UsersPermissionsUserFiltersInput>;
1456};
1457
1458export type UsersPermissionsUserInput = {
1459 username?: Maybe<Scalars['String']>;
1460 email?: Maybe<Scalars['String']>;
1461 provider?: Maybe<Scalars['String']>;
1462 password?: Maybe<Scalars['String']>;
1463 resetPasswordToken?: Maybe<Scalars['String']>;
1464 confirmationToken?: Maybe<Scalars['String']>;
1465 confirmed?: Maybe<Scalars['Boolean']>;
1466 blocked?: Maybe<Scalars['Boolean']>;
1467 role?: Maybe<Scalars['ID']>;
1468 events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1469 passengers?: Maybe<Array<Maybe<Scalars['ID']>>>;
1470 vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1471 firstName?: Maybe<Scalars['String']>;
1472 lastName?: Maybe<Scalars['String']>;
1473 onboardingUser?: Maybe<Scalars['Boolean']>;
1474 onboardingCreator?: Maybe<Scalars['Boolean']>;
1475 lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1476 oldPassword?: Maybe<Scalars['String']>;
1477};
1478
1479export type UsersPermissionsUserRelationResponseCollection = {
1480 __typename?: 'UsersPermissionsUserRelationResponseCollection';
1481 data: Array<UsersPermissionsUserEntity>;
1482};
1483
1484export type Vehicle = {
1485 __typename?: 'Vehicle';
1486 name: Scalars['String'];
1487 seats?: Maybe<Scalars['Int']>;
1488 phone_number?: Maybe<Scalars['String']>;
1489 user?: Maybe<UsersPermissionsUserEntityResponse>;
1490 createdAt?: Maybe<Scalars['DateTime']>;
1491 updatedAt?: Maybe<Scalars['DateTime']>;
1492};
1493
1494export type VehicleEntity = {
1495 __typename?: 'VehicleEntity';
1496 id?: Maybe<Scalars['ID']>;
1497 attributes?: Maybe<Vehicle>;
1498};
1499
1500export type VehicleEntityResponse = {
1501 __typename?: 'VehicleEntityResponse';
1502 data?: Maybe<VehicleEntity>;
1503};
1504
1505export type VehicleFiltersInput = {
1506 id?: Maybe<IdFilterInput>;
1507 name?: Maybe<StringFilterInput>;
1508 seats?: Maybe<IntFilterInput>;
1509 phone_number?: Maybe<StringFilterInput>;
1510 user?: Maybe<UsersPermissionsUserFiltersInput>;
1511 createdAt?: Maybe<DateTimeFilterInput>;
1512 updatedAt?: Maybe<DateTimeFilterInput>;
1513 and?: Maybe<Array<Maybe<VehicleFiltersInput>>>;
1514 or?: Maybe<Array<Maybe<VehicleFiltersInput>>>;
1515 not?: Maybe<VehicleFiltersInput>;
1516};
1517
1518export type VehicleInput = {
1519 name?: Maybe<Scalars['String']>;
1520 seats?: Maybe<Scalars['Int']>;
1521 phone_number?: Maybe<Scalars['String']>;
1522 user?: Maybe<Scalars['ID']>;
1523};
1524
1525export type VehicleRelationResponseCollection = {
1526 __typename?: 'VehicleRelationResponseCollection';
1527 data: Array<VehicleEntity>;
1528};
1529
1530export type MeFieldsFragment = (
1531 { __typename?: 'UsersPermissionsMe' }
1532 & Pick<UsersPermissionsMe, 'id' | 'username' | 'email' | 'confirmed'>
1533);
1534
1535export type RegisterMutationVariables = Exact<{
1536 user: UsersPermissionsRegisterInput;
1537}>;
1538
1539
1540export type RegisterMutation = (
1541 { __typename?: 'Mutation' }
1542 & { register: (
1543 { __typename?: 'UsersPermissionsLoginPayload' }
1544 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1545 & { user: (
1546 { __typename?: 'UsersPermissionsMe' }
1547 & MeFieldsFragment
1548 ) }
1549 ) }
1550);
1551
1552export type LoginMutationVariables = Exact<{
1553 identifier: Scalars['String'];
1554 password: Scalars['String'];
1555}>;
1556
1557
1558export type LoginMutation = (
1559 { __typename?: 'Mutation' }
1560 & { login: (
1561 { __typename?: 'UsersPermissionsLoginPayload' }
1562 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1563 & { user: (
1564 { __typename?: 'UsersPermissionsMe' }
1565 & MeFieldsFragment
1566 ) }
1567 ) }
1568);
1569
1570export type ForgotPasswordMutationVariables = Exact<{
1571 email: Scalars['String'];
1572}>;
1573
1574
1575export type ForgotPasswordMutation = (
1576 { __typename?: 'Mutation' }
1577 & { forgotPassword?: Maybe<(
1578 { __typename?: 'UsersPermissionsPasswordPayload' }
1579 & Pick<UsersPermissionsPasswordPayload, 'ok'>
1580 )> }
1581);
1582
1583export type ResetPasswordMutationVariables = Exact<{
1584 password: Scalars['String'];
1585 passwordConfirmation: Scalars['String'];
1586 code: Scalars['String'];
1587}>;
1588
1589
1590export type ResetPasswordMutation = (
1591 { __typename?: 'Mutation' }
1592 & { resetPassword?: Maybe<(
1593 { __typename?: 'UsersPermissionsLoginPayload' }
1594 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1595 & { user: (
1596 { __typename?: 'UsersPermissionsMe' }
1597 & MeFieldsFragment
1598 ) }
1599 )> }
1600);
1601
1602export type EventFieldsFragment = (
1603 { __typename?: 'EventEntity' }
1604 & Pick<EventEntity, 'id'>
1605 & { attributes?: Maybe<(
1606 { __typename?: 'Event' }
1607 & Pick<Event, 'uuid' | 'name' | 'description' | 'email' | 'date' | 'address' | 'position'>
1608 & { waitingPassengers?: Maybe<(
1609 { __typename?: 'PassengerRelationResponseCollection' }
1610 & { data: Array<(
1611 { __typename?: 'PassengerEntity' }
1612 & Pick<PassengerEntity, 'id'>
1613 & { attributes?: Maybe<(
1614 { __typename?: 'Passenger' }
1615 & Pick<Passenger, 'name' | 'email' | 'location'>
1616 & { user?: Maybe<(
1617 { __typename?: 'UsersPermissionsUserEntityResponse' }
1618 & { data?: Maybe<(
1619 { __typename?: 'UsersPermissionsUserEntity' }
1620 & Pick<UsersPermissionsUserEntity, 'id'>
1621 & { attributes?: Maybe<(
1622 { __typename?: 'UsersPermissionsUser' }
1623 & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1624 )> }
1625 )> }
1626 )> }
1627 )> }
1628 )> }
1629 )>, travels?: Maybe<(
1630 { __typename?: 'TravelRelationResponseCollection' }
1631 & { data: Array<(
1632 { __typename?: 'TravelEntity' }
1633 & Pick<TravelEntity, 'id'>
1634 & { attributes?: Maybe<(
1635 { __typename?: 'Travel' }
1636 & Pick<Travel, 'meeting' | 'departure' | 'details' | 'vehicleName' | 'phone_number' | 'seats'>
1637 & { passengers?: Maybe<(
1638 { __typename?: 'PassengerRelationResponseCollection' }
1639 & { data: Array<(
1640 { __typename?: 'PassengerEntity' }
1641 & Pick<PassengerEntity, 'id'>
1642 & { attributes?: Maybe<(
1643 { __typename?: 'Passenger' }
1644 & Pick<Passenger, 'name' | 'location'>
1645 & { user?: Maybe<(
1646 { __typename?: 'UsersPermissionsUserEntityResponse' }
1647 & { data?: Maybe<(
1648 { __typename?: 'UsersPermissionsUserEntity' }
1649 & Pick<UsersPermissionsUserEntity, 'id'>
1650 & { attributes?: Maybe<(
1651 { __typename?: 'UsersPermissionsUser' }
1652 & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1653 )> }
1654 )> }
1655 )> }
1656 )> }
1657 )> }
1658 )> }
1659 )> }
1660 )> }
1661 )> }
1662 )> }
1663);
1664
1665export type CreateEventMutationVariables = Exact<{
1666 name: Scalars['String'];
1667 email: Scalars['String'];
1668 date?: Maybe<Scalars['Date']>;
1669 address?: Maybe<Scalars['String']>;
1670 description?: Maybe<Scalars['String']>;
1671 newsletter?: Maybe<Scalars['Boolean']>;
1672}>;
1673
1674
1675export type CreateEventMutation = (
1676 { __typename?: 'Mutation' }
1677 & { createEvent?: Maybe<(
1678 { __typename?: 'EventEntityResponse' }
1679 & { data?: Maybe<(
1680 { __typename?: 'EventEntity' }
1681 & EventFieldsFragment
1682 )> }
1683 )> }
1684);
1685
1686export type UpdateEventMutationVariables = Exact<{
1687 uuid: Scalars['String'];
1688 eventUpdate: EventInput;
1689}>;
1690
1691
1692export type UpdateEventMutation = (
1693 { __typename?: 'Mutation' }
1694 & { updateEventByUUID?: Maybe<(
1695 { __typename?: 'EventEntityResponse' }
1696 & { data?: Maybe<(
1697 { __typename?: 'EventEntity' }
1698 & EventFieldsFragment
1699 )> }
1700 )> }
1701);
1702
1703export type EventByUuidQueryVariables = Exact<{
1704 uuid: Scalars['String'];
1705}>;
1706
1707
1708export type EventByUuidQuery = (
1709 { __typename?: 'Query' }
1710 & { eventByUUID?: Maybe<(
1711 { __typename?: 'EventEntityResponse' }
1712 & { data?: Maybe<(
1713 { __typename?: 'EventEntity' }
1714 & EventFieldsFragment
1715 )> }
1716 )> }
1717);
1718
1719export type PassengerFieldsFragment = (
1720 { __typename?: 'PassengerEntity' }
1721 & Pick<PassengerEntity, 'id'>
1722 & { attributes?: Maybe<(
1723 { __typename?: 'Passenger' }
1724 & Pick<Passenger, 'name' | 'location' | 'email'>
1725 & { user?: Maybe<(
1726 { __typename?: 'UsersPermissionsUserEntityResponse' }
1727 & { data?: Maybe<(
1728 { __typename?: 'UsersPermissionsUserEntity' }
1729 & Pick<UsersPermissionsUserEntity, 'id'>
1730 & { attributes?: Maybe<(
1731 { __typename?: 'UsersPermissionsUser' }
1732 & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1733 )> }
1734 )> }
1735 )> }
1736 )> }
1737);
1738
1739export type CreatePassengerMutationVariables = Exact<{
1740 passenger: PassengerInput;
1741}>;
1742
1743
1744export type CreatePassengerMutation = (
1745 { __typename?: 'Mutation' }
1746 & { createPassenger?: Maybe<(
1747 { __typename?: 'PassengerEntityResponse' }
1748 & { data?: Maybe<(
1749 { __typename?: 'PassengerEntity' }
1750 & PassengerFieldsFragment
1751 )> }
1752 )> }
1753);
1754
1755export type UpdatePassengerMutationVariables = Exact<{
1756 id: Scalars['ID'];
1757 passengerUpdate: PassengerInput;
1758}>;
1759
1760
1761export type UpdatePassengerMutation = (
1762 { __typename?: 'Mutation' }
1763 & { updatePassenger?: Maybe<(
1764 { __typename?: 'PassengerEntityResponse' }
1765 & { data?: Maybe<(
1766 { __typename?: 'PassengerEntity' }
1767 & PassengerFieldsFragment
1768 )> }
1769 )> }
1770);
1771
1772export type DeletePassengerMutationVariables = Exact<{
1773 id: Scalars['ID'];
1774}>;
1775
1776
1777export type DeletePassengerMutation = (
1778 { __typename?: 'Mutation' }
1779 & { deletePassenger?: Maybe<(
1780 { __typename?: 'PassengerEntityResponse' }
1781 & { data?: Maybe<(
1782 { __typename?: 'PassengerEntity' }
1783 & Pick<PassengerEntity, 'id'>
1784 )> }
1785 )> }
1786);
1787
1788export type SettingQueryVariables = Exact<{
1789 locale: Scalars['I18NLocaleCode'];
1790}>;
1791
1792
1793export type SettingQuery = (
1794 { __typename?: 'Query' }
1795 & { setting?: Maybe<(
1796 { __typename?: 'SettingEntityResponse' }
1797 & { data?: Maybe<(
1798 { __typename?: 'SettingEntity' }
1799 & Pick<SettingEntity, 'id'>
1800 & { attributes?: Maybe<(
1801 { __typename?: 'Setting' }
1802 & Pick<Setting, 'gtm_id' | 'about_link' | 'faq_link' | 'announcement' | 'matomo_script_url'>
1803 )> }
1804 )> }
1805 )> }
1806);
1807
1808export type TravelFieldsFragment = (
1809 { __typename?: 'TravelEntity' }
1810 & Pick<TravelEntity, 'id'>
1811 & { attributes?: Maybe<(
1812 { __typename?: 'Travel' }
1813 & Pick<Travel, 'meeting' | 'departure' | 'details' | 'vehicleName' | 'phone_number' | 'seats'>
1814 & { passengers?: Maybe<(
1815 { __typename?: 'PassengerRelationResponseCollection' }
1816 & { data: Array<(
1817 { __typename?: 'PassengerEntity' }
1818 & Pick<PassengerEntity, 'id'>
1819 & { attributes?: Maybe<(
1820 { __typename?: 'Passenger' }
1821 & Pick<Passenger, 'name' | 'location'>
1822 & { user?: Maybe<(
1823 { __typename?: 'UsersPermissionsUserEntityResponse' }
1824 & { data?: Maybe<(
1825 { __typename?: 'UsersPermissionsUserEntity' }
1826 & Pick<UsersPermissionsUserEntity, 'id'>
1827 & { attributes?: Maybe<(
1828 { __typename?: 'UsersPermissionsUser' }
1829 & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1830 )> }
1831 )> }
1832 )> }
1833 )> }
1834 )> }
1835 )> }
1836 )> }
1837);
1838
1839export type CreateTravelMutationVariables = Exact<{
1840 travel: TravelInput;
1841 createVehicle?: Maybe<Scalars['Boolean']>;
1842}>;
1843
1844
1845export type CreateTravelMutation = (
1846 { __typename?: 'Mutation' }
1847 & { createTravel?: Maybe<(
1848 { __typename?: 'TravelEntityResponse' }
1849 & { data?: Maybe<(
1850 { __typename?: 'TravelEntity' }
1851 & TravelFieldsFragment
1852 )> }
1853 )> }
1854);
1855
1856export type UpdateTravelMutationVariables = Exact<{
1857 id: Scalars['ID'];
1858 travelUpdate: TravelInput;
1859}>;
1860
1861
1862export type UpdateTravelMutation = (
1863 { __typename?: 'Mutation' }
1864 & { updateTravel?: Maybe<(
1865 { __typename?: 'TravelEntityResponse' }
1866 & { data?: Maybe<(
1867 { __typename?: 'TravelEntity' }
1868 & TravelFieldsFragment
1869 )> }
1870 )> }
1871);
1872
1873export type DeleteTravelMutationVariables = Exact<{
1874 id: Scalars['ID'];
1875}>;
1876
1877
1878export type DeleteTravelMutation = (
1879 { __typename?: 'Mutation' }
1880 & { deleteTravel?: Maybe<(
1881 { __typename?: 'TravelEntityResponse' }
1882 & { data?: Maybe<(
1883 { __typename?: 'TravelEntity' }
1884 & Pick<TravelEntity, 'id'>
1885 )> }
1886 )> }
1887);
1888
1889export type UserFieldsFragment = (
1890 { __typename?: 'UsersPermissionsUser' }
1891 & Pick<UsersPermissionsUser, 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName' | 'lang' | 'onboardingUser' | 'onboardingCreator'>
1892 & { events?: Maybe<(
1893 { __typename?: 'EventRelationResponseCollection' }
1894 & { data: Array<(
1895 { __typename?: 'EventEntity' }
1896 & Pick<EventEntity, 'id'>
1897 & { attributes?: Maybe<(
1898 { __typename?: 'Event' }
1899 & Pick<Event, 'uuid' | 'name' | 'date' | 'address'>
1900 )> }
1901 )> }
1902 )> }
1903);
1904
1905export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
1906
1907
1908export type ProfileQuery = (
1909 { __typename?: 'Query' }
1910 & { me?: Maybe<(
1911 { __typename?: 'UsersPermissionsMe' }
1912 & Pick<UsersPermissionsMe, 'id' | 'username'>
1913 & { profile?: Maybe<(
1914 { __typename?: 'UsersPermissionsUser' }
1915 & UserFieldsFragment
1916 )> }
1917 )> }
1918);
1919
1920export type UpdateMeMutationVariables = Exact<{
1921 userUpdate: UsersPermissionsUserInput;
1922}>;
1923
1924
1925export type UpdateMeMutation = (
1926 { __typename?: 'Mutation' }
1927 & { updateMe: (
1928 { __typename?: 'UsersPermissionsUserEntityResponse' }
1929 & { data?: Maybe<(
1930 { __typename?: 'UsersPermissionsUserEntity' }
1931 & Pick<UsersPermissionsUserEntity, 'id'>
1932 & { attributes?: Maybe<(
1933 { __typename?: 'UsersPermissionsUser' }
1934 & UserFieldsFragment
1935 )> }
1936 )> }
1937 ) }
1938);
1939
1940export type VehicleFieldsFragment = (
1941 { __typename?: 'VehicleEntity' }
1942 & Pick<VehicleEntity, 'id'>
1943 & { attributes?: Maybe<(
1944 { __typename?: 'Vehicle' }
1945 & Pick<Vehicle, 'name' | 'seats' | 'phone_number'>
1946 )> }
1947);
1948
1949export type FindUserVehiclesQueryVariables = Exact<{ [key: string]: never; }>;
1950
1951
1952export type FindUserVehiclesQuery = (
1953 { __typename?: 'Query' }
1954 & { me?: Maybe<(
1955 { __typename?: 'UsersPermissionsMe' }
1956 & Pick<UsersPermissionsMe, 'id' | 'username'>
1957 & { profile?: Maybe<(
1958 { __typename?: 'UsersPermissionsUser' }
1959 & { vehicles?: Maybe<(
1960 { __typename?: 'VehicleRelationResponseCollection' }
1961 & { data: Array<(
1962 { __typename?: 'VehicleEntity' }
1963 & VehicleFieldsFragment
1964 )> }
1965 )> }
1966 )> }
1967 )> }
1968);
1969
1970export type DeleteVehicleMutationVariables = Exact<{
1971 id: Scalars['ID'];
1972}>;
1973
1974
1975export type DeleteVehicleMutation = (
1976 { __typename?: 'Mutation' }
1977 & { deleteVehicle?: Maybe<(
1978 { __typename?: 'VehicleEntityResponse' }
1979 & { data?: Maybe<(
1980 { __typename?: 'VehicleEntity' }
1981 & Pick<VehicleEntity, 'id'>
1982 & { attributes?: Maybe<(
1983 { __typename?: 'Vehicle' }
1984 & Pick<Vehicle, 'name'>
1985 )> }
1986 )> }
1987 )> }
1988);
1989
1990export const MeFieldsFragmentDoc = gql`
1991 fragment MeFields on UsersPermissionsMe {
1992 id
1993 username
1994 email
1995 confirmed
1996}
1997 `;
1998export const EventFieldsFragmentDoc = gql`
1999 fragment EventFields on EventEntity {
2000 id
2001 attributes {
2002 uuid
2003 name
2004 description
2005 email
2006 date
2007 address
2008 position
2009 waitingPassengers {
2010 data {
2011 id
2012 attributes {
2013 name
2014 email
2015 location
2016 user {
2017 data {
2018 id
2019 attributes {
2020 firstName
2021 lastName
2022 }
2023 }
2024 }
2025 }
2026 }
2027 }
2028 travels {
2029 data {
2030 id
2031 attributes {
2032 meeting
2033 departure
2034 details
2035 vehicleName
2036 phone_number
2037 seats
2038 passengers {
2039 data {
2040 id
2041 attributes {
2042 name
2043 location
2044 user {
2045 data {
2046 id
2047 attributes {
2048 firstName
2049 lastName
2050 }
2051 }
2052 }
2053 }
2054 }
2055 }
2056 }
2057 }
2058 }
2059 }
2060}
2061 `;
2062export const PassengerFieldsFragmentDoc = gql`
2063 fragment PassengerFields on PassengerEntity {
2064 id
2065 attributes {
2066 name
2067 location
2068 email
2069 user {
2070 data {
2071 id
2072 attributes {
2073 firstName
2074 lastName
2075 }
2076 }
2077 }
2078 }
2079}
2080 `;
2081export const TravelFieldsFragmentDoc = gql`
2082 fragment TravelFields on TravelEntity {
2083 id
2084 attributes {
2085 meeting
2086 departure
2087 details
2088 vehicleName
2089 phone_number
2090 seats
2091 passengers {
2092 data {
2093 id
2094 attributes {
2095 name
2096 location
2097 user {
2098 data {
2099 id
2100 attributes {
2101 firstName
2102 lastName
2103 }
2104 }
2105 }
2106 }
2107 }
2108 }
2109 }
2110}
2111 `;
2112export const UserFieldsFragmentDoc = gql`
2113 fragment UserFields on UsersPermissionsUser {
2114 username
2115 email
2116 confirmed
2117 lastName
2118 firstName
2119 lang
2120 onboardingUser
2121 onboardingCreator
2122 events {
2123 data {
2124 id
2125 attributes {
2126 uuid
2127 name
2128 date
2129 address
2130 }
2131 }
2132 }
2133}
2134 `;
2135export const VehicleFieldsFragmentDoc = gql`
2136 fragment VehicleFields on VehicleEntity {
2137 id
2138 attributes {
2139 name
2140 seats
2141 phone_number
2142 }
2143}
2144 `;
2145export const RegisterDocument = gql`
2146 mutation register($user: UsersPermissionsRegisterInput!) {
2147 register(input: $user) {
2148 jwt
2149 user {
2150 ...MeFields
2151 }
2152 }
2153}
2154 ${MeFieldsFragmentDoc}`;
2155export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
2156
2157/**
2158 * __useRegisterMutation__
2159 *
2160 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
2161 * When your component renders, `useRegisterMutation` returns a tuple that includes:
2162 * - A mutate function that you can call at any time to execute the mutation
2163 * - An object with fields that represent the current status of the mutation's execution
2164 *
2165 * @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;
2166 *
2167 * @example
2168 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
2169 * variables: {
2170 * user: // value for 'user'
2171 * },
2172 * });
2173 */
2174export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
2175 return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
2176 }
2177export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
2178export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
2179export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
2180export const LoginDocument = gql`
2181 mutation login($identifier: String!, $password: String!) {
2182 login(input: {identifier: $identifier, password: $password}) {
2183 jwt
2184 user {
2185 ...MeFields
2186 }
2187 }
2188}
2189 ${MeFieldsFragmentDoc}`;
2190export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
2191
2192/**
2193 * __useLoginMutation__
2194 *
2195 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
2196 * When your component renders, `useLoginMutation` returns a tuple that includes:
2197 * - A mutate function that you can call at any time to execute the mutation
2198 * - An object with fields that represent the current status of the mutation's execution
2199 *
2200 * @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;
2201 *
2202 * @example
2203 * const [loginMutation, { data, loading, error }] = useLoginMutation({
2204 * variables: {
2205 * identifier: // value for 'identifier'
2206 * password: // value for 'password'
2207 * },
2208 * });
2209 */
2210export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
2211 return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
2212 }
2213export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
2214export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
2215export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
2216export const ForgotPasswordDocument = gql`
2217 mutation forgotPassword($email: String!) {
2218 forgotPassword(email: $email) {
2219 ok
2220 }
2221}
2222 `;
2223export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2224
2225/**
2226 * __useForgotPasswordMutation__
2227 *
2228 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
2229 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
2230 * - A mutate function that you can call at any time to execute the mutation
2231 * - An object with fields that represent the current status of the mutation's execution
2232 *
2233 * @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;
2234 *
2235 * @example
2236 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
2237 * variables: {
2238 * email: // value for 'email'
2239 * },
2240 * });
2241 */
2242export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
2243 return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
2244 }
2245export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
2246export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
2247export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2248export const ResetPasswordDocument = gql`
2249 mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
2250 resetPassword(
2251 password: $password
2252 passwordConfirmation: $passwordConfirmation
2253 code: $code
2254 ) {
2255 jwt
2256 user {
2257 ...MeFields
2258 }
2259 }
2260}
2261 ${MeFieldsFragmentDoc}`;
2262export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
2263
2264/**
2265 * __useResetPasswordMutation__
2266 *
2267 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
2268 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
2269 * - A mutate function that you can call at any time to execute the mutation
2270 * - An object with fields that represent the current status of the mutation's execution
2271 *
2272 * @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;
2273 *
2274 * @example
2275 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
2276 * variables: {
2277 * password: // value for 'password'
2278 * passwordConfirmation: // value for 'passwordConfirmation'
2279 * code: // value for 'code'
2280 * },
2281 * });
2282 */
2283export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
2284 return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
2285 }
2286export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
2287export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
2288export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
2289export const CreateEventDocument = gql`
2290 mutation createEvent($name: String!, $email: String!, $date: Date, $address: String, $description: String, $newsletter: Boolean) {
2291 createEvent(
2292 data: {name: $name, email: $email, date: $date, address: $address, description: $description, newsletter: $newsletter}
2293 ) {
2294 data {
2295 ...EventFields
2296 }
2297 }
2298}
2299 ${EventFieldsFragmentDoc}`;
2300export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2301
2302/**
2303 * __useCreateEventMutation__
2304 *
2305 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2306 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2307 * - A mutate function that you can call at any time to execute the mutation
2308 * - An object with fields that represent the current status of the mutation's execution
2309 *
2310 * @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;
2311 *
2312 * @example
2313 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2314 * variables: {
2315 * name: // value for 'name'
2316 * email: // value for 'email'
2317 * date: // value for 'date'
2318 * address: // value for 'address'
2319 * description: // value for 'description'
2320 * newsletter: // value for 'newsletter'
2321 * },
2322 * });
2323 */
2324export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2325 return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2326 }
2327export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2328export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2329export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2330export const UpdateEventDocument = gql`
2331 mutation updateEvent($uuid: String!, $eventUpdate: EventInput!) {
2332 updateEventByUUID(uuid: $uuid, data: $eventUpdate) {
2333 data {
2334 ...EventFields
2335 }
2336 }
2337}
2338 ${EventFieldsFragmentDoc}`;
2339export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2340
2341/**
2342 * __useUpdateEventMutation__
2343 *
2344 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2345 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2346 * - A mutate function that you can call at any time to execute the mutation
2347 * - An object with fields that represent the current status of the mutation's execution
2348 *
2349 * @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;
2350 *
2351 * @example
2352 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2353 * variables: {
2354 * uuid: // value for 'uuid'
2355 * eventUpdate: // value for 'eventUpdate'
2356 * },
2357 * });
2358 */
2359export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2360 return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2361 }
2362export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2363export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2364export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2365export const EventByUuidDocument = gql`
2366 query eventByUUID($uuid: String!) {
2367 eventByUUID(uuid: $uuid) {
2368 data {
2369 ...EventFields
2370 }
2371 }
2372}
2373 ${EventFieldsFragmentDoc}`;
2374
2375/**
2376 * __useEventByUuidQuery__
2377 *
2378 * To run a query within a React component, call `useEventByUuidQuery` and pass it any options that fit your needs.
2379 * When your component renders, `useEventByUuidQuery` returns an object from Apollo Client that contains loading, error, and data properties
2380 * you can use to render your UI.
2381 *
2382 * @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;
2383 *
2384 * @example
2385 * const { data, loading, error } = useEventByUuidQuery({
2386 * variables: {
2387 * uuid: // value for 'uuid'
2388 * },
2389 * });
2390 */
2391export function useEventByUuidQuery(baseOptions: Apollo.QueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2392 return Apollo.useQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2393 }
2394export function useEventByUuidLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2395 return Apollo.useLazyQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2396 }
2397export type EventByUuidQueryHookResult = ReturnType<typeof useEventByUuidQuery>;
2398export type EventByUuidLazyQueryHookResult = ReturnType<typeof useEventByUuidLazyQuery>;
2399export type EventByUuidQueryResult = Apollo.QueryResult<EventByUuidQuery, EventByUuidQueryVariables>;
2400export const CreatePassengerDocument = gql`
2401 mutation createPassenger($passenger: PassengerInput!) {
2402 createPassenger(data: $passenger) {
2403 data {
2404 ...PassengerFields
2405 }
2406 }
2407}
2408 ${PassengerFieldsFragmentDoc}`;
2409export type CreatePassengerMutationFn = Apollo.MutationFunction<CreatePassengerMutation, CreatePassengerMutationVariables>;
2410
2411/**
2412 * __useCreatePassengerMutation__
2413 *
2414 * To run a mutation, you first call `useCreatePassengerMutation` within a React component and pass it any options that fit your needs.
2415 * When your component renders, `useCreatePassengerMutation` returns a tuple that includes:
2416 * - A mutate function that you can call at any time to execute the mutation
2417 * - An object with fields that represent the current status of the mutation's execution
2418 *
2419 * @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;
2420 *
2421 * @example
2422 * const [createPassengerMutation, { data, loading, error }] = useCreatePassengerMutation({
2423 * variables: {
2424 * passenger: // value for 'passenger'
2425 * },
2426 * });
2427 */
2428export function useCreatePassengerMutation(baseOptions?: Apollo.MutationHookOptions<CreatePassengerMutation, CreatePassengerMutationVariables>) {
2429 return Apollo.useMutation<CreatePassengerMutation, CreatePassengerMutationVariables>(CreatePassengerDocument, baseOptions);
2430 }
2431export type CreatePassengerMutationHookResult = ReturnType<typeof useCreatePassengerMutation>;
2432export type CreatePassengerMutationResult = Apollo.MutationResult<CreatePassengerMutation>;
2433export type CreatePassengerMutationOptions = Apollo.BaseMutationOptions<CreatePassengerMutation, CreatePassengerMutationVariables>;
2434export const UpdatePassengerDocument = gql`
2435 mutation updatePassenger($id: ID!, $passengerUpdate: PassengerInput!) {
2436 updatePassenger(id: $id, data: $passengerUpdate) {
2437 data {
2438 ...PassengerFields
2439 }
2440 }
2441}
2442 ${PassengerFieldsFragmentDoc}`;
2443export type UpdatePassengerMutationFn = Apollo.MutationFunction<UpdatePassengerMutation, UpdatePassengerMutationVariables>;
2444
2445/**
2446 * __useUpdatePassengerMutation__
2447 *
2448 * To run a mutation, you first call `useUpdatePassengerMutation` within a React component and pass it any options that fit your needs.
2449 * When your component renders, `useUpdatePassengerMutation` returns a tuple that includes:
2450 * - A mutate function that you can call at any time to execute the mutation
2451 * - An object with fields that represent the current status of the mutation's execution
2452 *
2453 * @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;
2454 *
2455 * @example
2456 * const [updatePassengerMutation, { data, loading, error }] = useUpdatePassengerMutation({
2457 * variables: {
2458 * id: // value for 'id'
2459 * passengerUpdate: // value for 'passengerUpdate'
2460 * },
2461 * });
2462 */
2463export function useUpdatePassengerMutation(baseOptions?: Apollo.MutationHookOptions<UpdatePassengerMutation, UpdatePassengerMutationVariables>) {
2464 return Apollo.useMutation<UpdatePassengerMutation, UpdatePassengerMutationVariables>(UpdatePassengerDocument, baseOptions);
2465 }
2466export type UpdatePassengerMutationHookResult = ReturnType<typeof useUpdatePassengerMutation>;
2467export type UpdatePassengerMutationResult = Apollo.MutationResult<UpdatePassengerMutation>;
2468export type UpdatePassengerMutationOptions = Apollo.BaseMutationOptions<UpdatePassengerMutation, UpdatePassengerMutationVariables>;
2469export const DeletePassengerDocument = gql`
2470 mutation deletePassenger($id: ID!) {
2471 deletePassenger(id: $id) {
2472 data {
2473 id
2474 }
2475 }
2476}
2477 `;
2478export type DeletePassengerMutationFn = Apollo.MutationFunction<DeletePassengerMutation, DeletePassengerMutationVariables>;
2479
2480/**
2481 * __useDeletePassengerMutation__
2482 *
2483 * To run a mutation, you first call `useDeletePassengerMutation` within a React component and pass it any options that fit your needs.
2484 * When your component renders, `useDeletePassengerMutation` returns a tuple that includes:
2485 * - A mutate function that you can call at any time to execute the mutation
2486 * - An object with fields that represent the current status of the mutation's execution
2487 *
2488 * @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;
2489 *
2490 * @example
2491 * const [deletePassengerMutation, { data, loading, error }] = useDeletePassengerMutation({
2492 * variables: {
2493 * id: // value for 'id'
2494 * },
2495 * });
2496 */
2497export function useDeletePassengerMutation(baseOptions?: Apollo.MutationHookOptions<DeletePassengerMutation, DeletePassengerMutationVariables>) {
2498 return Apollo.useMutation<DeletePassengerMutation, DeletePassengerMutationVariables>(DeletePassengerDocument, baseOptions);
2499 }
2500export type DeletePassengerMutationHookResult = ReturnType<typeof useDeletePassengerMutation>;
2501export type DeletePassengerMutationResult = Apollo.MutationResult<DeletePassengerMutation>;
2502export type DeletePassengerMutationOptions = Apollo.BaseMutationOptions<DeletePassengerMutation, DeletePassengerMutationVariables>;
2503export const SettingDocument = gql`
2504 query setting($locale: I18NLocaleCode!) {
2505 setting(locale: $locale) {
2506 data {
2507 id
2508 attributes {
2509 gtm_id
2510 about_link
2511 faq_link
2512 announcement
2513 matomo_script_url
2514 }
2515 }
2516 }
2517}
2518 `;
2519
2520/**
2521 * __useSettingQuery__
2522 *
2523 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2524 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2525 * you can use to render your UI.
2526 *
2527 * @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;
2528 *
2529 * @example
2530 * const { data, loading, error } = useSettingQuery({
2531 * variables: {
2532 * locale: // value for 'locale'
2533 * },
2534 * });
2535 */
2536export function useSettingQuery(baseOptions: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2537 return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2538 }
2539export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2540 return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2541 }
2542export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2543export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2544export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2545export const CreateTravelDocument = gql`
2546 mutation createTravel($travel: TravelInput!, $createVehicle: Boolean) {
2547 createTravel(data: $travel, createVehicle: $createVehicle) {
2548 data {
2549 ...TravelFields
2550 }
2551 }
2552}
2553 ${TravelFieldsFragmentDoc}`;
2554export type CreateTravelMutationFn = Apollo.MutationFunction<CreateTravelMutation, CreateTravelMutationVariables>;
2555
2556/**
2557 * __useCreateTravelMutation__
2558 *
2559 * To run a mutation, you first call `useCreateTravelMutation` within a React component and pass it any options that fit your needs.
2560 * When your component renders, `useCreateTravelMutation` returns a tuple that includes:
2561 * - A mutate function that you can call at any time to execute the mutation
2562 * - An object with fields that represent the current status of the mutation's execution
2563 *
2564 * @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;
2565 *
2566 * @example
2567 * const [createTravelMutation, { data, loading, error }] = useCreateTravelMutation({
2568 * variables: {
2569 * travel: // value for 'travel'
2570 * createVehicle: // value for 'createVehicle'
2571 * },
2572 * });
2573 */
2574export function useCreateTravelMutation(baseOptions?: Apollo.MutationHookOptions<CreateTravelMutation, CreateTravelMutationVariables>) {
2575 return Apollo.useMutation<CreateTravelMutation, CreateTravelMutationVariables>(CreateTravelDocument, baseOptions);
2576 }
2577export type CreateTravelMutationHookResult = ReturnType<typeof useCreateTravelMutation>;
2578export type CreateTravelMutationResult = Apollo.MutationResult<CreateTravelMutation>;
2579export type CreateTravelMutationOptions = Apollo.BaseMutationOptions<CreateTravelMutation, CreateTravelMutationVariables>;
2580export const UpdateTravelDocument = gql`
2581 mutation updateTravel($id: ID!, $travelUpdate: TravelInput!) {
2582 updateTravel(id: $id, data: $travelUpdate) {
2583 data {
2584 ...TravelFields
2585 }
2586 }
2587}
2588 ${TravelFieldsFragmentDoc}`;
2589export type UpdateTravelMutationFn = Apollo.MutationFunction<UpdateTravelMutation, UpdateTravelMutationVariables>;
2590
2591/**
2592 * __useUpdateTravelMutation__
2593 *
2594 * To run a mutation, you first call `useUpdateTravelMutation` within a React component and pass it any options that fit your needs.
2595 * When your component renders, `useUpdateTravelMutation` returns a tuple that includes:
2596 * - A mutate function that you can call at any time to execute the mutation
2597 * - An object with fields that represent the current status of the mutation's execution
2598 *
2599 * @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;
2600 *
2601 * @example
2602 * const [updateTravelMutation, { data, loading, error }] = useUpdateTravelMutation({
2603 * variables: {
2604 * id: // value for 'id'
2605 * travelUpdate: // value for 'travelUpdate'
2606 * },
2607 * });
2608 */
2609export function useUpdateTravelMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTravelMutation, UpdateTravelMutationVariables>) {
2610 return Apollo.useMutation<UpdateTravelMutation, UpdateTravelMutationVariables>(UpdateTravelDocument, baseOptions);
2611 }
2612export type UpdateTravelMutationHookResult = ReturnType<typeof useUpdateTravelMutation>;
2613export type UpdateTravelMutationResult = Apollo.MutationResult<UpdateTravelMutation>;
2614export type UpdateTravelMutationOptions = Apollo.BaseMutationOptions<UpdateTravelMutation, UpdateTravelMutationVariables>;
2615export const DeleteTravelDocument = gql`
2616 mutation deleteTravel($id: ID!) {
2617 deleteTravel(id: $id) {
2618 data {
2619 id
2620 }
2621 }
2622}
2623 `;
2624export type DeleteTravelMutationFn = Apollo.MutationFunction<DeleteTravelMutation, DeleteTravelMutationVariables>;
2625
2626/**
2627 * __useDeleteTravelMutation__
2628 *
2629 * To run a mutation, you first call `useDeleteTravelMutation` within a React component and pass it any options that fit your needs.
2630 * When your component renders, `useDeleteTravelMutation` returns a tuple that includes:
2631 * - A mutate function that you can call at any time to execute the mutation
2632 * - An object with fields that represent the current status of the mutation's execution
2633 *
2634 * @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;
2635 *
2636 * @example
2637 * const [deleteTravelMutation, { data, loading, error }] = useDeleteTravelMutation({
2638 * variables: {
2639 * id: // value for 'id'
2640 * },
2641 * });
2642 */
2643export function useDeleteTravelMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTravelMutation, DeleteTravelMutationVariables>) {
2644 return Apollo.useMutation<DeleteTravelMutation, DeleteTravelMutationVariables>(DeleteTravelDocument, baseOptions);
2645 }
2646export type DeleteTravelMutationHookResult = ReturnType<typeof useDeleteTravelMutation>;
2647export type DeleteTravelMutationResult = Apollo.MutationResult<DeleteTravelMutation>;
2648export type DeleteTravelMutationOptions = Apollo.BaseMutationOptions<DeleteTravelMutation, DeleteTravelMutationVariables>;
2649export const ProfileDocument = gql`
2650 query profile {
2651 me {
2652 id
2653 username
2654 profile {
2655 ...UserFields
2656 }
2657 }
2658}
2659 ${UserFieldsFragmentDoc}`;
2660
2661/**
2662 * __useProfileQuery__
2663 *
2664 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2665 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2666 * you can use to render your UI.
2667 *
2668 * @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;
2669 *
2670 * @example
2671 * const { data, loading, error } = useProfileQuery({
2672 * variables: {
2673 * },
2674 * });
2675 */
2676export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2677 return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2678 }
2679export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2680 return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2681 }
2682export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2683export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2684export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2685export const UpdateMeDocument = gql`
2686 mutation updateMe($userUpdate: UsersPermissionsUserInput!) {
2687 updateMe(data: $userUpdate) {
2688 data {
2689 id
2690 attributes {
2691 ...UserFields
2692 }
2693 }
2694 }
2695}
2696 ${UserFieldsFragmentDoc}`;
2697export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2698
2699/**
2700 * __useUpdateMeMutation__
2701 *
2702 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2703 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2704 * - A mutate function that you can call at any time to execute the mutation
2705 * - An object with fields that represent the current status of the mutation's execution
2706 *
2707 * @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;
2708 *
2709 * @example
2710 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2711 * variables: {
2712 * userUpdate: // value for 'userUpdate'
2713 * },
2714 * });
2715 */
2716export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2717 return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2718 }
2719export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2720export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2721export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;
2722export const FindUserVehiclesDocument = gql`
2723 query findUserVehicles {
2724 me {
2725 id
2726 username
2727 profile {
2728 vehicles {
2729 data {
2730 ...VehicleFields
2731 }
2732 }
2733 }
2734 }
2735}
2736 ${VehicleFieldsFragmentDoc}`;
2737
2738/**
2739 * __useFindUserVehiclesQuery__
2740 *
2741 * To run a query within a React component, call `useFindUserVehiclesQuery` and pass it any options that fit your needs.
2742 * When your component renders, `useFindUserVehiclesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2743 * you can use to render your UI.
2744 *
2745 * @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;
2746 *
2747 * @example
2748 * const { data, loading, error } = useFindUserVehiclesQuery({
2749 * variables: {
2750 * },
2751 * });
2752 */
2753export function useFindUserVehiclesQuery(baseOptions?: Apollo.QueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
2754 return Apollo.useQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
2755 }
2756export function useFindUserVehiclesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
2757 return Apollo.useLazyQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
2758 }
2759export type FindUserVehiclesQueryHookResult = ReturnType<typeof useFindUserVehiclesQuery>;
2760export type FindUserVehiclesLazyQueryHookResult = ReturnType<typeof useFindUserVehiclesLazyQuery>;
2761export type FindUserVehiclesQueryResult = Apollo.QueryResult<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>;
2762export const DeleteVehicleDocument = gql`
2763 mutation deleteVehicle($id: ID!) {
2764 deleteVehicle(id: $id) {
2765 data {
2766 id
2767 attributes {
2768 name
2769 }
2770 }
2771 }
2772}
2773 `;
2774export type DeleteVehicleMutationFn = Apollo.MutationFunction<DeleteVehicleMutation, DeleteVehicleMutationVariables>;
2775
2776/**
2777 * __useDeleteVehicleMutation__
2778 *
2779 * To run a mutation, you first call `useDeleteVehicleMutation` within a React component and pass it any options that fit your needs.
2780 * When your component renders, `useDeleteVehicleMutation` returns a tuple that includes:
2781 * - A mutate function that you can call at any time to execute the mutation
2782 * - An object with fields that represent the current status of the mutation's execution
2783 *
2784 * @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;
2785 *
2786 * @example
2787 * const [deleteVehicleMutation, { data, loading, error }] = useDeleteVehicleMutation({
2788 * variables: {
2789 * id: // value for 'id'
2790 * },
2791 * });
2792 */
2793export function useDeleteVehicleMutation(baseOptions?: Apollo.MutationHookOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>) {
2794 return Apollo.useMutation<DeleteVehicleMutation, DeleteVehicleMutationVariables>(DeleteVehicleDocument, baseOptions);
2795 }
2796export type DeleteVehicleMutationHookResult = ReturnType<typeof useDeleteVehicleMutation>;
2797export type DeleteVehicleMutationResult = Apollo.MutationResult<DeleteVehicleMutation>;
2798export type DeleteVehicleMutationOptions = Apollo.BaseMutationOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>;