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