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