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