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<Scalars['JSON']>;
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 CarConnectionPassengers = {
131 __typename?: 'CarConnectionPassengers';
132 key?: Maybe<Scalars['JSON']>;
133 connection?: Maybe<CarConnection>;
134};
135
136export type CarConnectionPhone_Number = {
137 __typename?: 'CarConnectionPhone_number';
138 key?: Maybe<Scalars['String']>;
139 connection?: Maybe<CarConnection>;
140};
141
142export type CarConnectionSeats = {
143 __typename?: 'CarConnectionSeats';
144 key?: Maybe<Scalars['Int']>;
145 connection?: Maybe<CarConnection>;
146};
147
148export type CarConnectionUpdated_At = {
149 __typename?: 'CarConnectionUpdated_at';
150 key?: Maybe<Scalars['DateTime']>;
151 connection?: Maybe<CarConnection>;
152};
153
154export type CarGroupBy = {
155 __typename?: 'CarGroupBy';
156 id?: Maybe<Array<Maybe<CarConnectionId>>>;
157 created_at?: Maybe<Array<Maybe<CarConnectionCreated_At>>>;
158 updated_at?: Maybe<Array<Maybe<CarConnectionUpdated_At>>>;
159 name?: Maybe<Array<Maybe<CarConnectionName>>>;
160 seats?: Maybe<Array<Maybe<CarConnectionSeats>>>;
161 meeting?: Maybe<Array<Maybe<CarConnectionMeeting>>>;
162 departure?: Maybe<Array<Maybe<CarConnectionDeparture>>>;
163 phone_number?: Maybe<Array<Maybe<CarConnectionPhone_Number>>>;
164 details?: Maybe<Array<Maybe<CarConnectionDetails>>>;
165 event?: Maybe<Array<Maybe<CarConnectionEvent>>>;
166 passengers?: Maybe<Array<Maybe<CarConnectionPassengers>>>;
167};
168
169export type CarInput = {
170 name: Scalars['String'];
171 seats: Scalars['Int'];
172 meeting?: Maybe<Scalars['String']>;
173 departure?: Maybe<Scalars['DateTime']>;
174 phone_number?: Maybe<Scalars['String']>;
175 details?: Maybe<Scalars['String']>;
176 event?: Maybe<Scalars['ID']>;
177 passengers?: Maybe<Scalars['JSON']>;
178 created_by?: Maybe<Scalars['ID']>;
179 updated_by?: Maybe<Scalars['ID']>;
180};
181
182
183
184export type Dependency = {
185 __typename?: 'Dependency';
186 name: Scalars['String'];
187 version: Scalars['String'];
188};
189
190export enum Enum_Page_Type {
191 Tos = 'tos'
192}
193
194export type Event = {
195 __typename?: 'Event';
196 id: Scalars['ID'];
197 created_at: Scalars['DateTime'];
198 updated_at: Scalars['DateTime'];
199 name: Scalars['String'];
200 email: Scalars['String'];
201 date?: Maybe<Scalars['Date']>;
202 address?: Maybe<Scalars['String']>;
203 position?: Maybe<Scalars['JSON']>;
204 waiting_list?: Maybe<Scalars['JSON']>;
205 cars?: Maybe<Array<Maybe<Car>>>;
206 users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
207};
208
209
210export type EventCarsArgs = {
211 sort?: Maybe<Scalars['String']>;
212 limit?: Maybe<Scalars['Int']>;
213 start?: Maybe<Scalars['Int']>;
214 where?: Maybe<Scalars['JSON']>;
215};
216
217
218export type EventUsersArgs = {
219 sort?: Maybe<Scalars['String']>;
220 limit?: Maybe<Scalars['Int']>;
221 start?: Maybe<Scalars['Int']>;
222 where?: Maybe<Scalars['JSON']>;
223};
224
225export type EventAggregator = {
226 __typename?: 'EventAggregator';
227 count?: Maybe<Scalars['Int']>;
228 totalCount?: Maybe<Scalars['Int']>;
229};
230
231export type EventConnection = {
232 __typename?: 'EventConnection';
233 values?: Maybe<Array<Maybe<Event>>>;
234 groupBy?: Maybe<EventGroupBy>;
235 aggregate?: Maybe<EventAggregator>;
236};
237
238export type EventConnectionAddress = {
239 __typename?: 'EventConnectionAddress';
240 key?: Maybe<Scalars['String']>;
241 connection?: Maybe<EventConnection>;
242};
243
244export type EventConnectionCreated_At = {
245 __typename?: 'EventConnectionCreated_at';
246 key?: Maybe<Scalars['DateTime']>;
247 connection?: Maybe<EventConnection>;
248};
249
250export type EventConnectionDate = {
251 __typename?: 'EventConnectionDate';
252 key?: Maybe<Scalars['ID']>;
253 connection?: Maybe<EventConnection>;
254};
255
256export type EventConnectionEmail = {
257 __typename?: 'EventConnectionEmail';
258 key?: Maybe<Scalars['String']>;
259 connection?: Maybe<EventConnection>;
260};
261
262export type EventConnectionId = {
263 __typename?: 'EventConnectionId';
264 key?: Maybe<Scalars['ID']>;
265 connection?: Maybe<EventConnection>;
266};
267
268export type EventConnectionName = {
269 __typename?: 'EventConnectionName';
270 key?: Maybe<Scalars['String']>;
271 connection?: Maybe<EventConnection>;
272};
273
274export type EventConnectionPosition = {
275 __typename?: 'EventConnectionPosition';
276 key?: Maybe<Scalars['JSON']>;
277 connection?: Maybe<EventConnection>;
278};
279
280export type EventConnectionUpdated_At = {
281 __typename?: 'EventConnectionUpdated_at';
282 key?: Maybe<Scalars['DateTime']>;
283 connection?: Maybe<EventConnection>;
284};
285
286export type EventConnectionWaiting_List = {
287 __typename?: 'EventConnectionWaiting_list';
288 key?: Maybe<Scalars['JSON']>;
289 connection?: Maybe<EventConnection>;
290};
291
292export type EventGroupBy = {
293 __typename?: 'EventGroupBy';
294 id?: Maybe<Array<Maybe<EventConnectionId>>>;
295 created_at?: Maybe<Array<Maybe<EventConnectionCreated_At>>>;
296 updated_at?: Maybe<Array<Maybe<EventConnectionUpdated_At>>>;
297 name?: Maybe<Array<Maybe<EventConnectionName>>>;
298 email?: Maybe<Array<Maybe<EventConnectionEmail>>>;
299 date?: Maybe<Array<Maybe<EventConnectionDate>>>;
300 address?: Maybe<Array<Maybe<EventConnectionAddress>>>;
301 position?: Maybe<Array<Maybe<EventConnectionPosition>>>;
302 waiting_list?: Maybe<Array<Maybe<EventConnectionWaiting_List>>>;
303};
304
305export type EventInput = {
306 name: Scalars['String'];
307 email: Scalars['String'];
308 date?: Maybe<Scalars['Date']>;
309 address?: Maybe<Scalars['String']>;
310 cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
311 position?: Maybe<Scalars['JSON']>;
312 waiting_list?: Maybe<Scalars['JSON']>;
313 users?: Maybe<Array<Maybe<Scalars['ID']>>>;
314 created_by?: Maybe<Scalars['ID']>;
315 updated_by?: Maybe<Scalars['ID']>;
316};
317
318export type FileInfoInput = {
319 name?: Maybe<Scalars['String']>;
320 alternativeText?: Maybe<Scalars['String']>;
321 caption?: Maybe<Scalars['String']>;
322};
323
324export type FileInput = {
325 name: Scalars['String'];
326 alternativeText?: Maybe<Scalars['String']>;
327 caption?: Maybe<Scalars['String']>;
328 width?: Maybe<Scalars['Int']>;
329 height?: Maybe<Scalars['Int']>;
330 formats?: Maybe<Scalars['JSON']>;
331 hash: Scalars['String'];
332 ext?: Maybe<Scalars['String']>;
333 mime: Scalars['String'];
334 size: Scalars['Float'];
335 url: Scalars['String'];
336 previewUrl?: Maybe<Scalars['String']>;
337 provider: Scalars['String'];
338 provider_metadata?: Maybe<Scalars['JSON']>;
339 related?: Maybe<Array<Maybe<Scalars['ID']>>>;
340 created_by?: Maybe<Scalars['ID']>;
341 updated_by?: Maybe<Scalars['ID']>;
342};
343
344export type Info = {
345 __typename?: 'Info';
346 appVersion?: Maybe<Scalars['String']>;
347 host: Scalars['String'];
348 environment: Scalars['String'];
349 uuid: Scalars['String'];
350 launchedAt: Scalars['String'];
351 cron?: Maybe<Scalars['Boolean']>;
352 installedPlugins?: Maybe<Array<Maybe<Scalars['String']>>>;
353 installedMiddlewares?: Maybe<Array<Maybe<Scalars['String']>>>;
354 name: Scalars['String'];
355 npmVersion: Scalars['String'];
356 description: Scalars['String'];
357 strapiVersion: Scalars['String'];
358 license: Scalars['String'];
359 dependencies?: Maybe<Array<Maybe<Dependency>>>;
360};
361
362export type InputId = {
363 id: Scalars['ID'];
364};
365
366
367
368export 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 | CarConnectionPassengers | CreateCarPayload | UpdateCarPayload | DeleteCarPayload | Event | EventConnection | EventAggregator | EventGroupBy | EventConnectionId | EventConnectionCreated_At | EventConnectionUpdated_At | EventConnectionName | EventConnectionEmail | EventConnectionDate | EventConnectionAddress | EventConnectionPosition | EventConnectionWaiting_List | CreateEventPayload | UpdateEventPayload | DeleteEventPayload | Page | PageConnection | PageAggregator | PageGroupBy | PageConnectionId | PageConnectionCreated_At | PageConnectionUpdated_At | PageConnectionName | PageConnectionContent | PageConnectionType | CreatePagePayload | UpdatePagePayload | DeletePagePayload | Settings | UpdateSettingPayload | DeleteSettingPayload | 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 | CreateUserPayload | UpdateUserPayload | DeleteUserPayload;
369
370export type Mutation = {
371 __typename?: 'Mutation';
372 createCar?: Maybe<CreateCarPayload>;
373 updateCar?: Maybe<UpdateCarPayload>;
374 deleteCar?: Maybe<DeleteCarPayload>;
375 createEvent?: Maybe<CreateEventPayload>;
376 updateEvent?: Maybe<UpdateEventPayload>;
377 deleteEvent?: Maybe<DeleteEventPayload>;
378 createPage?: Maybe<CreatePagePayload>;
379 updatePage?: Maybe<UpdatePagePayload>;
380 deletePage?: Maybe<DeletePagePayload>;
381 updateSetting?: Maybe<UpdateSettingPayload>;
382 deleteSetting?: Maybe<DeleteSettingPayload>;
383 /** Delete one file */
384 deleteFile?: Maybe<DeleteFilePayload>;
385 /** Create a new role */
386 createRole?: Maybe<CreateRolePayload>;
387 /** Update an existing role */
388 updateRole?: Maybe<UpdateRolePayload>;
389 /** Delete an existing role */
390 deleteRole?: Maybe<DeleteRolePayload>;
391 /** Create a new user */
392 createUser?: Maybe<CreateUserPayload>;
393 /** Update an existing user */
394 updateUser?: Maybe<UpdateUserPayload>;
395 /** Delete an existing user */
396 deleteUser?: Maybe<DeleteUserPayload>;
397 upload: UploadFile;
398 multipleUpload: Array<Maybe<UploadFile>>;
399 updateFileInfo: UploadFile;
400 login: UsersPermissionsLoginPayload;
401 register: UsersPermissionsLoginPayload;
402 forgotPassword?: Maybe<UserPermissionsPasswordPayload>;
403 resetPassword?: Maybe<UsersPermissionsLoginPayload>;
404 emailConfirmation?: Maybe<UsersPermissionsLoginPayload>;
405 updateMe: UpdateUserPayload;
406};
407
408
409export type MutationCreateCarArgs = {
410 input?: Maybe<CreateCarInput>;
411};
412
413
414export type MutationUpdateCarArgs = {
415 input?: Maybe<UpdateCarInput>;
416};
417
418
419export type MutationDeleteCarArgs = {
420 input?: Maybe<DeleteCarInput>;
421};
422
423
424export type MutationCreateEventArgs = {
425 input?: Maybe<CreateEventInput>;
426};
427
428
429export type MutationUpdateEventArgs = {
430 input?: Maybe<UpdateEventInput>;
431};
432
433
434export type MutationDeleteEventArgs = {
435 input?: Maybe<DeleteEventInput>;
436};
437
438
439export type MutationCreatePageArgs = {
440 input?: Maybe<CreatePageInput>;
441};
442
443
444export type MutationUpdatePageArgs = {
445 input?: Maybe<UpdatePageInput>;
446};
447
448
449export type MutationDeletePageArgs = {
450 input?: Maybe<DeletePageInput>;
451};
452
453
454export type MutationUpdateSettingArgs = {
455 input?: Maybe<UpdateSettingInput>;
456};
457
458
459export type MutationDeleteFileArgs = {
460 input?: Maybe<DeleteFileInput>;
461};
462
463
464export type MutationCreateRoleArgs = {
465 input?: Maybe<CreateRoleInput>;
466};
467
468
469export type MutationUpdateRoleArgs = {
470 input?: Maybe<UpdateRoleInput>;
471};
472
473
474export type MutationDeleteRoleArgs = {
475 input?: Maybe<DeleteRoleInput>;
476};
477
478
479export type MutationCreateUserArgs = {
480 input?: Maybe<CreateUserInput>;
481};
482
483
484export type MutationUpdateUserArgs = {
485 input?: Maybe<UpdateUserInput>;
486};
487
488
489export type MutationDeleteUserArgs = {
490 input?: Maybe<DeleteUserInput>;
491};
492
493
494export type MutationUploadArgs = {
495 refId?: Maybe<Scalars['ID']>;
496 ref?: Maybe<Scalars['String']>;
497 field?: Maybe<Scalars['String']>;
498 source?: Maybe<Scalars['String']>;
499 info?: Maybe<FileInfoInput>;
500 file: Scalars['Upload'];
501};
502
503
504export type MutationMultipleUploadArgs = {
505 refId?: Maybe<Scalars['ID']>;
506 ref?: Maybe<Scalars['String']>;
507 field?: Maybe<Scalars['String']>;
508 source?: Maybe<Scalars['String']>;
509 files: Array<Maybe<Scalars['Upload']>>;
510};
511
512
513export type MutationUpdateFileInfoArgs = {
514 id: Scalars['ID'];
515 info: FileInfoInput;
516};
517
518
519export type MutationLoginArgs = {
520 input: UsersPermissionsLoginInput;
521};
522
523
524export type MutationRegisterArgs = {
525 input: UsersPermissionsRegisterInput;
526};
527
528
529export type MutationForgotPasswordArgs = {
530 email: Scalars['String'];
531};
532
533
534export type MutationResetPasswordArgs = {
535 password: Scalars['String'];
536 passwordConfirmation: Scalars['String'];
537 code: Scalars['String'];
538};
539
540
541export type MutationEmailConfirmationArgs = {
542 confirmation: Scalars['String'];
543};
544
545
546export type MutationUpdateMeArgs = {
547 input?: Maybe<EditUserInput>;
548};
549
550export type Page = {
551 __typename?: 'Page';
552 id: Scalars['ID'];
553 created_at: Scalars['DateTime'];
554 updated_at: Scalars['DateTime'];
555 name: Scalars['String'];
556 content?: Maybe<Scalars['String']>;
557 type?: Maybe<Enum_Page_Type>;
558};
559
560export type PageAggregator = {
561 __typename?: 'PageAggregator';
562 count?: Maybe<Scalars['Int']>;
563 totalCount?: Maybe<Scalars['Int']>;
564};
565
566export type PageConnection = {
567 __typename?: 'PageConnection';
568 values?: Maybe<Array<Maybe<Page>>>;
569 groupBy?: Maybe<PageGroupBy>;
570 aggregate?: Maybe<PageAggregator>;
571};
572
573export type PageConnectionContent = {
574 __typename?: 'PageConnectionContent';
575 key?: Maybe<Scalars['String']>;
576 connection?: Maybe<PageConnection>;
577};
578
579export type PageConnectionCreated_At = {
580 __typename?: 'PageConnectionCreated_at';
581 key?: Maybe<Scalars['DateTime']>;
582 connection?: Maybe<PageConnection>;
583};
584
585export type PageConnectionId = {
586 __typename?: 'PageConnectionId';
587 key?: Maybe<Scalars['ID']>;
588 connection?: Maybe<PageConnection>;
589};
590
591export type PageConnectionName = {
592 __typename?: 'PageConnectionName';
593 key?: Maybe<Scalars['String']>;
594 connection?: Maybe<PageConnection>;
595};
596
597export type PageConnectionType = {
598 __typename?: 'PageConnectionType';
599 key?: Maybe<Scalars['String']>;
600 connection?: Maybe<PageConnection>;
601};
602
603export type PageConnectionUpdated_At = {
604 __typename?: 'PageConnectionUpdated_at';
605 key?: Maybe<Scalars['DateTime']>;
606 connection?: Maybe<PageConnection>;
607};
608
609export type PageGroupBy = {
610 __typename?: 'PageGroupBy';
611 id?: Maybe<Array<Maybe<PageConnectionId>>>;
612 created_at?: Maybe<Array<Maybe<PageConnectionCreated_At>>>;
613 updated_at?: Maybe<Array<Maybe<PageConnectionUpdated_At>>>;
614 name?: Maybe<Array<Maybe<PageConnectionName>>>;
615 content?: Maybe<Array<Maybe<PageConnectionContent>>>;
616 type?: Maybe<Array<Maybe<PageConnectionType>>>;
617};
618
619export type PageInput = {
620 name: Scalars['String'];
621 content?: Maybe<Scalars['String']>;
622 type?: Maybe<Enum_Page_Type>;
623 created_by?: Maybe<Scalars['ID']>;
624 updated_by?: Maybe<Scalars['ID']>;
625};
626
627export enum PublicationState {
628 Live = 'LIVE',
629 Preview = 'PREVIEW'
630}
631
632export type Query = {
633 __typename?: 'Query';
634 car?: Maybe<Car>;
635 cars?: Maybe<Array<Maybe<Car>>>;
636 carsConnection?: Maybe<CarConnection>;
637 event?: Maybe<Event>;
638 events?: Maybe<Array<Maybe<Event>>>;
639 eventsConnection?: Maybe<EventConnection>;
640 page?: Maybe<Page>;
641 pages?: Maybe<Array<Maybe<Page>>>;
642 pagesConnection?: Maybe<PageConnection>;
643 setting?: Maybe<Settings>;
644 files?: Maybe<Array<Maybe<UploadFile>>>;
645 filesConnection?: Maybe<UploadFileConnection>;
646 role?: Maybe<UsersPermissionsRole>;
647 /** Retrieve all the existing roles. You can't apply filters on this query. */
648 roles?: Maybe<Array<Maybe<UsersPermissionsRole>>>;
649 rolesConnection?: Maybe<UsersPermissionsRoleConnection>;
650 user?: Maybe<UsersPermissionsUser>;
651 users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
652 usersConnection?: Maybe<UsersPermissionsUserConnection>;
653 strapiInfo: Info;
654 me?: Maybe<UsersPermissionsMe>;
655};
656
657
658export type QueryCarArgs = {
659 id: Scalars['ID'];
660 publicationState?: Maybe<PublicationState>;
661};
662
663
664export type QueryCarsArgs = {
665 sort?: Maybe<Scalars['String']>;
666 limit?: Maybe<Scalars['Int']>;
667 start?: Maybe<Scalars['Int']>;
668 where?: Maybe<Scalars['JSON']>;
669 publicationState?: Maybe<PublicationState>;
670};
671
672
673export type QueryCarsConnectionArgs = {
674 sort?: Maybe<Scalars['String']>;
675 limit?: Maybe<Scalars['Int']>;
676 start?: Maybe<Scalars['Int']>;
677 where?: Maybe<Scalars['JSON']>;
678};
679
680
681export type QueryEventArgs = {
682 id: Scalars['ID'];
683 publicationState?: Maybe<PublicationState>;
684};
685
686
687export type QueryEventsArgs = {
688 sort?: Maybe<Scalars['String']>;
689 limit?: Maybe<Scalars['Int']>;
690 start?: Maybe<Scalars['Int']>;
691 where?: Maybe<Scalars['JSON']>;
692 publicationState?: Maybe<PublicationState>;
693};
694
695
696export type QueryEventsConnectionArgs = {
697 sort?: Maybe<Scalars['String']>;
698 limit?: Maybe<Scalars['Int']>;
699 start?: Maybe<Scalars['Int']>;
700 where?: Maybe<Scalars['JSON']>;
701};
702
703
704export type QueryPageArgs = {
705 id: Scalars['ID'];
706 publicationState?: Maybe<PublicationState>;
707};
708
709
710export type QueryPagesArgs = {
711 sort?: Maybe<Scalars['String']>;
712 limit?: Maybe<Scalars['Int']>;
713 start?: Maybe<Scalars['Int']>;
714 where?: Maybe<Scalars['JSON']>;
715 publicationState?: Maybe<PublicationState>;
716};
717
718
719export type QueryPagesConnectionArgs = {
720 sort?: Maybe<Scalars['String']>;
721 limit?: Maybe<Scalars['Int']>;
722 start?: Maybe<Scalars['Int']>;
723 where?: Maybe<Scalars['JSON']>;
724};
725
726
727export type QuerySettingArgs = {
728 publicationState?: Maybe<PublicationState>;
729};
730
731
732export type QueryFilesArgs = {
733 sort?: Maybe<Scalars['String']>;
734 limit?: Maybe<Scalars['Int']>;
735 start?: Maybe<Scalars['Int']>;
736 where?: Maybe<Scalars['JSON']>;
737 publicationState?: Maybe<PublicationState>;
738};
739
740
741export type QueryFilesConnectionArgs = {
742 sort?: Maybe<Scalars['String']>;
743 limit?: Maybe<Scalars['Int']>;
744 start?: Maybe<Scalars['Int']>;
745 where?: Maybe<Scalars['JSON']>;
746};
747
748
749export type QueryRoleArgs = {
750 id: Scalars['ID'];
751 publicationState?: Maybe<PublicationState>;
752};
753
754
755export type QueryRolesArgs = {
756 sort?: Maybe<Scalars['String']>;
757 limit?: Maybe<Scalars['Int']>;
758 start?: Maybe<Scalars['Int']>;
759 where?: Maybe<Scalars['JSON']>;
760 publicationState?: Maybe<PublicationState>;
761};
762
763
764export type QueryRolesConnectionArgs = {
765 sort?: Maybe<Scalars['String']>;
766 limit?: Maybe<Scalars['Int']>;
767 start?: Maybe<Scalars['Int']>;
768 where?: Maybe<Scalars['JSON']>;
769};
770
771
772export type QueryUserArgs = {
773 id: Scalars['ID'];
774 publicationState?: Maybe<PublicationState>;
775};
776
777
778export type QueryUsersArgs = {
779 sort?: Maybe<Scalars['String']>;
780 limit?: Maybe<Scalars['Int']>;
781 start?: Maybe<Scalars['Int']>;
782 where?: Maybe<Scalars['JSON']>;
783 publicationState?: Maybe<PublicationState>;
784};
785
786
787export type QueryUsersConnectionArgs = {
788 sort?: Maybe<Scalars['String']>;
789 limit?: Maybe<Scalars['Int']>;
790 start?: Maybe<Scalars['Int']>;
791 where?: Maybe<Scalars['JSON']>;
792};
793
794export type RoleInput = {
795 name: Scalars['String'];
796 description?: Maybe<Scalars['String']>;
797 type?: Maybe<Scalars['String']>;
798 permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
799 users?: Maybe<Array<Maybe<Scalars['ID']>>>;
800 created_by?: Maybe<Scalars['ID']>;
801 updated_by?: Maybe<Scalars['ID']>;
802};
803
804export type SettingInput = {
805 gtm_id?: Maybe<Scalars['String']>;
806 about_link?: Maybe<Scalars['String']>;
807 created_by?: Maybe<Scalars['ID']>;
808 updated_by?: Maybe<Scalars['ID']>;
809};
810
811export type Settings = {
812 __typename?: 'Settings';
813 id: Scalars['ID'];
814 created_at: Scalars['DateTime'];
815 updated_at: Scalars['DateTime'];
816 gtm_id?: Maybe<Scalars['String']>;
817 about_link?: Maybe<Scalars['String']>;
818};
819
820
821
822export type UploadFile = {
823 __typename?: 'UploadFile';
824 id: Scalars['ID'];
825 created_at: Scalars['DateTime'];
826 updated_at: Scalars['DateTime'];
827 name: Scalars['String'];
828 alternativeText?: Maybe<Scalars['String']>;
829 caption?: Maybe<Scalars['String']>;
830 width?: Maybe<Scalars['Int']>;
831 height?: Maybe<Scalars['Int']>;
832 formats?: Maybe<Scalars['JSON']>;
833 hash: Scalars['String'];
834 ext?: Maybe<Scalars['String']>;
835 mime: Scalars['String'];
836 size: Scalars['Float'];
837 url: Scalars['String'];
838 previewUrl?: Maybe<Scalars['String']>;
839 provider: Scalars['String'];
840 provider_metadata?: Maybe<Scalars['JSON']>;
841 related?: Maybe<Array<Maybe<Morph>>>;
842};
843
844
845export type UploadFileRelatedArgs = {
846 sort?: Maybe<Scalars['String']>;
847 limit?: Maybe<Scalars['Int']>;
848 start?: Maybe<Scalars['Int']>;
849 where?: Maybe<Scalars['JSON']>;
850};
851
852export type UploadFileAggregator = {
853 __typename?: 'UploadFileAggregator';
854 count?: Maybe<Scalars['Int']>;
855 totalCount?: Maybe<Scalars['Int']>;
856 sum?: Maybe<UploadFileAggregatorSum>;
857 avg?: Maybe<UploadFileAggregatorAvg>;
858 min?: Maybe<UploadFileAggregatorMin>;
859 max?: Maybe<UploadFileAggregatorMax>;
860};
861
862export type UploadFileAggregatorAvg = {
863 __typename?: 'UploadFileAggregatorAvg';
864 width?: Maybe<Scalars['Float']>;
865 height?: Maybe<Scalars['Float']>;
866 size?: Maybe<Scalars['Float']>;
867};
868
869export type UploadFileAggregatorMax = {
870 __typename?: 'UploadFileAggregatorMax';
871 width?: Maybe<Scalars['Float']>;
872 height?: Maybe<Scalars['Float']>;
873 size?: Maybe<Scalars['Float']>;
874};
875
876export type UploadFileAggregatorMin = {
877 __typename?: 'UploadFileAggregatorMin';
878 width?: Maybe<Scalars['Float']>;
879 height?: Maybe<Scalars['Float']>;
880 size?: Maybe<Scalars['Float']>;
881};
882
883export type UploadFileAggregatorSum = {
884 __typename?: 'UploadFileAggregatorSum';
885 width?: Maybe<Scalars['Float']>;
886 height?: Maybe<Scalars['Float']>;
887 size?: Maybe<Scalars['Float']>;
888};
889
890export type UploadFileConnection = {
891 __typename?: 'UploadFileConnection';
892 values?: Maybe<Array<Maybe<UploadFile>>>;
893 groupBy?: Maybe<UploadFileGroupBy>;
894 aggregate?: Maybe<UploadFileAggregator>;
895};
896
897export type UploadFileConnectionAlternativeText = {
898 __typename?: 'UploadFileConnectionAlternativeText';
899 key?: Maybe<Scalars['String']>;
900 connection?: Maybe<UploadFileConnection>;
901};
902
903export type UploadFileConnectionCaption = {
904 __typename?: 'UploadFileConnectionCaption';
905 key?: Maybe<Scalars['String']>;
906 connection?: Maybe<UploadFileConnection>;
907};
908
909export type UploadFileConnectionCreated_At = {
910 __typename?: 'UploadFileConnectionCreated_at';
911 key?: Maybe<Scalars['DateTime']>;
912 connection?: Maybe<UploadFileConnection>;
913};
914
915export type UploadFileConnectionExt = {
916 __typename?: 'UploadFileConnectionExt';
917 key?: Maybe<Scalars['String']>;
918 connection?: Maybe<UploadFileConnection>;
919};
920
921export type UploadFileConnectionFormats = {
922 __typename?: 'UploadFileConnectionFormats';
923 key?: Maybe<Scalars['JSON']>;
924 connection?: Maybe<UploadFileConnection>;
925};
926
927export type UploadFileConnectionHash = {
928 __typename?: 'UploadFileConnectionHash';
929 key?: Maybe<Scalars['String']>;
930 connection?: Maybe<UploadFileConnection>;
931};
932
933export type UploadFileConnectionHeight = {
934 __typename?: 'UploadFileConnectionHeight';
935 key?: Maybe<Scalars['Int']>;
936 connection?: Maybe<UploadFileConnection>;
937};
938
939export type UploadFileConnectionId = {
940 __typename?: 'UploadFileConnectionId';
941 key?: Maybe<Scalars['ID']>;
942 connection?: Maybe<UploadFileConnection>;
943};
944
945export type UploadFileConnectionMime = {
946 __typename?: 'UploadFileConnectionMime';
947 key?: Maybe<Scalars['String']>;
948 connection?: Maybe<UploadFileConnection>;
949};
950
951export type UploadFileConnectionName = {
952 __typename?: 'UploadFileConnectionName';
953 key?: Maybe<Scalars['String']>;
954 connection?: Maybe<UploadFileConnection>;
955};
956
957export type UploadFileConnectionPreviewUrl = {
958 __typename?: 'UploadFileConnectionPreviewUrl';
959 key?: Maybe<Scalars['String']>;
960 connection?: Maybe<UploadFileConnection>;
961};
962
963export type UploadFileConnectionProvider = {
964 __typename?: 'UploadFileConnectionProvider';
965 key?: Maybe<Scalars['String']>;
966 connection?: Maybe<UploadFileConnection>;
967};
968
969export type UploadFileConnectionProvider_Metadata = {
970 __typename?: 'UploadFileConnectionProvider_metadata';
971 key?: Maybe<Scalars['JSON']>;
972 connection?: Maybe<UploadFileConnection>;
973};
974
975export type UploadFileConnectionSize = {
976 __typename?: 'UploadFileConnectionSize';
977 key?: Maybe<Scalars['Float']>;
978 connection?: Maybe<UploadFileConnection>;
979};
980
981export type UploadFileConnectionUpdated_At = {
982 __typename?: 'UploadFileConnectionUpdated_at';
983 key?: Maybe<Scalars['DateTime']>;
984 connection?: Maybe<UploadFileConnection>;
985};
986
987export type UploadFileConnectionUrl = {
988 __typename?: 'UploadFileConnectionUrl';
989 key?: Maybe<Scalars['String']>;
990 connection?: Maybe<UploadFileConnection>;
991};
992
993export type UploadFileConnectionWidth = {
994 __typename?: 'UploadFileConnectionWidth';
995 key?: Maybe<Scalars['Int']>;
996 connection?: Maybe<UploadFileConnection>;
997};
998
999export type UploadFileGroupBy = {
1000 __typename?: 'UploadFileGroupBy';
1001 id?: Maybe<Array<Maybe<UploadFileConnectionId>>>;
1002 created_at?: Maybe<Array<Maybe<UploadFileConnectionCreated_At>>>;
1003 updated_at?: Maybe<Array<Maybe<UploadFileConnectionUpdated_At>>>;
1004 name?: Maybe<Array<Maybe<UploadFileConnectionName>>>;
1005 alternativeText?: Maybe<Array<Maybe<UploadFileConnectionAlternativeText>>>;
1006 caption?: Maybe<Array<Maybe<UploadFileConnectionCaption>>>;
1007 width?: Maybe<Array<Maybe<UploadFileConnectionWidth>>>;
1008 height?: Maybe<Array<Maybe<UploadFileConnectionHeight>>>;
1009 formats?: Maybe<Array<Maybe<UploadFileConnectionFormats>>>;
1010 hash?: Maybe<Array<Maybe<UploadFileConnectionHash>>>;
1011 ext?: Maybe<Array<Maybe<UploadFileConnectionExt>>>;
1012 mime?: Maybe<Array<Maybe<UploadFileConnectionMime>>>;
1013 size?: Maybe<Array<Maybe<UploadFileConnectionSize>>>;
1014 url?: Maybe<Array<Maybe<UploadFileConnectionUrl>>>;
1015 previewUrl?: Maybe<Array<Maybe<UploadFileConnectionPreviewUrl>>>;
1016 provider?: Maybe<Array<Maybe<UploadFileConnectionProvider>>>;
1017 provider_metadata?: Maybe<Array<Maybe<UploadFileConnectionProvider_Metadata>>>;
1018};
1019
1020export type UserInput = {
1021 username: Scalars['String'];
1022 firstName?: Maybe<Scalars['String']>;
1023 lastName?: Maybe<Scalars['String']>;
1024 email: Scalars['String'];
1025 provider?: Maybe<Scalars['String']>;
1026 password?: Maybe<Scalars['String']>;
1027 resetPasswordToken?: Maybe<Scalars['String']>;
1028 confirmed?: Maybe<Scalars['Boolean']>;
1029 blocked?: Maybe<Scalars['Boolean']>;
1030 role?: Maybe<Scalars['ID']>;
1031 events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1032 confirmationToken?: Maybe<Scalars['String']>;
1033 created_by?: Maybe<Scalars['ID']>;
1034 updated_by?: Maybe<Scalars['ID']>;
1035};
1036
1037export type UserPermissionsPasswordPayload = {
1038 __typename?: 'UserPermissionsPasswordPayload';
1039 ok: Scalars['Boolean'];
1040};
1041
1042export type UsersPermissionsLoginInput = {
1043 identifier: Scalars['String'];
1044 password: Scalars['String'];
1045 provider?: Maybe<Scalars['String']>;
1046};
1047
1048export type UsersPermissionsLoginPayload = {
1049 __typename?: 'UsersPermissionsLoginPayload';
1050 jwt?: Maybe<Scalars['String']>;
1051 user: UsersPermissionsMe;
1052};
1053
1054export type UsersPermissionsMe = {
1055 __typename?: 'UsersPermissionsMe';
1056 id: Scalars['ID'];
1057 username: Scalars['String'];
1058 email: Scalars['String'];
1059 confirmed?: Maybe<Scalars['Boolean']>;
1060 blocked?: Maybe<Scalars['Boolean']>;
1061 role?: Maybe<UsersPermissionsMeRole>;
1062 profile?: Maybe<UsersPermissionsUser>;
1063};
1064
1065export type UsersPermissionsMeRole = {
1066 __typename?: 'UsersPermissionsMeRole';
1067 id: Scalars['ID'];
1068 name: Scalars['String'];
1069 description?: Maybe<Scalars['String']>;
1070 type?: Maybe<Scalars['String']>;
1071};
1072
1073export type UsersPermissionsPermission = {
1074 __typename?: 'UsersPermissionsPermission';
1075 id: Scalars['ID'];
1076 type: Scalars['String'];
1077 controller: Scalars['String'];
1078 action: Scalars['String'];
1079 enabled: Scalars['Boolean'];
1080 policy?: Maybe<Scalars['String']>;
1081 role?: Maybe<UsersPermissionsRole>;
1082};
1083
1084export type UsersPermissionsRegisterInput = {
1085 username: Scalars['String'];
1086 email: Scalars['String'];
1087 password: Scalars['String'];
1088};
1089
1090export type UsersPermissionsRole = {
1091 __typename?: 'UsersPermissionsRole';
1092 id: Scalars['ID'];
1093 name: Scalars['String'];
1094 description?: Maybe<Scalars['String']>;
1095 type?: Maybe<Scalars['String']>;
1096 permissions?: Maybe<Array<Maybe<UsersPermissionsPermission>>>;
1097 users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1098};
1099
1100
1101export type UsersPermissionsRolePermissionsArgs = {
1102 sort?: Maybe<Scalars['String']>;
1103 limit?: Maybe<Scalars['Int']>;
1104 start?: Maybe<Scalars['Int']>;
1105 where?: Maybe<Scalars['JSON']>;
1106};
1107
1108
1109export type UsersPermissionsRoleUsersArgs = {
1110 sort?: Maybe<Scalars['String']>;
1111 limit?: Maybe<Scalars['Int']>;
1112 start?: Maybe<Scalars['Int']>;
1113 where?: Maybe<Scalars['JSON']>;
1114};
1115
1116export type UsersPermissionsRoleAggregator = {
1117 __typename?: 'UsersPermissionsRoleAggregator';
1118 count?: Maybe<Scalars['Int']>;
1119 totalCount?: Maybe<Scalars['Int']>;
1120};
1121
1122export type UsersPermissionsRoleConnection = {
1123 __typename?: 'UsersPermissionsRoleConnection';
1124 values?: Maybe<Array<Maybe<UsersPermissionsRole>>>;
1125 groupBy?: Maybe<UsersPermissionsRoleGroupBy>;
1126 aggregate?: Maybe<UsersPermissionsRoleAggregator>;
1127};
1128
1129export type UsersPermissionsRoleConnectionDescription = {
1130 __typename?: 'UsersPermissionsRoleConnectionDescription';
1131 key?: Maybe<Scalars['String']>;
1132 connection?: Maybe<UsersPermissionsRoleConnection>;
1133};
1134
1135export type UsersPermissionsRoleConnectionId = {
1136 __typename?: 'UsersPermissionsRoleConnectionId';
1137 key?: Maybe<Scalars['ID']>;
1138 connection?: Maybe<UsersPermissionsRoleConnection>;
1139};
1140
1141export type UsersPermissionsRoleConnectionName = {
1142 __typename?: 'UsersPermissionsRoleConnectionName';
1143 key?: Maybe<Scalars['String']>;
1144 connection?: Maybe<UsersPermissionsRoleConnection>;
1145};
1146
1147export type UsersPermissionsRoleConnectionType = {
1148 __typename?: 'UsersPermissionsRoleConnectionType';
1149 key?: Maybe<Scalars['String']>;
1150 connection?: Maybe<UsersPermissionsRoleConnection>;
1151};
1152
1153export type UsersPermissionsRoleGroupBy = {
1154 __typename?: 'UsersPermissionsRoleGroupBy';
1155 id?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionId>>>;
1156 name?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionName>>>;
1157 description?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionDescription>>>;
1158 type?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionType>>>;
1159};
1160
1161export type UsersPermissionsUser = {
1162 __typename?: 'UsersPermissionsUser';
1163 id: Scalars['ID'];
1164 created_at: Scalars['DateTime'];
1165 updated_at: Scalars['DateTime'];
1166 username: Scalars['String'];
1167 firstName?: Maybe<Scalars['String']>;
1168 lastName?: Maybe<Scalars['String']>;
1169 email: Scalars['String'];
1170 provider?: Maybe<Scalars['String']>;
1171 confirmed?: Maybe<Scalars['Boolean']>;
1172 blocked?: Maybe<Scalars['Boolean']>;
1173 role?: Maybe<UsersPermissionsRole>;
1174 events?: Maybe<Array<Maybe<Event>>>;
1175};
1176
1177
1178export type UsersPermissionsUserEventsArgs = {
1179 sort?: Maybe<Scalars['String']>;
1180 limit?: Maybe<Scalars['Int']>;
1181 start?: Maybe<Scalars['Int']>;
1182 where?: Maybe<Scalars['JSON']>;
1183};
1184
1185export type UsersPermissionsUserAggregator = {
1186 __typename?: 'UsersPermissionsUserAggregator';
1187 count?: Maybe<Scalars['Int']>;
1188 totalCount?: Maybe<Scalars['Int']>;
1189};
1190
1191export type UsersPermissionsUserConnection = {
1192 __typename?: 'UsersPermissionsUserConnection';
1193 values?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1194 groupBy?: Maybe<UsersPermissionsUserGroupBy>;
1195 aggregate?: Maybe<UsersPermissionsUserAggregator>;
1196};
1197
1198export type UsersPermissionsUserConnectionBlocked = {
1199 __typename?: 'UsersPermissionsUserConnectionBlocked';
1200 key?: Maybe<Scalars['Boolean']>;
1201 connection?: Maybe<UsersPermissionsUserConnection>;
1202};
1203
1204export type UsersPermissionsUserConnectionConfirmed = {
1205 __typename?: 'UsersPermissionsUserConnectionConfirmed';
1206 key?: Maybe<Scalars['Boolean']>;
1207 connection?: Maybe<UsersPermissionsUserConnection>;
1208};
1209
1210export type UsersPermissionsUserConnectionCreated_At = {
1211 __typename?: 'UsersPermissionsUserConnectionCreated_at';
1212 key?: Maybe<Scalars['DateTime']>;
1213 connection?: Maybe<UsersPermissionsUserConnection>;
1214};
1215
1216export type UsersPermissionsUserConnectionEmail = {
1217 __typename?: 'UsersPermissionsUserConnectionEmail';
1218 key?: Maybe<Scalars['String']>;
1219 connection?: Maybe<UsersPermissionsUserConnection>;
1220};
1221
1222export type UsersPermissionsUserConnectionFirstName = {
1223 __typename?: 'UsersPermissionsUserConnectionFirstName';
1224 key?: Maybe<Scalars['String']>;
1225 connection?: Maybe<UsersPermissionsUserConnection>;
1226};
1227
1228export type UsersPermissionsUserConnectionId = {
1229 __typename?: 'UsersPermissionsUserConnectionId';
1230 key?: Maybe<Scalars['ID']>;
1231 connection?: Maybe<UsersPermissionsUserConnection>;
1232};
1233
1234export type UsersPermissionsUserConnectionLastName = {
1235 __typename?: 'UsersPermissionsUserConnectionLastName';
1236 key?: Maybe<Scalars['String']>;
1237 connection?: Maybe<UsersPermissionsUserConnection>;
1238};
1239
1240export type UsersPermissionsUserConnectionProvider = {
1241 __typename?: 'UsersPermissionsUserConnectionProvider';
1242 key?: Maybe<Scalars['String']>;
1243 connection?: Maybe<UsersPermissionsUserConnection>;
1244};
1245
1246export type UsersPermissionsUserConnectionRole = {
1247 __typename?: 'UsersPermissionsUserConnectionRole';
1248 key?: Maybe<Scalars['ID']>;
1249 connection?: Maybe<UsersPermissionsUserConnection>;
1250};
1251
1252export type UsersPermissionsUserConnectionUpdated_At = {
1253 __typename?: 'UsersPermissionsUserConnectionUpdated_at';
1254 key?: Maybe<Scalars['DateTime']>;
1255 connection?: Maybe<UsersPermissionsUserConnection>;
1256};
1257
1258export type UsersPermissionsUserConnectionUsername = {
1259 __typename?: 'UsersPermissionsUserConnectionUsername';
1260 key?: Maybe<Scalars['String']>;
1261 connection?: Maybe<UsersPermissionsUserConnection>;
1262};
1263
1264export type UsersPermissionsUserGroupBy = {
1265 __typename?: 'UsersPermissionsUserGroupBy';
1266 id?: Maybe<Array<Maybe<UsersPermissionsUserConnectionId>>>;
1267 created_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionCreated_At>>>;
1268 updated_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUpdated_At>>>;
1269 username?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUsername>>>;
1270 firstName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionFirstName>>>;
1271 lastName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLastName>>>;
1272 email?: Maybe<Array<Maybe<UsersPermissionsUserConnectionEmail>>>;
1273 provider?: Maybe<Array<Maybe<UsersPermissionsUserConnectionProvider>>>;
1274 confirmed?: Maybe<Array<Maybe<UsersPermissionsUserConnectionConfirmed>>>;
1275 blocked?: Maybe<Array<Maybe<UsersPermissionsUserConnectionBlocked>>>;
1276 role?: Maybe<Array<Maybe<UsersPermissionsUserConnectionRole>>>;
1277};
1278
1279export type CreateCarInput = {
1280 data?: Maybe<CarInput>;
1281};
1282
1283export type CreateCarPayload = {
1284 __typename?: 'createCarPayload';
1285 car?: Maybe<Car>;
1286};
1287
1288export type CreateEventInput = {
1289 data?: Maybe<EventInput>;
1290};
1291
1292export type CreateEventPayload = {
1293 __typename?: 'createEventPayload';
1294 event?: Maybe<Event>;
1295};
1296
1297export type CreatePageInput = {
1298 data?: Maybe<PageInput>;
1299};
1300
1301export type CreatePagePayload = {
1302 __typename?: 'createPagePayload';
1303 page?: Maybe<Page>;
1304};
1305
1306export type CreateRoleInput = {
1307 data?: Maybe<RoleInput>;
1308};
1309
1310export type CreateRolePayload = {
1311 __typename?: 'createRolePayload';
1312 role?: Maybe<UsersPermissionsRole>;
1313};
1314
1315export type CreateUserInput = {
1316 data?: Maybe<UserInput>;
1317};
1318
1319export type CreateUserPayload = {
1320 __typename?: 'createUserPayload';
1321 user?: Maybe<UsersPermissionsUser>;
1322};
1323
1324export type DeleteCarInput = {
1325 where?: Maybe<InputId>;
1326};
1327
1328export type DeleteCarPayload = {
1329 __typename?: 'deleteCarPayload';
1330 car?: Maybe<Car>;
1331};
1332
1333export type DeleteEventInput = {
1334 where?: Maybe<InputId>;
1335};
1336
1337export type DeleteEventPayload = {
1338 __typename?: 'deleteEventPayload';
1339 event?: Maybe<Event>;
1340};
1341
1342export type DeleteFileInput = {
1343 where?: Maybe<InputId>;
1344};
1345
1346export type DeleteFilePayload = {
1347 __typename?: 'deleteFilePayload';
1348 file?: Maybe<UploadFile>;
1349};
1350
1351export type DeletePageInput = {
1352 where?: Maybe<InputId>;
1353};
1354
1355export type DeletePagePayload = {
1356 __typename?: 'deletePagePayload';
1357 page?: Maybe<Page>;
1358};
1359
1360export type DeleteRoleInput = {
1361 where?: Maybe<InputId>;
1362};
1363
1364export type DeleteRolePayload = {
1365 __typename?: 'deleteRolePayload';
1366 role?: Maybe<UsersPermissionsRole>;
1367};
1368
1369export type DeleteSettingPayload = {
1370 __typename?: 'deleteSettingPayload';
1371 setting?: Maybe<Settings>;
1372};
1373
1374export type DeleteUserInput = {
1375 where?: Maybe<InputId>;
1376};
1377
1378export type DeleteUserPayload = {
1379 __typename?: 'deleteUserPayload';
1380 user?: Maybe<UsersPermissionsUser>;
1381};
1382
1383export type EditCarInput = {
1384 name?: Maybe<Scalars['String']>;
1385 seats?: Maybe<Scalars['Int']>;
1386 meeting?: Maybe<Scalars['String']>;
1387 departure?: Maybe<Scalars['DateTime']>;
1388 phone_number?: Maybe<Scalars['String']>;
1389 details?: Maybe<Scalars['String']>;
1390 event?: Maybe<Scalars['ID']>;
1391 passengers?: Maybe<Scalars['JSON']>;
1392 created_by?: Maybe<Scalars['ID']>;
1393 updated_by?: Maybe<Scalars['ID']>;
1394};
1395
1396export type EditEventInput = {
1397 name?: Maybe<Scalars['String']>;
1398 email?: Maybe<Scalars['String']>;
1399 date?: Maybe<Scalars['Date']>;
1400 address?: Maybe<Scalars['String']>;
1401 cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
1402 position?: Maybe<Scalars['JSON']>;
1403 waiting_list?: Maybe<Scalars['JSON']>;
1404 users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1405 created_by?: Maybe<Scalars['ID']>;
1406 updated_by?: Maybe<Scalars['ID']>;
1407};
1408
1409export type EditFileInput = {
1410 name?: Maybe<Scalars['String']>;
1411 alternativeText?: Maybe<Scalars['String']>;
1412 caption?: Maybe<Scalars['String']>;
1413 width?: Maybe<Scalars['Int']>;
1414 height?: Maybe<Scalars['Int']>;
1415 formats?: Maybe<Scalars['JSON']>;
1416 hash?: Maybe<Scalars['String']>;
1417 ext?: Maybe<Scalars['String']>;
1418 mime?: Maybe<Scalars['String']>;
1419 size?: Maybe<Scalars['Float']>;
1420 url?: Maybe<Scalars['String']>;
1421 previewUrl?: Maybe<Scalars['String']>;
1422 provider?: Maybe<Scalars['String']>;
1423 provider_metadata?: Maybe<Scalars['JSON']>;
1424 related?: Maybe<Array<Maybe<Scalars['ID']>>>;
1425 created_by?: Maybe<Scalars['ID']>;
1426 updated_by?: Maybe<Scalars['ID']>;
1427};
1428
1429export type EditPageInput = {
1430 name?: Maybe<Scalars['String']>;
1431 content?: Maybe<Scalars['String']>;
1432 type?: Maybe<Enum_Page_Type>;
1433 created_by?: Maybe<Scalars['ID']>;
1434 updated_by?: Maybe<Scalars['ID']>;
1435};
1436
1437export type EditRoleInput = {
1438 name?: Maybe<Scalars['String']>;
1439 description?: Maybe<Scalars['String']>;
1440 type?: Maybe<Scalars['String']>;
1441 permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
1442 users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1443 created_by?: Maybe<Scalars['ID']>;
1444 updated_by?: Maybe<Scalars['ID']>;
1445};
1446
1447export type EditSettingInput = {
1448 gtm_id?: Maybe<Scalars['String']>;
1449 about_link?: Maybe<Scalars['String']>;
1450 created_by?: Maybe<Scalars['ID']>;
1451 updated_by?: Maybe<Scalars['ID']>;
1452};
1453
1454export type EditUserInput = {
1455 username?: Maybe<Scalars['String']>;
1456 firstName?: Maybe<Scalars['String']>;
1457 lastName?: Maybe<Scalars['String']>;
1458 email?: Maybe<Scalars['String']>;
1459 provider?: Maybe<Scalars['String']>;
1460 password?: Maybe<Scalars['String']>;
1461 resetPasswordToken?: Maybe<Scalars['String']>;
1462 confirmed?: Maybe<Scalars['Boolean']>;
1463 blocked?: Maybe<Scalars['Boolean']>;
1464 role?: Maybe<Scalars['ID']>;
1465 events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1466 confirmationToken?: Maybe<Scalars['String']>;
1467 created_by?: Maybe<Scalars['ID']>;
1468 updated_by?: Maybe<Scalars['ID']>;
1469 old_password?: Maybe<Scalars['String']>;
1470};
1471
1472export type UpdateCarInput = {
1473 where?: Maybe<InputId>;
1474 data?: Maybe<EditCarInput>;
1475};
1476
1477export type UpdateCarPayload = {
1478 __typename?: 'updateCarPayload';
1479 car?: Maybe<Car>;
1480};
1481
1482export type UpdateEventInput = {
1483 where?: Maybe<InputId>;
1484 data?: Maybe<EditEventInput>;
1485};
1486
1487export type UpdateEventPayload = {
1488 __typename?: 'updateEventPayload';
1489 event?: Maybe<Event>;
1490};
1491
1492export type UpdatePageInput = {
1493 where?: Maybe<InputId>;
1494 data?: Maybe<EditPageInput>;
1495};
1496
1497export type UpdatePagePayload = {
1498 __typename?: 'updatePagePayload';
1499 page?: Maybe<Page>;
1500};
1501
1502export type UpdateRoleInput = {
1503 where?: Maybe<InputId>;
1504 data?: Maybe<EditRoleInput>;
1505};
1506
1507export type UpdateRolePayload = {
1508 __typename?: 'updateRolePayload';
1509 role?: Maybe<UsersPermissionsRole>;
1510};
1511
1512export type UpdateSettingInput = {
1513 data?: Maybe<EditSettingInput>;
1514};
1515
1516export type UpdateSettingPayload = {
1517 __typename?: 'updateSettingPayload';
1518 setting?: Maybe<Settings>;
1519};
1520
1521export type UpdateUserInput = {
1522 where?: Maybe<InputId>;
1523 data?: Maybe<EditUserInput>;
1524};
1525
1526export type UpdateUserPayload = {
1527 __typename?: 'updateUserPayload';
1528 user?: Maybe<UsersPermissionsUser>;
1529};
1530
1531export type MeFieldsFragment = (
1532 { __typename?: 'UsersPermissionsMe' }
1533 & Pick<UsersPermissionsMe, 'id' | 'username' | 'email' | 'confirmed'>
1534);
1535
1536export type RegisterMutationVariables = Exact<{
1537 email: Scalars['String'];
1538 password: Scalars['String'];
1539 username: Scalars['String'];
1540}>;
1541
1542
1543export type RegisterMutation = (
1544 { __typename?: 'Mutation' }
1545 & { register: (
1546 { __typename?: 'UsersPermissionsLoginPayload' }
1547 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1548 & { user: (
1549 { __typename?: 'UsersPermissionsMe' }
1550 & MeFieldsFragment
1551 ) }
1552 ) }
1553);
1554
1555export type LoginMutationVariables = Exact<{
1556 identifier: Scalars['String'];
1557 password: Scalars['String'];
1558 provider?: Maybe<Scalars['String']>;
1559}>;
1560
1561
1562export type LoginMutation = (
1563 { __typename?: 'Mutation' }
1564 & { login: (
1565 { __typename?: 'UsersPermissionsLoginPayload' }
1566 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1567 & { user: (
1568 { __typename?: 'UsersPermissionsMe' }
1569 & MeFieldsFragment
1570 ) }
1571 ) }
1572);
1573
1574export type ForgotPasswordMutationVariables = Exact<{
1575 email: Scalars['String'];
1576}>;
1577
1578
1579export type ForgotPasswordMutation = (
1580 { __typename?: 'Mutation' }
1581 & { forgotPassword?: Maybe<(
1582 { __typename?: 'UserPermissionsPasswordPayload' }
1583 & Pick<UserPermissionsPasswordPayload, 'ok'>
1584 )> }
1585);
1586
1587export type ResetPasswordMutationVariables = Exact<{
1588 password: Scalars['String'];
1589 passwordConfirmation: Scalars['String'];
1590 code: Scalars['String'];
1591}>;
1592
1593
1594export type ResetPasswordMutation = (
1595 { __typename?: 'Mutation' }
1596 & { resetPassword?: Maybe<(
1597 { __typename?: 'UsersPermissionsLoginPayload' }
1598 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1599 & { user: (
1600 { __typename?: 'UsersPermissionsMe' }
1601 & MeFieldsFragment
1602 ) }
1603 )> }
1604);
1605
1606export type CarFieldsFragment = (
1607 { __typename?: 'Car' }
1608 & Pick<Car, 'id' | 'name' | 'seats' | 'meeting' | 'departure' | 'phone_number' | 'details' | 'passengers'>
1609 & { event?: Maybe<(
1610 { __typename?: 'Event' }
1611 & Pick<Event, 'id' | 'name'>
1612 )> }
1613);
1614
1615export type CreateCarMutationVariables = Exact<{
1616 car: CarInput;
1617}>;
1618
1619
1620export type CreateCarMutation = (
1621 { __typename?: 'Mutation' }
1622 & { createCar?: Maybe<(
1623 { __typename?: 'createCarPayload' }
1624 & { car?: Maybe<(
1625 { __typename?: 'Car' }
1626 & CarFieldsFragment
1627 )> }
1628 )> }
1629);
1630
1631export type UpdateCarMutationVariables = Exact<{
1632 id: Scalars['ID'];
1633 carUpdate: EditCarInput;
1634}>;
1635
1636
1637export type UpdateCarMutation = (
1638 { __typename?: 'Mutation' }
1639 & { updateCar?: Maybe<(
1640 { __typename?: 'updateCarPayload' }
1641 & { car?: Maybe<(
1642 { __typename?: 'Car' }
1643 & CarFieldsFragment
1644 )> }
1645 )> }
1646);
1647
1648export type DeleteCarMutationVariables = Exact<{
1649 id: Scalars['ID'];
1650}>;
1651
1652
1653export type DeleteCarMutation = (
1654 { __typename?: 'Mutation' }
1655 & { deleteCar?: Maybe<(
1656 { __typename?: 'deleteCarPayload' }
1657 & { car?: Maybe<(
1658 { __typename?: 'Car' }
1659 & Pick<Car, 'id' | 'name'>
1660 )> }
1661 )> }
1662);
1663
1664export type EventFielsFragment = (
1665 { __typename?: 'Event' }
1666 & Pick<Event, 'id' | 'name' | 'email' | 'date' | 'address' | 'position' | 'waiting_list'>
1667 & { cars?: Maybe<Array<Maybe<(
1668 { __typename?: 'Car' }
1669 & Pick<Car, 'id' | 'name' | 'seats' | 'meeting' | 'departure' | 'details' | 'phone_number' | 'passengers'>
1670 )>>> }
1671);
1672
1673export type CreateEventMutationVariables = Exact<{
1674 name: Scalars['String'];
1675 email: Scalars['String'];
1676 date?: Maybe<Scalars['Date']>;
1677 address?: Maybe<Scalars['String']>;
1678}>;
1679
1680
1681export type CreateEventMutation = (
1682 { __typename?: 'Mutation' }
1683 & { createEvent?: Maybe<(
1684 { __typename?: 'createEventPayload' }
1685 & { event?: Maybe<(
1686 { __typename?: 'Event' }
1687 & EventFielsFragment
1688 )> }
1689 )> }
1690);
1691
1692export type UpdateEventMutationVariables = Exact<{
1693 id: Scalars['ID'];
1694 eventUpdate?: Maybe<EditEventInput>;
1695}>;
1696
1697
1698export type UpdateEventMutation = (
1699 { __typename?: 'Mutation' }
1700 & { updateEvent?: Maybe<(
1701 { __typename?: 'updateEventPayload' }
1702 & { event?: Maybe<(
1703 { __typename?: 'Event' }
1704 & EventFielsFragment
1705 )> }
1706 )> }
1707);
1708
1709export type EventQueryVariables = Exact<{
1710 id: Scalars['ID'];
1711}>;
1712
1713
1714export type EventQuery = (
1715 { __typename?: 'Query' }
1716 & { event?: Maybe<(
1717 { __typename?: 'Event' }
1718 & EventFielsFragment
1719 )> }
1720);
1721
1722export type SettingQueryVariables = Exact<{ [key: string]: never; }>;
1723
1724
1725export type SettingQuery = (
1726 { __typename?: 'Query' }
1727 & { setting?: Maybe<(
1728 { __typename?: 'Settings' }
1729 & Pick<Settings, 'id' | 'gtm_id' | 'about_link'>
1730 )> }
1731);
1732
1733export type UserFieldsFragment = (
1734 { __typename?: 'UsersPermissionsUser' }
1735 & Pick<UsersPermissionsUser, 'id' | 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName'>
1736 & { events?: Maybe<Array<Maybe<(
1737 { __typename?: 'Event' }
1738 & Pick<Event, 'id' | 'name' | 'date' | 'address'>
1739 )>>> }
1740);
1741
1742export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
1743
1744
1745export type ProfileQuery = (
1746 { __typename?: 'Query' }
1747 & { me?: Maybe<(
1748 { __typename?: 'UsersPermissionsMe' }
1749 & Pick<UsersPermissionsMe, 'id' | 'username'>
1750 & { profile?: Maybe<(
1751 { __typename?: 'UsersPermissionsUser' }
1752 & UserFieldsFragment
1753 )> }
1754 )> }
1755);
1756
1757export type UpdateMeMutationVariables = Exact<{
1758 userUpdate: EditUserInput;
1759}>;
1760
1761
1762export type UpdateMeMutation = (
1763 { __typename?: 'Mutation' }
1764 & { updateMe: (
1765 { __typename?: 'updateUserPayload' }
1766 & { user?: Maybe<(
1767 { __typename?: 'UsersPermissionsUser' }
1768 & UserFieldsFragment
1769 )> }
1770 ) }
1771);
1772
1773export const MeFieldsFragmentDoc = gql`
1774 fragment MeFields on UsersPermissionsMe {
1775 id
1776 username
1777 email
1778 confirmed
1779}
1780 `;
1781export const CarFieldsFragmentDoc = gql`
1782 fragment CarFields on Car {
1783 id
1784 name
1785 seats
1786 meeting
1787 departure
1788 phone_number
1789 details
1790 passengers
1791 event {
1792 id
1793 name
1794 }
1795}
1796 `;
1797export const EventFielsFragmentDoc = gql`
1798 fragment EventFiels on Event {
1799 id
1800 name
1801 email
1802 date
1803 address
1804 position
1805 waiting_list
1806 cars {
1807 id
1808 name
1809 seats
1810 meeting
1811 departure
1812 details
1813 phone_number
1814 passengers
1815 }
1816}
1817 `;
1818export const UserFieldsFragmentDoc = gql`
1819 fragment UserFields on UsersPermissionsUser {
1820 id
1821 username
1822 email
1823 confirmed
1824 lastName
1825 firstName
1826 events {
1827 id
1828 name
1829 date
1830 address
1831 }
1832}
1833 `;
1834export const RegisterDocument = gql`
1835 mutation register($email: String!, $password: String!, $username: String!) {
1836 register(input: {email: $email, password: $password, username: $username}) {
1837 jwt
1838 user {
1839 ...MeFields
1840 }
1841 }
1842}
1843 ${MeFieldsFragmentDoc}`;
1844export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
1845
1846/**
1847 * __useRegisterMutation__
1848 *
1849 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
1850 * When your component renders, `useRegisterMutation` returns a tuple that includes:
1851 * - A mutate function that you can call at any time to execute the mutation
1852 * - An object with fields that represent the current status of the mutation's execution
1853 *
1854 * @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;
1855 *
1856 * @example
1857 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
1858 * variables: {
1859 * email: // value for 'email'
1860 * password: // value for 'password'
1861 * username: // value for 'username'
1862 * },
1863 * });
1864 */
1865export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
1866 return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
1867 }
1868export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
1869export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
1870export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
1871export const LoginDocument = gql`
1872 mutation login($identifier: String!, $password: String!, $provider: String = "local") {
1873 login(
1874 input: {identifier: $identifier, password: $password, provider: $provider}
1875 ) {
1876 jwt
1877 user {
1878 ...MeFields
1879 }
1880 }
1881}
1882 ${MeFieldsFragmentDoc}`;
1883export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
1884
1885/**
1886 * __useLoginMutation__
1887 *
1888 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
1889 * When your component renders, `useLoginMutation` returns a tuple that includes:
1890 * - A mutate function that you can call at any time to execute the mutation
1891 * - An object with fields that represent the current status of the mutation's execution
1892 *
1893 * @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;
1894 *
1895 * @example
1896 * const [loginMutation, { data, loading, error }] = useLoginMutation({
1897 * variables: {
1898 * identifier: // value for 'identifier'
1899 * password: // value for 'password'
1900 * provider: // value for 'provider'
1901 * },
1902 * });
1903 */
1904export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
1905 return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
1906 }
1907export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
1908export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
1909export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
1910export const ForgotPasswordDocument = gql`
1911 mutation forgotPassword($email: String!) {
1912 forgotPassword(email: $email) {
1913 ok
1914 }
1915}
1916 `;
1917export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
1918
1919/**
1920 * __useForgotPasswordMutation__
1921 *
1922 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
1923 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
1924 * - A mutate function that you can call at any time to execute the mutation
1925 * - An object with fields that represent the current status of the mutation's execution
1926 *
1927 * @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;
1928 *
1929 * @example
1930 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
1931 * variables: {
1932 * email: // value for 'email'
1933 * },
1934 * });
1935 */
1936export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
1937 return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
1938 }
1939export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
1940export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
1941export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
1942export const ResetPasswordDocument = gql`
1943 mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
1944 resetPassword(
1945 password: $password
1946 passwordConfirmation: $passwordConfirmation
1947 code: $code
1948 ) {
1949 jwt
1950 user {
1951 ...MeFields
1952 }
1953 }
1954}
1955 ${MeFieldsFragmentDoc}`;
1956export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
1957
1958/**
1959 * __useResetPasswordMutation__
1960 *
1961 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
1962 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
1963 * - A mutate function that you can call at any time to execute the mutation
1964 * - An object with fields that represent the current status of the mutation's execution
1965 *
1966 * @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;
1967 *
1968 * @example
1969 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
1970 * variables: {
1971 * password: // value for 'password'
1972 * passwordConfirmation: // value for 'passwordConfirmation'
1973 * code: // value for 'code'
1974 * },
1975 * });
1976 */
1977export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
1978 return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
1979 }
1980export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
1981export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
1982export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
1983export const CreateCarDocument = gql`
1984 mutation createCar($car: CarInput!) {
1985 createCar(input: {data: $car}) {
1986 car {
1987 ...CarFields
1988 }
1989 }
1990}
1991 ${CarFieldsFragmentDoc}`;
1992export type CreateCarMutationFn = Apollo.MutationFunction<CreateCarMutation, CreateCarMutationVariables>;
1993
1994/**
1995 * __useCreateCarMutation__
1996 *
1997 * To run a mutation, you first call `useCreateCarMutation` within a React component and pass it any options that fit your needs.
1998 * When your component renders, `useCreateCarMutation` returns a tuple that includes:
1999 * - A mutate function that you can call at any time to execute the mutation
2000 * - An object with fields that represent the current status of the mutation's execution
2001 *
2002 * @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;
2003 *
2004 * @example
2005 * const [createCarMutation, { data, loading, error }] = useCreateCarMutation({
2006 * variables: {
2007 * car: // value for 'car'
2008 * },
2009 * });
2010 */
2011export function useCreateCarMutation(baseOptions?: Apollo.MutationHookOptions<CreateCarMutation, CreateCarMutationVariables>) {
2012 return Apollo.useMutation<CreateCarMutation, CreateCarMutationVariables>(CreateCarDocument, baseOptions);
2013 }
2014export type CreateCarMutationHookResult = ReturnType<typeof useCreateCarMutation>;
2015export type CreateCarMutationResult = Apollo.MutationResult<CreateCarMutation>;
2016export type CreateCarMutationOptions = Apollo.BaseMutationOptions<CreateCarMutation, CreateCarMutationVariables>;
2017export const UpdateCarDocument = gql`
2018 mutation updateCar($id: ID!, $carUpdate: editCarInput!) {
2019 updateCar(input: {where: {id: $id}, data: $carUpdate}) {
2020 car {
2021 ...CarFields
2022 }
2023 }
2024}
2025 ${CarFieldsFragmentDoc}`;
2026export type UpdateCarMutationFn = Apollo.MutationFunction<UpdateCarMutation, UpdateCarMutationVariables>;
2027
2028/**
2029 * __useUpdateCarMutation__
2030 *
2031 * To run a mutation, you first call `useUpdateCarMutation` within a React component and pass it any options that fit your needs.
2032 * When your component renders, `useUpdateCarMutation` returns a tuple that includes:
2033 * - A mutate function that you can call at any time to execute the mutation
2034 * - An object with fields that represent the current status of the mutation's execution
2035 *
2036 * @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;
2037 *
2038 * @example
2039 * const [updateCarMutation, { data, loading, error }] = useUpdateCarMutation({
2040 * variables: {
2041 * id: // value for 'id'
2042 * carUpdate: // value for 'carUpdate'
2043 * },
2044 * });
2045 */
2046export function useUpdateCarMutation(baseOptions?: Apollo.MutationHookOptions<UpdateCarMutation, UpdateCarMutationVariables>) {
2047 return Apollo.useMutation<UpdateCarMutation, UpdateCarMutationVariables>(UpdateCarDocument, baseOptions);
2048 }
2049export type UpdateCarMutationHookResult = ReturnType<typeof useUpdateCarMutation>;
2050export type UpdateCarMutationResult = Apollo.MutationResult<UpdateCarMutation>;
2051export type UpdateCarMutationOptions = Apollo.BaseMutationOptions<UpdateCarMutation, UpdateCarMutationVariables>;
2052export const DeleteCarDocument = gql`
2053 mutation deleteCar($id: ID!) {
2054 deleteCar(input: {where: {id: $id}}) {
2055 car {
2056 id
2057 name
2058 }
2059 }
2060}
2061 `;
2062export type DeleteCarMutationFn = Apollo.MutationFunction<DeleteCarMutation, DeleteCarMutationVariables>;
2063
2064/**
2065 * __useDeleteCarMutation__
2066 *
2067 * To run a mutation, you first call `useDeleteCarMutation` within a React component and pass it any options that fit your needs.
2068 * When your component renders, `useDeleteCarMutation` returns a tuple that includes:
2069 * - A mutate function that you can call at any time to execute the mutation
2070 * - An object with fields that represent the current status of the mutation's execution
2071 *
2072 * @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;
2073 *
2074 * @example
2075 * const [deleteCarMutation, { data, loading, error }] = useDeleteCarMutation({
2076 * variables: {
2077 * id: // value for 'id'
2078 * },
2079 * });
2080 */
2081export function useDeleteCarMutation(baseOptions?: Apollo.MutationHookOptions<DeleteCarMutation, DeleteCarMutationVariables>) {
2082 return Apollo.useMutation<DeleteCarMutation, DeleteCarMutationVariables>(DeleteCarDocument, baseOptions);
2083 }
2084export type DeleteCarMutationHookResult = ReturnType<typeof useDeleteCarMutation>;
2085export type DeleteCarMutationResult = Apollo.MutationResult<DeleteCarMutation>;
2086export type DeleteCarMutationOptions = Apollo.BaseMutationOptions<DeleteCarMutation, DeleteCarMutationVariables>;
2087export const CreateEventDocument = gql`
2088 mutation createEvent($name: String!, $email: String!, $date: Date, $address: String) {
2089 createEvent(
2090 input: {data: {name: $name, email: $email, date: $date, address: $address}}
2091 ) {
2092 event {
2093 ...EventFiels
2094 }
2095 }
2096}
2097 ${EventFielsFragmentDoc}`;
2098export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2099
2100/**
2101 * __useCreateEventMutation__
2102 *
2103 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2104 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2105 * - A mutate function that you can call at any time to execute the mutation
2106 * - An object with fields that represent the current status of the mutation's execution
2107 *
2108 * @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;
2109 *
2110 * @example
2111 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2112 * variables: {
2113 * name: // value for 'name'
2114 * email: // value for 'email'
2115 * date: // value for 'date'
2116 * address: // value for 'address'
2117 * },
2118 * });
2119 */
2120export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2121 return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2122 }
2123export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2124export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2125export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2126export const UpdateEventDocument = gql`
2127 mutation updateEvent($id: ID!, $eventUpdate: editEventInput) {
2128 updateEvent(input: {where: {id: $id}, data: $eventUpdate}) {
2129 event {
2130 ...EventFiels
2131 }
2132 }
2133}
2134 ${EventFielsFragmentDoc}`;
2135export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2136
2137/**
2138 * __useUpdateEventMutation__
2139 *
2140 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2141 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2142 * - A mutate function that you can call at any time to execute the mutation
2143 * - An object with fields that represent the current status of the mutation's execution
2144 *
2145 * @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;
2146 *
2147 * @example
2148 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2149 * variables: {
2150 * id: // value for 'id'
2151 * eventUpdate: // value for 'eventUpdate'
2152 * },
2153 * });
2154 */
2155export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2156 return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2157 }
2158export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2159export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2160export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2161export const EventDocument = gql`
2162 query event($id: ID!) {
2163 event(id: $id) {
2164 ...EventFiels
2165 }
2166}
2167 ${EventFielsFragmentDoc}`;
2168
2169/**
2170 * __useEventQuery__
2171 *
2172 * To run a query within a React component, call `useEventQuery` and pass it any options that fit your needs.
2173 * When your component renders, `useEventQuery` returns an object from Apollo Client that contains loading, error, and data properties
2174 * you can use to render your UI.
2175 *
2176 * @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;
2177 *
2178 * @example
2179 * const { data, loading, error } = useEventQuery({
2180 * variables: {
2181 * id: // value for 'id'
2182 * },
2183 * });
2184 */
2185export function useEventQuery(baseOptions: Apollo.QueryHookOptions<EventQuery, EventQueryVariables>) {
2186 return Apollo.useQuery<EventQuery, EventQueryVariables>(EventDocument, baseOptions);
2187 }
2188export function useEventLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventQuery, EventQueryVariables>) {
2189 return Apollo.useLazyQuery<EventQuery, EventQueryVariables>(EventDocument, baseOptions);
2190 }
2191export type EventQueryHookResult = ReturnType<typeof useEventQuery>;
2192export type EventLazyQueryHookResult = ReturnType<typeof useEventLazyQuery>;
2193export type EventQueryResult = Apollo.QueryResult<EventQuery, EventQueryVariables>;
2194export const SettingDocument = gql`
2195 query setting {
2196 setting {
2197 id
2198 gtm_id
2199 about_link
2200 }
2201}
2202 `;
2203
2204/**
2205 * __useSettingQuery__
2206 *
2207 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2208 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2209 * you can use to render your UI.
2210 *
2211 * @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;
2212 *
2213 * @example
2214 * const { data, loading, error } = useSettingQuery({
2215 * variables: {
2216 * },
2217 * });
2218 */
2219export function useSettingQuery(baseOptions?: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2220 return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2221 }
2222export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2223 return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2224 }
2225export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2226export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2227export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2228export const ProfileDocument = gql`
2229 query profile {
2230 me {
2231 id
2232 username
2233 profile {
2234 ...UserFields
2235 }
2236 }
2237}
2238 ${UserFieldsFragmentDoc}`;
2239
2240/**
2241 * __useProfileQuery__
2242 *
2243 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2244 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2245 * you can use to render your UI.
2246 *
2247 * @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;
2248 *
2249 * @example
2250 * const { data, loading, error } = useProfileQuery({
2251 * variables: {
2252 * },
2253 * });
2254 */
2255export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2256 return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2257 }
2258export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2259 return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2260 }
2261export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2262export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2263export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2264export const UpdateMeDocument = gql`
2265 mutation updateMe($userUpdate: editUserInput!) {
2266 updateMe(input: $userUpdate) {
2267 user {
2268 ...UserFields
2269 }
2270 }
2271}
2272 ${UserFieldsFragmentDoc}`;
2273export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2274
2275/**
2276 * __useUpdateMeMutation__
2277 *
2278 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2279 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2280 * - A mutate function that you can call at any time to execute the mutation
2281 * - An object with fields that represent the current status of the mutation's execution
2282 *
2283 * @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;
2284 *
2285 * @example
2286 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2287 * variables: {
2288 * userUpdate: // value for 'userUpdate'
2289 * },
2290 * });
2291 */
2292export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2293 return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2294 }
2295export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2296export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2297export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;