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};
1149
1150export type UsersPermissionsRole = {
1151  __typename?: 'UsersPermissionsRole';
1152  id: Scalars['ID'];
1153  name: Scalars['String'];
1154  description?: Maybe<Scalars['String']>;
1155  type?: Maybe<Scalars['String']>;
1156  permissions?: Maybe<Array<Maybe<UsersPermissionsPermission>>>;
1157  users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1158};
1159
1160
1161export type UsersPermissionsRolePermissionsArgs = {
1162  sort?: Maybe<Scalars['String']>;
1163  limit?: Maybe<Scalars['Int']>;
1164  start?: Maybe<Scalars['Int']>;
1165  where?: Maybe<Scalars['JSON']>;
1166};
1167
1168
1169export type UsersPermissionsRoleUsersArgs = {
1170  sort?: Maybe<Scalars['String']>;
1171  limit?: Maybe<Scalars['Int']>;
1172  start?: Maybe<Scalars['Int']>;
1173  where?: Maybe<Scalars['JSON']>;
1174};
1175
1176export type UsersPermissionsRoleAggregator = {
1177  __typename?: 'UsersPermissionsRoleAggregator';
1178  count?: Maybe<Scalars['Int']>;
1179  totalCount?: Maybe<Scalars['Int']>;
1180};
1181
1182export type UsersPermissionsRoleConnection = {
1183  __typename?: 'UsersPermissionsRoleConnection';
1184  values?: Maybe<Array<Maybe<UsersPermissionsRole>>>;
1185  groupBy?: Maybe<UsersPermissionsRoleGroupBy>;
1186  aggregate?: Maybe<UsersPermissionsRoleAggregator>;
1187};
1188
1189export type UsersPermissionsRoleConnectionDescription = {
1190  __typename?: 'UsersPermissionsRoleConnectionDescription';
1191  key?: Maybe<Scalars['String']>;
1192  connection?: Maybe<UsersPermissionsRoleConnection>;
1193};
1194
1195export type UsersPermissionsRoleConnectionId = {
1196  __typename?: 'UsersPermissionsRoleConnectionId';
1197  key?: Maybe<Scalars['ID']>;
1198  connection?: Maybe<UsersPermissionsRoleConnection>;
1199};
1200
1201export type UsersPermissionsRoleConnectionName = {
1202  __typename?: 'UsersPermissionsRoleConnectionName';
1203  key?: Maybe<Scalars['String']>;
1204  connection?: Maybe<UsersPermissionsRoleConnection>;
1205};
1206
1207export type UsersPermissionsRoleConnectionType = {
1208  __typename?: 'UsersPermissionsRoleConnectionType';
1209  key?: Maybe<Scalars['String']>;
1210  connection?: Maybe<UsersPermissionsRoleConnection>;
1211};
1212
1213export type UsersPermissionsRoleGroupBy = {
1214  __typename?: 'UsersPermissionsRoleGroupBy';
1215  id?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionId>>>;
1216  name?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionName>>>;
1217  description?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionDescription>>>;
1218  type?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionType>>>;
1219};
1220
1221export type UsersPermissionsUser = {
1222  __typename?: 'UsersPermissionsUser';
1223  id: Scalars['ID'];
1224  created_at: Scalars['DateTime'];
1225  updated_at: Scalars['DateTime'];
1226  username: Scalars['String'];
1227  firstName?: Maybe<Scalars['String']>;
1228  lastName?: Maybe<Scalars['String']>;
1229  email: Scalars['String'];
1230  provider?: Maybe<Scalars['String']>;
1231  confirmed?: Maybe<Scalars['Boolean']>;
1232  blocked?: Maybe<Scalars['Boolean']>;
1233  role?: Maybe<UsersPermissionsRole>;
1234  onboardingUser?: Maybe<Scalars['Boolean']>;
1235  onboardingCreator?: Maybe<Scalars['Boolean']>;
1236  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1237  events?: Maybe<Array<Maybe<Event>>>;
1238};
1239
1240
1241export type UsersPermissionsUserEventsArgs = {
1242  sort?: Maybe<Scalars['String']>;
1243  limit?: Maybe<Scalars['Int']>;
1244  start?: Maybe<Scalars['Int']>;
1245  where?: Maybe<Scalars['JSON']>;
1246};
1247
1248export type UsersPermissionsUserAggregator = {
1249  __typename?: 'UsersPermissionsUserAggregator';
1250  count?: Maybe<Scalars['Int']>;
1251  totalCount?: Maybe<Scalars['Int']>;
1252};
1253
1254export type UsersPermissionsUserConnection = {
1255  __typename?: 'UsersPermissionsUserConnection';
1256  values?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1257  groupBy?: Maybe<UsersPermissionsUserGroupBy>;
1258  aggregate?: Maybe<UsersPermissionsUserAggregator>;
1259};
1260
1261export type UsersPermissionsUserConnectionBlocked = {
1262  __typename?: 'UsersPermissionsUserConnectionBlocked';
1263  key?: Maybe<Scalars['Boolean']>;
1264  connection?: Maybe<UsersPermissionsUserConnection>;
1265};
1266
1267export type UsersPermissionsUserConnectionConfirmed = {
1268  __typename?: 'UsersPermissionsUserConnectionConfirmed';
1269  key?: Maybe<Scalars['Boolean']>;
1270  connection?: Maybe<UsersPermissionsUserConnection>;
1271};
1272
1273export type UsersPermissionsUserConnectionCreated_At = {
1274  __typename?: 'UsersPermissionsUserConnectionCreated_at';
1275  key?: Maybe<Scalars['DateTime']>;
1276  connection?: Maybe<UsersPermissionsUserConnection>;
1277};
1278
1279export type UsersPermissionsUserConnectionEmail = {
1280  __typename?: 'UsersPermissionsUserConnectionEmail';
1281  key?: Maybe<Scalars['String']>;
1282  connection?: Maybe<UsersPermissionsUserConnection>;
1283};
1284
1285export type UsersPermissionsUserConnectionFirstName = {
1286  __typename?: 'UsersPermissionsUserConnectionFirstName';
1287  key?: Maybe<Scalars['String']>;
1288  connection?: Maybe<UsersPermissionsUserConnection>;
1289};
1290
1291export type UsersPermissionsUserConnectionId = {
1292  __typename?: 'UsersPermissionsUserConnectionId';
1293  key?: Maybe<Scalars['ID']>;
1294  connection?: Maybe<UsersPermissionsUserConnection>;
1295};
1296
1297export type UsersPermissionsUserConnectionLang = {
1298  __typename?: 'UsersPermissionsUserConnectionLang';
1299  key?: Maybe<Scalars['String']>;
1300  connection?: Maybe<UsersPermissionsUserConnection>;
1301};
1302
1303export type UsersPermissionsUserConnectionLastName = {
1304  __typename?: 'UsersPermissionsUserConnectionLastName';
1305  key?: Maybe<Scalars['String']>;
1306  connection?: Maybe<UsersPermissionsUserConnection>;
1307};
1308
1309export type UsersPermissionsUserConnectionOnboardingCreator = {
1310  __typename?: 'UsersPermissionsUserConnectionOnboardingCreator';
1311  key?: Maybe<Scalars['Boolean']>;
1312  connection?: Maybe<UsersPermissionsUserConnection>;
1313};
1314
1315export type UsersPermissionsUserConnectionOnboardingUser = {
1316  __typename?: 'UsersPermissionsUserConnectionOnboardingUser';
1317  key?: Maybe<Scalars['Boolean']>;
1318  connection?: Maybe<UsersPermissionsUserConnection>;
1319};
1320
1321export type UsersPermissionsUserConnectionProvider = {
1322  __typename?: 'UsersPermissionsUserConnectionProvider';
1323  key?: Maybe<Scalars['String']>;
1324  connection?: Maybe<UsersPermissionsUserConnection>;
1325};
1326
1327export type UsersPermissionsUserConnectionRole = {
1328  __typename?: 'UsersPermissionsUserConnectionRole';
1329  key?: Maybe<Scalars['ID']>;
1330  connection?: Maybe<UsersPermissionsUserConnection>;
1331};
1332
1333export type UsersPermissionsUserConnectionUpdated_At = {
1334  __typename?: 'UsersPermissionsUserConnectionUpdated_at';
1335  key?: Maybe<Scalars['DateTime']>;
1336  connection?: Maybe<UsersPermissionsUserConnection>;
1337};
1338
1339export type UsersPermissionsUserConnectionUsername = {
1340  __typename?: 'UsersPermissionsUserConnectionUsername';
1341  key?: Maybe<Scalars['String']>;
1342  connection?: Maybe<UsersPermissionsUserConnection>;
1343};
1344
1345export type UsersPermissionsUserGroupBy = {
1346  __typename?: 'UsersPermissionsUserGroupBy';
1347  id?: Maybe<Array<Maybe<UsersPermissionsUserConnectionId>>>;
1348  created_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionCreated_At>>>;
1349  updated_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUpdated_At>>>;
1350  username?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUsername>>>;
1351  firstName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionFirstName>>>;
1352  lastName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLastName>>>;
1353  email?: Maybe<Array<Maybe<UsersPermissionsUserConnectionEmail>>>;
1354  provider?: Maybe<Array<Maybe<UsersPermissionsUserConnectionProvider>>>;
1355  confirmed?: Maybe<Array<Maybe<UsersPermissionsUserConnectionConfirmed>>>;
1356  blocked?: Maybe<Array<Maybe<UsersPermissionsUserConnectionBlocked>>>;
1357  role?: Maybe<Array<Maybe<UsersPermissionsUserConnectionRole>>>;
1358  onboardingUser?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingUser>>>;
1359  onboardingCreator?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingCreator>>>;
1360  lang?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLang>>>;
1361};
1362
1363export type CreateCarInput = {
1364  data?: Maybe<CarInput>;
1365};
1366
1367export type CreateCarPayload = {
1368  __typename?: 'createCarPayload';
1369  car?: Maybe<Car>;
1370};
1371
1372export type CreateEventInput = {
1373  data?: Maybe<EventInput>;
1374};
1375
1376export type CreateEventPayload = {
1377  __typename?: 'createEventPayload';
1378  event?: Maybe<Event>;
1379};
1380
1381export type CreatePageInput = {
1382  data?: Maybe<PageInput>;
1383};
1384
1385export type CreatePagePayload = {
1386  __typename?: 'createPagePayload';
1387  page?: Maybe<Page>;
1388};
1389
1390export type CreateRoleInput = {
1391  data?: Maybe<RoleInput>;
1392};
1393
1394export type CreateRolePayload = {
1395  __typename?: 'createRolePayload';
1396  role?: Maybe<UsersPermissionsRole>;
1397};
1398
1399export type CreateUserInput = {
1400  data?: Maybe<UserInput>;
1401};
1402
1403export type CreateUserPayload = {
1404  __typename?: 'createUserPayload';
1405  user?: Maybe<UsersPermissionsUser>;
1406};
1407
1408export type DeleteCarInput = {
1409  where?: Maybe<InputId>;
1410};
1411
1412export type DeleteCarPayload = {
1413  __typename?: 'deleteCarPayload';
1414  car?: Maybe<Car>;
1415};
1416
1417export type DeleteEventInput = {
1418  where?: Maybe<InputId>;
1419};
1420
1421export type DeleteEventPayload = {
1422  __typename?: 'deleteEventPayload';
1423  event?: Maybe<Event>;
1424};
1425
1426export type DeleteFileInput = {
1427  where?: Maybe<InputId>;
1428};
1429
1430export type DeleteFilePayload = {
1431  __typename?: 'deleteFilePayload';
1432  file?: Maybe<UploadFile>;
1433};
1434
1435export type DeletePageInput = {
1436  where?: Maybe<InputId>;
1437};
1438
1439export type DeletePagePayload = {
1440  __typename?: 'deletePagePayload';
1441  page?: Maybe<Page>;
1442};
1443
1444export type DeleteRoleInput = {
1445  where?: Maybe<InputId>;
1446};
1447
1448export type DeleteRolePayload = {
1449  __typename?: 'deleteRolePayload';
1450  role?: Maybe<UsersPermissionsRole>;
1451};
1452
1453export type DeleteSettingPayload = {
1454  __typename?: 'deleteSettingPayload';
1455  setting?: Maybe<Settings>;
1456};
1457
1458export type DeleteUserInput = {
1459  where?: Maybe<InputId>;
1460};
1461
1462export type DeleteUserPayload = {
1463  __typename?: 'deleteUserPayload';
1464  user?: Maybe<UsersPermissionsUser>;
1465};
1466
1467export type EditCarInput = {
1468  name?: Maybe<Scalars['String']>;
1469  seats?: Maybe<Scalars['Int']>;
1470  meeting?: Maybe<Scalars['String']>;
1471  departure?: Maybe<Scalars['DateTime']>;
1472  phone_number?: Maybe<Scalars['String']>;
1473  details?: Maybe<Scalars['String']>;
1474  event?: Maybe<Scalars['ID']>;
1475  passengers?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1476  created_by?: Maybe<Scalars['ID']>;
1477  updated_by?: Maybe<Scalars['ID']>;
1478};
1479
1480export type EditComponentPassengerPassengerInput = {
1481  id?: Maybe<Scalars['ID']>;
1482  name?: Maybe<Scalars['String']>;
1483  email?: Maybe<Scalars['String']>;
1484};
1485
1486export type EditEmailTemplateInput = {
1487  sourceCodeToTemplateId?: Maybe<Scalars['Int']>;
1488  design?: Maybe<Scalars['JSON']>;
1489  name?: Maybe<Scalars['String']>;
1490  subject?: Maybe<Scalars['String']>;
1491  bodyHtml?: Maybe<Scalars['String']>;
1492  bodyText?: Maybe<Scalars['String']>;
1493  enabled?: Maybe<Scalars['Boolean']>;
1494  tags?: Maybe<Scalars['JSON']>;
1495  created_by?: Maybe<Scalars['ID']>;
1496  updated_by?: Maybe<Scalars['ID']>;
1497};
1498
1499export type EditEventInput = {
1500  name?: Maybe<Scalars['String']>;
1501  email?: Maybe<Scalars['String']>;
1502  date?: Maybe<Scalars['Date']>;
1503  address?: Maybe<Scalars['String']>;
1504  cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
1505  position?: Maybe<Scalars['JSON']>;
1506  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1507  uuid?: Maybe<Scalars['String']>;
1508  waitingList?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1509  created_by?: Maybe<Scalars['ID']>;
1510  updated_by?: Maybe<Scalars['ID']>;
1511};
1512
1513export type EditFileInput = {
1514  name?: Maybe<Scalars['String']>;
1515  alternativeText?: Maybe<Scalars['String']>;
1516  caption?: Maybe<Scalars['String']>;
1517  width?: Maybe<Scalars['Int']>;
1518  height?: Maybe<Scalars['Int']>;
1519  formats?: Maybe<Scalars['JSON']>;
1520  hash?: Maybe<Scalars['String']>;
1521  ext?: Maybe<Scalars['String']>;
1522  mime?: Maybe<Scalars['String']>;
1523  size?: Maybe<Scalars['Float']>;
1524  url?: Maybe<Scalars['String']>;
1525  previewUrl?: Maybe<Scalars['String']>;
1526  provider?: Maybe<Scalars['String']>;
1527  provider_metadata?: Maybe<Scalars['JSON']>;
1528  related?: Maybe<Array<Maybe<Scalars['ID']>>>;
1529  created_by?: Maybe<Scalars['ID']>;
1530  updated_by?: Maybe<Scalars['ID']>;
1531};
1532
1533export type EditPageInput = {
1534  name?: Maybe<Scalars['String']>;
1535  content?: Maybe<Scalars['String']>;
1536  type?: Maybe<Enum_Page_Type>;
1537  created_by?: Maybe<Scalars['ID']>;
1538  updated_by?: Maybe<Scalars['ID']>;
1539};
1540
1541export type EditRoleInput = {
1542  name?: Maybe<Scalars['String']>;
1543  description?: Maybe<Scalars['String']>;
1544  type?: Maybe<Scalars['String']>;
1545  permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
1546  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1547  created_by?: Maybe<Scalars['ID']>;
1548  updated_by?: Maybe<Scalars['ID']>;
1549};
1550
1551export type EditSettingInput = {
1552  gtm_id?: Maybe<Scalars['String']>;
1553  about_link?: Maybe<Scalars['String']>;
1554  created_by?: Maybe<Scalars['ID']>;
1555  updated_by?: Maybe<Scalars['ID']>;
1556};
1557
1558export type EditUserInput = {
1559  username?: Maybe<Scalars['String']>;
1560  firstName?: Maybe<Scalars['String']>;
1561  lastName?: Maybe<Scalars['String']>;
1562  email?: Maybe<Scalars['String']>;
1563  provider?: Maybe<Scalars['String']>;
1564  password?: Maybe<Scalars['String']>;
1565  resetPasswordToken?: Maybe<Scalars['String']>;
1566  confirmed?: Maybe<Scalars['Boolean']>;
1567  blocked?: Maybe<Scalars['Boolean']>;
1568  role?: Maybe<Scalars['ID']>;
1569  confirmationToken?: Maybe<Scalars['String']>;
1570  events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1571  onboardingUser?: Maybe<Scalars['Boolean']>;
1572  onboardingCreator?: Maybe<Scalars['Boolean']>;
1573  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1574  created_by?: Maybe<Scalars['ID']>;
1575  updated_by?: Maybe<Scalars['ID']>;
1576  old_password?: Maybe<Scalars['String']>;
1577};
1578
1579export type UpdateCarInput = {
1580  where?: Maybe<InputId>;
1581  data?: Maybe<EditCarInput>;
1582};
1583
1584export type UpdateCarPayload = {
1585  __typename?: 'updateCarPayload';
1586  car?: Maybe<Car>;
1587};
1588
1589export type UpdateEventByUuidInput = {
1590  where?: Maybe<InputUuid>;
1591  data?: Maybe<EditEventInput>;
1592};
1593
1594export type UpdateEventInput = {
1595  where?: Maybe<InputId>;
1596  data?: Maybe<EditEventInput>;
1597};
1598
1599export type UpdateEventPayload = {
1600  __typename?: 'updateEventPayload';
1601  event?: Maybe<Event>;
1602};
1603
1604export type UpdatePageInput = {
1605  where?: Maybe<InputId>;
1606  data?: Maybe<EditPageInput>;
1607};
1608
1609export type UpdatePagePayload = {
1610  __typename?: 'updatePagePayload';
1611  page?: Maybe<Page>;
1612};
1613
1614export type UpdateRoleInput = {
1615  where?: Maybe<InputId>;
1616  data?: Maybe<EditRoleInput>;
1617};
1618
1619export type UpdateRolePayload = {
1620  __typename?: 'updateRolePayload';
1621  role?: Maybe<UsersPermissionsRole>;
1622};
1623
1624export type UpdateSettingInput = {
1625  data?: Maybe<EditSettingInput>;
1626};
1627
1628export type UpdateSettingPayload = {
1629  __typename?: 'updateSettingPayload';
1630  setting?: Maybe<Settings>;
1631};
1632
1633export type UpdateUserInput = {
1634  where?: Maybe<InputId>;
1635  data?: Maybe<EditUserInput>;
1636};
1637
1638export type UpdateUserPayload = {
1639  __typename?: 'updateUserPayload';
1640  user?: Maybe<UsersPermissionsUser>;
1641};
1642
1643export type MeFieldsFragment = (
1644  { __typename?: 'UsersPermissionsMe' }
1645  & Pick<UsersPermissionsMe, 'id' | 'username' | 'email' | 'confirmed'>
1646);
1647
1648export type RegisterMutationVariables = Exact<{
1649  email: Scalars['String'];
1650  password: Scalars['String'];
1651  username: Scalars['String'];
1652}>;
1653
1654
1655export type RegisterMutation = (
1656  { __typename?: 'Mutation' }
1657  & { register: (
1658    { __typename?: 'UsersPermissionsLoginPayload' }
1659    & Pick<UsersPermissionsLoginPayload, 'jwt'>
1660    & { user: (
1661      { __typename?: 'UsersPermissionsMe' }
1662      & MeFieldsFragment
1663    ) }
1664  ) }
1665);
1666
1667export type LoginMutationVariables = Exact<{
1668  identifier: Scalars['String'];
1669  password: Scalars['String'];
1670}>;
1671
1672
1673export type LoginMutation = (
1674  { __typename?: 'Mutation' }
1675  & { login: (
1676    { __typename?: 'UsersPermissionsLoginPayload' }
1677    & Pick<UsersPermissionsLoginPayload, 'jwt'>
1678    & { user: (
1679      { __typename?: 'UsersPermissionsMe' }
1680      & MeFieldsFragment
1681    ) }
1682  ) }
1683);
1684
1685export type ForgotPasswordMutationVariables = Exact<{
1686  email: Scalars['String'];
1687}>;
1688
1689
1690export type ForgotPasswordMutation = (
1691  { __typename?: 'Mutation' }
1692  & { forgotPassword?: Maybe<(
1693    { __typename?: 'UserPermissionsPasswordPayload' }
1694    & Pick<UserPermissionsPasswordPayload, 'ok'>
1695  )> }
1696);
1697
1698export type ResetPasswordMutationVariables = Exact<{
1699  password: Scalars['String'];
1700  passwordConfirmation: Scalars['String'];
1701  code: Scalars['String'];
1702}>;
1703
1704
1705export type ResetPasswordMutation = (
1706  { __typename?: 'Mutation' }
1707  & { resetPassword?: Maybe<(
1708    { __typename?: 'UsersPermissionsLoginPayload' }
1709    & Pick<UsersPermissionsLoginPayload, 'jwt'>
1710    & { user: (
1711      { __typename?: 'UsersPermissionsMe' }
1712      & MeFieldsFragment
1713    ) }
1714  )> }
1715);
1716
1717export type CarFieldsFragment = (
1718  { __typename?: 'Car' }
1719  & Pick<Car, 'id' | 'name' | 'seats' | 'meeting' | 'departure' | 'phone_number' | 'details'>
1720  & { passengers?: Maybe<Array<Maybe<(
1721    { __typename?: 'ComponentPassengerPassenger' }
1722    & Pick<ComponentPassengerPassenger, 'id' | 'name'>
1723  )>>>, event?: Maybe<(
1724    { __typename?: 'Event' }
1725    & Pick<Event, 'id' | 'name'>
1726  )> }
1727);
1728
1729export type CreateCarMutationVariables = Exact<{
1730  car: CarInput;
1731}>;
1732
1733
1734export type CreateCarMutation = (
1735  { __typename?: 'Mutation' }
1736  & { createCar?: Maybe<(
1737    { __typename?: 'createCarPayload' }
1738    & { car?: Maybe<(
1739      { __typename?: 'Car' }
1740      & CarFieldsFragment
1741    )> }
1742  )> }
1743);
1744
1745export type UpdateCarMutationVariables = Exact<{
1746  id: Scalars['ID'];
1747  carUpdate: EditCarInput;
1748}>;
1749
1750
1751export type UpdateCarMutation = (
1752  { __typename?: 'Mutation' }
1753  & { updateCar?: Maybe<(
1754    { __typename?: 'updateCarPayload' }
1755    & { car?: Maybe<(
1756      { __typename?: 'Car' }
1757      & CarFieldsFragment
1758    )> }
1759  )> }
1760);
1761
1762export type DeleteCarMutationVariables = Exact<{
1763  id: Scalars['ID'];
1764}>;
1765
1766
1767export type DeleteCarMutation = (
1768  { __typename?: 'Mutation' }
1769  & { deleteCar?: Maybe<(
1770    { __typename?: 'deleteCarPayload' }
1771    & { car?: Maybe<(
1772      { __typename?: 'Car' }
1773      & Pick<Car, 'id' | 'name'>
1774    )> }
1775  )> }
1776);
1777
1778export type EventFieldsFragment = (
1779  { __typename?: 'Event' }
1780  & Pick<Event, 'id' | 'uuid' | 'name' | 'email' | 'date' | 'address' | 'position'>
1781  & { waitingList?: Maybe<Array<Maybe<(
1782    { __typename?: 'ComponentPassengerPassenger' }
1783    & Pick<ComponentPassengerPassenger, 'id' | 'name'>
1784  )>>>, cars?: Maybe<Array<Maybe<(
1785    { __typename?: 'Car' }
1786    & Pick<Car, 'id' | 'name' | 'seats' | 'meeting' | 'departure' | 'details' | 'phone_number'>
1787    & { passengers?: Maybe<Array<Maybe<(
1788      { __typename?: 'ComponentPassengerPassenger' }
1789      & Pick<ComponentPassengerPassenger, 'id' | 'name'>
1790    )>>> }
1791  )>>> }
1792);
1793
1794export type CreateEventMutationVariables = Exact<{
1795  name: Scalars['String'];
1796  email: Scalars['String'];
1797  date?: Maybe<Scalars['Date']>;
1798  address?: Maybe<Scalars['String']>;
1799  newsletter?: Maybe<Scalars['Boolean']>;
1800}>;
1801
1802
1803export type CreateEventMutation = (
1804  { __typename?: 'Mutation' }
1805  & { createEvent?: Maybe<(
1806    { __typename?: 'createEventPayload' }
1807    & { event?: Maybe<(
1808      { __typename?: 'Event' }
1809      & EventFieldsFragment
1810    )> }
1811  )> }
1812);
1813
1814export type UpdateEventMutationVariables = Exact<{
1815  uuid: Scalars['String'];
1816  eventUpdate?: Maybe<EditEventInput>;
1817}>;
1818
1819
1820export type UpdateEventMutation = (
1821  { __typename?: 'Mutation' }
1822  & { updateEventByUUID?: Maybe<(
1823    { __typename?: 'updateEventPayload' }
1824    & { event?: Maybe<(
1825      { __typename?: 'Event' }
1826      & EventFieldsFragment
1827    )> }
1828  )> }
1829);
1830
1831export type EventByUuidQueryVariables = Exact<{
1832  uuid: Scalars['String'];
1833}>;
1834
1835
1836export type EventByUuidQuery = (
1837  { __typename?: 'Query' }
1838  & { eventByUUID?: Maybe<(
1839    { __typename?: 'Event' }
1840    & EventFieldsFragment
1841  )> }
1842);
1843
1844export type SettingQueryVariables = Exact<{ [key: string]: never; }>;
1845
1846
1847export type SettingQuery = (
1848  { __typename?: 'Query' }
1849  & { setting?: Maybe<(
1850    { __typename?: 'Settings' }
1851    & Pick<Settings, 'id' | 'gtm_id' | 'about_link'>
1852  )> }
1853);
1854
1855export type UserFieldsFragment = (
1856  { __typename?: 'UsersPermissionsUser' }
1857  & Pick<UsersPermissionsUser, 'id' | 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName' | 'lang'>
1858  & { events?: Maybe<Array<Maybe<(
1859    { __typename?: 'Event' }
1860    & Pick<Event, 'id' | 'uuid' | 'name' | 'date' | 'address'>
1861  )>>> }
1862);
1863
1864export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
1865
1866
1867export type ProfileQuery = (
1868  { __typename?: 'Query' }
1869  & { me?: Maybe<(
1870    { __typename?: 'UsersPermissionsMe' }
1871    & Pick<UsersPermissionsMe, 'id' | 'username'>
1872    & { profile?: Maybe<(
1873      { __typename?: 'UsersPermissionsUser' }
1874      & UserFieldsFragment
1875    )> }
1876  )> }
1877);
1878
1879export type UpdateMeMutationVariables = Exact<{
1880  userUpdate: EditUserInput;
1881}>;
1882
1883
1884export type UpdateMeMutation = (
1885  { __typename?: 'Mutation' }
1886  & { updateMe: (
1887    { __typename?: 'updateUserPayload' }
1888    & { user?: Maybe<(
1889      { __typename?: 'UsersPermissionsUser' }
1890      & UserFieldsFragment
1891    )> }
1892  ) }
1893);
1894
1895export const MeFieldsFragmentDoc = gql`
1896    fragment MeFields on UsersPermissionsMe {
1897  id
1898  username
1899  email
1900  confirmed
1901}
1902    `;
1903export const CarFieldsFragmentDoc = gql`
1904    fragment CarFields on Car {
1905  id
1906  name
1907  seats
1908  meeting
1909  departure
1910  phone_number
1911  details
1912  passengers {
1913    id
1914    name
1915  }
1916  event {
1917    id
1918    name
1919  }
1920}
1921    `;
1922export const EventFieldsFragmentDoc = gql`
1923    fragment EventFields on Event {
1924  id
1925  uuid
1926  name
1927  email
1928  date
1929  address
1930  position
1931  waitingList {
1932    id
1933    name
1934  }
1935  cars {
1936    id
1937    name
1938    seats
1939    meeting
1940    departure
1941    details
1942    phone_number
1943    passengers {
1944      id
1945      name
1946    }
1947  }
1948}
1949    `;
1950export const UserFieldsFragmentDoc = gql`
1951    fragment UserFields on UsersPermissionsUser {
1952  id
1953  username
1954  email
1955  confirmed
1956  lastName
1957  firstName
1958  lang
1959  events {
1960    id
1961    uuid
1962    name
1963    date
1964    address
1965  }
1966}
1967    `;
1968export const RegisterDocument = gql`
1969    mutation register($email: String!, $password: String!, $username: String!) {
1970  register(input: {email: $email, password: $password, username: $username}) {
1971    jwt
1972    user {
1973      ...MeFields
1974    }
1975  }
1976}
1977    ${MeFieldsFragmentDoc}`;
1978export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
1979
1980/**
1981 * __useRegisterMutation__
1982 *
1983 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
1984 * When your component renders, `useRegisterMutation` returns a tuple that includes:
1985 * - A mutate function that you can call at any time to execute the mutation
1986 * - An object with fields that represent the current status of the mutation's execution
1987 *
1988 * @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;
1989 *
1990 * @example
1991 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
1992 *   variables: {
1993 *      email: // value for 'email'
1994 *      password: // value for 'password'
1995 *      username: // value for 'username'
1996 *   },
1997 * });
1998 */
1999export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
2000        return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
2001      }
2002export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
2003export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
2004export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
2005export const LoginDocument = gql`
2006    mutation login($identifier: String!, $password: String!) {
2007  login(input: {identifier: $identifier, password: $password}) {
2008    jwt
2009    user {
2010      ...MeFields
2011    }
2012  }
2013}
2014    ${MeFieldsFragmentDoc}`;
2015export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
2016
2017/**
2018 * __useLoginMutation__
2019 *
2020 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
2021 * When your component renders, `useLoginMutation` returns a tuple that includes:
2022 * - A mutate function that you can call at any time to execute the mutation
2023 * - An object with fields that represent the current status of the mutation's execution
2024 *
2025 * @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;
2026 *
2027 * @example
2028 * const [loginMutation, { data, loading, error }] = useLoginMutation({
2029 *   variables: {
2030 *      identifier: // value for 'identifier'
2031 *      password: // value for 'password'
2032 *   },
2033 * });
2034 */
2035export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
2036        return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
2037      }
2038export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
2039export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
2040export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
2041export const ForgotPasswordDocument = gql`
2042    mutation forgotPassword($email: String!) {
2043  forgotPassword(email: $email) {
2044    ok
2045  }
2046}
2047    `;
2048export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2049
2050/**
2051 * __useForgotPasswordMutation__
2052 *
2053 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
2054 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
2055 * - A mutate function that you can call at any time to execute the mutation
2056 * - An object with fields that represent the current status of the mutation's execution
2057 *
2058 * @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;
2059 *
2060 * @example
2061 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
2062 *   variables: {
2063 *      email: // value for 'email'
2064 *   },
2065 * });
2066 */
2067export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
2068        return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
2069      }
2070export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
2071export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
2072export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2073export const ResetPasswordDocument = gql`
2074    mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
2075  resetPassword(
2076    password: $password
2077    passwordConfirmation: $passwordConfirmation
2078    code: $code
2079  ) {
2080    jwt
2081    user {
2082      ...MeFields
2083    }
2084  }
2085}
2086    ${MeFieldsFragmentDoc}`;
2087export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
2088
2089/**
2090 * __useResetPasswordMutation__
2091 *
2092 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
2093 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
2094 * - A mutate function that you can call at any time to execute the mutation
2095 * - An object with fields that represent the current status of the mutation's execution
2096 *
2097 * @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;
2098 *
2099 * @example
2100 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
2101 *   variables: {
2102 *      password: // value for 'password'
2103 *      passwordConfirmation: // value for 'passwordConfirmation'
2104 *      code: // value for 'code'
2105 *   },
2106 * });
2107 */
2108export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
2109        return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
2110      }
2111export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
2112export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
2113export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
2114export const CreateCarDocument = gql`
2115    mutation createCar($car: CarInput!) {
2116  createCar(input: {data: $car}) {
2117    car {
2118      ...CarFields
2119    }
2120  }
2121}
2122    ${CarFieldsFragmentDoc}`;
2123export type CreateCarMutationFn = Apollo.MutationFunction<CreateCarMutation, CreateCarMutationVariables>;
2124
2125/**
2126 * __useCreateCarMutation__
2127 *
2128 * To run a mutation, you first call `useCreateCarMutation` within a React component and pass it any options that fit your needs.
2129 * When your component renders, `useCreateCarMutation` returns a tuple that includes:
2130 * - A mutate function that you can call at any time to execute the mutation
2131 * - An object with fields that represent the current status of the mutation's execution
2132 *
2133 * @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;
2134 *
2135 * @example
2136 * const [createCarMutation, { data, loading, error }] = useCreateCarMutation({
2137 *   variables: {
2138 *      car: // value for 'car'
2139 *   },
2140 * });
2141 */
2142export function useCreateCarMutation(baseOptions?: Apollo.MutationHookOptions<CreateCarMutation, CreateCarMutationVariables>) {
2143        return Apollo.useMutation<CreateCarMutation, CreateCarMutationVariables>(CreateCarDocument, baseOptions);
2144      }
2145export type CreateCarMutationHookResult = ReturnType<typeof useCreateCarMutation>;
2146export type CreateCarMutationResult = Apollo.MutationResult<CreateCarMutation>;
2147export type CreateCarMutationOptions = Apollo.BaseMutationOptions<CreateCarMutation, CreateCarMutationVariables>;
2148export const UpdateCarDocument = gql`
2149    mutation updateCar($id: ID!, $carUpdate: editCarInput!) {
2150  updateCar(input: {where: {id: $id}, data: $carUpdate}) {
2151    car {
2152      ...CarFields
2153    }
2154  }
2155}
2156    ${CarFieldsFragmentDoc}`;
2157export type UpdateCarMutationFn = Apollo.MutationFunction<UpdateCarMutation, UpdateCarMutationVariables>;
2158
2159/**
2160 * __useUpdateCarMutation__
2161 *
2162 * To run a mutation, you first call `useUpdateCarMutation` within a React component and pass it any options that fit your needs.
2163 * When your component renders, `useUpdateCarMutation` returns a tuple that includes:
2164 * - A mutate function that you can call at any time to execute the mutation
2165 * - An object with fields that represent the current status of the mutation's execution
2166 *
2167 * @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;
2168 *
2169 * @example
2170 * const [updateCarMutation, { data, loading, error }] = useUpdateCarMutation({
2171 *   variables: {
2172 *      id: // value for 'id'
2173 *      carUpdate: // value for 'carUpdate'
2174 *   },
2175 * });
2176 */
2177export function useUpdateCarMutation(baseOptions?: Apollo.MutationHookOptions<UpdateCarMutation, UpdateCarMutationVariables>) {
2178        return Apollo.useMutation<UpdateCarMutation, UpdateCarMutationVariables>(UpdateCarDocument, baseOptions);
2179      }
2180export type UpdateCarMutationHookResult = ReturnType<typeof useUpdateCarMutation>;
2181export type UpdateCarMutationResult = Apollo.MutationResult<UpdateCarMutation>;
2182export type UpdateCarMutationOptions = Apollo.BaseMutationOptions<UpdateCarMutation, UpdateCarMutationVariables>;
2183export const DeleteCarDocument = gql`
2184    mutation deleteCar($id: ID!) {
2185  deleteCar(input: {where: {id: $id}}) {
2186    car {
2187      id
2188      name
2189    }
2190  }
2191}
2192    `;
2193export type DeleteCarMutationFn = Apollo.MutationFunction<DeleteCarMutation, DeleteCarMutationVariables>;
2194
2195/**
2196 * __useDeleteCarMutation__
2197 *
2198 * To run a mutation, you first call `useDeleteCarMutation` within a React component and pass it any options that fit your needs.
2199 * When your component renders, `useDeleteCarMutation` returns a tuple that includes:
2200 * - A mutate function that you can call at any time to execute the mutation
2201 * - An object with fields that represent the current status of the mutation's execution
2202 *
2203 * @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;
2204 *
2205 * @example
2206 * const [deleteCarMutation, { data, loading, error }] = useDeleteCarMutation({
2207 *   variables: {
2208 *      id: // value for 'id'
2209 *   },
2210 * });
2211 */
2212export function useDeleteCarMutation(baseOptions?: Apollo.MutationHookOptions<DeleteCarMutation, DeleteCarMutationVariables>) {
2213        return Apollo.useMutation<DeleteCarMutation, DeleteCarMutationVariables>(DeleteCarDocument, baseOptions);
2214      }
2215export type DeleteCarMutationHookResult = ReturnType<typeof useDeleteCarMutation>;
2216export type DeleteCarMutationResult = Apollo.MutationResult<DeleteCarMutation>;
2217export type DeleteCarMutationOptions = Apollo.BaseMutationOptions<DeleteCarMutation, DeleteCarMutationVariables>;
2218export const CreateEventDocument = gql`
2219    mutation createEvent($name: String!, $email: String!, $date: Date, $address: String, $newsletter: Boolean) {
2220  createEvent(
2221    input: {data: {name: $name, email: $email, date: $date, address: $address, newsletter: $newsletter}}
2222  ) {
2223    event {
2224      ...EventFields
2225    }
2226  }
2227}
2228    ${EventFieldsFragmentDoc}`;
2229export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2230
2231/**
2232 * __useCreateEventMutation__
2233 *
2234 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2235 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2236 * - A mutate function that you can call at any time to execute the mutation
2237 * - An object with fields that represent the current status of the mutation's execution
2238 *
2239 * @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;
2240 *
2241 * @example
2242 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2243 *   variables: {
2244 *      name: // value for 'name'
2245 *      email: // value for 'email'
2246 *      date: // value for 'date'
2247 *      address: // value for 'address'
2248 *      newsletter: // value for 'newsletter'
2249 *   },
2250 * });
2251 */
2252export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2253        return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2254      }
2255export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2256export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2257export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2258export const UpdateEventDocument = gql`
2259    mutation updateEvent($uuid: String!, $eventUpdate: editEventInput) {
2260  updateEventByUUID(input: {where: {uuid: $uuid}, data: $eventUpdate}) {
2261    event {
2262      ...EventFields
2263    }
2264  }
2265}
2266    ${EventFieldsFragmentDoc}`;
2267export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2268
2269/**
2270 * __useUpdateEventMutation__
2271 *
2272 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2273 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2274 * - A mutate function that you can call at any time to execute the mutation
2275 * - An object with fields that represent the current status of the mutation's execution
2276 *
2277 * @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;
2278 *
2279 * @example
2280 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2281 *   variables: {
2282 *      uuid: // value for 'uuid'
2283 *      eventUpdate: // value for 'eventUpdate'
2284 *   },
2285 * });
2286 */
2287export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2288        return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2289      }
2290export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2291export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2292export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2293export const EventByUuidDocument = gql`
2294    query eventByUUID($uuid: String!) {
2295  eventByUUID(uuid: $uuid) {
2296    ...EventFields
2297  }
2298}
2299    ${EventFieldsFragmentDoc}`;
2300
2301/**
2302 * __useEventByUuidQuery__
2303 *
2304 * To run a query within a React component, call `useEventByUuidQuery` and pass it any options that fit your needs.
2305 * When your component renders, `useEventByUuidQuery` returns an object from Apollo Client that contains loading, error, and data properties
2306 * you can use to render your UI.
2307 *
2308 * @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;
2309 *
2310 * @example
2311 * const { data, loading, error } = useEventByUuidQuery({
2312 *   variables: {
2313 *      uuid: // value for 'uuid'
2314 *   },
2315 * });
2316 */
2317export function useEventByUuidQuery(baseOptions: Apollo.QueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2318        return Apollo.useQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2319      }
2320export function useEventByUuidLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2321          return Apollo.useLazyQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2322        }
2323export type EventByUuidQueryHookResult = ReturnType<typeof useEventByUuidQuery>;
2324export type EventByUuidLazyQueryHookResult = ReturnType<typeof useEventByUuidLazyQuery>;
2325export type EventByUuidQueryResult = Apollo.QueryResult<EventByUuidQuery, EventByUuidQueryVariables>;
2326export const SettingDocument = gql`
2327    query setting {
2328  setting {
2329    id
2330    gtm_id
2331    about_link
2332  }
2333}
2334    `;
2335
2336/**
2337 * __useSettingQuery__
2338 *
2339 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2340 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2341 * you can use to render your UI.
2342 *
2343 * @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;
2344 *
2345 * @example
2346 * const { data, loading, error } = useSettingQuery({
2347 *   variables: {
2348 *   },
2349 * });
2350 */
2351export function useSettingQuery(baseOptions?: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2352        return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2353      }
2354export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2355          return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2356        }
2357export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2358export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2359export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2360export const ProfileDocument = gql`
2361    query profile {
2362  me {
2363    id
2364    username
2365    profile {
2366      ...UserFields
2367    }
2368  }
2369}
2370    ${UserFieldsFragmentDoc}`;
2371
2372/**
2373 * __useProfileQuery__
2374 *
2375 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2376 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2377 * you can use to render your UI.
2378 *
2379 * @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;
2380 *
2381 * @example
2382 * const { data, loading, error } = useProfileQuery({
2383 *   variables: {
2384 *   },
2385 * });
2386 */
2387export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2388        return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2389      }
2390export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2391          return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2392        }
2393export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2394export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2395export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2396export const UpdateMeDocument = gql`
2397    mutation updateMe($userUpdate: editUserInput!) {
2398  updateMe(input: $userUpdate) {
2399    user {
2400      ...UserFields
2401    }
2402  }
2403}
2404    ${UserFieldsFragmentDoc}`;
2405export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2406
2407/**
2408 * __useUpdateMeMutation__
2409 *
2410 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2411 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2412 * - A mutate function that you can call at any time to execute the mutation
2413 * - An object with fields that represent the current status of the mutation's execution
2414 *
2415 * @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;
2416 *
2417 * @example
2418 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2419 *   variables: {
2420 *      userUpdate: // value for 'userUpdate'
2421 *   },
2422 * });
2423 */
2424export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2425        return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2426      }
2427export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2428export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2429export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;