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