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