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 | TravelGroupBy | TravelConnectionId | TravelConnectionCreated_At | TravelConnectionUpdated_At | TravelConnectionMeeting | TravelConnectionDeparture | TravelConnectionDetails | TravelConnectionEvent | TravelConnectionVehicle | 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 vehicle?: Maybe<Vehicle>;
1000};
1001
1002export type TravelAggregator = {
1003 __typename?: 'TravelAggregator';
1004 count?: Maybe<Scalars['Int']>;
1005 totalCount?: Maybe<Scalars['Int']>;
1006};
1007
1008export type TravelConnection = {
1009 __typename?: 'TravelConnection';
1010 values?: Maybe<Array<Maybe<Travel>>>;
1011 groupBy?: Maybe<TravelGroupBy>;
1012 aggregate?: Maybe<TravelAggregator>;
1013};
1014
1015export type TravelConnectionCreated_At = {
1016 __typename?: 'TravelConnectionCreated_at';
1017 key?: Maybe<Scalars['DateTime']>;
1018 connection?: Maybe<TravelConnection>;
1019};
1020
1021export type TravelConnectionDeparture = {
1022 __typename?: 'TravelConnectionDeparture';
1023 key?: Maybe<Scalars['DateTime']>;
1024 connection?: Maybe<TravelConnection>;
1025};
1026
1027export type TravelConnectionDetails = {
1028 __typename?: 'TravelConnectionDetails';
1029 key?: Maybe<Scalars['String']>;
1030 connection?: Maybe<TravelConnection>;
1031};
1032
1033export type TravelConnectionEvent = {
1034 __typename?: 'TravelConnectionEvent';
1035 key?: Maybe<Scalars['ID']>;
1036 connection?: Maybe<TravelConnection>;
1037};
1038
1039export type TravelConnectionId = {
1040 __typename?: 'TravelConnectionId';
1041 key?: Maybe<Scalars['ID']>;
1042 connection?: Maybe<TravelConnection>;
1043};
1044
1045export type TravelConnectionMeeting = {
1046 __typename?: 'TravelConnectionMeeting';
1047 key?: Maybe<Scalars['String']>;
1048 connection?: Maybe<TravelConnection>;
1049};
1050
1051export type TravelConnectionUpdated_At = {
1052 __typename?: 'TravelConnectionUpdated_at';
1053 key?: Maybe<Scalars['DateTime']>;
1054 connection?: Maybe<TravelConnection>;
1055};
1056
1057export type TravelConnectionVehicle = {
1058 __typename?: 'TravelConnectionVehicle';
1059 key?: Maybe<Scalars['ID']>;
1060 connection?: Maybe<TravelConnection>;
1061};
1062
1063export type TravelGroupBy = {
1064 __typename?: 'TravelGroupBy';
1065 id?: Maybe<Array<Maybe<TravelConnectionId>>>;
1066 created_at?: Maybe<Array<Maybe<TravelConnectionCreated_At>>>;
1067 updated_at?: Maybe<Array<Maybe<TravelConnectionUpdated_At>>>;
1068 meeting?: Maybe<Array<Maybe<TravelConnectionMeeting>>>;
1069 departure?: Maybe<Array<Maybe<TravelConnectionDeparture>>>;
1070 details?: Maybe<Array<Maybe<TravelConnectionDetails>>>;
1071 event?: Maybe<Array<Maybe<TravelConnectionEvent>>>;
1072 vehicle?: Maybe<Array<Maybe<TravelConnectionVehicle>>>;
1073};
1074
1075export type TravelInput = {
1076 meeting?: Maybe<Scalars['String']>;
1077 departure?: Maybe<Scalars['DateTime']>;
1078 details?: Maybe<Scalars['String']>;
1079 passengers?: Maybe<Array<Maybe<ComponentPassengerPassengerInput>>>;
1080 event?: Maybe<Scalars['ID']>;
1081 vehicle?: Maybe<Scalars['ID']>;
1082 created_by?: Maybe<Scalars['ID']>;
1083 updated_by?: Maybe<Scalars['ID']>;
1084};
1085
1086
1087export type UploadFile = {
1088 __typename?: 'UploadFile';
1089 id: Scalars['ID'];
1090 created_at: Scalars['DateTime'];
1091 updated_at: Scalars['DateTime'];
1092 name: Scalars['String'];
1093 alternativeText?: Maybe<Scalars['String']>;
1094 caption?: Maybe<Scalars['String']>;
1095 width?: Maybe<Scalars['Int']>;
1096 height?: Maybe<Scalars['Int']>;
1097 formats?: Maybe<Scalars['JSON']>;
1098 hash: Scalars['String'];
1099 ext?: Maybe<Scalars['String']>;
1100 mime: Scalars['String'];
1101 size: Scalars['Float'];
1102 url: Scalars['String'];
1103 previewUrl?: Maybe<Scalars['String']>;
1104 provider: Scalars['String'];
1105 provider_metadata?: Maybe<Scalars['JSON']>;
1106 related?: Maybe<Array<Maybe<Morph>>>;
1107};
1108
1109
1110export type UploadFileRelatedArgs = {
1111 sort?: Maybe<Scalars['String']>;
1112 limit?: Maybe<Scalars['Int']>;
1113 start?: Maybe<Scalars['Int']>;
1114 where?: Maybe<Scalars['JSON']>;
1115};
1116
1117export type UploadFileAggregator = {
1118 __typename?: 'UploadFileAggregator';
1119 count?: Maybe<Scalars['Int']>;
1120 totalCount?: Maybe<Scalars['Int']>;
1121 sum?: Maybe<UploadFileAggregatorSum>;
1122 avg?: Maybe<UploadFileAggregatorAvg>;
1123 min?: Maybe<UploadFileAggregatorMin>;
1124 max?: Maybe<UploadFileAggregatorMax>;
1125};
1126
1127export type UploadFileAggregatorAvg = {
1128 __typename?: 'UploadFileAggregatorAvg';
1129 width?: Maybe<Scalars['Float']>;
1130 height?: Maybe<Scalars['Float']>;
1131 size?: Maybe<Scalars['Float']>;
1132};
1133
1134export type UploadFileAggregatorMax = {
1135 __typename?: 'UploadFileAggregatorMax';
1136 width?: Maybe<Scalars['Float']>;
1137 height?: Maybe<Scalars['Float']>;
1138 size?: Maybe<Scalars['Float']>;
1139};
1140
1141export type UploadFileAggregatorMin = {
1142 __typename?: 'UploadFileAggregatorMin';
1143 width?: Maybe<Scalars['Float']>;
1144 height?: Maybe<Scalars['Float']>;
1145 size?: Maybe<Scalars['Float']>;
1146};
1147
1148export type UploadFileAggregatorSum = {
1149 __typename?: 'UploadFileAggregatorSum';
1150 width?: Maybe<Scalars['Float']>;
1151 height?: Maybe<Scalars['Float']>;
1152 size?: Maybe<Scalars['Float']>;
1153};
1154
1155export type UploadFileConnection = {
1156 __typename?: 'UploadFileConnection';
1157 values?: Maybe<Array<Maybe<UploadFile>>>;
1158 groupBy?: Maybe<UploadFileGroupBy>;
1159 aggregate?: Maybe<UploadFileAggregator>;
1160};
1161
1162export type UploadFileConnectionAlternativeText = {
1163 __typename?: 'UploadFileConnectionAlternativeText';
1164 key?: Maybe<Scalars['String']>;
1165 connection?: Maybe<UploadFileConnection>;
1166};
1167
1168export type UploadFileConnectionCaption = {
1169 __typename?: 'UploadFileConnectionCaption';
1170 key?: Maybe<Scalars['String']>;
1171 connection?: Maybe<UploadFileConnection>;
1172};
1173
1174export type UploadFileConnectionCreated_At = {
1175 __typename?: 'UploadFileConnectionCreated_at';
1176 key?: Maybe<Scalars['DateTime']>;
1177 connection?: Maybe<UploadFileConnection>;
1178};
1179
1180export type UploadFileConnectionExt = {
1181 __typename?: 'UploadFileConnectionExt';
1182 key?: Maybe<Scalars['String']>;
1183 connection?: Maybe<UploadFileConnection>;
1184};
1185
1186export type UploadFileConnectionFormats = {
1187 __typename?: 'UploadFileConnectionFormats';
1188 key?: Maybe<Scalars['JSON']>;
1189 connection?: Maybe<UploadFileConnection>;
1190};
1191
1192export type UploadFileConnectionHash = {
1193 __typename?: 'UploadFileConnectionHash';
1194 key?: Maybe<Scalars['String']>;
1195 connection?: Maybe<UploadFileConnection>;
1196};
1197
1198export type UploadFileConnectionHeight = {
1199 __typename?: 'UploadFileConnectionHeight';
1200 key?: Maybe<Scalars['Int']>;
1201 connection?: Maybe<UploadFileConnection>;
1202};
1203
1204export type UploadFileConnectionId = {
1205 __typename?: 'UploadFileConnectionId';
1206 key?: Maybe<Scalars['ID']>;
1207 connection?: Maybe<UploadFileConnection>;
1208};
1209
1210export type UploadFileConnectionMime = {
1211 __typename?: 'UploadFileConnectionMime';
1212 key?: Maybe<Scalars['String']>;
1213 connection?: Maybe<UploadFileConnection>;
1214};
1215
1216export type UploadFileConnectionName = {
1217 __typename?: 'UploadFileConnectionName';
1218 key?: Maybe<Scalars['String']>;
1219 connection?: Maybe<UploadFileConnection>;
1220};
1221
1222export type UploadFileConnectionPreviewUrl = {
1223 __typename?: 'UploadFileConnectionPreviewUrl';
1224 key?: Maybe<Scalars['String']>;
1225 connection?: Maybe<UploadFileConnection>;
1226};
1227
1228export type UploadFileConnectionProvider = {
1229 __typename?: 'UploadFileConnectionProvider';
1230 key?: Maybe<Scalars['String']>;
1231 connection?: Maybe<UploadFileConnection>;
1232};
1233
1234export type UploadFileConnectionProvider_Metadata = {
1235 __typename?: 'UploadFileConnectionProvider_metadata';
1236 key?: Maybe<Scalars['JSON']>;
1237 connection?: Maybe<UploadFileConnection>;
1238};
1239
1240export type UploadFileConnectionSize = {
1241 __typename?: 'UploadFileConnectionSize';
1242 key?: Maybe<Scalars['Float']>;
1243 connection?: Maybe<UploadFileConnection>;
1244};
1245
1246export type UploadFileConnectionUpdated_At = {
1247 __typename?: 'UploadFileConnectionUpdated_at';
1248 key?: Maybe<Scalars['DateTime']>;
1249 connection?: Maybe<UploadFileConnection>;
1250};
1251
1252export type UploadFileConnectionUrl = {
1253 __typename?: 'UploadFileConnectionUrl';
1254 key?: Maybe<Scalars['String']>;
1255 connection?: Maybe<UploadFileConnection>;
1256};
1257
1258export type UploadFileConnectionWidth = {
1259 __typename?: 'UploadFileConnectionWidth';
1260 key?: Maybe<Scalars['Int']>;
1261 connection?: Maybe<UploadFileConnection>;
1262};
1263
1264export type UploadFileGroupBy = {
1265 __typename?: 'UploadFileGroupBy';
1266 id?: Maybe<Array<Maybe<UploadFileConnectionId>>>;
1267 created_at?: Maybe<Array<Maybe<UploadFileConnectionCreated_At>>>;
1268 updated_at?: Maybe<Array<Maybe<UploadFileConnectionUpdated_At>>>;
1269 name?: Maybe<Array<Maybe<UploadFileConnectionName>>>;
1270 alternativeText?: Maybe<Array<Maybe<UploadFileConnectionAlternativeText>>>;
1271 caption?: Maybe<Array<Maybe<UploadFileConnectionCaption>>>;
1272 width?: Maybe<Array<Maybe<UploadFileConnectionWidth>>>;
1273 height?: Maybe<Array<Maybe<UploadFileConnectionHeight>>>;
1274 formats?: Maybe<Array<Maybe<UploadFileConnectionFormats>>>;
1275 hash?: Maybe<Array<Maybe<UploadFileConnectionHash>>>;
1276 ext?: Maybe<Array<Maybe<UploadFileConnectionExt>>>;
1277 mime?: Maybe<Array<Maybe<UploadFileConnectionMime>>>;
1278 size?: Maybe<Array<Maybe<UploadFileConnectionSize>>>;
1279 url?: Maybe<Array<Maybe<UploadFileConnectionUrl>>>;
1280 previewUrl?: Maybe<Array<Maybe<UploadFileConnectionPreviewUrl>>>;
1281 provider?: Maybe<Array<Maybe<UploadFileConnectionProvider>>>;
1282 provider_metadata?: Maybe<Array<Maybe<UploadFileConnectionProvider_Metadata>>>;
1283};
1284
1285export type UserInput = {
1286 username: Scalars['String'];
1287 firstName?: Maybe<Scalars['String']>;
1288 lastName?: Maybe<Scalars['String']>;
1289 email: Scalars['String'];
1290 provider?: Maybe<Scalars['String']>;
1291 password?: Maybe<Scalars['String']>;
1292 resetPasswordToken?: Maybe<Scalars['String']>;
1293 confirmed?: Maybe<Scalars['Boolean']>;
1294 blocked?: Maybe<Scalars['Boolean']>;
1295 role?: Maybe<Scalars['ID']>;
1296 confirmationToken?: Maybe<Scalars['String']>;
1297 events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1298 onboardingUser?: Maybe<Scalars['Boolean']>;
1299 onboardingCreator?: Maybe<Scalars['Boolean']>;
1300 lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1301 vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1302 created_by?: Maybe<Scalars['ID']>;
1303 updated_by?: Maybe<Scalars['ID']>;
1304};
1305
1306export type UserPermissionsPasswordPayload = {
1307 __typename?: 'UserPermissionsPasswordPayload';
1308 ok: Scalars['Boolean'];
1309};
1310
1311export type UsersPermissionsLoginInput = {
1312 identifier: Scalars['String'];
1313 password: Scalars['String'];
1314 provider?: Maybe<Scalars['String']>;
1315};
1316
1317export type UsersPermissionsLoginPayload = {
1318 __typename?: 'UsersPermissionsLoginPayload';
1319 jwt?: Maybe<Scalars['String']>;
1320 user: UsersPermissionsMe;
1321};
1322
1323export type UsersPermissionsMe = {
1324 __typename?: 'UsersPermissionsMe';
1325 id: Scalars['ID'];
1326 username: Scalars['String'];
1327 email: Scalars['String'];
1328 confirmed?: Maybe<Scalars['Boolean']>;
1329 blocked?: Maybe<Scalars['Boolean']>;
1330 role?: Maybe<UsersPermissionsMeRole>;
1331 profile?: Maybe<UsersPermissionsUser>;
1332};
1333
1334export type UsersPermissionsMeRole = {
1335 __typename?: 'UsersPermissionsMeRole';
1336 id: Scalars['ID'];
1337 name: Scalars['String'];
1338 description?: Maybe<Scalars['String']>;
1339 type?: Maybe<Scalars['String']>;
1340};
1341
1342export type UsersPermissionsPermission = {
1343 __typename?: 'UsersPermissionsPermission';
1344 id: Scalars['ID'];
1345 type: Scalars['String'];
1346 controller: Scalars['String'];
1347 action: Scalars['String'];
1348 enabled: Scalars['Boolean'];
1349 policy?: Maybe<Scalars['String']>;
1350 role?: Maybe<UsersPermissionsRole>;
1351};
1352
1353export type UsersPermissionsRegisterInput = {
1354 username: Scalars['String'];
1355 email: Scalars['String'];
1356 password: Scalars['String'];
1357 firstName?: Maybe<Scalars['String']>;
1358 lastName?: Maybe<Scalars['String']>;
1359 lang?: Maybe<Scalars['String']>;
1360};
1361
1362export type UsersPermissionsRole = {
1363 __typename?: 'UsersPermissionsRole';
1364 id: Scalars['ID'];
1365 name: Scalars['String'];
1366 description?: Maybe<Scalars['String']>;
1367 type?: Maybe<Scalars['String']>;
1368 permissions?: Maybe<Array<Maybe<UsersPermissionsPermission>>>;
1369 users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1370};
1371
1372
1373export type UsersPermissionsRolePermissionsArgs = {
1374 sort?: Maybe<Scalars['String']>;
1375 limit?: Maybe<Scalars['Int']>;
1376 start?: Maybe<Scalars['Int']>;
1377 where?: Maybe<Scalars['JSON']>;
1378};
1379
1380
1381export type UsersPermissionsRoleUsersArgs = {
1382 sort?: Maybe<Scalars['String']>;
1383 limit?: Maybe<Scalars['Int']>;
1384 start?: Maybe<Scalars['Int']>;
1385 where?: Maybe<Scalars['JSON']>;
1386};
1387
1388export type UsersPermissionsRoleAggregator = {
1389 __typename?: 'UsersPermissionsRoleAggregator';
1390 count?: Maybe<Scalars['Int']>;
1391 totalCount?: Maybe<Scalars['Int']>;
1392};
1393
1394export type UsersPermissionsRoleConnection = {
1395 __typename?: 'UsersPermissionsRoleConnection';
1396 values?: Maybe<Array<Maybe<UsersPermissionsRole>>>;
1397 groupBy?: Maybe<UsersPermissionsRoleGroupBy>;
1398 aggregate?: Maybe<UsersPermissionsRoleAggregator>;
1399};
1400
1401export type UsersPermissionsRoleConnectionDescription = {
1402 __typename?: 'UsersPermissionsRoleConnectionDescription';
1403 key?: Maybe<Scalars['String']>;
1404 connection?: Maybe<UsersPermissionsRoleConnection>;
1405};
1406
1407export type UsersPermissionsRoleConnectionId = {
1408 __typename?: 'UsersPermissionsRoleConnectionId';
1409 key?: Maybe<Scalars['ID']>;
1410 connection?: Maybe<UsersPermissionsRoleConnection>;
1411};
1412
1413export type UsersPermissionsRoleConnectionName = {
1414 __typename?: 'UsersPermissionsRoleConnectionName';
1415 key?: Maybe<Scalars['String']>;
1416 connection?: Maybe<UsersPermissionsRoleConnection>;
1417};
1418
1419export type UsersPermissionsRoleConnectionType = {
1420 __typename?: 'UsersPermissionsRoleConnectionType';
1421 key?: Maybe<Scalars['String']>;
1422 connection?: Maybe<UsersPermissionsRoleConnection>;
1423};
1424
1425export type UsersPermissionsRoleGroupBy = {
1426 __typename?: 'UsersPermissionsRoleGroupBy';
1427 id?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionId>>>;
1428 name?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionName>>>;
1429 description?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionDescription>>>;
1430 type?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionType>>>;
1431};
1432
1433export type UsersPermissionsUser = {
1434 __typename?: 'UsersPermissionsUser';
1435 id: Scalars['ID'];
1436 created_at: Scalars['DateTime'];
1437 updated_at: Scalars['DateTime'];
1438 username: Scalars['String'];
1439 firstName?: Maybe<Scalars['String']>;
1440 lastName?: Maybe<Scalars['String']>;
1441 email: Scalars['String'];
1442 provider?: Maybe<Scalars['String']>;
1443 confirmed?: Maybe<Scalars['Boolean']>;
1444 blocked?: Maybe<Scalars['Boolean']>;
1445 role?: Maybe<UsersPermissionsRole>;
1446 onboardingUser?: Maybe<Scalars['Boolean']>;
1447 onboardingCreator?: Maybe<Scalars['Boolean']>;
1448 lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1449 events?: Maybe<Array<Maybe<Event>>>;
1450 vehicles?: Maybe<Array<Maybe<Vehicle>>>;
1451};
1452
1453
1454export type UsersPermissionsUserEventsArgs = {
1455 sort?: Maybe<Scalars['String']>;
1456 limit?: Maybe<Scalars['Int']>;
1457 start?: Maybe<Scalars['Int']>;
1458 where?: Maybe<Scalars['JSON']>;
1459};
1460
1461
1462export type UsersPermissionsUserVehiclesArgs = {
1463 sort?: Maybe<Scalars['String']>;
1464 limit?: Maybe<Scalars['Int']>;
1465 start?: Maybe<Scalars['Int']>;
1466 where?: Maybe<Scalars['JSON']>;
1467};
1468
1469export type UsersPermissionsUserAggregator = {
1470 __typename?: 'UsersPermissionsUserAggregator';
1471 count?: Maybe<Scalars['Int']>;
1472 totalCount?: Maybe<Scalars['Int']>;
1473};
1474
1475export type UsersPermissionsUserConnection = {
1476 __typename?: 'UsersPermissionsUserConnection';
1477 values?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1478 groupBy?: Maybe<UsersPermissionsUserGroupBy>;
1479 aggregate?: Maybe<UsersPermissionsUserAggregator>;
1480};
1481
1482export type UsersPermissionsUserConnectionBlocked = {
1483 __typename?: 'UsersPermissionsUserConnectionBlocked';
1484 key?: Maybe<Scalars['Boolean']>;
1485 connection?: Maybe<UsersPermissionsUserConnection>;
1486};
1487
1488export type UsersPermissionsUserConnectionConfirmed = {
1489 __typename?: 'UsersPermissionsUserConnectionConfirmed';
1490 key?: Maybe<Scalars['Boolean']>;
1491 connection?: Maybe<UsersPermissionsUserConnection>;
1492};
1493
1494export type UsersPermissionsUserConnectionCreated_At = {
1495 __typename?: 'UsersPermissionsUserConnectionCreated_at';
1496 key?: Maybe<Scalars['DateTime']>;
1497 connection?: Maybe<UsersPermissionsUserConnection>;
1498};
1499
1500export type UsersPermissionsUserConnectionEmail = {
1501 __typename?: 'UsersPermissionsUserConnectionEmail';
1502 key?: Maybe<Scalars['String']>;
1503 connection?: Maybe<UsersPermissionsUserConnection>;
1504};
1505
1506export type UsersPermissionsUserConnectionFirstName = {
1507 __typename?: 'UsersPermissionsUserConnectionFirstName';
1508 key?: Maybe<Scalars['String']>;
1509 connection?: Maybe<UsersPermissionsUserConnection>;
1510};
1511
1512export type UsersPermissionsUserConnectionId = {
1513 __typename?: 'UsersPermissionsUserConnectionId';
1514 key?: Maybe<Scalars['ID']>;
1515 connection?: Maybe<UsersPermissionsUserConnection>;
1516};
1517
1518export type UsersPermissionsUserConnectionLang = {
1519 __typename?: 'UsersPermissionsUserConnectionLang';
1520 key?: Maybe<Scalars['String']>;
1521 connection?: Maybe<UsersPermissionsUserConnection>;
1522};
1523
1524export type UsersPermissionsUserConnectionLastName = {
1525 __typename?: 'UsersPermissionsUserConnectionLastName';
1526 key?: Maybe<Scalars['String']>;
1527 connection?: Maybe<UsersPermissionsUserConnection>;
1528};
1529
1530export type UsersPermissionsUserConnectionOnboardingCreator = {
1531 __typename?: 'UsersPermissionsUserConnectionOnboardingCreator';
1532 key?: Maybe<Scalars['Boolean']>;
1533 connection?: Maybe<UsersPermissionsUserConnection>;
1534};
1535
1536export type UsersPermissionsUserConnectionOnboardingUser = {
1537 __typename?: 'UsersPermissionsUserConnectionOnboardingUser';
1538 key?: Maybe<Scalars['Boolean']>;
1539 connection?: Maybe<UsersPermissionsUserConnection>;
1540};
1541
1542export type UsersPermissionsUserConnectionProvider = {
1543 __typename?: 'UsersPermissionsUserConnectionProvider';
1544 key?: Maybe<Scalars['String']>;
1545 connection?: Maybe<UsersPermissionsUserConnection>;
1546};
1547
1548export type UsersPermissionsUserConnectionRole = {
1549 __typename?: 'UsersPermissionsUserConnectionRole';
1550 key?: Maybe<Scalars['ID']>;
1551 connection?: Maybe<UsersPermissionsUserConnection>;
1552};
1553
1554export type UsersPermissionsUserConnectionUpdated_At = {
1555 __typename?: 'UsersPermissionsUserConnectionUpdated_at';
1556 key?: Maybe<Scalars['DateTime']>;
1557 connection?: Maybe<UsersPermissionsUserConnection>;
1558};
1559
1560export type UsersPermissionsUserConnectionUsername = {
1561 __typename?: 'UsersPermissionsUserConnectionUsername';
1562 key?: Maybe<Scalars['String']>;
1563 connection?: Maybe<UsersPermissionsUserConnection>;
1564};
1565
1566export type UsersPermissionsUserGroupBy = {
1567 __typename?: 'UsersPermissionsUserGroupBy';
1568 id?: Maybe<Array<Maybe<UsersPermissionsUserConnectionId>>>;
1569 created_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionCreated_At>>>;
1570 updated_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUpdated_At>>>;
1571 username?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUsername>>>;
1572 firstName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionFirstName>>>;
1573 lastName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLastName>>>;
1574 email?: Maybe<Array<Maybe<UsersPermissionsUserConnectionEmail>>>;
1575 provider?: Maybe<Array<Maybe<UsersPermissionsUserConnectionProvider>>>;
1576 confirmed?: Maybe<Array<Maybe<UsersPermissionsUserConnectionConfirmed>>>;
1577 blocked?: Maybe<Array<Maybe<UsersPermissionsUserConnectionBlocked>>>;
1578 role?: Maybe<Array<Maybe<UsersPermissionsUserConnectionRole>>>;
1579 onboardingUser?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingUser>>>;
1580 onboardingCreator?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingCreator>>>;
1581 lang?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLang>>>;
1582};
1583
1584export type Vehicle = {
1585 __typename?: 'Vehicle';
1586 id: Scalars['ID'];
1587 created_at: Scalars['DateTime'];
1588 updated_at: Scalars['DateTime'];
1589 name: Scalars['String'];
1590 seats?: Maybe<Scalars['Int']>;
1591 phone_number?: Maybe<Scalars['String']>;
1592 user?: Maybe<UsersPermissionsUser>;
1593 travels?: Maybe<Array<Maybe<Travel>>>;
1594};
1595
1596
1597export type VehicleTravelsArgs = {
1598 sort?: Maybe<Scalars['String']>;
1599 limit?: Maybe<Scalars['Int']>;
1600 start?: Maybe<Scalars['Int']>;
1601 where?: Maybe<Scalars['JSON']>;
1602};
1603
1604export type VehicleAggregator = {
1605 __typename?: 'VehicleAggregator';
1606 count?: Maybe<Scalars['Int']>;
1607 totalCount?: Maybe<Scalars['Int']>;
1608 sum?: Maybe<VehicleAggregatorSum>;
1609 avg?: Maybe<VehicleAggregatorAvg>;
1610 min?: Maybe<VehicleAggregatorMin>;
1611 max?: Maybe<VehicleAggregatorMax>;
1612};
1613
1614export type VehicleAggregatorAvg = {
1615 __typename?: 'VehicleAggregatorAvg';
1616 seats?: Maybe<Scalars['Float']>;
1617};
1618
1619export type VehicleAggregatorMax = {
1620 __typename?: 'VehicleAggregatorMax';
1621 seats?: Maybe<Scalars['Float']>;
1622};
1623
1624export type VehicleAggregatorMin = {
1625 __typename?: 'VehicleAggregatorMin';
1626 seats?: Maybe<Scalars['Float']>;
1627};
1628
1629export type VehicleAggregatorSum = {
1630 __typename?: 'VehicleAggregatorSum';
1631 seats?: Maybe<Scalars['Float']>;
1632};
1633
1634export type VehicleConnection = {
1635 __typename?: 'VehicleConnection';
1636 values?: Maybe<Array<Maybe<Vehicle>>>;
1637 groupBy?: Maybe<VehicleGroupBy>;
1638 aggregate?: Maybe<VehicleAggregator>;
1639};
1640
1641export type VehicleConnectionCreated_At = {
1642 __typename?: 'VehicleConnectionCreated_at';
1643 key?: Maybe<Scalars['DateTime']>;
1644 connection?: Maybe<VehicleConnection>;
1645};
1646
1647export type VehicleConnectionId = {
1648 __typename?: 'VehicleConnectionId';
1649 key?: Maybe<Scalars['ID']>;
1650 connection?: Maybe<VehicleConnection>;
1651};
1652
1653export type VehicleConnectionName = {
1654 __typename?: 'VehicleConnectionName';
1655 key?: Maybe<Scalars['String']>;
1656 connection?: Maybe<VehicleConnection>;
1657};
1658
1659export type VehicleConnectionPhone_Number = {
1660 __typename?: 'VehicleConnectionPhone_number';
1661 key?: Maybe<Scalars['String']>;
1662 connection?: Maybe<VehicleConnection>;
1663};
1664
1665export type VehicleConnectionSeats = {
1666 __typename?: 'VehicleConnectionSeats';
1667 key?: Maybe<Scalars['Int']>;
1668 connection?: Maybe<VehicleConnection>;
1669};
1670
1671export type VehicleConnectionUpdated_At = {
1672 __typename?: 'VehicleConnectionUpdated_at';
1673 key?: Maybe<Scalars['DateTime']>;
1674 connection?: Maybe<VehicleConnection>;
1675};
1676
1677export type VehicleConnectionUser = {
1678 __typename?: 'VehicleConnectionUser';
1679 key?: Maybe<Scalars['ID']>;
1680 connection?: Maybe<VehicleConnection>;
1681};
1682
1683export type VehicleGroupBy = {
1684 __typename?: 'VehicleGroupBy';
1685 id?: Maybe<Array<Maybe<VehicleConnectionId>>>;
1686 created_at?: Maybe<Array<Maybe<VehicleConnectionCreated_At>>>;
1687 updated_at?: Maybe<Array<Maybe<VehicleConnectionUpdated_At>>>;
1688 name?: Maybe<Array<Maybe<VehicleConnectionName>>>;
1689 seats?: Maybe<Array<Maybe<VehicleConnectionSeats>>>;
1690 phone_number?: Maybe<Array<Maybe<VehicleConnectionPhone_Number>>>;
1691 user?: Maybe<Array<Maybe<VehicleConnectionUser>>>;
1692};
1693
1694export type VehicleInput = {
1695 name: Scalars['String'];
1696 seats?: Maybe<Scalars['Int']>;
1697 travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1698 phone_number?: Maybe<Scalars['String']>;
1699 user?: Maybe<Scalars['ID']>;
1700 created_by?: Maybe<Scalars['ID']>;
1701 updated_by?: Maybe<Scalars['ID']>;
1702};
1703
1704export type CreateCarInput = {
1705 data?: Maybe<CarInput>;
1706};
1707
1708export type CreateCarPayload = {
1709 __typename?: 'createCarPayload';
1710 car?: Maybe<Car>;
1711};
1712
1713export type CreateEventInput = {
1714 data?: Maybe<EventInput>;
1715};
1716
1717export type CreateEventPayload = {
1718 __typename?: 'createEventPayload';
1719 event?: Maybe<Event>;
1720};
1721
1722export type CreatePageInput = {
1723 data?: Maybe<PageInput>;
1724};
1725
1726export type CreatePagePayload = {
1727 __typename?: 'createPagePayload';
1728 page?: Maybe<Page>;
1729};
1730
1731export type CreateRoleInput = {
1732 data?: Maybe<RoleInput>;
1733};
1734
1735export type CreateRolePayload = {
1736 __typename?: 'createRolePayload';
1737 role?: Maybe<UsersPermissionsRole>;
1738};
1739
1740export type CreateTravelInput = {
1741 data?: Maybe<TravelInput>;
1742};
1743
1744export type CreateTravelPayload = {
1745 __typename?: 'createTravelPayload';
1746 travel?: Maybe<Travel>;
1747};
1748
1749export type CreateUserInput = {
1750 data?: Maybe<UserInput>;
1751};
1752
1753export type CreateUserPayload = {
1754 __typename?: 'createUserPayload';
1755 user?: Maybe<UsersPermissionsUser>;
1756};
1757
1758export type CreateVehicleInput = {
1759 data?: Maybe<VehicleInput>;
1760};
1761
1762export type CreateVehiclePayload = {
1763 __typename?: 'createVehiclePayload';
1764 vehicle?: Maybe<Vehicle>;
1765};
1766
1767export type DeleteCarInput = {
1768 where?: Maybe<InputId>;
1769};
1770
1771export type DeleteCarPayload = {
1772 __typename?: 'deleteCarPayload';
1773 car?: Maybe<Car>;
1774};
1775
1776export type DeleteEventInput = {
1777 where?: Maybe<InputId>;
1778};
1779
1780export type DeleteEventPayload = {
1781 __typename?: 'deleteEventPayload';
1782 event?: Maybe<Event>;
1783};
1784
1785export type DeleteFileInput = {
1786 where?: Maybe<InputId>;
1787};
1788
1789export type DeleteFilePayload = {
1790 __typename?: 'deleteFilePayload';
1791 file?: Maybe<UploadFile>;
1792};
1793
1794export type DeletePageInput = {
1795 where?: Maybe<InputId>;
1796};
1797
1798export type DeletePagePayload = {
1799 __typename?: 'deletePagePayload';
1800 page?: Maybe<Page>;
1801};
1802
1803export type DeleteRoleInput = {
1804 where?: Maybe<InputId>;
1805};
1806
1807export type DeleteRolePayload = {
1808 __typename?: 'deleteRolePayload';
1809 role?: Maybe<UsersPermissionsRole>;
1810};
1811
1812export type DeleteSettingPayload = {
1813 __typename?: 'deleteSettingPayload';
1814 setting?: Maybe<Settings>;
1815};
1816
1817export type DeleteTravelInput = {
1818 where?: Maybe<InputId>;
1819};
1820
1821export type DeleteTravelPayload = {
1822 __typename?: 'deleteTravelPayload';
1823 travel?: Maybe<Travel>;
1824};
1825
1826export type DeleteUserInput = {
1827 where?: Maybe<InputId>;
1828};
1829
1830export type DeleteUserPayload = {
1831 __typename?: 'deleteUserPayload';
1832 user?: Maybe<UsersPermissionsUser>;
1833};
1834
1835export type DeleteVehicleInput = {
1836 where?: Maybe<InputId>;
1837};
1838
1839export type DeleteVehiclePayload = {
1840 __typename?: 'deleteVehiclePayload';
1841 vehicle?: Maybe<Vehicle>;
1842};
1843
1844export type EditCarInput = {
1845 name?: Maybe<Scalars['String']>;
1846 seats?: Maybe<Scalars['Int']>;
1847 meeting?: Maybe<Scalars['String']>;
1848 departure?: Maybe<Scalars['DateTime']>;
1849 phone_number?: Maybe<Scalars['String']>;
1850 details?: Maybe<Scalars['String']>;
1851 event?: Maybe<Scalars['ID']>;
1852 passengers?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1853 created_by?: Maybe<Scalars['ID']>;
1854 updated_by?: Maybe<Scalars['ID']>;
1855};
1856
1857export type EditComponentPassengerPassengerInput = {
1858 id?: Maybe<Scalars['ID']>;
1859 name?: Maybe<Scalars['String']>;
1860 email?: Maybe<Scalars['String']>;
1861 location?: Maybe<Scalars['String']>;
1862 user?: Maybe<Scalars['ID']>;
1863};
1864
1865export type EditEmailTemplateInput = {
1866 sourceCodeToTemplateId?: Maybe<Scalars['Int']>;
1867 design?: Maybe<Scalars['JSON']>;
1868 name?: Maybe<Scalars['String']>;
1869 subject?: Maybe<Scalars['String']>;
1870 bodyHtml?: Maybe<Scalars['String']>;
1871 bodyText?: Maybe<Scalars['String']>;
1872 enabled?: Maybe<Scalars['Boolean']>;
1873 tags?: Maybe<Scalars['JSON']>;
1874 created_by?: Maybe<Scalars['ID']>;
1875 updated_by?: Maybe<Scalars['ID']>;
1876};
1877
1878export type EditEventInput = {
1879 name?: Maybe<Scalars['String']>;
1880 email?: Maybe<Scalars['String']>;
1881 date?: Maybe<Scalars['Date']>;
1882 address?: Maybe<Scalars['String']>;
1883 cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
1884 position?: Maybe<Scalars['JSON']>;
1885 users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1886 uuid?: Maybe<Scalars['String']>;
1887 waitingList?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1888 travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1889 description?: Maybe<Scalars['String']>;
1890 created_by?: Maybe<Scalars['ID']>;
1891 updated_by?: Maybe<Scalars['ID']>;
1892};
1893
1894export type EditFileInput = {
1895 name?: Maybe<Scalars['String']>;
1896 alternativeText?: Maybe<Scalars['String']>;
1897 caption?: Maybe<Scalars['String']>;
1898 width?: Maybe<Scalars['Int']>;
1899 height?: Maybe<Scalars['Int']>;
1900 formats?: Maybe<Scalars['JSON']>;
1901 hash?: Maybe<Scalars['String']>;
1902 ext?: Maybe<Scalars['String']>;
1903 mime?: Maybe<Scalars['String']>;
1904 size?: Maybe<Scalars['Float']>;
1905 url?: Maybe<Scalars['String']>;
1906 previewUrl?: Maybe<Scalars['String']>;
1907 provider?: Maybe<Scalars['String']>;
1908 provider_metadata?: Maybe<Scalars['JSON']>;
1909 related?: Maybe<Array<Maybe<Scalars['ID']>>>;
1910 created_by?: Maybe<Scalars['ID']>;
1911 updated_by?: Maybe<Scalars['ID']>;
1912};
1913
1914export type EditPageInput = {
1915 name?: Maybe<Scalars['String']>;
1916 content?: Maybe<Scalars['String']>;
1917 type?: Maybe<Enum_Page_Type>;
1918 created_by?: Maybe<Scalars['ID']>;
1919 updated_by?: Maybe<Scalars['ID']>;
1920};
1921
1922export type EditRoleInput = {
1923 name?: Maybe<Scalars['String']>;
1924 description?: Maybe<Scalars['String']>;
1925 type?: Maybe<Scalars['String']>;
1926 permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
1927 users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1928 created_by?: Maybe<Scalars['ID']>;
1929 updated_by?: Maybe<Scalars['ID']>;
1930};
1931
1932export type EditSettingInput = {
1933 gtm_id?: Maybe<Scalars['String']>;
1934 about_link?: Maybe<Scalars['String']>;
1935 created_by?: Maybe<Scalars['ID']>;
1936 updated_by?: Maybe<Scalars['ID']>;
1937};
1938
1939export type EditTravelInput = {
1940 meeting?: Maybe<Scalars['String']>;
1941 departure?: Maybe<Scalars['DateTime']>;
1942 details?: Maybe<Scalars['String']>;
1943 passengers?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1944 event?: Maybe<Scalars['ID']>;
1945 vehicle?: Maybe<Scalars['ID']>;
1946 created_by?: Maybe<Scalars['ID']>;
1947 updated_by?: Maybe<Scalars['ID']>;
1948};
1949
1950export type EditUserInput = {
1951 username?: Maybe<Scalars['String']>;
1952 firstName?: Maybe<Scalars['String']>;
1953 lastName?: Maybe<Scalars['String']>;
1954 email?: Maybe<Scalars['String']>;
1955 provider?: Maybe<Scalars['String']>;
1956 password?: Maybe<Scalars['String']>;
1957 resetPasswordToken?: Maybe<Scalars['String']>;
1958 confirmed?: Maybe<Scalars['Boolean']>;
1959 blocked?: Maybe<Scalars['Boolean']>;
1960 role?: Maybe<Scalars['ID']>;
1961 confirmationToken?: Maybe<Scalars['String']>;
1962 events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1963 onboardingUser?: Maybe<Scalars['Boolean']>;
1964 onboardingCreator?: Maybe<Scalars['Boolean']>;
1965 lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1966 vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1967 created_by?: Maybe<Scalars['ID']>;
1968 updated_by?: Maybe<Scalars['ID']>;
1969 old_password?: Maybe<Scalars['String']>;
1970};
1971
1972export type EditVehicleInput = {
1973 name?: Maybe<Scalars['String']>;
1974 seats?: Maybe<Scalars['Int']>;
1975 travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1976 phone_number?: Maybe<Scalars['String']>;
1977 user?: Maybe<Scalars['ID']>;
1978 created_by?: Maybe<Scalars['ID']>;
1979 updated_by?: Maybe<Scalars['ID']>;
1980};
1981
1982export type UpdateCarInput = {
1983 where?: Maybe<InputId>;
1984 data?: Maybe<EditCarInput>;
1985};
1986
1987export type UpdateCarPayload = {
1988 __typename?: 'updateCarPayload';
1989 car?: Maybe<Car>;
1990};
1991
1992export type UpdateEventByUuidInput = {
1993 where?: Maybe<InputUuid>;
1994 data?: Maybe<EditEventInput>;
1995};
1996
1997export type UpdateEventInput = {
1998 where?: Maybe<InputId>;
1999 data?: Maybe<EditEventInput>;
2000};
2001
2002export type UpdateEventPayload = {
2003 __typename?: 'updateEventPayload';
2004 event?: Maybe<Event>;
2005};
2006
2007export type UpdatePageInput = {
2008 where?: Maybe<InputId>;
2009 data?: Maybe<EditPageInput>;
2010};
2011
2012export type UpdatePagePayload = {
2013 __typename?: 'updatePagePayload';
2014 page?: Maybe<Page>;
2015};
2016
2017export type UpdateRoleInput = {
2018 where?: Maybe<InputId>;
2019 data?: Maybe<EditRoleInput>;
2020};
2021
2022export type UpdateRolePayload = {
2023 __typename?: 'updateRolePayload';
2024 role?: Maybe<UsersPermissionsRole>;
2025};
2026
2027export type UpdateSettingInput = {
2028 data?: Maybe<EditSettingInput>;
2029};
2030
2031export type UpdateSettingPayload = {
2032 __typename?: 'updateSettingPayload';
2033 setting?: Maybe<Settings>;
2034};
2035
2036export type UpdateTravelInput = {
2037 where?: Maybe<InputId>;
2038 data?: Maybe<EditTravelInput>;
2039};
2040
2041export type UpdateTravelPayload = {
2042 __typename?: 'updateTravelPayload';
2043 travel?: Maybe<Travel>;
2044};
2045
2046export type UpdateUserInput = {
2047 where?: Maybe<InputId>;
2048 data?: Maybe<EditUserInput>;
2049};
2050
2051export type UpdateUserPayload = {
2052 __typename?: 'updateUserPayload';
2053 user?: Maybe<UsersPermissionsUser>;
2054};
2055
2056export type UpdateVehicleInput = {
2057 where?: Maybe<InputId>;
2058 data?: Maybe<EditVehicleInput>;
2059};
2060
2061export type UpdateVehiclePayload = {
2062 __typename?: 'updateVehiclePayload';
2063 vehicle?: Maybe<Vehicle>;
2064};
2065
2066export type MeFieldsFragment = (
2067 { __typename?: 'UsersPermissionsMe' }
2068 & Pick<UsersPermissionsMe, 'id' | 'username' | 'email' | 'confirmed'>
2069);
2070
2071export type RegisterMutationVariables = Exact<{
2072 user: UsersPermissionsRegisterInput;
2073}>;
2074
2075
2076export type RegisterMutation = (
2077 { __typename?: 'Mutation' }
2078 & { register: (
2079 { __typename?: 'UsersPermissionsLoginPayload' }
2080 & Pick<UsersPermissionsLoginPayload, 'jwt'>
2081 & { user: (
2082 { __typename?: 'UsersPermissionsMe' }
2083 & MeFieldsFragment
2084 ) }
2085 ) }
2086);
2087
2088export type LoginMutationVariables = Exact<{
2089 identifier: Scalars['String'];
2090 password: Scalars['String'];
2091}>;
2092
2093
2094export type LoginMutation = (
2095 { __typename?: 'Mutation' }
2096 & { login: (
2097 { __typename?: 'UsersPermissionsLoginPayload' }
2098 & Pick<UsersPermissionsLoginPayload, 'jwt'>
2099 & { user: (
2100 { __typename?: 'UsersPermissionsMe' }
2101 & MeFieldsFragment
2102 ) }
2103 ) }
2104);
2105
2106export type ForgotPasswordMutationVariables = Exact<{
2107 email: Scalars['String'];
2108}>;
2109
2110
2111export type ForgotPasswordMutation = (
2112 { __typename?: 'Mutation' }
2113 & { forgotPassword?: Maybe<(
2114 { __typename?: 'UserPermissionsPasswordPayload' }
2115 & Pick<UserPermissionsPasswordPayload, 'ok'>
2116 )> }
2117);
2118
2119export type ResetPasswordMutationVariables = Exact<{
2120 password: Scalars['String'];
2121 passwordConfirmation: Scalars['String'];
2122 code: Scalars['String'];
2123}>;
2124
2125
2126export type ResetPasswordMutation = (
2127 { __typename?: 'Mutation' }
2128 & { resetPassword?: Maybe<(
2129 { __typename?: 'UsersPermissionsLoginPayload' }
2130 & Pick<UsersPermissionsLoginPayload, 'jwt'>
2131 & { user: (
2132 { __typename?: 'UsersPermissionsMe' }
2133 & MeFieldsFragment
2134 ) }
2135 )> }
2136);
2137
2138export type EventFieldsFragment = (
2139 { __typename?: 'Event' }
2140 & Pick<Event, 'id' | 'uuid' | 'name' | 'description' | 'email' | 'date' | 'address' | 'position'>
2141 & { waitingList?: Maybe<Array<Maybe<(
2142 { __typename?: 'ComponentPassengerPassenger' }
2143 & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2144 & { user?: Maybe<(
2145 { __typename?: 'UsersPermissionsUser' }
2146 & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2147 )> }
2148 )>>>, travels?: Maybe<Array<Maybe<(
2149 { __typename?: 'Travel' }
2150 & Pick<Travel, 'id' | 'meeting' | 'departure' | 'details'>
2151 & { vehicle?: Maybe<(
2152 { __typename?: 'Vehicle' }
2153 & Pick<Vehicle, 'id' | 'name' | 'phone_number' | 'seats'>
2154 )>, passengers?: Maybe<Array<Maybe<(
2155 { __typename?: 'ComponentPassengerPassenger' }
2156 & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2157 & { user?: Maybe<(
2158 { __typename?: 'UsersPermissionsUser' }
2159 & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2160 )> }
2161 )>>> }
2162 )>>> }
2163);
2164
2165export type CreateEventMutationVariables = Exact<{
2166 name: Scalars['String'];
2167 email: Scalars['String'];
2168 date?: Maybe<Scalars['Date']>;
2169 address?: Maybe<Scalars['String']>;
2170 description?: Maybe<Scalars['String']>;
2171 newsletter?: Maybe<Scalars['Boolean']>;
2172}>;
2173
2174
2175export type CreateEventMutation = (
2176 { __typename?: 'Mutation' }
2177 & { createEvent?: Maybe<(
2178 { __typename?: 'createEventPayload' }
2179 & { event?: Maybe<(
2180 { __typename?: 'Event' }
2181 & EventFieldsFragment
2182 )> }
2183 )> }
2184);
2185
2186export type UpdateEventMutationVariables = Exact<{
2187 uuid: Scalars['String'];
2188 eventUpdate?: Maybe<EditEventInput>;
2189}>;
2190
2191
2192export type UpdateEventMutation = (
2193 { __typename?: 'Mutation' }
2194 & { updateEventByUUID?: Maybe<(
2195 { __typename?: 'updateEventPayload' }
2196 & { event?: Maybe<(
2197 { __typename?: 'Event' }
2198 & EventFieldsFragment
2199 )> }
2200 )> }
2201);
2202
2203export type EventByUuidQueryVariables = Exact<{
2204 uuid: Scalars['String'];
2205}>;
2206
2207
2208export type EventByUuidQuery = (
2209 { __typename?: 'Query' }
2210 & { eventByUUID?: Maybe<(
2211 { __typename?: 'Event' }
2212 & EventFieldsFragment
2213 )> }
2214);
2215
2216export type SettingQueryVariables = Exact<{ [key: string]: never; }>;
2217
2218
2219export type SettingQuery = (
2220 { __typename?: 'Query' }
2221 & { setting?: Maybe<(
2222 { __typename?: 'Settings' }
2223 & Pick<Settings, 'id' | 'gtm_id' | 'about_link'>
2224 )> }
2225);
2226
2227export type TravelFieldsFragment = (
2228 { __typename?: 'Travel' }
2229 & Pick<Travel, 'id' | 'meeting' | 'departure' | 'details'>
2230 & { vehicle?: Maybe<(
2231 { __typename?: 'Vehicle' }
2232 & Pick<Vehicle, 'id' | 'name' | 'phone_number' | 'seats'>
2233 )>, passengers?: Maybe<Array<Maybe<(
2234 { __typename?: 'ComponentPassengerPassenger' }
2235 & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2236 & { user?: Maybe<(
2237 { __typename?: 'UsersPermissionsUser' }
2238 & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2239 )> }
2240 )>>> }
2241);
2242
2243export type CreateTravelMutationVariables = Exact<{
2244 travel: TravelInput;
2245}>;
2246
2247
2248export type CreateTravelMutation = (
2249 { __typename?: 'Mutation' }
2250 & { createTravel?: Maybe<(
2251 { __typename?: 'createTravelPayload' }
2252 & { travel?: Maybe<(
2253 { __typename?: 'Travel' }
2254 & TravelFieldsFragment
2255 )> }
2256 )> }
2257);
2258
2259export type UpdateTravelMutationVariables = Exact<{
2260 id: Scalars['ID'];
2261 travelUpdate: EditTravelInput;
2262}>;
2263
2264
2265export type UpdateTravelMutation = (
2266 { __typename?: 'Mutation' }
2267 & { updateTravel?: Maybe<(
2268 { __typename?: 'updateTravelPayload' }
2269 & { travel?: Maybe<(
2270 { __typename?: 'Travel' }
2271 & TravelFieldsFragment
2272 )> }
2273 )> }
2274);
2275
2276export type DeleteTravelMutationVariables = Exact<{
2277 id: Scalars['ID'];
2278}>;
2279
2280
2281export type DeleteTravelMutation = (
2282 { __typename?: 'Mutation' }
2283 & { deleteTravel?: Maybe<(
2284 { __typename?: 'deleteTravelPayload' }
2285 & { travel?: Maybe<(
2286 { __typename?: 'Travel' }
2287 & Pick<Travel, 'id'>
2288 )> }
2289 )> }
2290);
2291
2292export type UserFieldsFragment = (
2293 { __typename?: 'UsersPermissionsUser' }
2294 & Pick<UsersPermissionsUser, 'id' | 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName' | 'lang' | 'onboardingUser' | 'onboardingCreator'>
2295 & { events?: Maybe<Array<Maybe<(
2296 { __typename?: 'Event' }
2297 & Pick<Event, 'id' | 'uuid' | 'name' | 'date' | 'address'>
2298 )>>> }
2299);
2300
2301export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
2302
2303
2304export type ProfileQuery = (
2305 { __typename?: 'Query' }
2306 & { me?: Maybe<(
2307 { __typename?: 'UsersPermissionsMe' }
2308 & Pick<UsersPermissionsMe, 'id' | 'username'>
2309 & { profile?: Maybe<(
2310 { __typename?: 'UsersPermissionsUser' }
2311 & UserFieldsFragment
2312 )> }
2313 )> }
2314);
2315
2316export type UpdateMeMutationVariables = Exact<{
2317 userUpdate: EditUserInput;
2318}>;
2319
2320
2321export type UpdateMeMutation = (
2322 { __typename?: 'Mutation' }
2323 & { updateMe: (
2324 { __typename?: 'updateUserPayload' }
2325 & { user?: Maybe<(
2326 { __typename?: 'UsersPermissionsUser' }
2327 & UserFieldsFragment
2328 )> }
2329 ) }
2330);
2331
2332export type VehicleFieldsFragment = (
2333 { __typename?: 'Vehicle' }
2334 & Pick<Vehicle, 'id' | 'name' | 'seats' | 'phone_number'>
2335);
2336
2337export type FindUserVehiclesQueryVariables = Exact<{ [key: string]: never; }>;
2338
2339
2340export type FindUserVehiclesQuery = (
2341 { __typename?: 'Query' }
2342 & { me?: Maybe<(
2343 { __typename?: 'UsersPermissionsMe' }
2344 & Pick<UsersPermissionsMe, 'id' | 'username'>
2345 & { profile?: Maybe<(
2346 { __typename?: 'UsersPermissionsUser' }
2347 & { vehicles?: Maybe<Array<Maybe<(
2348 { __typename?: 'Vehicle' }
2349 & VehicleFieldsFragment
2350 )>>> }
2351 )> }
2352 )> }
2353);
2354
2355export type CreateVehicleMutationVariables = Exact<{
2356 vehicle: VehicleInput;
2357}>;
2358
2359
2360export type CreateVehicleMutation = (
2361 { __typename?: 'Mutation' }
2362 & { createVehicle?: Maybe<(
2363 { __typename?: 'createVehiclePayload' }
2364 & { vehicle?: Maybe<(
2365 { __typename?: 'Vehicle' }
2366 & VehicleFieldsFragment
2367 )> }
2368 )> }
2369);
2370
2371export type UpdateVehicleMutationVariables = Exact<{
2372 id: Scalars['ID'];
2373 vehicleUpdate: EditVehicleInput;
2374}>;
2375
2376
2377export type UpdateVehicleMutation = (
2378 { __typename?: 'Mutation' }
2379 & { updateVehicle?: Maybe<(
2380 { __typename?: 'updateVehiclePayload' }
2381 & { vehicle?: Maybe<(
2382 { __typename?: 'Vehicle' }
2383 & VehicleFieldsFragment
2384 )> }
2385 )> }
2386);
2387
2388export type DeleteVehicleMutationVariables = Exact<{
2389 id: Scalars['ID'];
2390}>;
2391
2392
2393export type DeleteVehicleMutation = (
2394 { __typename?: 'Mutation' }
2395 & { deleteVehicle?: Maybe<(
2396 { __typename?: 'deleteVehiclePayload' }
2397 & { vehicle?: Maybe<(
2398 { __typename?: 'Vehicle' }
2399 & Pick<Vehicle, 'id' | 'name'>
2400 )> }
2401 )> }
2402);
2403
2404export const MeFieldsFragmentDoc = gql`
2405 fragment MeFields on UsersPermissionsMe {
2406 id
2407 username
2408 email
2409 confirmed
2410}
2411 `;
2412export const EventFieldsFragmentDoc = gql`
2413 fragment EventFields on Event {
2414 id
2415 uuid
2416 name
2417 description
2418 email
2419 date
2420 address
2421 position
2422 waitingList {
2423 id
2424 name
2425 location
2426 user {
2427 id
2428 firstName
2429 lastName
2430 }
2431 }
2432 travels {
2433 id
2434 meeting
2435 departure
2436 details
2437 vehicle {
2438 id
2439 name
2440 phone_number
2441 seats
2442 }
2443 passengers {
2444 id
2445 name
2446 location
2447 user {
2448 id
2449 firstName
2450 lastName
2451 }
2452 }
2453 }
2454}
2455 `;
2456export const TravelFieldsFragmentDoc = gql`
2457 fragment TravelFields on Travel {
2458 id
2459 meeting
2460 departure
2461 details
2462 vehicle {
2463 id
2464 name
2465 phone_number
2466 seats
2467 }
2468 passengers {
2469 id
2470 name
2471 location
2472 user {
2473 id
2474 firstName
2475 lastName
2476 }
2477 }
2478}
2479 `;
2480export const UserFieldsFragmentDoc = gql`
2481 fragment UserFields on UsersPermissionsUser {
2482 id
2483 username
2484 email
2485 confirmed
2486 lastName
2487 firstName
2488 lang
2489 onboardingUser
2490 onboardingCreator
2491 events {
2492 id
2493 uuid
2494 name
2495 date
2496 address
2497 }
2498}
2499 `;
2500export const VehicleFieldsFragmentDoc = gql`
2501 fragment VehicleFields on Vehicle {
2502 id
2503 name
2504 seats
2505 phone_number
2506}
2507 `;
2508export const RegisterDocument = gql`
2509 mutation register($user: UsersPermissionsRegisterInput!) {
2510 register(input: $user) {
2511 jwt
2512 user {
2513 ...MeFields
2514 }
2515 }
2516}
2517 ${MeFieldsFragmentDoc}`;
2518export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
2519
2520/**
2521 * __useRegisterMutation__
2522 *
2523 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
2524 * When your component renders, `useRegisterMutation` returns a tuple that includes:
2525 * - A mutate function that you can call at any time to execute the mutation
2526 * - An object with fields that represent the current status of the mutation's execution
2527 *
2528 * @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;
2529 *
2530 * @example
2531 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
2532 * variables: {
2533 * user: // value for 'user'
2534 * },
2535 * });
2536 */
2537export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
2538 return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
2539 }
2540export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
2541export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
2542export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
2543export const LoginDocument = gql`
2544 mutation login($identifier: String!, $password: String!) {
2545 login(input: {identifier: $identifier, password: $password}) {
2546 jwt
2547 user {
2548 ...MeFields
2549 }
2550 }
2551}
2552 ${MeFieldsFragmentDoc}`;
2553export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
2554
2555/**
2556 * __useLoginMutation__
2557 *
2558 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
2559 * When your component renders, `useLoginMutation` returns a tuple that includes:
2560 * - A mutate function that you can call at any time to execute the mutation
2561 * - An object with fields that represent the current status of the mutation's execution
2562 *
2563 * @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;
2564 *
2565 * @example
2566 * const [loginMutation, { data, loading, error }] = useLoginMutation({
2567 * variables: {
2568 * identifier: // value for 'identifier'
2569 * password: // value for 'password'
2570 * },
2571 * });
2572 */
2573export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
2574 return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
2575 }
2576export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
2577export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
2578export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
2579export const ForgotPasswordDocument = gql`
2580 mutation forgotPassword($email: String!) {
2581 forgotPassword(email: $email) {
2582 ok
2583 }
2584}
2585 `;
2586export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2587
2588/**
2589 * __useForgotPasswordMutation__
2590 *
2591 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
2592 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
2593 * - A mutate function that you can call at any time to execute the mutation
2594 * - An object with fields that represent the current status of the mutation's execution
2595 *
2596 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2597 *
2598 * @example
2599 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
2600 * variables: {
2601 * email: // value for 'email'
2602 * },
2603 * });
2604 */
2605export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
2606 return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
2607 }
2608export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
2609export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
2610export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2611export const ResetPasswordDocument = gql`
2612 mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
2613 resetPassword(
2614 password: $password
2615 passwordConfirmation: $passwordConfirmation
2616 code: $code
2617 ) {
2618 jwt
2619 user {
2620 ...MeFields
2621 }
2622 }
2623}
2624 ${MeFieldsFragmentDoc}`;
2625export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
2626
2627/**
2628 * __useResetPasswordMutation__
2629 *
2630 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
2631 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
2632 * - A mutate function that you can call at any time to execute the mutation
2633 * - An object with fields that represent the current status of the mutation's execution
2634 *
2635 * @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;
2636 *
2637 * @example
2638 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
2639 * variables: {
2640 * password: // value for 'password'
2641 * passwordConfirmation: // value for 'passwordConfirmation'
2642 * code: // value for 'code'
2643 * },
2644 * });
2645 */
2646export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
2647 return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
2648 }
2649export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
2650export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
2651export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
2652export const CreateEventDocument = gql`
2653 mutation createEvent($name: String!, $email: String!, $date: Date, $address: String, $description: String, $newsletter: Boolean) {
2654 createEvent(
2655 input: {data: {name: $name, email: $email, date: $date, address: $address, description: $description, newsletter: $newsletter}}
2656 ) {
2657 event {
2658 ...EventFields
2659 }
2660 }
2661}
2662 ${EventFieldsFragmentDoc}`;
2663export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2664
2665/**
2666 * __useCreateEventMutation__
2667 *
2668 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2669 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2670 * - A mutate function that you can call at any time to execute the mutation
2671 * - An object with fields that represent the current status of the mutation's execution
2672 *
2673 * @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;
2674 *
2675 * @example
2676 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2677 * variables: {
2678 * name: // value for 'name'
2679 * email: // value for 'email'
2680 * date: // value for 'date'
2681 * address: // value for 'address'
2682 * description: // value for 'description'
2683 * newsletter: // value for 'newsletter'
2684 * },
2685 * });
2686 */
2687export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2688 return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2689 }
2690export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2691export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2692export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2693export const UpdateEventDocument = gql`
2694 mutation updateEvent($uuid: String!, $eventUpdate: editEventInput) {
2695 updateEventByUUID(input: {where: {uuid: $uuid}, data: $eventUpdate}) {
2696 event {
2697 ...EventFields
2698 }
2699 }
2700}
2701 ${EventFieldsFragmentDoc}`;
2702export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2703
2704/**
2705 * __useUpdateEventMutation__
2706 *
2707 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2708 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2709 * - A mutate function that you can call at any time to execute the mutation
2710 * - An object with fields that represent the current status of the mutation's execution
2711 *
2712 * @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;
2713 *
2714 * @example
2715 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2716 * variables: {
2717 * uuid: // value for 'uuid'
2718 * eventUpdate: // value for 'eventUpdate'
2719 * },
2720 * });
2721 */
2722export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2723 return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2724 }
2725export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2726export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2727export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2728export const EventByUuidDocument = gql`
2729 query eventByUUID($uuid: String!) {
2730 eventByUUID(uuid: $uuid) {
2731 ...EventFields
2732 }
2733}
2734 ${EventFieldsFragmentDoc}`;
2735
2736/**
2737 * __useEventByUuidQuery__
2738 *
2739 * To run a query within a React component, call `useEventByUuidQuery` and pass it any options that fit your needs.
2740 * When your component renders, `useEventByUuidQuery` returns an object from Apollo Client that contains loading, error, and data properties
2741 * you can use to render your UI.
2742 *
2743 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
2744 *
2745 * @example
2746 * const { data, loading, error } = useEventByUuidQuery({
2747 * variables: {
2748 * uuid: // value for 'uuid'
2749 * },
2750 * });
2751 */
2752export function useEventByUuidQuery(baseOptions: Apollo.QueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2753 return Apollo.useQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2754 }
2755export function useEventByUuidLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2756 return Apollo.useLazyQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2757 }
2758export type EventByUuidQueryHookResult = ReturnType<typeof useEventByUuidQuery>;
2759export type EventByUuidLazyQueryHookResult = ReturnType<typeof useEventByUuidLazyQuery>;
2760export type EventByUuidQueryResult = Apollo.QueryResult<EventByUuidQuery, EventByUuidQueryVariables>;
2761export const SettingDocument = gql`
2762 query setting {
2763 setting {
2764 id
2765 gtm_id
2766 about_link
2767 }
2768}
2769 `;
2770
2771/**
2772 * __useSettingQuery__
2773 *
2774 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2775 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2776 * you can use to render your UI.
2777 *
2778 * @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;
2779 *
2780 * @example
2781 * const { data, loading, error } = useSettingQuery({
2782 * variables: {
2783 * },
2784 * });
2785 */
2786export function useSettingQuery(baseOptions?: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2787 return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2788 }
2789export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2790 return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2791 }
2792export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2793export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2794export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2795export const CreateTravelDocument = gql`
2796 mutation createTravel($travel: TravelInput!) {
2797 createTravel(input: {data: $travel}) {
2798 travel {
2799 ...TravelFields
2800 }
2801 }
2802}
2803 ${TravelFieldsFragmentDoc}`;
2804export type CreateTravelMutationFn = Apollo.MutationFunction<CreateTravelMutation, CreateTravelMutationVariables>;
2805
2806/**
2807 * __useCreateTravelMutation__
2808 *
2809 * To run a mutation, you first call `useCreateTravelMutation` within a React component and pass it any options that fit your needs.
2810 * When your component renders, `useCreateTravelMutation` returns a tuple that includes:
2811 * - A mutate function that you can call at any time to execute the mutation
2812 * - An object with fields that represent the current status of the mutation's execution
2813 *
2814 * @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;
2815 *
2816 * @example
2817 * const [createTravelMutation, { data, loading, error }] = useCreateTravelMutation({
2818 * variables: {
2819 * travel: // value for 'travel'
2820 * },
2821 * });
2822 */
2823export function useCreateTravelMutation(baseOptions?: Apollo.MutationHookOptions<CreateTravelMutation, CreateTravelMutationVariables>) {
2824 return Apollo.useMutation<CreateTravelMutation, CreateTravelMutationVariables>(CreateTravelDocument, baseOptions);
2825 }
2826export type CreateTravelMutationHookResult = ReturnType<typeof useCreateTravelMutation>;
2827export type CreateTravelMutationResult = Apollo.MutationResult<CreateTravelMutation>;
2828export type CreateTravelMutationOptions = Apollo.BaseMutationOptions<CreateTravelMutation, CreateTravelMutationVariables>;
2829export const UpdateTravelDocument = gql`
2830 mutation updateTravel($id: ID!, $travelUpdate: editTravelInput!) {
2831 updateTravel(input: {where: {id: $id}, data: $travelUpdate}) {
2832 travel {
2833 ...TravelFields
2834 }
2835 }
2836}
2837 ${TravelFieldsFragmentDoc}`;
2838export type UpdateTravelMutationFn = Apollo.MutationFunction<UpdateTravelMutation, UpdateTravelMutationVariables>;
2839
2840/**
2841 * __useUpdateTravelMutation__
2842 *
2843 * To run a mutation, you first call `useUpdateTravelMutation` within a React component and pass it any options that fit your needs.
2844 * When your component renders, `useUpdateTravelMutation` returns a tuple that includes:
2845 * - A mutate function that you can call at any time to execute the mutation
2846 * - An object with fields that represent the current status of the mutation's execution
2847 *
2848 * @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;
2849 *
2850 * @example
2851 * const [updateTravelMutation, { data, loading, error }] = useUpdateTravelMutation({
2852 * variables: {
2853 * id: // value for 'id'
2854 * travelUpdate: // value for 'travelUpdate'
2855 * },
2856 * });
2857 */
2858export function useUpdateTravelMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTravelMutation, UpdateTravelMutationVariables>) {
2859 return Apollo.useMutation<UpdateTravelMutation, UpdateTravelMutationVariables>(UpdateTravelDocument, baseOptions);
2860 }
2861export type UpdateTravelMutationHookResult = ReturnType<typeof useUpdateTravelMutation>;
2862export type UpdateTravelMutationResult = Apollo.MutationResult<UpdateTravelMutation>;
2863export type UpdateTravelMutationOptions = Apollo.BaseMutationOptions<UpdateTravelMutation, UpdateTravelMutationVariables>;
2864export const DeleteTravelDocument = gql`
2865 mutation deleteTravel($id: ID!) {
2866 deleteTravel(input: {where: {id: $id}}) {
2867 travel {
2868 id
2869 }
2870 }
2871}
2872 `;
2873export type DeleteTravelMutationFn = Apollo.MutationFunction<DeleteTravelMutation, DeleteTravelMutationVariables>;
2874
2875/**
2876 * __useDeleteTravelMutation__
2877 *
2878 * To run a mutation, you first call `useDeleteTravelMutation` within a React component and pass it any options that fit your needs.
2879 * When your component renders, `useDeleteTravelMutation` returns a tuple that includes:
2880 * - A mutate function that you can call at any time to execute the mutation
2881 * - An object with fields that represent the current status of the mutation's execution
2882 *
2883 * @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;
2884 *
2885 * @example
2886 * const [deleteTravelMutation, { data, loading, error }] = useDeleteTravelMutation({
2887 * variables: {
2888 * id: // value for 'id'
2889 * },
2890 * });
2891 */
2892export function useDeleteTravelMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTravelMutation, DeleteTravelMutationVariables>) {
2893 return Apollo.useMutation<DeleteTravelMutation, DeleteTravelMutationVariables>(DeleteTravelDocument, baseOptions);
2894 }
2895export type DeleteTravelMutationHookResult = ReturnType<typeof useDeleteTravelMutation>;
2896export type DeleteTravelMutationResult = Apollo.MutationResult<DeleteTravelMutation>;
2897export type DeleteTravelMutationOptions = Apollo.BaseMutationOptions<DeleteTravelMutation, DeleteTravelMutationVariables>;
2898export const ProfileDocument = gql`
2899 query profile {
2900 me {
2901 id
2902 username
2903 profile {
2904 ...UserFields
2905 }
2906 }
2907}
2908 ${UserFieldsFragmentDoc}`;
2909
2910/**
2911 * __useProfileQuery__
2912 *
2913 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2914 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2915 * you can use to render your UI.
2916 *
2917 * @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;
2918 *
2919 * @example
2920 * const { data, loading, error } = useProfileQuery({
2921 * variables: {
2922 * },
2923 * });
2924 */
2925export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2926 return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2927 }
2928export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2929 return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2930 }
2931export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2932export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2933export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2934export const UpdateMeDocument = gql`
2935 mutation updateMe($userUpdate: editUserInput!) {
2936 updateMe(input: $userUpdate) {
2937 user {
2938 ...UserFields
2939 }
2940 }
2941}
2942 ${UserFieldsFragmentDoc}`;
2943export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2944
2945/**
2946 * __useUpdateMeMutation__
2947 *
2948 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2949 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2950 * - A mutate function that you can call at any time to execute the mutation
2951 * - An object with fields that represent the current status of the mutation's execution
2952 *
2953 * @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;
2954 *
2955 * @example
2956 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2957 * variables: {
2958 * userUpdate: // value for 'userUpdate'
2959 * },
2960 * });
2961 */
2962export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2963 return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2964 }
2965export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2966export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2967export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;
2968export const FindUserVehiclesDocument = gql`
2969 query findUserVehicles {
2970 me {
2971 id
2972 username
2973 profile {
2974 vehicles {
2975 ...VehicleFields
2976 }
2977 }
2978 }
2979}
2980 ${VehicleFieldsFragmentDoc}`;
2981
2982/**
2983 * __useFindUserVehiclesQuery__
2984 *
2985 * To run a query within a React component, call `useFindUserVehiclesQuery` and pass it any options that fit your needs.
2986 * When your component renders, `useFindUserVehiclesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2987 * you can use to render your UI.
2988 *
2989 * @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;
2990 *
2991 * @example
2992 * const { data, loading, error } = useFindUserVehiclesQuery({
2993 * variables: {
2994 * },
2995 * });
2996 */
2997export function useFindUserVehiclesQuery(baseOptions?: Apollo.QueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
2998 return Apollo.useQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
2999 }
3000export function useFindUserVehiclesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
3001 return Apollo.useLazyQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
3002 }
3003export type FindUserVehiclesQueryHookResult = ReturnType<typeof useFindUserVehiclesQuery>;
3004export type FindUserVehiclesLazyQueryHookResult = ReturnType<typeof useFindUserVehiclesLazyQuery>;
3005export type FindUserVehiclesQueryResult = Apollo.QueryResult<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>;
3006export const CreateVehicleDocument = gql`
3007 mutation createVehicle($vehicle: VehicleInput!) {
3008 createVehicle(input: {data: $vehicle}) {
3009 vehicle {
3010 ...VehicleFields
3011 }
3012 }
3013}
3014 ${VehicleFieldsFragmentDoc}`;
3015export type CreateVehicleMutationFn = Apollo.MutationFunction<CreateVehicleMutation, CreateVehicleMutationVariables>;
3016
3017/**
3018 * __useCreateVehicleMutation__
3019 *
3020 * To run a mutation, you first call `useCreateVehicleMutation` within a React component and pass it any options that fit your needs.
3021 * When your component renders, `useCreateVehicleMutation` returns a tuple that includes:
3022 * - A mutate function that you can call at any time to execute the mutation
3023 * - An object with fields that represent the current status of the mutation's execution
3024 *
3025 * @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;
3026 *
3027 * @example
3028 * const [createVehicleMutation, { data, loading, error }] = useCreateVehicleMutation({
3029 * variables: {
3030 * vehicle: // value for 'vehicle'
3031 * },
3032 * });
3033 */
3034export function useCreateVehicleMutation(baseOptions?: Apollo.MutationHookOptions<CreateVehicleMutation, CreateVehicleMutationVariables>) {
3035 return Apollo.useMutation<CreateVehicleMutation, CreateVehicleMutationVariables>(CreateVehicleDocument, baseOptions);
3036 }
3037export type CreateVehicleMutationHookResult = ReturnType<typeof useCreateVehicleMutation>;
3038export type CreateVehicleMutationResult = Apollo.MutationResult<CreateVehicleMutation>;
3039export type CreateVehicleMutationOptions = Apollo.BaseMutationOptions<CreateVehicleMutation, CreateVehicleMutationVariables>;
3040export const UpdateVehicleDocument = gql`
3041 mutation updateVehicle($id: ID!, $vehicleUpdate: editVehicleInput!) {
3042 updateVehicle(input: {where: {id: $id}, data: $vehicleUpdate}) {
3043 vehicle {
3044 ...VehicleFields
3045 }
3046 }
3047}
3048 ${VehicleFieldsFragmentDoc}`;
3049export type UpdateVehicleMutationFn = Apollo.MutationFunction<UpdateVehicleMutation, UpdateVehicleMutationVariables>;
3050
3051/**
3052 * __useUpdateVehicleMutation__
3053 *
3054 * To run a mutation, you first call `useUpdateVehicleMutation` within a React component and pass it any options that fit your needs.
3055 * When your component renders, `useUpdateVehicleMutation` returns a tuple that includes:
3056 * - A mutate function that you can call at any time to execute the mutation
3057 * - An object with fields that represent the current status of the mutation's execution
3058 *
3059 * @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;
3060 *
3061 * @example
3062 * const [updateVehicleMutation, { data, loading, error }] = useUpdateVehicleMutation({
3063 * variables: {
3064 * id: // value for 'id'
3065 * vehicleUpdate: // value for 'vehicleUpdate'
3066 * },
3067 * });
3068 */
3069export function useUpdateVehicleMutation(baseOptions?: Apollo.MutationHookOptions<UpdateVehicleMutation, UpdateVehicleMutationVariables>) {
3070 return Apollo.useMutation<UpdateVehicleMutation, UpdateVehicleMutationVariables>(UpdateVehicleDocument, baseOptions);
3071 }
3072export type UpdateVehicleMutationHookResult = ReturnType<typeof useUpdateVehicleMutation>;
3073export type UpdateVehicleMutationResult = Apollo.MutationResult<UpdateVehicleMutation>;
3074export type UpdateVehicleMutationOptions = Apollo.BaseMutationOptions<UpdateVehicleMutation, UpdateVehicleMutationVariables>;
3075export const DeleteVehicleDocument = gql`
3076 mutation deleteVehicle($id: ID!) {
3077 deleteVehicle(input: {where: {id: $id}}) {
3078 vehicle {
3079 id
3080 name
3081 }
3082 }
3083}
3084 `;
3085export type DeleteVehicleMutationFn = Apollo.MutationFunction<DeleteVehicleMutation, DeleteVehicleMutationVariables>;
3086
3087/**
3088 * __useDeleteVehicleMutation__
3089 *
3090 * To run a mutation, you first call `useDeleteVehicleMutation` within a React component and pass it any options that fit your needs.
3091 * When your component renders, `useDeleteVehicleMutation` returns a tuple that includes:
3092 * - A mutate function that you can call at any time to execute the mutation
3093 * - An object with fields that represent the current status of the mutation's execution
3094 *
3095 * @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;
3096 *
3097 * @example
3098 * const [deleteVehicleMutation, { data, loading, error }] = useDeleteVehicleMutation({
3099 * variables: {
3100 * id: // value for 'id'
3101 * },
3102 * });
3103 */
3104export function useDeleteVehicleMutation(baseOptions?: Apollo.MutationHookOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>) {
3105 return Apollo.useMutation<DeleteVehicleMutation, DeleteVehicleMutationVariables>(DeleteVehicleDocument, baseOptions);
3106 }
3107export type DeleteVehicleMutationHookResult = ReturnType<typeof useDeleteVehicleMutation>;
3108export type DeleteVehicleMutationResult = Apollo.MutationResult<DeleteVehicleMutation>;
3109export type DeleteVehicleMutationOptions = Apollo.BaseMutationOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>;