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}>;
1559
1560
1561export type LoginMutation = (
1562 { __typename?: 'Mutation' }
1563 & { login: (
1564 { __typename?: 'UsersPermissionsLoginPayload' }
1565 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1566 & { user: (
1567 { __typename?: 'UsersPermissionsMe' }
1568 & MeFieldsFragment
1569 ) }
1570 ) }
1571);
1572
1573export type ForgotPasswordMutationVariables = Exact<{
1574 email: Scalars['String'];
1575}>;
1576
1577
1578export type ForgotPasswordMutation = (
1579 { __typename?: 'Mutation' }
1580 & { forgotPassword?: Maybe<(
1581 { __typename?: 'UserPermissionsPasswordPayload' }
1582 & Pick<UserPermissionsPasswordPayload, 'ok'>
1583 )> }
1584);
1585
1586export type ResetPasswordMutationVariables = Exact<{
1587 password: Scalars['String'];
1588 passwordConfirmation: Scalars['String'];
1589 code: Scalars['String'];
1590}>;
1591
1592
1593export type ResetPasswordMutation = (
1594 { __typename?: 'Mutation' }
1595 & { resetPassword?: Maybe<(
1596 { __typename?: 'UsersPermissionsLoginPayload' }
1597 & Pick<UsersPermissionsLoginPayload, 'jwt'>
1598 & { user: (
1599 { __typename?: 'UsersPermissionsMe' }
1600 & MeFieldsFragment
1601 ) }
1602 )> }
1603);
1604
1605export type CarFieldsFragment = (
1606 { __typename?: 'Car' }
1607 & Pick<Car, 'id' | 'name' | 'seats' | 'meeting' | 'departure' | 'phone_number' | 'details' | 'passengers'>
1608 & { event?: Maybe<(
1609 { __typename?: 'Event' }
1610 & Pick<Event, 'id' | 'name'>
1611 )> }
1612);
1613
1614export type CreateCarMutationVariables = Exact<{
1615 car: CarInput;
1616}>;
1617
1618
1619export type CreateCarMutation = (
1620 { __typename?: 'Mutation' }
1621 & { createCar?: Maybe<(
1622 { __typename?: 'createCarPayload' }
1623 & { car?: Maybe<(
1624 { __typename?: 'Car' }
1625 & CarFieldsFragment
1626 )> }
1627 )> }
1628);
1629
1630export type UpdateCarMutationVariables = Exact<{
1631 id: Scalars['ID'];
1632 carUpdate: EditCarInput;
1633}>;
1634
1635
1636export type UpdateCarMutation = (
1637 { __typename?: 'Mutation' }
1638 & { updateCar?: Maybe<(
1639 { __typename?: 'updateCarPayload' }
1640 & { car?: Maybe<(
1641 { __typename?: 'Car' }
1642 & CarFieldsFragment
1643 )> }
1644 )> }
1645);
1646
1647export type DeleteCarMutationVariables = Exact<{
1648 id: Scalars['ID'];
1649}>;
1650
1651
1652export type DeleteCarMutation = (
1653 { __typename?: 'Mutation' }
1654 & { deleteCar?: Maybe<(
1655 { __typename?: 'deleteCarPayload' }
1656 & { car?: Maybe<(
1657 { __typename?: 'Car' }
1658 & Pick<Car, 'id' | 'name'>
1659 )> }
1660 )> }
1661);
1662
1663export type EventFieldsFragment = (
1664 { __typename?: 'Event' }
1665 & Pick<Event, 'id' | 'name' | 'email' | 'date' | 'address' | 'position' | 'waiting_list'>
1666 & { cars?: Maybe<Array<Maybe<(
1667 { __typename?: 'Car' }
1668 & Pick<Car, 'id' | 'name' | 'seats' | 'meeting' | 'departure' | 'details' | 'phone_number' | 'passengers'>
1669 )>>> }
1670);
1671
1672export type CreateEventMutationVariables = Exact<{
1673 name: Scalars['String'];
1674 email: Scalars['String'];
1675 date?: Maybe<Scalars['Date']>;
1676 address?: Maybe<Scalars['String']>;
1677}>;
1678
1679
1680export type CreateEventMutation = (
1681 { __typename?: 'Mutation' }
1682 & { createEvent?: Maybe<(
1683 { __typename?: 'createEventPayload' }
1684 & { event?: Maybe<(
1685 { __typename?: 'Event' }
1686 & EventFieldsFragment
1687 )> }
1688 )> }
1689);
1690
1691export type UpdateEventMutationVariables = Exact<{
1692 id: Scalars['ID'];
1693 eventUpdate?: Maybe<EditEventInput>;
1694}>;
1695
1696
1697export type UpdateEventMutation = (
1698 { __typename?: 'Mutation' }
1699 & { updateEvent?: Maybe<(
1700 { __typename?: 'updateEventPayload' }
1701 & { event?: Maybe<(
1702 { __typename?: 'Event' }
1703 & EventFieldsFragment
1704 )> }
1705 )> }
1706);
1707
1708export type EventQueryVariables = Exact<{
1709 id: Scalars['ID'];
1710}>;
1711
1712
1713export type EventQuery = (
1714 { __typename?: 'Query' }
1715 & { event?: Maybe<(
1716 { __typename?: 'Event' }
1717 & EventFieldsFragment
1718 )> }
1719);
1720
1721export type SettingQueryVariables = Exact<{ [key: string]: never; }>;
1722
1723
1724export type SettingQuery = (
1725 { __typename?: 'Query' }
1726 & { setting?: Maybe<(
1727 { __typename?: 'Settings' }
1728 & Pick<Settings, 'id' | 'gtm_id' | 'about_link'>
1729 )> }
1730);
1731
1732export type UserFieldsFragment = (
1733 { __typename?: 'UsersPermissionsUser' }
1734 & Pick<UsersPermissionsUser, 'id' | 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName'>
1735 & { events?: Maybe<Array<Maybe<(
1736 { __typename?: 'Event' }
1737 & Pick<Event, 'id' | 'name' | 'date' | 'address'>
1738 )>>> }
1739);
1740
1741export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
1742
1743
1744export type ProfileQuery = (
1745 { __typename?: 'Query' }
1746 & { me?: Maybe<(
1747 { __typename?: 'UsersPermissionsMe' }
1748 & Pick<UsersPermissionsMe, 'id' | 'username'>
1749 & { profile?: Maybe<(
1750 { __typename?: 'UsersPermissionsUser' }
1751 & UserFieldsFragment
1752 )> }
1753 )> }
1754);
1755
1756export type UpdateMeMutationVariables = Exact<{
1757 userUpdate: EditUserInput;
1758}>;
1759
1760
1761export type UpdateMeMutation = (
1762 { __typename?: 'Mutation' }
1763 & { updateMe: (
1764 { __typename?: 'updateUserPayload' }
1765 & { user?: Maybe<(
1766 { __typename?: 'UsersPermissionsUser' }
1767 & UserFieldsFragment
1768 )> }
1769 ) }
1770);
1771
1772export const MeFieldsFragmentDoc = gql`
1773 fragment MeFields on UsersPermissionsMe {
1774 id
1775 username
1776 email
1777 confirmed
1778}
1779 `;
1780export const CarFieldsFragmentDoc = gql`
1781 fragment CarFields on Car {
1782 id
1783 name
1784 seats
1785 meeting
1786 departure
1787 phone_number
1788 details
1789 passengers
1790 event {
1791 id
1792 name
1793 }
1794}
1795 `;
1796export const EventFieldsFragmentDoc = gql`
1797 fragment EventFields on Event {
1798 id
1799 name
1800 email
1801 date
1802 address
1803 position
1804 waiting_list
1805 cars {
1806 id
1807 name
1808 seats
1809 meeting
1810 departure
1811 details
1812 phone_number
1813 passengers
1814 }
1815}
1816 `;
1817export const UserFieldsFragmentDoc = gql`
1818 fragment UserFields on UsersPermissionsUser {
1819 id
1820 username
1821 email
1822 confirmed
1823 lastName
1824 firstName
1825 events {
1826 id
1827 name
1828 date
1829 address
1830 }
1831}
1832 `;
1833export const RegisterDocument = gql`
1834 mutation register($email: String!, $password: String!, $username: String!) {
1835 register(input: {email: $email, password: $password, username: $username}) {
1836 jwt
1837 user {
1838 ...MeFields
1839 }
1840 }
1841}
1842 ${MeFieldsFragmentDoc}`;
1843export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
1844
1845/**
1846 * __useRegisterMutation__
1847 *
1848 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
1849 * When your component renders, `useRegisterMutation` returns a tuple that includes:
1850 * - A mutate function that you can call at any time to execute the mutation
1851 * - An object with fields that represent the current status of the mutation's execution
1852 *
1853 * @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;
1854 *
1855 * @example
1856 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
1857 * variables: {
1858 * email: // value for 'email'
1859 * password: // value for 'password'
1860 * username: // value for 'username'
1861 * },
1862 * });
1863 */
1864export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
1865 return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
1866 }
1867export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
1868export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
1869export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
1870export const LoginDocument = gql`
1871 mutation login($identifier: String!, $password: String!) {
1872 login(input: {identifier: $identifier, password: $password}) {
1873 jwt
1874 user {
1875 ...MeFields
1876 }
1877 }
1878}
1879 ${MeFieldsFragmentDoc}`;
1880export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
1881
1882/**
1883 * __useLoginMutation__
1884 *
1885 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
1886 * When your component renders, `useLoginMutation` returns a tuple that includes:
1887 * - A mutate function that you can call at any time to execute the mutation
1888 * - An object with fields that represent the current status of the mutation's execution
1889 *
1890 * @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;
1891 *
1892 * @example
1893 * const [loginMutation, { data, loading, error }] = useLoginMutation({
1894 * variables: {
1895 * identifier: // value for 'identifier'
1896 * password: // value for 'password'
1897 * },
1898 * });
1899 */
1900export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
1901 return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
1902 }
1903export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
1904export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
1905export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
1906export const ForgotPasswordDocument = gql`
1907 mutation forgotPassword($email: String!) {
1908 forgotPassword(email: $email) {
1909 ok
1910 }
1911}
1912 `;
1913export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
1914
1915/**
1916 * __useForgotPasswordMutation__
1917 *
1918 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
1919 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
1920 * - A mutate function that you can call at any time to execute the mutation
1921 * - An object with fields that represent the current status of the mutation's execution
1922 *
1923 * @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;
1924 *
1925 * @example
1926 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
1927 * variables: {
1928 * email: // value for 'email'
1929 * },
1930 * });
1931 */
1932export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
1933 return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
1934 }
1935export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
1936export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
1937export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
1938export const ResetPasswordDocument = gql`
1939 mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
1940 resetPassword(
1941 password: $password
1942 passwordConfirmation: $passwordConfirmation
1943 code: $code
1944 ) {
1945 jwt
1946 user {
1947 ...MeFields
1948 }
1949 }
1950}
1951 ${MeFieldsFragmentDoc}`;
1952export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
1953
1954/**
1955 * __useResetPasswordMutation__
1956 *
1957 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
1958 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
1959 * - A mutate function that you can call at any time to execute the mutation
1960 * - An object with fields that represent the current status of the mutation's execution
1961 *
1962 * @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;
1963 *
1964 * @example
1965 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
1966 * variables: {
1967 * password: // value for 'password'
1968 * passwordConfirmation: // value for 'passwordConfirmation'
1969 * code: // value for 'code'
1970 * },
1971 * });
1972 */
1973export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
1974 return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
1975 }
1976export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
1977export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
1978export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
1979export const CreateCarDocument = gql`
1980 mutation createCar($car: CarInput!) {
1981 createCar(input: {data: $car}) {
1982 car {
1983 ...CarFields
1984 }
1985 }
1986}
1987 ${CarFieldsFragmentDoc}`;
1988export type CreateCarMutationFn = Apollo.MutationFunction<CreateCarMutation, CreateCarMutationVariables>;
1989
1990/**
1991 * __useCreateCarMutation__
1992 *
1993 * To run a mutation, you first call `useCreateCarMutation` within a React component and pass it any options that fit your needs.
1994 * When your component renders, `useCreateCarMutation` returns a tuple that includes:
1995 * - A mutate function that you can call at any time to execute the mutation
1996 * - An object with fields that represent the current status of the mutation's execution
1997 *
1998 * @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;
1999 *
2000 * @example
2001 * const [createCarMutation, { data, loading, error }] = useCreateCarMutation({
2002 * variables: {
2003 * car: // value for 'car'
2004 * },
2005 * });
2006 */
2007export function useCreateCarMutation(baseOptions?: Apollo.MutationHookOptions<CreateCarMutation, CreateCarMutationVariables>) {
2008 return Apollo.useMutation<CreateCarMutation, CreateCarMutationVariables>(CreateCarDocument, baseOptions);
2009 }
2010export type CreateCarMutationHookResult = ReturnType<typeof useCreateCarMutation>;
2011export type CreateCarMutationResult = Apollo.MutationResult<CreateCarMutation>;
2012export type CreateCarMutationOptions = Apollo.BaseMutationOptions<CreateCarMutation, CreateCarMutationVariables>;
2013export const UpdateCarDocument = gql`
2014 mutation updateCar($id: ID!, $carUpdate: editCarInput!) {
2015 updateCar(input: {where: {id: $id}, data: $carUpdate}) {
2016 car {
2017 ...CarFields
2018 }
2019 }
2020}
2021 ${CarFieldsFragmentDoc}`;
2022export type UpdateCarMutationFn = Apollo.MutationFunction<UpdateCarMutation, UpdateCarMutationVariables>;
2023
2024/**
2025 * __useUpdateCarMutation__
2026 *
2027 * To run a mutation, you first call `useUpdateCarMutation` within a React component and pass it any options that fit your needs.
2028 * When your component renders, `useUpdateCarMutation` returns a tuple that includes:
2029 * - A mutate function that you can call at any time to execute the mutation
2030 * - An object with fields that represent the current status of the mutation's execution
2031 *
2032 * @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;
2033 *
2034 * @example
2035 * const [updateCarMutation, { data, loading, error }] = useUpdateCarMutation({
2036 * variables: {
2037 * id: // value for 'id'
2038 * carUpdate: // value for 'carUpdate'
2039 * },
2040 * });
2041 */
2042export function useUpdateCarMutation(baseOptions?: Apollo.MutationHookOptions<UpdateCarMutation, UpdateCarMutationVariables>) {
2043 return Apollo.useMutation<UpdateCarMutation, UpdateCarMutationVariables>(UpdateCarDocument, baseOptions);
2044 }
2045export type UpdateCarMutationHookResult = ReturnType<typeof useUpdateCarMutation>;
2046export type UpdateCarMutationResult = Apollo.MutationResult<UpdateCarMutation>;
2047export type UpdateCarMutationOptions = Apollo.BaseMutationOptions<UpdateCarMutation, UpdateCarMutationVariables>;
2048export const DeleteCarDocument = gql`
2049 mutation deleteCar($id: ID!) {
2050 deleteCar(input: {where: {id: $id}}) {
2051 car {
2052 id
2053 name
2054 }
2055 }
2056}
2057 `;
2058export type DeleteCarMutationFn = Apollo.MutationFunction<DeleteCarMutation, DeleteCarMutationVariables>;
2059
2060/**
2061 * __useDeleteCarMutation__
2062 *
2063 * To run a mutation, you first call `useDeleteCarMutation` within a React component and pass it any options that fit your needs.
2064 * When your component renders, `useDeleteCarMutation` returns a tuple that includes:
2065 * - A mutate function that you can call at any time to execute the mutation
2066 * - An object with fields that represent the current status of the mutation's execution
2067 *
2068 * @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;
2069 *
2070 * @example
2071 * const [deleteCarMutation, { data, loading, error }] = useDeleteCarMutation({
2072 * variables: {
2073 * id: // value for 'id'
2074 * },
2075 * });
2076 */
2077export function useDeleteCarMutation(baseOptions?: Apollo.MutationHookOptions<DeleteCarMutation, DeleteCarMutationVariables>) {
2078 return Apollo.useMutation<DeleteCarMutation, DeleteCarMutationVariables>(DeleteCarDocument, baseOptions);
2079 }
2080export type DeleteCarMutationHookResult = ReturnType<typeof useDeleteCarMutation>;
2081export type DeleteCarMutationResult = Apollo.MutationResult<DeleteCarMutation>;
2082export type DeleteCarMutationOptions = Apollo.BaseMutationOptions<DeleteCarMutation, DeleteCarMutationVariables>;
2083export const CreateEventDocument = gql`
2084 mutation createEvent($name: String!, $email: String!, $date: Date, $address: String) {
2085 createEvent(
2086 input: {data: {name: $name, email: $email, date: $date, address: $address}}
2087 ) {
2088 event {
2089 ...EventFields
2090 }
2091 }
2092}
2093 ${EventFieldsFragmentDoc}`;
2094export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2095
2096/**
2097 * __useCreateEventMutation__
2098 *
2099 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2100 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2101 * - A mutate function that you can call at any time to execute the mutation
2102 * - An object with fields that represent the current status of the mutation's execution
2103 *
2104 * @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;
2105 *
2106 * @example
2107 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2108 * variables: {
2109 * name: // value for 'name'
2110 * email: // value for 'email'
2111 * date: // value for 'date'
2112 * address: // value for 'address'
2113 * },
2114 * });
2115 */
2116export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2117 return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2118 }
2119export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2120export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2121export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2122export const UpdateEventDocument = gql`
2123 mutation updateEvent($id: ID!, $eventUpdate: editEventInput) {
2124 updateEvent(input: {where: {id: $id}, data: $eventUpdate}) {
2125 event {
2126 ...EventFields
2127 }
2128 }
2129}
2130 ${EventFieldsFragmentDoc}`;
2131export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2132
2133/**
2134 * __useUpdateEventMutation__
2135 *
2136 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2137 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2138 * - A mutate function that you can call at any time to execute the mutation
2139 * - An object with fields that represent the current status of the mutation's execution
2140 *
2141 * @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;
2142 *
2143 * @example
2144 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2145 * variables: {
2146 * id: // value for 'id'
2147 * eventUpdate: // value for 'eventUpdate'
2148 * },
2149 * });
2150 */
2151export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2152 return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2153 }
2154export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2155export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2156export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2157export const EventDocument = gql`
2158 query event($id: ID!) {
2159 event(id: $id) {
2160 ...EventFields
2161 }
2162}
2163 ${EventFieldsFragmentDoc}`;
2164
2165/**
2166 * __useEventQuery__
2167 *
2168 * To run a query within a React component, call `useEventQuery` and pass it any options that fit your needs.
2169 * When your component renders, `useEventQuery` returns an object from Apollo Client that contains loading, error, and data properties
2170 * you can use to render your UI.
2171 *
2172 * @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;
2173 *
2174 * @example
2175 * const { data, loading, error } = useEventQuery({
2176 * variables: {
2177 * id: // value for 'id'
2178 * },
2179 * });
2180 */
2181export function useEventQuery(baseOptions: Apollo.QueryHookOptions<EventQuery, EventQueryVariables>) {
2182 return Apollo.useQuery<EventQuery, EventQueryVariables>(EventDocument, baseOptions);
2183 }
2184export function useEventLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventQuery, EventQueryVariables>) {
2185 return Apollo.useLazyQuery<EventQuery, EventQueryVariables>(EventDocument, baseOptions);
2186 }
2187export type EventQueryHookResult = ReturnType<typeof useEventQuery>;
2188export type EventLazyQueryHookResult = ReturnType<typeof useEventLazyQuery>;
2189export type EventQueryResult = Apollo.QueryResult<EventQuery, EventQueryVariables>;
2190export const SettingDocument = gql`
2191 query setting {
2192 setting {
2193 id
2194 gtm_id
2195 about_link
2196 }
2197}
2198 `;
2199
2200/**
2201 * __useSettingQuery__
2202 *
2203 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2204 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2205 * you can use to render your UI.
2206 *
2207 * @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;
2208 *
2209 * @example
2210 * const { data, loading, error } = useSettingQuery({
2211 * variables: {
2212 * },
2213 * });
2214 */
2215export function useSettingQuery(baseOptions?: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2216 return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2217 }
2218export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2219 return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2220 }
2221export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2222export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2223export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2224export const ProfileDocument = gql`
2225 query profile {
2226 me {
2227 id
2228 username
2229 profile {
2230 ...UserFields
2231 }
2232 }
2233}
2234 ${UserFieldsFragmentDoc}`;
2235
2236/**
2237 * __useProfileQuery__
2238 *
2239 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2240 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2241 * you can use to render your UI.
2242 *
2243 * @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;
2244 *
2245 * @example
2246 * const { data, loading, error } = useProfileQuery({
2247 * variables: {
2248 * },
2249 * });
2250 */
2251export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2252 return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2253 }
2254export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2255 return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2256 }
2257export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2258export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2259export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2260export const UpdateMeDocument = gql`
2261 mutation updateMe($userUpdate: editUserInput!) {
2262 updateMe(input: $userUpdate) {
2263 user {
2264 ...UserFields
2265 }
2266 }
2267}
2268 ${UserFieldsFragmentDoc}`;
2269export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2270
2271/**
2272 * __useUpdateMeMutation__
2273 *
2274 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2275 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2276 * - A mutate function that you can call at any time to execute the mutation
2277 * - An object with fields that represent the current status of the mutation's execution
2278 *
2279 * @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;
2280 *
2281 * @example
2282 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2283 * variables: {
2284 * userUpdate: // value for 'userUpdate'
2285 * },
2286 * });
2287 */
2288export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2289 return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2290 }
2291export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2292export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2293export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;