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