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