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  user?: Maybe<UsersPermissionsUser>;
  50};
  51
  52export type CarAggregator = {
  53  __typename?: 'CarAggregator';
  54  count?: Maybe<Scalars['Int']>;
  55  totalCount?: Maybe<Scalars['Int']>;
  56  sum?: Maybe<CarAggregatorSum>;
  57  avg?: Maybe<CarAggregatorAvg>;
  58  min?: Maybe<CarAggregatorMin>;
  59  max?: Maybe<CarAggregatorMax>;
  60};
  61
  62export type CarAggregatorAvg = {
  63  __typename?: 'CarAggregatorAvg';
  64  seats?: Maybe<Scalars['Float']>;
  65};
  66
  67export type CarAggregatorMax = {
  68  __typename?: 'CarAggregatorMax';
  69  seats?: Maybe<Scalars['Float']>;
  70};
  71
  72export type CarAggregatorMin = {
  73  __typename?: 'CarAggregatorMin';
  74  seats?: Maybe<Scalars['Float']>;
  75};
  76
  77export type CarAggregatorSum = {
  78  __typename?: 'CarAggregatorSum';
  79  seats?: Maybe<Scalars['Float']>;
  80};
  81
  82export type CarConnection = {
  83  __typename?: 'CarConnection';
  84  values?: Maybe<Array<Maybe<Car>>>;
  85  groupBy?: Maybe<CarGroupBy>;
  86  aggregate?: Maybe<CarAggregator>;
  87};
  88
  89export type CarConnectionCreated_At = {
  90  __typename?: 'CarConnectionCreated_at';
  91  key?: Maybe<Scalars['DateTime']>;
  92  connection?: Maybe<CarConnection>;
  93};
  94
  95export type CarConnectionDeparture = {
  96  __typename?: 'CarConnectionDeparture';
  97  key?: Maybe<Scalars['DateTime']>;
  98  connection?: Maybe<CarConnection>;
  99};
 100
 101export type CarConnectionDetails = {
 102  __typename?: 'CarConnectionDetails';
 103  key?: Maybe<Scalars['String']>;
 104  connection?: Maybe<CarConnection>;
 105};
 106
 107export type CarConnectionEvent = {
 108  __typename?: 'CarConnectionEvent';
 109  key?: Maybe<Scalars['ID']>;
 110  connection?: Maybe<CarConnection>;
 111};
 112
 113export type CarConnectionId = {
 114  __typename?: 'CarConnectionId';
 115  key?: Maybe<Scalars['ID']>;
 116  connection?: Maybe<CarConnection>;
 117};
 118
 119export type CarConnectionMeeting = {
 120  __typename?: 'CarConnectionMeeting';
 121  key?: Maybe<Scalars['String']>;
 122  connection?: Maybe<CarConnection>;
 123};
 124
 125export type CarConnectionName = {
 126  __typename?: 'CarConnectionName';
 127  key?: Maybe<Scalars['String']>;
 128  connection?: Maybe<CarConnection>;
 129};
 130
 131export type CarConnectionPhone_Number = {
 132  __typename?: 'CarConnectionPhone_number';
 133  key?: Maybe<Scalars['String']>;
 134  connection?: Maybe<CarConnection>;
 135};
 136
 137export type CarConnectionSeats = {
 138  __typename?: 'CarConnectionSeats';
 139  key?: Maybe<Scalars['Int']>;
 140  connection?: Maybe<CarConnection>;
 141};
 142
 143export type CarConnectionUpdated_At = {
 144  __typename?: 'CarConnectionUpdated_at';
 145  key?: Maybe<Scalars['DateTime']>;
 146  connection?: Maybe<CarConnection>;
 147};
 148
 149export type CarConnectionUser = {
 150  __typename?: 'CarConnectionUser';
 151  key?: Maybe<Scalars['ID']>;
 152  connection?: Maybe<CarConnection>;
 153};
 154
 155export type CarGroupBy = {
 156  __typename?: 'CarGroupBy';
 157  id?: Maybe<Array<Maybe<CarConnectionId>>>;
 158  created_at?: Maybe<Array<Maybe<CarConnectionCreated_At>>>;
 159  updated_at?: Maybe<Array<Maybe<CarConnectionUpdated_At>>>;
 160  name?: Maybe<Array<Maybe<CarConnectionName>>>;
 161  seats?: Maybe<Array<Maybe<CarConnectionSeats>>>;
 162  meeting?: Maybe<Array<Maybe<CarConnectionMeeting>>>;
 163  departure?: Maybe<Array<Maybe<CarConnectionDeparture>>>;
 164  phone_number?: Maybe<Array<Maybe<CarConnectionPhone_Number>>>;
 165  details?: Maybe<Array<Maybe<CarConnectionDetails>>>;
 166  event?: Maybe<Array<Maybe<CarConnectionEvent>>>;
 167  user?: Maybe<Array<Maybe<CarConnectionUser>>>;
 168};
 169
 170export type CarInput = {
 171  name: Scalars['String'];
 172  seats: Scalars['Int'];
 173  meeting?: Maybe<Scalars['String']>;
 174  departure?: Maybe<Scalars['DateTime']>;
 175  phone_number?: Maybe<Scalars['String']>;
 176  details?: Maybe<Scalars['String']>;
 177  event?: Maybe<Scalars['ID']>;
 178  passengers?: Maybe<Array<Maybe<ComponentPassengerPassengerInput>>>;
 179  user?: Maybe<Scalars['ID']>;
 180  created_by?: Maybe<Scalars['ID']>;
 181  updated_by?: Maybe<Scalars['ID']>;
 182};
 183
 184export type ComponentPassengerPassenger = {
 185  __typename?: 'ComponentPassengerPassenger';
 186  id: Scalars['ID'];
 187  name: Scalars['String'];
 188  email?: Maybe<Scalars['String']>;
 189  location?: Maybe<Scalars['String']>;
 190  user?: Maybe<UsersPermissionsUser>;
 191};
 192
 193export type ComponentPassengerPassengerInput = {
 194  name: Scalars['String'];
 195  email?: Maybe<Scalars['String']>;
 196  location?: Maybe<Scalars['String']>;
 197  user?: Maybe<Scalars['ID']>;
 198};
 199
 200
 201
 202export type Dependency = {
 203  __typename?: 'Dependency';
 204  name: Scalars['String'];
 205  version: Scalars['String'];
 206};
 207
 208export enum Enum_Page_Type {
 209  Tos = 'tos'
 210}
 211
 212export enum Enum_Userspermissionsuser_Lang {
 213  Fr = 'FR',
 214  En = 'EN'
 215}
 216
 217export type EmailDesignerEmailTemplate = {
 218  __typename?: 'EmailDesignerEmailTemplate';
 219  id: Scalars['ID'];
 220  created_at: Scalars['DateTime'];
 221  updated_at: Scalars['DateTime'];
 222  sourceCodeToTemplateId?: Maybe<Scalars['Int']>;
 223  design?: Maybe<Scalars['JSON']>;
 224  name?: Maybe<Scalars['String']>;
 225  subject?: Maybe<Scalars['String']>;
 226  bodyHtml?: Maybe<Scalars['String']>;
 227  bodyText?: Maybe<Scalars['String']>;
 228  enabled?: Maybe<Scalars['Boolean']>;
 229  tags?: Maybe<Scalars['JSON']>;
 230};
 231
 232export type EmailTemplateInput = {
 233  sourceCodeToTemplateId?: Maybe<Scalars['Int']>;
 234  design?: Maybe<Scalars['JSON']>;
 235  name?: Maybe<Scalars['String']>;
 236  subject?: Maybe<Scalars['String']>;
 237  bodyHtml?: Maybe<Scalars['String']>;
 238  bodyText?: Maybe<Scalars['String']>;
 239  enabled?: Maybe<Scalars['Boolean']>;
 240  tags?: Maybe<Scalars['JSON']>;
 241  created_by?: Maybe<Scalars['ID']>;
 242  updated_by?: Maybe<Scalars['ID']>;
 243};
 244
 245export type Event = {
 246  __typename?: 'Event';
 247  id: Scalars['ID'];
 248  created_at: Scalars['DateTime'];
 249  updated_at: Scalars['DateTime'];
 250  name: Scalars['String'];
 251  email: Scalars['String'];
 252  date?: Maybe<Scalars['Date']>;
 253  address?: Maybe<Scalars['String']>;
 254  position?: Maybe<Scalars['JSON']>;
 255  uuid?: Maybe<Scalars['String']>;
 256  waitingList?: Maybe<Array<Maybe<ComponentPassengerPassenger>>>;
 257  cars?: Maybe<Array<Maybe<Car>>>;
 258  users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
 259  travels?: Maybe<Array<Maybe<Travel>>>;
 260};
 261
 262
 263export type EventCarsArgs = {
 264  sort?: Maybe<Scalars['String']>;
 265  limit?: Maybe<Scalars['Int']>;
 266  start?: Maybe<Scalars['Int']>;
 267  where?: Maybe<Scalars['JSON']>;
 268};
 269
 270
 271export type EventUsersArgs = {
 272  sort?: Maybe<Scalars['String']>;
 273  limit?: Maybe<Scalars['Int']>;
 274  start?: Maybe<Scalars['Int']>;
 275  where?: Maybe<Scalars['JSON']>;
 276};
 277
 278
 279export type EventTravelsArgs = {
 280  sort?: Maybe<Scalars['String']>;
 281  limit?: Maybe<Scalars['Int']>;
 282  start?: Maybe<Scalars['Int']>;
 283  where?: Maybe<Scalars['JSON']>;
 284};
 285
 286export type EventAggregator = {
 287  __typename?: 'EventAggregator';
 288  count?: Maybe<Scalars['Int']>;
 289  totalCount?: Maybe<Scalars['Int']>;
 290};
 291
 292export type EventConnection = {
 293  __typename?: 'EventConnection';
 294  values?: Maybe<Array<Maybe<Event>>>;
 295  groupBy?: Maybe<EventGroupBy>;
 296  aggregate?: Maybe<EventAggregator>;
 297};
 298
 299export type EventConnectionAddress = {
 300  __typename?: 'EventConnectionAddress';
 301  key?: Maybe<Scalars['String']>;
 302  connection?: Maybe<EventConnection>;
 303};
 304
 305export type EventConnectionCreated_At = {
 306  __typename?: 'EventConnectionCreated_at';
 307  key?: Maybe<Scalars['DateTime']>;
 308  connection?: Maybe<EventConnection>;
 309};
 310
 311export type EventConnectionDate = {
 312  __typename?: 'EventConnectionDate';
 313  key?: Maybe<Scalars['ID']>;
 314  connection?: Maybe<EventConnection>;
 315};
 316
 317export type EventConnectionEmail = {
 318  __typename?: 'EventConnectionEmail';
 319  key?: Maybe<Scalars['String']>;
 320  connection?: Maybe<EventConnection>;
 321};
 322
 323export type EventConnectionId = {
 324  __typename?: 'EventConnectionId';
 325  key?: Maybe<Scalars['ID']>;
 326  connection?: Maybe<EventConnection>;
 327};
 328
 329export type EventConnectionName = {
 330  __typename?: 'EventConnectionName';
 331  key?: Maybe<Scalars['String']>;
 332  connection?: Maybe<EventConnection>;
 333};
 334
 335export type EventConnectionPosition = {
 336  __typename?: 'EventConnectionPosition';
 337  key?: Maybe<Scalars['JSON']>;
 338  connection?: Maybe<EventConnection>;
 339};
 340
 341export type EventConnectionUpdated_At = {
 342  __typename?: 'EventConnectionUpdated_at';
 343  key?: Maybe<Scalars['DateTime']>;
 344  connection?: Maybe<EventConnection>;
 345};
 346
 347export type EventConnectionUuid = {
 348  __typename?: 'EventConnectionUuid';
 349  key?: Maybe<Scalars['String']>;
 350  connection?: Maybe<EventConnection>;
 351};
 352
 353export type EventGroupBy = {
 354  __typename?: 'EventGroupBy';
 355  id?: Maybe<Array<Maybe<EventConnectionId>>>;
 356  created_at?: Maybe<Array<Maybe<EventConnectionCreated_At>>>;
 357  updated_at?: Maybe<Array<Maybe<EventConnectionUpdated_At>>>;
 358  name?: Maybe<Array<Maybe<EventConnectionName>>>;
 359  email?: Maybe<Array<Maybe<EventConnectionEmail>>>;
 360  date?: Maybe<Array<Maybe<EventConnectionDate>>>;
 361  address?: Maybe<Array<Maybe<EventConnectionAddress>>>;
 362  position?: Maybe<Array<Maybe<EventConnectionPosition>>>;
 363  uuid?: Maybe<Array<Maybe<EventConnectionUuid>>>;
 364};
 365
 366export type EventInput = {
 367  name: Scalars['String'];
 368  email: Scalars['String'];
 369  date?: Maybe<Scalars['Date']>;
 370  address?: Maybe<Scalars['String']>;
 371  cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
 372  position?: Maybe<Scalars['JSON']>;
 373  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
 374  uuid?: Maybe<Scalars['String']>;
 375  waitingList?: Maybe<Array<Maybe<ComponentPassengerPassengerInput>>>;
 376  travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
 377  created_by?: Maybe<Scalars['ID']>;
 378  updated_by?: Maybe<Scalars['ID']>;
 379  newsletter?: Maybe<Scalars['Boolean']>;
 380};
 381
 382export type FileInfoInput = {
 383  name?: Maybe<Scalars['String']>;
 384  alternativeText?: Maybe<Scalars['String']>;
 385  caption?: Maybe<Scalars['String']>;
 386};
 387
 388export type FileInput = {
 389  name: Scalars['String'];
 390  alternativeText?: Maybe<Scalars['String']>;
 391  caption?: Maybe<Scalars['String']>;
 392  width?: Maybe<Scalars['Int']>;
 393  height?: Maybe<Scalars['Int']>;
 394  formats?: Maybe<Scalars['JSON']>;
 395  hash: Scalars['String'];
 396  ext?: Maybe<Scalars['String']>;
 397  mime: Scalars['String'];
 398  size: Scalars['Float'];
 399  url: Scalars['String'];
 400  previewUrl?: Maybe<Scalars['String']>;
 401  provider: Scalars['String'];
 402  provider_metadata?: Maybe<Scalars['JSON']>;
 403  related?: Maybe<Array<Maybe<Scalars['ID']>>>;
 404  created_by?: Maybe<Scalars['ID']>;
 405  updated_by?: Maybe<Scalars['ID']>;
 406};
 407
 408export type Info = {
 409  __typename?: 'Info';
 410  appVersion?: Maybe<Scalars['String']>;
 411  host: Scalars['String'];
 412  environment: Scalars['String'];
 413  uuid: Scalars['String'];
 414  launchedAt: Scalars['String'];
 415  cron?: Maybe<Scalars['Boolean']>;
 416  installedPlugins?: Maybe<Array<Maybe<Scalars['String']>>>;
 417  installedMiddlewares?: Maybe<Array<Maybe<Scalars['String']>>>;
 418  name: Scalars['String'];
 419  npmVersion: Scalars['String'];
 420  description: Scalars['String'];
 421  strapiVersion: Scalars['String'];
 422  license: Scalars['String'];
 423  dependencies?: Maybe<Array<Maybe<Dependency>>>;
 424};
 425
 426export type InputId = {
 427  id: Scalars['ID'];
 428};
 429
 430export type InputUuid = {
 431  uuid: Scalars['String'];
 432};
 433
 434
 435
 436export 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 | CarConnectionUser | 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 | Travel | TravelConnection | TravelAggregator | TravelGroupBy | TravelConnectionId | TravelConnectionCreated_At | TravelConnectionUpdated_At | TravelConnectionMeeting | TravelConnectionDeparture | TravelConnectionDetails | TravelConnectionEvent | TravelConnectionVehicle | CreateTravelPayload | UpdateTravelPayload | DeleteTravelPayload | Vehicle | VehicleConnection | VehicleAggregator | VehicleAggregatorSum | VehicleAggregatorAvg | VehicleAggregatorMin | VehicleAggregatorMax | VehicleGroupBy | VehicleConnectionId | VehicleConnectionCreated_At | VehicleConnectionUpdated_At | VehicleConnectionName | VehicleConnectionSeats | VehicleConnectionUser | VehicleConnectionPhone_Number | CreateVehiclePayload | UpdateVehiclePayload | DeleteVehiclePayload | EmailDesignerEmailTemplate | UploadFile | UploadFileConnection | UploadFileAggregator | UploadFileAggregatorSum | UploadFileAggregatorAvg | UploadFileAggregatorMin | UploadFileAggregatorMax | UploadFileGroupBy | UploadFileConnectionId | UploadFileConnectionCreated_At | UploadFileConnectionUpdated_At | UploadFileConnectionName | UploadFileConnectionAlternativeText | UploadFileConnectionCaption | UploadFileConnectionWidth | UploadFileConnectionHeight | UploadFileConnectionFormats | UploadFileConnectionHash | UploadFileConnectionExt | UploadFileConnectionMime | UploadFileConnectionSize | UploadFileConnectionUrl | UploadFileConnectionPreviewUrl | UploadFileConnectionProvider | UploadFileConnectionProvider_Metadata | DeleteFilePayload | UsersPermissionsPermission | UsersPermissionsRole | UsersPermissionsRoleConnection | UsersPermissionsRoleAggregator | UsersPermissionsRoleGroupBy | UsersPermissionsRoleConnectionId | UsersPermissionsRoleConnectionName | UsersPermissionsRoleConnectionDescription | UsersPermissionsRoleConnectionType | CreateRolePayload | UpdateRolePayload | DeleteRolePayload | UsersPermissionsUser | UsersPermissionsUserConnection | UsersPermissionsUserAggregator | UsersPermissionsUserGroupBy | UsersPermissionsUserConnectionId | UsersPermissionsUserConnectionCreated_At | UsersPermissionsUserConnectionUpdated_At | UsersPermissionsUserConnectionUsername | UsersPermissionsUserConnectionFirstName | UsersPermissionsUserConnectionLastName | UsersPermissionsUserConnectionEmail | UsersPermissionsUserConnectionProvider | UsersPermissionsUserConnectionConfirmed | UsersPermissionsUserConnectionBlocked | UsersPermissionsUserConnectionRole | UsersPermissionsUserConnectionOnboardingUser | UsersPermissionsUserConnectionOnboardingCreator | UsersPermissionsUserConnectionLang | CreateUserPayload | UpdateUserPayload | DeleteUserPayload | ComponentPassengerPassenger;
 437
 438export type Mutation = {
 439  __typename?: 'Mutation';
 440  createCar?: Maybe<CreateCarPayload>;
 441  updateCar?: Maybe<UpdateCarPayload>;
 442  deleteCar?: Maybe<DeleteCarPayload>;
 443  createEvent?: Maybe<CreateEventPayload>;
 444  updateEvent?: Maybe<UpdateEventPayload>;
 445  deleteEvent?: Maybe<DeleteEventPayload>;
 446  createPage?: Maybe<CreatePagePayload>;
 447  updatePage?: Maybe<UpdatePagePayload>;
 448  deletePage?: Maybe<DeletePagePayload>;
 449  updateSetting?: Maybe<UpdateSettingPayload>;
 450  deleteSetting?: Maybe<DeleteSettingPayload>;
 451  createTravel?: Maybe<CreateTravelPayload>;
 452  updateTravel?: Maybe<UpdateTravelPayload>;
 453  deleteTravel?: Maybe<DeleteTravelPayload>;
 454  createVehicle?: Maybe<CreateVehiclePayload>;
 455  updateVehicle?: Maybe<UpdateVehiclePayload>;
 456  deleteVehicle?: Maybe<DeleteVehiclePayload>;
 457  /** Delete one file */
 458  deleteFile?: Maybe<DeleteFilePayload>;
 459  /** Create a new role */
 460  createRole?: Maybe<CreateRolePayload>;
 461  /** Update an existing role */
 462  updateRole?: Maybe<UpdateRolePayload>;
 463  /** Delete an existing role */
 464  deleteRole?: Maybe<DeleteRolePayload>;
 465  /** Create a new user */
 466  createUser?: Maybe<CreateUserPayload>;
 467  /** Update an existing user */
 468  updateUser?: Maybe<UpdateUserPayload>;
 469  /** Delete an existing user */
 470  deleteUser?: Maybe<DeleteUserPayload>;
 471  upload: UploadFile;
 472  multipleUpload: Array<Maybe<UploadFile>>;
 473  updateFileInfo: UploadFile;
 474  login: UsersPermissionsLoginPayload;
 475  register: UsersPermissionsLoginPayload;
 476  forgotPassword?: Maybe<UserPermissionsPasswordPayload>;
 477  resetPassword?: Maybe<UsersPermissionsLoginPayload>;
 478  emailConfirmation?: Maybe<UsersPermissionsLoginPayload>;
 479  updateMe: UpdateUserPayload;
 480  updateEventByUUID?: Maybe<UpdateEventPayload>;
 481};
 482
 483
 484export type MutationCreateCarArgs = {
 485  input?: Maybe<CreateCarInput>;
 486};
 487
 488
 489export type MutationUpdateCarArgs = {
 490  input?: Maybe<UpdateCarInput>;
 491};
 492
 493
 494export type MutationDeleteCarArgs = {
 495  input?: Maybe<DeleteCarInput>;
 496};
 497
 498
 499export type MutationCreateEventArgs = {
 500  input?: Maybe<CreateEventInput>;
 501};
 502
 503
 504export type MutationUpdateEventArgs = {
 505  input?: Maybe<UpdateEventInput>;
 506};
 507
 508
 509export type MutationDeleteEventArgs = {
 510  input?: Maybe<DeleteEventInput>;
 511};
 512
 513
 514export type MutationCreatePageArgs = {
 515  input?: Maybe<CreatePageInput>;
 516};
 517
 518
 519export type MutationUpdatePageArgs = {
 520  input?: Maybe<UpdatePageInput>;
 521};
 522
 523
 524export type MutationDeletePageArgs = {
 525  input?: Maybe<DeletePageInput>;
 526};
 527
 528
 529export type MutationUpdateSettingArgs = {
 530  input?: Maybe<UpdateSettingInput>;
 531};
 532
 533
 534export type MutationCreateTravelArgs = {
 535  input?: Maybe<CreateTravelInput>;
 536};
 537
 538
 539export type MutationUpdateTravelArgs = {
 540  input?: Maybe<UpdateTravelInput>;
 541};
 542
 543
 544export type MutationDeleteTravelArgs = {
 545  input?: Maybe<DeleteTravelInput>;
 546};
 547
 548
 549export type MutationCreateVehicleArgs = {
 550  input?: Maybe<CreateVehicleInput>;
 551};
 552
 553
 554export type MutationUpdateVehicleArgs = {
 555  input?: Maybe<UpdateVehicleInput>;
 556};
 557
 558
 559export type MutationDeleteVehicleArgs = {
 560  input?: Maybe<DeleteVehicleInput>;
 561};
 562
 563
 564export type MutationDeleteFileArgs = {
 565  input?: Maybe<DeleteFileInput>;
 566};
 567
 568
 569export type MutationCreateRoleArgs = {
 570  input?: Maybe<CreateRoleInput>;
 571};
 572
 573
 574export type MutationUpdateRoleArgs = {
 575  input?: Maybe<UpdateRoleInput>;
 576};
 577
 578
 579export type MutationDeleteRoleArgs = {
 580  input?: Maybe<DeleteRoleInput>;
 581};
 582
 583
 584export type MutationCreateUserArgs = {
 585  input?: Maybe<CreateUserInput>;
 586};
 587
 588
 589export type MutationUpdateUserArgs = {
 590  input?: Maybe<UpdateUserInput>;
 591};
 592
 593
 594export type MutationDeleteUserArgs = {
 595  input?: Maybe<DeleteUserInput>;
 596};
 597
 598
 599export type MutationUploadArgs = {
 600  refId?: Maybe<Scalars['ID']>;
 601  ref?: Maybe<Scalars['String']>;
 602  field?: Maybe<Scalars['String']>;
 603  source?: Maybe<Scalars['String']>;
 604  info?: Maybe<FileInfoInput>;
 605  file: Scalars['Upload'];
 606};
 607
 608
 609export type MutationMultipleUploadArgs = {
 610  refId?: Maybe<Scalars['ID']>;
 611  ref?: Maybe<Scalars['String']>;
 612  field?: Maybe<Scalars['String']>;
 613  source?: Maybe<Scalars['String']>;
 614  files: Array<Maybe<Scalars['Upload']>>;
 615};
 616
 617
 618export type MutationUpdateFileInfoArgs = {
 619  id: Scalars['ID'];
 620  info: FileInfoInput;
 621};
 622
 623
 624export type MutationLoginArgs = {
 625  input: UsersPermissionsLoginInput;
 626};
 627
 628
 629export type MutationRegisterArgs = {
 630  input: UsersPermissionsRegisterInput;
 631};
 632
 633
 634export type MutationForgotPasswordArgs = {
 635  email: Scalars['String'];
 636};
 637
 638
 639export type MutationResetPasswordArgs = {
 640  password: Scalars['String'];
 641  passwordConfirmation: Scalars['String'];
 642  code: Scalars['String'];
 643};
 644
 645
 646export type MutationEmailConfirmationArgs = {
 647  confirmation: Scalars['String'];
 648};
 649
 650
 651export type MutationUpdateMeArgs = {
 652  input?: Maybe<EditUserInput>;
 653};
 654
 655
 656export type MutationUpdateEventByUuidArgs = {
 657  input?: Maybe<UpdateEventByUuidInput>;
 658};
 659
 660export type Page = {
 661  __typename?: 'Page';
 662  id: Scalars['ID'];
 663  created_at: Scalars['DateTime'];
 664  updated_at: Scalars['DateTime'];
 665  name: Scalars['String'];
 666  content?: Maybe<Scalars['String']>;
 667  type?: Maybe<Enum_Page_Type>;
 668};
 669
 670export type PageAggregator = {
 671  __typename?: 'PageAggregator';
 672  count?: Maybe<Scalars['Int']>;
 673  totalCount?: Maybe<Scalars['Int']>;
 674};
 675
 676export type PageConnection = {
 677  __typename?: 'PageConnection';
 678  values?: Maybe<Array<Maybe<Page>>>;
 679  groupBy?: Maybe<PageGroupBy>;
 680  aggregate?: Maybe<PageAggregator>;
 681};
 682
 683export type PageConnectionContent = {
 684  __typename?: 'PageConnectionContent';
 685  key?: Maybe<Scalars['String']>;
 686  connection?: Maybe<PageConnection>;
 687};
 688
 689export type PageConnectionCreated_At = {
 690  __typename?: 'PageConnectionCreated_at';
 691  key?: Maybe<Scalars['DateTime']>;
 692  connection?: Maybe<PageConnection>;
 693};
 694
 695export type PageConnectionId = {
 696  __typename?: 'PageConnectionId';
 697  key?: Maybe<Scalars['ID']>;
 698  connection?: Maybe<PageConnection>;
 699};
 700
 701export type PageConnectionName = {
 702  __typename?: 'PageConnectionName';
 703  key?: Maybe<Scalars['String']>;
 704  connection?: Maybe<PageConnection>;
 705};
 706
 707export type PageConnectionType = {
 708  __typename?: 'PageConnectionType';
 709  key?: Maybe<Scalars['String']>;
 710  connection?: Maybe<PageConnection>;
 711};
 712
 713export type PageConnectionUpdated_At = {
 714  __typename?: 'PageConnectionUpdated_at';
 715  key?: Maybe<Scalars['DateTime']>;
 716  connection?: Maybe<PageConnection>;
 717};
 718
 719export type PageGroupBy = {
 720  __typename?: 'PageGroupBy';
 721  id?: Maybe<Array<Maybe<PageConnectionId>>>;
 722  created_at?: Maybe<Array<Maybe<PageConnectionCreated_At>>>;
 723  updated_at?: Maybe<Array<Maybe<PageConnectionUpdated_At>>>;
 724  name?: Maybe<Array<Maybe<PageConnectionName>>>;
 725  content?: Maybe<Array<Maybe<PageConnectionContent>>>;
 726  type?: Maybe<Array<Maybe<PageConnectionType>>>;
 727};
 728
 729export type PageInput = {
 730  name: Scalars['String'];
 731  content?: Maybe<Scalars['String']>;
 732  type?: Maybe<Enum_Page_Type>;
 733  created_by?: Maybe<Scalars['ID']>;
 734  updated_by?: Maybe<Scalars['ID']>;
 735};
 736
 737export enum PublicationState {
 738  Live = 'LIVE',
 739  Preview = 'PREVIEW'
 740}
 741
 742export type Query = {
 743  __typename?: 'Query';
 744  car?: Maybe<Car>;
 745  cars?: Maybe<Array<Maybe<Car>>>;
 746  carsConnection?: Maybe<CarConnection>;
 747  event?: Maybe<Event>;
 748  events?: Maybe<Array<Maybe<Event>>>;
 749  eventsConnection?: Maybe<EventConnection>;
 750  page?: Maybe<Page>;
 751  pages?: Maybe<Array<Maybe<Page>>>;
 752  pagesConnection?: Maybe<PageConnection>;
 753  setting?: Maybe<Settings>;
 754  travel?: Maybe<Travel>;
 755  travels?: Maybe<Array<Maybe<Travel>>>;
 756  travelsConnection?: Maybe<TravelConnection>;
 757  vehicle?: Maybe<Vehicle>;
 758  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
 759  vehiclesConnection?: Maybe<VehicleConnection>;
 760  files?: Maybe<Array<Maybe<UploadFile>>>;
 761  filesConnection?: Maybe<UploadFileConnection>;
 762  role?: Maybe<UsersPermissionsRole>;
 763  /** Retrieve all the existing roles. You can't apply filters on this query. */
 764  roles?: Maybe<Array<Maybe<UsersPermissionsRole>>>;
 765  rolesConnection?: Maybe<UsersPermissionsRoleConnection>;
 766  user?: Maybe<UsersPermissionsUser>;
 767  users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
 768  usersConnection?: Maybe<UsersPermissionsUserConnection>;
 769  strapiInfo: Info;
 770  me?: Maybe<UsersPermissionsMe>;
 771  eventByUUID?: Maybe<Event>;
 772};
 773
 774
 775export type QueryCarArgs = {
 776  id: Scalars['ID'];
 777  publicationState?: Maybe<PublicationState>;
 778};
 779
 780
 781export type QueryCarsArgs = {
 782  sort?: Maybe<Scalars['String']>;
 783  limit?: Maybe<Scalars['Int']>;
 784  start?: Maybe<Scalars['Int']>;
 785  where?: Maybe<Scalars['JSON']>;
 786  publicationState?: Maybe<PublicationState>;
 787};
 788
 789
 790export type QueryCarsConnectionArgs = {
 791  sort?: Maybe<Scalars['String']>;
 792  limit?: Maybe<Scalars['Int']>;
 793  start?: Maybe<Scalars['Int']>;
 794  where?: Maybe<Scalars['JSON']>;
 795};
 796
 797
 798export type QueryEventArgs = {
 799  id: Scalars['ID'];
 800  publicationState?: Maybe<PublicationState>;
 801};
 802
 803
 804export type QueryEventsArgs = {
 805  sort?: Maybe<Scalars['String']>;
 806  limit?: Maybe<Scalars['Int']>;
 807  start?: Maybe<Scalars['Int']>;
 808  where?: Maybe<Scalars['JSON']>;
 809  publicationState?: Maybe<PublicationState>;
 810};
 811
 812
 813export type QueryEventsConnectionArgs = {
 814  sort?: Maybe<Scalars['String']>;
 815  limit?: Maybe<Scalars['Int']>;
 816  start?: Maybe<Scalars['Int']>;
 817  where?: Maybe<Scalars['JSON']>;
 818};
 819
 820
 821export type QueryPageArgs = {
 822  id: Scalars['ID'];
 823  publicationState?: Maybe<PublicationState>;
 824};
 825
 826
 827export type QueryPagesArgs = {
 828  sort?: Maybe<Scalars['String']>;
 829  limit?: Maybe<Scalars['Int']>;
 830  start?: Maybe<Scalars['Int']>;
 831  where?: Maybe<Scalars['JSON']>;
 832  publicationState?: Maybe<PublicationState>;
 833};
 834
 835
 836export type QueryPagesConnectionArgs = {
 837  sort?: Maybe<Scalars['String']>;
 838  limit?: Maybe<Scalars['Int']>;
 839  start?: Maybe<Scalars['Int']>;
 840  where?: Maybe<Scalars['JSON']>;
 841};
 842
 843
 844export type QuerySettingArgs = {
 845  publicationState?: Maybe<PublicationState>;
 846};
 847
 848
 849export type QueryTravelArgs = {
 850  id: Scalars['ID'];
 851  publicationState?: Maybe<PublicationState>;
 852};
 853
 854
 855export type QueryTravelsArgs = {
 856  sort?: Maybe<Scalars['String']>;
 857  limit?: Maybe<Scalars['Int']>;
 858  start?: Maybe<Scalars['Int']>;
 859  where?: Maybe<Scalars['JSON']>;
 860  publicationState?: Maybe<PublicationState>;
 861};
 862
 863
 864export type QueryTravelsConnectionArgs = {
 865  sort?: Maybe<Scalars['String']>;
 866  limit?: Maybe<Scalars['Int']>;
 867  start?: Maybe<Scalars['Int']>;
 868  where?: Maybe<Scalars['JSON']>;
 869};
 870
 871
 872export type QueryVehicleArgs = {
 873  id: Scalars['ID'];
 874  publicationState?: Maybe<PublicationState>;
 875};
 876
 877
 878export type QueryVehiclesArgs = {
 879  sort?: Maybe<Scalars['String']>;
 880  limit?: Maybe<Scalars['Int']>;
 881  start?: Maybe<Scalars['Int']>;
 882  where?: Maybe<Scalars['JSON']>;
 883  publicationState?: Maybe<PublicationState>;
 884};
 885
 886
 887export type QueryVehiclesConnectionArgs = {
 888  sort?: Maybe<Scalars['String']>;
 889  limit?: Maybe<Scalars['Int']>;
 890  start?: Maybe<Scalars['Int']>;
 891  where?: Maybe<Scalars['JSON']>;
 892};
 893
 894
 895export type QueryFilesArgs = {
 896  sort?: Maybe<Scalars['String']>;
 897  limit?: Maybe<Scalars['Int']>;
 898  start?: Maybe<Scalars['Int']>;
 899  where?: Maybe<Scalars['JSON']>;
 900  publicationState?: Maybe<PublicationState>;
 901};
 902
 903
 904export type QueryFilesConnectionArgs = {
 905  sort?: Maybe<Scalars['String']>;
 906  limit?: Maybe<Scalars['Int']>;
 907  start?: Maybe<Scalars['Int']>;
 908  where?: Maybe<Scalars['JSON']>;
 909};
 910
 911
 912export type QueryRoleArgs = {
 913  id: Scalars['ID'];
 914  publicationState?: Maybe<PublicationState>;
 915};
 916
 917
 918export type QueryRolesArgs = {
 919  sort?: Maybe<Scalars['String']>;
 920  limit?: Maybe<Scalars['Int']>;
 921  start?: Maybe<Scalars['Int']>;
 922  where?: Maybe<Scalars['JSON']>;
 923  publicationState?: Maybe<PublicationState>;
 924};
 925
 926
 927export type QueryRolesConnectionArgs = {
 928  sort?: Maybe<Scalars['String']>;
 929  limit?: Maybe<Scalars['Int']>;
 930  start?: Maybe<Scalars['Int']>;
 931  where?: Maybe<Scalars['JSON']>;
 932};
 933
 934
 935export type QueryUserArgs = {
 936  id: Scalars['ID'];
 937  publicationState?: Maybe<PublicationState>;
 938};
 939
 940
 941export type QueryUsersArgs = {
 942  sort?: Maybe<Scalars['String']>;
 943  limit?: Maybe<Scalars['Int']>;
 944  start?: Maybe<Scalars['Int']>;
 945  where?: Maybe<Scalars['JSON']>;
 946  publicationState?: Maybe<PublicationState>;
 947};
 948
 949
 950export type QueryUsersConnectionArgs = {
 951  sort?: Maybe<Scalars['String']>;
 952  limit?: Maybe<Scalars['Int']>;
 953  start?: Maybe<Scalars['Int']>;
 954  where?: Maybe<Scalars['JSON']>;
 955};
 956
 957
 958export type QueryEventByUuidArgs = {
 959  uuid: Scalars['String'];
 960};
 961
 962export type RoleInput = {
 963  name: Scalars['String'];
 964  description?: Maybe<Scalars['String']>;
 965  type?: Maybe<Scalars['String']>;
 966  permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
 967  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
 968  created_by?: Maybe<Scalars['ID']>;
 969  updated_by?: Maybe<Scalars['ID']>;
 970};
 971
 972export type SettingInput = {
 973  gtm_id?: Maybe<Scalars['String']>;
 974  about_link?: Maybe<Scalars['String']>;
 975  created_by?: Maybe<Scalars['ID']>;
 976  updated_by?: Maybe<Scalars['ID']>;
 977};
 978
 979export type Settings = {
 980  __typename?: 'Settings';
 981  id: Scalars['ID'];
 982  created_at: Scalars['DateTime'];
 983  updated_at: Scalars['DateTime'];
 984  gtm_id?: Maybe<Scalars['String']>;
 985  about_link?: Maybe<Scalars['String']>;
 986};
 987
 988
 989export type Travel = {
 990  __typename?: 'Travel';
 991  id: Scalars['ID'];
 992  created_at: Scalars['DateTime'];
 993  updated_at: Scalars['DateTime'];
 994  meeting?: Maybe<Scalars['String']>;
 995  departure?: Maybe<Scalars['DateTime']>;
 996  details?: Maybe<Scalars['String']>;
 997  passengers?: Maybe<Array<Maybe<ComponentPassengerPassenger>>>;
 998  event?: Maybe<Event>;
 999  vehicle?: Maybe<Vehicle>;
1000};
1001
1002export type TravelAggregator = {
1003  __typename?: 'TravelAggregator';
1004  count?: Maybe<Scalars['Int']>;
1005  totalCount?: Maybe<Scalars['Int']>;
1006};
1007
1008export type TravelConnection = {
1009  __typename?: 'TravelConnection';
1010  values?: Maybe<Array<Maybe<Travel>>>;
1011  groupBy?: Maybe<TravelGroupBy>;
1012  aggregate?: Maybe<TravelAggregator>;
1013};
1014
1015export type TravelConnectionCreated_At = {
1016  __typename?: 'TravelConnectionCreated_at';
1017  key?: Maybe<Scalars['DateTime']>;
1018  connection?: Maybe<TravelConnection>;
1019};
1020
1021export type TravelConnectionDeparture = {
1022  __typename?: 'TravelConnectionDeparture';
1023  key?: Maybe<Scalars['DateTime']>;
1024  connection?: Maybe<TravelConnection>;
1025};
1026
1027export type TravelConnectionDetails = {
1028  __typename?: 'TravelConnectionDetails';
1029  key?: Maybe<Scalars['String']>;
1030  connection?: Maybe<TravelConnection>;
1031};
1032
1033export type TravelConnectionEvent = {
1034  __typename?: 'TravelConnectionEvent';
1035  key?: Maybe<Scalars['ID']>;
1036  connection?: Maybe<TravelConnection>;
1037};
1038
1039export type TravelConnectionId = {
1040  __typename?: 'TravelConnectionId';
1041  key?: Maybe<Scalars['ID']>;
1042  connection?: Maybe<TravelConnection>;
1043};
1044
1045export type TravelConnectionMeeting = {
1046  __typename?: 'TravelConnectionMeeting';
1047  key?: Maybe<Scalars['String']>;
1048  connection?: Maybe<TravelConnection>;
1049};
1050
1051export type TravelConnectionUpdated_At = {
1052  __typename?: 'TravelConnectionUpdated_at';
1053  key?: Maybe<Scalars['DateTime']>;
1054  connection?: Maybe<TravelConnection>;
1055};
1056
1057export type TravelConnectionVehicle = {
1058  __typename?: 'TravelConnectionVehicle';
1059  key?: Maybe<Scalars['ID']>;
1060  connection?: Maybe<TravelConnection>;
1061};
1062
1063export type TravelGroupBy = {
1064  __typename?: 'TravelGroupBy';
1065  id?: Maybe<Array<Maybe<TravelConnectionId>>>;
1066  created_at?: Maybe<Array<Maybe<TravelConnectionCreated_At>>>;
1067  updated_at?: Maybe<Array<Maybe<TravelConnectionUpdated_At>>>;
1068  meeting?: Maybe<Array<Maybe<TravelConnectionMeeting>>>;
1069  departure?: Maybe<Array<Maybe<TravelConnectionDeparture>>>;
1070  details?: Maybe<Array<Maybe<TravelConnectionDetails>>>;
1071  event?: Maybe<Array<Maybe<TravelConnectionEvent>>>;
1072  vehicle?: Maybe<Array<Maybe<TravelConnectionVehicle>>>;
1073};
1074
1075export type TravelInput = {
1076  meeting?: Maybe<Scalars['String']>;
1077  departure?: Maybe<Scalars['DateTime']>;
1078  details?: Maybe<Scalars['String']>;
1079  passengers?: Maybe<Array<Maybe<ComponentPassengerPassengerInput>>>;
1080  event?: Maybe<Scalars['ID']>;
1081  vehicle?: Maybe<Scalars['ID']>;
1082  created_by?: Maybe<Scalars['ID']>;
1083  updated_by?: Maybe<Scalars['ID']>;
1084};
1085
1086
1087export type UploadFile = {
1088  __typename?: 'UploadFile';
1089  id: Scalars['ID'];
1090  created_at: Scalars['DateTime'];
1091  updated_at: Scalars['DateTime'];
1092  name: Scalars['String'];
1093  alternativeText?: Maybe<Scalars['String']>;
1094  caption?: Maybe<Scalars['String']>;
1095  width?: Maybe<Scalars['Int']>;
1096  height?: Maybe<Scalars['Int']>;
1097  formats?: Maybe<Scalars['JSON']>;
1098  hash: Scalars['String'];
1099  ext?: Maybe<Scalars['String']>;
1100  mime: Scalars['String'];
1101  size: Scalars['Float'];
1102  url: Scalars['String'];
1103  previewUrl?: Maybe<Scalars['String']>;
1104  provider: Scalars['String'];
1105  provider_metadata?: Maybe<Scalars['JSON']>;
1106  related?: Maybe<Array<Maybe<Morph>>>;
1107};
1108
1109
1110export type UploadFileRelatedArgs = {
1111  sort?: Maybe<Scalars['String']>;
1112  limit?: Maybe<Scalars['Int']>;
1113  start?: Maybe<Scalars['Int']>;
1114  where?: Maybe<Scalars['JSON']>;
1115};
1116
1117export type UploadFileAggregator = {
1118  __typename?: 'UploadFileAggregator';
1119  count?: Maybe<Scalars['Int']>;
1120  totalCount?: Maybe<Scalars['Int']>;
1121  sum?: Maybe<UploadFileAggregatorSum>;
1122  avg?: Maybe<UploadFileAggregatorAvg>;
1123  min?: Maybe<UploadFileAggregatorMin>;
1124  max?: Maybe<UploadFileAggregatorMax>;
1125};
1126
1127export type UploadFileAggregatorAvg = {
1128  __typename?: 'UploadFileAggregatorAvg';
1129  width?: Maybe<Scalars['Float']>;
1130  height?: Maybe<Scalars['Float']>;
1131  size?: Maybe<Scalars['Float']>;
1132};
1133
1134export type UploadFileAggregatorMax = {
1135  __typename?: 'UploadFileAggregatorMax';
1136  width?: Maybe<Scalars['Float']>;
1137  height?: Maybe<Scalars['Float']>;
1138  size?: Maybe<Scalars['Float']>;
1139};
1140
1141export type UploadFileAggregatorMin = {
1142  __typename?: 'UploadFileAggregatorMin';
1143  width?: Maybe<Scalars['Float']>;
1144  height?: Maybe<Scalars['Float']>;
1145  size?: Maybe<Scalars['Float']>;
1146};
1147
1148export type UploadFileAggregatorSum = {
1149  __typename?: 'UploadFileAggregatorSum';
1150  width?: Maybe<Scalars['Float']>;
1151  height?: Maybe<Scalars['Float']>;
1152  size?: Maybe<Scalars['Float']>;
1153};
1154
1155export type UploadFileConnection = {
1156  __typename?: 'UploadFileConnection';
1157  values?: Maybe<Array<Maybe<UploadFile>>>;
1158  groupBy?: Maybe<UploadFileGroupBy>;
1159  aggregate?: Maybe<UploadFileAggregator>;
1160};
1161
1162export type UploadFileConnectionAlternativeText = {
1163  __typename?: 'UploadFileConnectionAlternativeText';
1164  key?: Maybe<Scalars['String']>;
1165  connection?: Maybe<UploadFileConnection>;
1166};
1167
1168export type UploadFileConnectionCaption = {
1169  __typename?: 'UploadFileConnectionCaption';
1170  key?: Maybe<Scalars['String']>;
1171  connection?: Maybe<UploadFileConnection>;
1172};
1173
1174export type UploadFileConnectionCreated_At = {
1175  __typename?: 'UploadFileConnectionCreated_at';
1176  key?: Maybe<Scalars['DateTime']>;
1177  connection?: Maybe<UploadFileConnection>;
1178};
1179
1180export type UploadFileConnectionExt = {
1181  __typename?: 'UploadFileConnectionExt';
1182  key?: Maybe<Scalars['String']>;
1183  connection?: Maybe<UploadFileConnection>;
1184};
1185
1186export type UploadFileConnectionFormats = {
1187  __typename?: 'UploadFileConnectionFormats';
1188  key?: Maybe<Scalars['JSON']>;
1189  connection?: Maybe<UploadFileConnection>;
1190};
1191
1192export type UploadFileConnectionHash = {
1193  __typename?: 'UploadFileConnectionHash';
1194  key?: Maybe<Scalars['String']>;
1195  connection?: Maybe<UploadFileConnection>;
1196};
1197
1198export type UploadFileConnectionHeight = {
1199  __typename?: 'UploadFileConnectionHeight';
1200  key?: Maybe<Scalars['Int']>;
1201  connection?: Maybe<UploadFileConnection>;
1202};
1203
1204export type UploadFileConnectionId = {
1205  __typename?: 'UploadFileConnectionId';
1206  key?: Maybe<Scalars['ID']>;
1207  connection?: Maybe<UploadFileConnection>;
1208};
1209
1210export type UploadFileConnectionMime = {
1211  __typename?: 'UploadFileConnectionMime';
1212  key?: Maybe<Scalars['String']>;
1213  connection?: Maybe<UploadFileConnection>;
1214};
1215
1216export type UploadFileConnectionName = {
1217  __typename?: 'UploadFileConnectionName';
1218  key?: Maybe<Scalars['String']>;
1219  connection?: Maybe<UploadFileConnection>;
1220};
1221
1222export type UploadFileConnectionPreviewUrl = {
1223  __typename?: 'UploadFileConnectionPreviewUrl';
1224  key?: Maybe<Scalars['String']>;
1225  connection?: Maybe<UploadFileConnection>;
1226};
1227
1228export type UploadFileConnectionProvider = {
1229  __typename?: 'UploadFileConnectionProvider';
1230  key?: Maybe<Scalars['String']>;
1231  connection?: Maybe<UploadFileConnection>;
1232};
1233
1234export type UploadFileConnectionProvider_Metadata = {
1235  __typename?: 'UploadFileConnectionProvider_metadata';
1236  key?: Maybe<Scalars['JSON']>;
1237  connection?: Maybe<UploadFileConnection>;
1238};
1239
1240export type UploadFileConnectionSize = {
1241  __typename?: 'UploadFileConnectionSize';
1242  key?: Maybe<Scalars['Float']>;
1243  connection?: Maybe<UploadFileConnection>;
1244};
1245
1246export type UploadFileConnectionUpdated_At = {
1247  __typename?: 'UploadFileConnectionUpdated_at';
1248  key?: Maybe<Scalars['DateTime']>;
1249  connection?: Maybe<UploadFileConnection>;
1250};
1251
1252export type UploadFileConnectionUrl = {
1253  __typename?: 'UploadFileConnectionUrl';
1254  key?: Maybe<Scalars['String']>;
1255  connection?: Maybe<UploadFileConnection>;
1256};
1257
1258export type UploadFileConnectionWidth = {
1259  __typename?: 'UploadFileConnectionWidth';
1260  key?: Maybe<Scalars['Int']>;
1261  connection?: Maybe<UploadFileConnection>;
1262};
1263
1264export type UploadFileGroupBy = {
1265  __typename?: 'UploadFileGroupBy';
1266  id?: Maybe<Array<Maybe<UploadFileConnectionId>>>;
1267  created_at?: Maybe<Array<Maybe<UploadFileConnectionCreated_At>>>;
1268  updated_at?: Maybe<Array<Maybe<UploadFileConnectionUpdated_At>>>;
1269  name?: Maybe<Array<Maybe<UploadFileConnectionName>>>;
1270  alternativeText?: Maybe<Array<Maybe<UploadFileConnectionAlternativeText>>>;
1271  caption?: Maybe<Array<Maybe<UploadFileConnectionCaption>>>;
1272  width?: Maybe<Array<Maybe<UploadFileConnectionWidth>>>;
1273  height?: Maybe<Array<Maybe<UploadFileConnectionHeight>>>;
1274  formats?: Maybe<Array<Maybe<UploadFileConnectionFormats>>>;
1275  hash?: Maybe<Array<Maybe<UploadFileConnectionHash>>>;
1276  ext?: Maybe<Array<Maybe<UploadFileConnectionExt>>>;
1277  mime?: Maybe<Array<Maybe<UploadFileConnectionMime>>>;
1278  size?: Maybe<Array<Maybe<UploadFileConnectionSize>>>;
1279  url?: Maybe<Array<Maybe<UploadFileConnectionUrl>>>;
1280  previewUrl?: Maybe<Array<Maybe<UploadFileConnectionPreviewUrl>>>;
1281  provider?: Maybe<Array<Maybe<UploadFileConnectionProvider>>>;
1282  provider_metadata?: Maybe<Array<Maybe<UploadFileConnectionProvider_Metadata>>>;
1283};
1284
1285export type UserInput = {
1286  username: Scalars['String'];
1287  firstName?: Maybe<Scalars['String']>;
1288  lastName?: Maybe<Scalars['String']>;
1289  email: Scalars['String'];
1290  provider?: Maybe<Scalars['String']>;
1291  password?: Maybe<Scalars['String']>;
1292  resetPasswordToken?: Maybe<Scalars['String']>;
1293  confirmed?: Maybe<Scalars['Boolean']>;
1294  blocked?: Maybe<Scalars['Boolean']>;
1295  role?: Maybe<Scalars['ID']>;
1296  confirmationToken?: Maybe<Scalars['String']>;
1297  events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1298  onboardingUser?: Maybe<Scalars['Boolean']>;
1299  onboardingCreator?: Maybe<Scalars['Boolean']>;
1300  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1301  cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
1302  vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1303  created_by?: Maybe<Scalars['ID']>;
1304  updated_by?: Maybe<Scalars['ID']>;
1305};
1306
1307export type UserPermissionsPasswordPayload = {
1308  __typename?: 'UserPermissionsPasswordPayload';
1309  ok: Scalars['Boolean'];
1310};
1311
1312export type UsersPermissionsLoginInput = {
1313  identifier: Scalars['String'];
1314  password: Scalars['String'];
1315  provider?: Maybe<Scalars['String']>;
1316};
1317
1318export type UsersPermissionsLoginPayload = {
1319  __typename?: 'UsersPermissionsLoginPayload';
1320  jwt?: Maybe<Scalars['String']>;
1321  user: UsersPermissionsMe;
1322};
1323
1324export type UsersPermissionsMe = {
1325  __typename?: 'UsersPermissionsMe';
1326  id: Scalars['ID'];
1327  username: Scalars['String'];
1328  email: Scalars['String'];
1329  confirmed?: Maybe<Scalars['Boolean']>;
1330  blocked?: Maybe<Scalars['Boolean']>;
1331  role?: Maybe<UsersPermissionsMeRole>;
1332  profile?: Maybe<UsersPermissionsUser>;
1333};
1334
1335export type UsersPermissionsMeRole = {
1336  __typename?: 'UsersPermissionsMeRole';
1337  id: Scalars['ID'];
1338  name: Scalars['String'];
1339  description?: Maybe<Scalars['String']>;
1340  type?: Maybe<Scalars['String']>;
1341};
1342
1343export type UsersPermissionsPermission = {
1344  __typename?: 'UsersPermissionsPermission';
1345  id: Scalars['ID'];
1346  type: Scalars['String'];
1347  controller: Scalars['String'];
1348  action: Scalars['String'];
1349  enabled: Scalars['Boolean'];
1350  policy?: Maybe<Scalars['String']>;
1351  role?: Maybe<UsersPermissionsRole>;
1352};
1353
1354export type UsersPermissionsRegisterInput = {
1355  username: Scalars['String'];
1356  email: Scalars['String'];
1357  password: Scalars['String'];
1358  firstName?: Maybe<Scalars['String']>;
1359  lastName?: Maybe<Scalars['String']>;
1360  lang?: Maybe<Scalars['String']>;
1361};
1362
1363export type UsersPermissionsRole = {
1364  __typename?: 'UsersPermissionsRole';
1365  id: Scalars['ID'];
1366  name: Scalars['String'];
1367  description?: Maybe<Scalars['String']>;
1368  type?: Maybe<Scalars['String']>;
1369  permissions?: Maybe<Array<Maybe<UsersPermissionsPermission>>>;
1370  users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1371};
1372
1373
1374export type UsersPermissionsRolePermissionsArgs = {
1375  sort?: Maybe<Scalars['String']>;
1376  limit?: Maybe<Scalars['Int']>;
1377  start?: Maybe<Scalars['Int']>;
1378  where?: Maybe<Scalars['JSON']>;
1379};
1380
1381
1382export type UsersPermissionsRoleUsersArgs = {
1383  sort?: Maybe<Scalars['String']>;
1384  limit?: Maybe<Scalars['Int']>;
1385  start?: Maybe<Scalars['Int']>;
1386  where?: Maybe<Scalars['JSON']>;
1387};
1388
1389export type UsersPermissionsRoleAggregator = {
1390  __typename?: 'UsersPermissionsRoleAggregator';
1391  count?: Maybe<Scalars['Int']>;
1392  totalCount?: Maybe<Scalars['Int']>;
1393};
1394
1395export type UsersPermissionsRoleConnection = {
1396  __typename?: 'UsersPermissionsRoleConnection';
1397  values?: Maybe<Array<Maybe<UsersPermissionsRole>>>;
1398  groupBy?: Maybe<UsersPermissionsRoleGroupBy>;
1399  aggregate?: Maybe<UsersPermissionsRoleAggregator>;
1400};
1401
1402export type UsersPermissionsRoleConnectionDescription = {
1403  __typename?: 'UsersPermissionsRoleConnectionDescription';
1404  key?: Maybe<Scalars['String']>;
1405  connection?: Maybe<UsersPermissionsRoleConnection>;
1406};
1407
1408export type UsersPermissionsRoleConnectionId = {
1409  __typename?: 'UsersPermissionsRoleConnectionId';
1410  key?: Maybe<Scalars['ID']>;
1411  connection?: Maybe<UsersPermissionsRoleConnection>;
1412};
1413
1414export type UsersPermissionsRoleConnectionName = {
1415  __typename?: 'UsersPermissionsRoleConnectionName';
1416  key?: Maybe<Scalars['String']>;
1417  connection?: Maybe<UsersPermissionsRoleConnection>;
1418};
1419
1420export type UsersPermissionsRoleConnectionType = {
1421  __typename?: 'UsersPermissionsRoleConnectionType';
1422  key?: Maybe<Scalars['String']>;
1423  connection?: Maybe<UsersPermissionsRoleConnection>;
1424};
1425
1426export type UsersPermissionsRoleGroupBy = {
1427  __typename?: 'UsersPermissionsRoleGroupBy';
1428  id?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionId>>>;
1429  name?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionName>>>;
1430  description?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionDescription>>>;
1431  type?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionType>>>;
1432};
1433
1434export type UsersPermissionsUser = {
1435  __typename?: 'UsersPermissionsUser';
1436  id: Scalars['ID'];
1437  created_at: Scalars['DateTime'];
1438  updated_at: Scalars['DateTime'];
1439  username: Scalars['String'];
1440  firstName?: Maybe<Scalars['String']>;
1441  lastName?: Maybe<Scalars['String']>;
1442  email: Scalars['String'];
1443  provider?: Maybe<Scalars['String']>;
1444  confirmed?: Maybe<Scalars['Boolean']>;
1445  blocked?: Maybe<Scalars['Boolean']>;
1446  role?: Maybe<UsersPermissionsRole>;
1447  onboardingUser?: Maybe<Scalars['Boolean']>;
1448  onboardingCreator?: Maybe<Scalars['Boolean']>;
1449  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1450  events?: Maybe<Array<Maybe<Event>>>;
1451  cars?: Maybe<Array<Maybe<Car>>>;
1452  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
1453};
1454
1455
1456export type UsersPermissionsUserEventsArgs = {
1457  sort?: Maybe<Scalars['String']>;
1458  limit?: Maybe<Scalars['Int']>;
1459  start?: Maybe<Scalars['Int']>;
1460  where?: Maybe<Scalars['JSON']>;
1461};
1462
1463
1464export type UsersPermissionsUserCarsArgs = {
1465  sort?: Maybe<Scalars['String']>;
1466  limit?: Maybe<Scalars['Int']>;
1467  start?: Maybe<Scalars['Int']>;
1468  where?: Maybe<Scalars['JSON']>;
1469};
1470
1471
1472export type UsersPermissionsUserVehiclesArgs = {
1473  sort?: Maybe<Scalars['String']>;
1474  limit?: Maybe<Scalars['Int']>;
1475  start?: Maybe<Scalars['Int']>;
1476  where?: Maybe<Scalars['JSON']>;
1477};
1478
1479export type UsersPermissionsUserAggregator = {
1480  __typename?: 'UsersPermissionsUserAggregator';
1481  count?: Maybe<Scalars['Int']>;
1482  totalCount?: Maybe<Scalars['Int']>;
1483};
1484
1485export type UsersPermissionsUserConnection = {
1486  __typename?: 'UsersPermissionsUserConnection';
1487  values?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1488  groupBy?: Maybe<UsersPermissionsUserGroupBy>;
1489  aggregate?: Maybe<UsersPermissionsUserAggregator>;
1490};
1491
1492export type UsersPermissionsUserConnectionBlocked = {
1493  __typename?: 'UsersPermissionsUserConnectionBlocked';
1494  key?: Maybe<Scalars['Boolean']>;
1495  connection?: Maybe<UsersPermissionsUserConnection>;
1496};
1497
1498export type UsersPermissionsUserConnectionConfirmed = {
1499  __typename?: 'UsersPermissionsUserConnectionConfirmed';
1500  key?: Maybe<Scalars['Boolean']>;
1501  connection?: Maybe<UsersPermissionsUserConnection>;
1502};
1503
1504export type UsersPermissionsUserConnectionCreated_At = {
1505  __typename?: 'UsersPermissionsUserConnectionCreated_at';
1506  key?: Maybe<Scalars['DateTime']>;
1507  connection?: Maybe<UsersPermissionsUserConnection>;
1508};
1509
1510export type UsersPermissionsUserConnectionEmail = {
1511  __typename?: 'UsersPermissionsUserConnectionEmail';
1512  key?: Maybe<Scalars['String']>;
1513  connection?: Maybe<UsersPermissionsUserConnection>;
1514};
1515
1516export type UsersPermissionsUserConnectionFirstName = {
1517  __typename?: 'UsersPermissionsUserConnectionFirstName';
1518  key?: Maybe<Scalars['String']>;
1519  connection?: Maybe<UsersPermissionsUserConnection>;
1520};
1521
1522export type UsersPermissionsUserConnectionId = {
1523  __typename?: 'UsersPermissionsUserConnectionId';
1524  key?: Maybe<Scalars['ID']>;
1525  connection?: Maybe<UsersPermissionsUserConnection>;
1526};
1527
1528export type UsersPermissionsUserConnectionLang = {
1529  __typename?: 'UsersPermissionsUserConnectionLang';
1530  key?: Maybe<Scalars['String']>;
1531  connection?: Maybe<UsersPermissionsUserConnection>;
1532};
1533
1534export type UsersPermissionsUserConnectionLastName = {
1535  __typename?: 'UsersPermissionsUserConnectionLastName';
1536  key?: Maybe<Scalars['String']>;
1537  connection?: Maybe<UsersPermissionsUserConnection>;
1538};
1539
1540export type UsersPermissionsUserConnectionOnboardingCreator = {
1541  __typename?: 'UsersPermissionsUserConnectionOnboardingCreator';
1542  key?: Maybe<Scalars['Boolean']>;
1543  connection?: Maybe<UsersPermissionsUserConnection>;
1544};
1545
1546export type UsersPermissionsUserConnectionOnboardingUser = {
1547  __typename?: 'UsersPermissionsUserConnectionOnboardingUser';
1548  key?: Maybe<Scalars['Boolean']>;
1549  connection?: Maybe<UsersPermissionsUserConnection>;
1550};
1551
1552export type UsersPermissionsUserConnectionProvider = {
1553  __typename?: 'UsersPermissionsUserConnectionProvider';
1554  key?: Maybe<Scalars['String']>;
1555  connection?: Maybe<UsersPermissionsUserConnection>;
1556};
1557
1558export type UsersPermissionsUserConnectionRole = {
1559  __typename?: 'UsersPermissionsUserConnectionRole';
1560  key?: Maybe<Scalars['ID']>;
1561  connection?: Maybe<UsersPermissionsUserConnection>;
1562};
1563
1564export type UsersPermissionsUserConnectionUpdated_At = {
1565  __typename?: 'UsersPermissionsUserConnectionUpdated_at';
1566  key?: Maybe<Scalars['DateTime']>;
1567  connection?: Maybe<UsersPermissionsUserConnection>;
1568};
1569
1570export type UsersPermissionsUserConnectionUsername = {
1571  __typename?: 'UsersPermissionsUserConnectionUsername';
1572  key?: Maybe<Scalars['String']>;
1573  connection?: Maybe<UsersPermissionsUserConnection>;
1574};
1575
1576export type UsersPermissionsUserGroupBy = {
1577  __typename?: 'UsersPermissionsUserGroupBy';
1578  id?: Maybe<Array<Maybe<UsersPermissionsUserConnectionId>>>;
1579  created_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionCreated_At>>>;
1580  updated_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUpdated_At>>>;
1581  username?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUsername>>>;
1582  firstName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionFirstName>>>;
1583  lastName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLastName>>>;
1584  email?: Maybe<Array<Maybe<UsersPermissionsUserConnectionEmail>>>;
1585  provider?: Maybe<Array<Maybe<UsersPermissionsUserConnectionProvider>>>;
1586  confirmed?: Maybe<Array<Maybe<UsersPermissionsUserConnectionConfirmed>>>;
1587  blocked?: Maybe<Array<Maybe<UsersPermissionsUserConnectionBlocked>>>;
1588  role?: Maybe<Array<Maybe<UsersPermissionsUserConnectionRole>>>;
1589  onboardingUser?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingUser>>>;
1590  onboardingCreator?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingCreator>>>;
1591  lang?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLang>>>;
1592};
1593
1594export type Vehicle = {
1595  __typename?: 'Vehicle';
1596  id: Scalars['ID'];
1597  created_at: Scalars['DateTime'];
1598  updated_at: Scalars['DateTime'];
1599  name: Scalars['String'];
1600  seats?: Maybe<Scalars['Int']>;
1601  user?: Maybe<UsersPermissionsUser>;
1602  phone_number?: Maybe<Scalars['String']>;
1603  travels?: Maybe<Array<Maybe<Travel>>>;
1604};
1605
1606
1607export type VehicleTravelsArgs = {
1608  sort?: Maybe<Scalars['String']>;
1609  limit?: Maybe<Scalars['Int']>;
1610  start?: Maybe<Scalars['Int']>;
1611  where?: Maybe<Scalars['JSON']>;
1612};
1613
1614export type VehicleAggregator = {
1615  __typename?: 'VehicleAggregator';
1616  count?: Maybe<Scalars['Int']>;
1617  totalCount?: Maybe<Scalars['Int']>;
1618  sum?: Maybe<VehicleAggregatorSum>;
1619  avg?: Maybe<VehicleAggregatorAvg>;
1620  min?: Maybe<VehicleAggregatorMin>;
1621  max?: Maybe<VehicleAggregatorMax>;
1622};
1623
1624export type VehicleAggregatorAvg = {
1625  __typename?: 'VehicleAggregatorAvg';
1626  seats?: Maybe<Scalars['Float']>;
1627};
1628
1629export type VehicleAggregatorMax = {
1630  __typename?: 'VehicleAggregatorMax';
1631  seats?: Maybe<Scalars['Float']>;
1632};
1633
1634export type VehicleAggregatorMin = {
1635  __typename?: 'VehicleAggregatorMin';
1636  seats?: Maybe<Scalars['Float']>;
1637};
1638
1639export type VehicleAggregatorSum = {
1640  __typename?: 'VehicleAggregatorSum';
1641  seats?: Maybe<Scalars['Float']>;
1642};
1643
1644export type VehicleConnection = {
1645  __typename?: 'VehicleConnection';
1646  values?: Maybe<Array<Maybe<Vehicle>>>;
1647  groupBy?: Maybe<VehicleGroupBy>;
1648  aggregate?: Maybe<VehicleAggregator>;
1649};
1650
1651export type VehicleConnectionCreated_At = {
1652  __typename?: 'VehicleConnectionCreated_at';
1653  key?: Maybe<Scalars['DateTime']>;
1654  connection?: Maybe<VehicleConnection>;
1655};
1656
1657export type VehicleConnectionId = {
1658  __typename?: 'VehicleConnectionId';
1659  key?: Maybe<Scalars['ID']>;
1660  connection?: Maybe<VehicleConnection>;
1661};
1662
1663export type VehicleConnectionName = {
1664  __typename?: 'VehicleConnectionName';
1665  key?: Maybe<Scalars['String']>;
1666  connection?: Maybe<VehicleConnection>;
1667};
1668
1669export type VehicleConnectionPhone_Number = {
1670  __typename?: 'VehicleConnectionPhone_number';
1671  key?: Maybe<Scalars['String']>;
1672  connection?: Maybe<VehicleConnection>;
1673};
1674
1675export type VehicleConnectionSeats = {
1676  __typename?: 'VehicleConnectionSeats';
1677  key?: Maybe<Scalars['Int']>;
1678  connection?: Maybe<VehicleConnection>;
1679};
1680
1681export type VehicleConnectionUpdated_At = {
1682  __typename?: 'VehicleConnectionUpdated_at';
1683  key?: Maybe<Scalars['DateTime']>;
1684  connection?: Maybe<VehicleConnection>;
1685};
1686
1687export type VehicleConnectionUser = {
1688  __typename?: 'VehicleConnectionUser';
1689  key?: Maybe<Scalars['ID']>;
1690  connection?: Maybe<VehicleConnection>;
1691};
1692
1693export type VehicleGroupBy = {
1694  __typename?: 'VehicleGroupBy';
1695  id?: Maybe<Array<Maybe<VehicleConnectionId>>>;
1696  created_at?: Maybe<Array<Maybe<VehicleConnectionCreated_At>>>;
1697  updated_at?: Maybe<Array<Maybe<VehicleConnectionUpdated_At>>>;
1698  name?: Maybe<Array<Maybe<VehicleConnectionName>>>;
1699  seats?: Maybe<Array<Maybe<VehicleConnectionSeats>>>;
1700  user?: Maybe<Array<Maybe<VehicleConnectionUser>>>;
1701  phone_number?: Maybe<Array<Maybe<VehicleConnectionPhone_Number>>>;
1702};
1703
1704export type VehicleInput = {
1705  name: Scalars['String'];
1706  seats?: Maybe<Scalars['Int']>;
1707  user?: Maybe<Scalars['ID']>;
1708  travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1709  phone_number?: Maybe<Scalars['String']>;
1710  created_by?: Maybe<Scalars['ID']>;
1711  updated_by?: Maybe<Scalars['ID']>;
1712};
1713
1714export type CreateCarInput = {
1715  data?: Maybe<CarInput>;
1716};
1717
1718export type CreateCarPayload = {
1719  __typename?: 'createCarPayload';
1720  car?: Maybe<Car>;
1721};
1722
1723export type CreateEventInput = {
1724  data?: Maybe<EventInput>;
1725};
1726
1727export type CreateEventPayload = {
1728  __typename?: 'createEventPayload';
1729  event?: Maybe<Event>;
1730};
1731
1732export type CreatePageInput = {
1733  data?: Maybe<PageInput>;
1734};
1735
1736export type CreatePagePayload = {
1737  __typename?: 'createPagePayload';
1738  page?: Maybe<Page>;
1739};
1740
1741export type CreateRoleInput = {
1742  data?: Maybe<RoleInput>;
1743};
1744
1745export type CreateRolePayload = {
1746  __typename?: 'createRolePayload';
1747  role?: Maybe<UsersPermissionsRole>;
1748};
1749
1750export type CreateTravelInput = {
1751  data?: Maybe<TravelInput>;
1752};
1753
1754export type CreateTravelPayload = {
1755  __typename?: 'createTravelPayload';
1756  travel?: Maybe<Travel>;
1757};
1758
1759export type CreateUserInput = {
1760  data?: Maybe<UserInput>;
1761};
1762
1763export type CreateUserPayload = {
1764  __typename?: 'createUserPayload';
1765  user?: Maybe<UsersPermissionsUser>;
1766};
1767
1768export type CreateVehicleInput = {
1769  data?: Maybe<VehicleInput>;
1770};
1771
1772export type CreateVehiclePayload = {
1773  __typename?: 'createVehiclePayload';
1774  vehicle?: Maybe<Vehicle>;
1775};
1776
1777export type DeleteCarInput = {
1778  where?: Maybe<InputId>;
1779};
1780
1781export type DeleteCarPayload = {
1782  __typename?: 'deleteCarPayload';
1783  car?: Maybe<Car>;
1784};
1785
1786export type DeleteEventInput = {
1787  where?: Maybe<InputId>;
1788};
1789
1790export type DeleteEventPayload = {
1791  __typename?: 'deleteEventPayload';
1792  event?: Maybe<Event>;
1793};
1794
1795export type DeleteFileInput = {
1796  where?: Maybe<InputId>;
1797};
1798
1799export type DeleteFilePayload = {
1800  __typename?: 'deleteFilePayload';
1801  file?: Maybe<UploadFile>;
1802};
1803
1804export type DeletePageInput = {
1805  where?: Maybe<InputId>;
1806};
1807
1808export type DeletePagePayload = {
1809  __typename?: 'deletePagePayload';
1810  page?: Maybe<Page>;
1811};
1812
1813export type DeleteRoleInput = {
1814  where?: Maybe<InputId>;
1815};
1816
1817export type DeleteRolePayload = {
1818  __typename?: 'deleteRolePayload';
1819  role?: Maybe<UsersPermissionsRole>;
1820};
1821
1822export type DeleteSettingPayload = {
1823  __typename?: 'deleteSettingPayload';
1824  setting?: Maybe<Settings>;
1825};
1826
1827export type DeleteTravelInput = {
1828  where?: Maybe<InputId>;
1829};
1830
1831export type DeleteTravelPayload = {
1832  __typename?: 'deleteTravelPayload';
1833  travel?: Maybe<Travel>;
1834};
1835
1836export type DeleteUserInput = {
1837  where?: Maybe<InputId>;
1838};
1839
1840export type DeleteUserPayload = {
1841  __typename?: 'deleteUserPayload';
1842  user?: Maybe<UsersPermissionsUser>;
1843};
1844
1845export type DeleteVehicleInput = {
1846  where?: Maybe<InputId>;
1847};
1848
1849export type DeleteVehiclePayload = {
1850  __typename?: 'deleteVehiclePayload';
1851  vehicle?: Maybe<Vehicle>;
1852};
1853
1854export type EditCarInput = {
1855  name?: Maybe<Scalars['String']>;
1856  seats?: Maybe<Scalars['Int']>;
1857  meeting?: Maybe<Scalars['String']>;
1858  departure?: Maybe<Scalars['DateTime']>;
1859  phone_number?: Maybe<Scalars['String']>;
1860  details?: Maybe<Scalars['String']>;
1861  event?: Maybe<Scalars['ID']>;
1862  passengers?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1863  user?: Maybe<Scalars['ID']>;
1864  created_by?: Maybe<Scalars['ID']>;
1865  updated_by?: Maybe<Scalars['ID']>;
1866};
1867
1868export type EditComponentPassengerPassengerInput = {
1869  id?: Maybe<Scalars['ID']>;
1870  name?: Maybe<Scalars['String']>;
1871  email?: Maybe<Scalars['String']>;
1872  location?: Maybe<Scalars['String']>;
1873  user?: Maybe<Scalars['ID']>;
1874};
1875
1876export type EditEmailTemplateInput = {
1877  sourceCodeToTemplateId?: Maybe<Scalars['Int']>;
1878  design?: Maybe<Scalars['JSON']>;
1879  name?: Maybe<Scalars['String']>;
1880  subject?: Maybe<Scalars['String']>;
1881  bodyHtml?: Maybe<Scalars['String']>;
1882  bodyText?: Maybe<Scalars['String']>;
1883  enabled?: Maybe<Scalars['Boolean']>;
1884  tags?: Maybe<Scalars['JSON']>;
1885  created_by?: Maybe<Scalars['ID']>;
1886  updated_by?: Maybe<Scalars['ID']>;
1887};
1888
1889export type EditEventInput = {
1890  name?: Maybe<Scalars['String']>;
1891  email?: Maybe<Scalars['String']>;
1892  date?: Maybe<Scalars['Date']>;
1893  address?: Maybe<Scalars['String']>;
1894  cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
1895  position?: Maybe<Scalars['JSON']>;
1896  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1897  uuid?: Maybe<Scalars['String']>;
1898  waitingList?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1899  travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1900  created_by?: Maybe<Scalars['ID']>;
1901  updated_by?: Maybe<Scalars['ID']>;
1902};
1903
1904export type EditFileInput = {
1905  name?: Maybe<Scalars['String']>;
1906  alternativeText?: Maybe<Scalars['String']>;
1907  caption?: Maybe<Scalars['String']>;
1908  width?: Maybe<Scalars['Int']>;
1909  height?: Maybe<Scalars['Int']>;
1910  formats?: Maybe<Scalars['JSON']>;
1911  hash?: Maybe<Scalars['String']>;
1912  ext?: Maybe<Scalars['String']>;
1913  mime?: Maybe<Scalars['String']>;
1914  size?: Maybe<Scalars['Float']>;
1915  url?: Maybe<Scalars['String']>;
1916  previewUrl?: Maybe<Scalars['String']>;
1917  provider?: Maybe<Scalars['String']>;
1918  provider_metadata?: Maybe<Scalars['JSON']>;
1919  related?: Maybe<Array<Maybe<Scalars['ID']>>>;
1920  created_by?: Maybe<Scalars['ID']>;
1921  updated_by?: Maybe<Scalars['ID']>;
1922};
1923
1924export type EditPageInput = {
1925  name?: Maybe<Scalars['String']>;
1926  content?: Maybe<Scalars['String']>;
1927  type?: Maybe<Enum_Page_Type>;
1928  created_by?: Maybe<Scalars['ID']>;
1929  updated_by?: Maybe<Scalars['ID']>;
1930};
1931
1932export type EditRoleInput = {
1933  name?: Maybe<Scalars['String']>;
1934  description?: Maybe<Scalars['String']>;
1935  type?: Maybe<Scalars['String']>;
1936  permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
1937  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1938  created_by?: Maybe<Scalars['ID']>;
1939  updated_by?: Maybe<Scalars['ID']>;
1940};
1941
1942export type EditSettingInput = {
1943  gtm_id?: Maybe<Scalars['String']>;
1944  about_link?: Maybe<Scalars['String']>;
1945  created_by?: Maybe<Scalars['ID']>;
1946  updated_by?: Maybe<Scalars['ID']>;
1947};
1948
1949export type EditTravelInput = {
1950  meeting?: Maybe<Scalars['String']>;
1951  departure?: Maybe<Scalars['DateTime']>;
1952  details?: Maybe<Scalars['String']>;
1953  passengers?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1954  event?: Maybe<Scalars['ID']>;
1955  vehicle?: Maybe<Scalars['ID']>;
1956  created_by?: Maybe<Scalars['ID']>;
1957  updated_by?: Maybe<Scalars['ID']>;
1958};
1959
1960export type EditUserInput = {
1961  username?: Maybe<Scalars['String']>;
1962  firstName?: Maybe<Scalars['String']>;
1963  lastName?: Maybe<Scalars['String']>;
1964  email?: Maybe<Scalars['String']>;
1965  provider?: Maybe<Scalars['String']>;
1966  password?: Maybe<Scalars['String']>;
1967  resetPasswordToken?: Maybe<Scalars['String']>;
1968  confirmed?: Maybe<Scalars['Boolean']>;
1969  blocked?: Maybe<Scalars['Boolean']>;
1970  role?: Maybe<Scalars['ID']>;
1971  confirmationToken?: Maybe<Scalars['String']>;
1972  events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1973  onboardingUser?: Maybe<Scalars['Boolean']>;
1974  onboardingCreator?: Maybe<Scalars['Boolean']>;
1975  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1976  cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
1977  vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1978  created_by?: Maybe<Scalars['ID']>;
1979  updated_by?: Maybe<Scalars['ID']>;
1980  old_password?: Maybe<Scalars['String']>;
1981};
1982
1983export type EditVehicleInput = {
1984  name?: Maybe<Scalars['String']>;
1985  seats?: Maybe<Scalars['Int']>;
1986  user?: Maybe<Scalars['ID']>;
1987  travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1988  phone_number?: Maybe<Scalars['String']>;
1989  created_by?: Maybe<Scalars['ID']>;
1990  updated_by?: Maybe<Scalars['ID']>;
1991};
1992
1993export type UpdateCarInput = {
1994  where?: Maybe<InputId>;
1995  data?: Maybe<EditCarInput>;
1996};
1997
1998export type UpdateCarPayload = {
1999  __typename?: 'updateCarPayload';
2000  car?: Maybe<Car>;
2001};
2002
2003export type UpdateEventByUuidInput = {
2004  where?: Maybe<InputUuid>;
2005  data?: Maybe<EditEventInput>;
2006};
2007
2008export type UpdateEventInput = {
2009  where?: Maybe<InputId>;
2010  data?: Maybe<EditEventInput>;
2011};
2012
2013export type UpdateEventPayload = {
2014  __typename?: 'updateEventPayload';
2015  event?: Maybe<Event>;
2016};
2017
2018export type UpdatePageInput = {
2019  where?: Maybe<InputId>;
2020  data?: Maybe<EditPageInput>;
2021};
2022
2023export type UpdatePagePayload = {
2024  __typename?: 'updatePagePayload';
2025  page?: Maybe<Page>;
2026};
2027
2028export type UpdateRoleInput = {
2029  where?: Maybe<InputId>;
2030  data?: Maybe<EditRoleInput>;
2031};
2032
2033export type UpdateRolePayload = {
2034  __typename?: 'updateRolePayload';
2035  role?: Maybe<UsersPermissionsRole>;
2036};
2037
2038export type UpdateSettingInput = {
2039  data?: Maybe<EditSettingInput>;
2040};
2041
2042export type UpdateSettingPayload = {
2043  __typename?: 'updateSettingPayload';
2044  setting?: Maybe<Settings>;
2045};
2046
2047export type UpdateTravelInput = {
2048  where?: Maybe<InputId>;
2049  data?: Maybe<EditTravelInput>;
2050};
2051
2052export type UpdateTravelPayload = {
2053  __typename?: 'updateTravelPayload';
2054  travel?: Maybe<Travel>;
2055};
2056
2057export type UpdateUserInput = {
2058  where?: Maybe<InputId>;
2059  data?: Maybe<EditUserInput>;
2060};
2061
2062export type UpdateUserPayload = {
2063  __typename?: 'updateUserPayload';
2064  user?: Maybe<UsersPermissionsUser>;
2065};
2066
2067export type UpdateVehicleInput = {
2068  where?: Maybe<InputId>;
2069  data?: Maybe<EditVehicleInput>;
2070};
2071
2072export type UpdateVehiclePayload = {
2073  __typename?: 'updateVehiclePayload';
2074  vehicle?: Maybe<Vehicle>;
2075};
2076
2077export type MeFieldsFragment = (
2078  { __typename?: 'UsersPermissionsMe' }
2079  & Pick<UsersPermissionsMe, 'id' | 'username' | 'email' | 'confirmed'>
2080);
2081
2082export type RegisterMutationVariables = Exact<{
2083  user: UsersPermissionsRegisterInput;
2084}>;
2085
2086
2087export type RegisterMutation = (
2088  { __typename?: 'Mutation' }
2089  & { register: (
2090    { __typename?: 'UsersPermissionsLoginPayload' }
2091    & Pick<UsersPermissionsLoginPayload, 'jwt'>
2092    & { user: (
2093      { __typename?: 'UsersPermissionsMe' }
2094      & MeFieldsFragment
2095    ) }
2096  ) }
2097);
2098
2099export type LoginMutationVariables = Exact<{
2100  identifier: Scalars['String'];
2101  password: Scalars['String'];
2102}>;
2103
2104
2105export type LoginMutation = (
2106  { __typename?: 'Mutation' }
2107  & { login: (
2108    { __typename?: 'UsersPermissionsLoginPayload' }
2109    & Pick<UsersPermissionsLoginPayload, 'jwt'>
2110    & { user: (
2111      { __typename?: 'UsersPermissionsMe' }
2112      & MeFieldsFragment
2113    ) }
2114  ) }
2115);
2116
2117export type ForgotPasswordMutationVariables = Exact<{
2118  email: Scalars['String'];
2119}>;
2120
2121
2122export type ForgotPasswordMutation = (
2123  { __typename?: 'Mutation' }
2124  & { forgotPassword?: Maybe<(
2125    { __typename?: 'UserPermissionsPasswordPayload' }
2126    & Pick<UserPermissionsPasswordPayload, 'ok'>
2127  )> }
2128);
2129
2130export type ResetPasswordMutationVariables = Exact<{
2131  password: Scalars['String'];
2132  passwordConfirmation: Scalars['String'];
2133  code: Scalars['String'];
2134}>;
2135
2136
2137export type ResetPasswordMutation = (
2138  { __typename?: 'Mutation' }
2139  & { resetPassword?: Maybe<(
2140    { __typename?: 'UsersPermissionsLoginPayload' }
2141    & Pick<UsersPermissionsLoginPayload, 'jwt'>
2142    & { user: (
2143      { __typename?: 'UsersPermissionsMe' }
2144      & MeFieldsFragment
2145    ) }
2146  )> }
2147);
2148
2149export type EventFieldsFragment = (
2150  { __typename?: 'Event' }
2151  & Pick<Event, 'id' | 'uuid' | 'name' | 'email' | 'date' | 'address' | 'position'>
2152  & { waitingList?: Maybe<Array<Maybe<(
2153    { __typename?: 'ComponentPassengerPassenger' }
2154    & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2155    & { user?: Maybe<(
2156      { __typename?: 'UsersPermissionsUser' }
2157      & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2158    )> }
2159  )>>>, travels?: Maybe<Array<Maybe<(
2160    { __typename?: 'Travel' }
2161    & Pick<Travel, 'id' | 'meeting' | 'departure' | 'details'>
2162    & { vehicle?: Maybe<(
2163      { __typename?: 'Vehicle' }
2164      & Pick<Vehicle, 'id' | 'name' | 'phone_number' | 'seats'>
2165    )>, passengers?: Maybe<Array<Maybe<(
2166      { __typename?: 'ComponentPassengerPassenger' }
2167      & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2168      & { user?: Maybe<(
2169        { __typename?: 'UsersPermissionsUser' }
2170        & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2171      )> }
2172    )>>> }
2173  )>>> }
2174);
2175
2176export type CreateEventMutationVariables = Exact<{
2177  name: Scalars['String'];
2178  email: Scalars['String'];
2179  date?: Maybe<Scalars['Date']>;
2180  address?: Maybe<Scalars['String']>;
2181  newsletter?: Maybe<Scalars['Boolean']>;
2182}>;
2183
2184
2185export type CreateEventMutation = (
2186  { __typename?: 'Mutation' }
2187  & { createEvent?: Maybe<(
2188    { __typename?: 'createEventPayload' }
2189    & { event?: Maybe<(
2190      { __typename?: 'Event' }
2191      & EventFieldsFragment
2192    )> }
2193  )> }
2194);
2195
2196export type UpdateEventMutationVariables = Exact<{
2197  uuid: Scalars['String'];
2198  eventUpdate?: Maybe<EditEventInput>;
2199}>;
2200
2201
2202export type UpdateEventMutation = (
2203  { __typename?: 'Mutation' }
2204  & { updateEventByUUID?: Maybe<(
2205    { __typename?: 'updateEventPayload' }
2206    & { event?: Maybe<(
2207      { __typename?: 'Event' }
2208      & EventFieldsFragment
2209    )> }
2210  )> }
2211);
2212
2213export type EventByUuidQueryVariables = Exact<{
2214  uuid: Scalars['String'];
2215}>;
2216
2217
2218export type EventByUuidQuery = (
2219  { __typename?: 'Query' }
2220  & { eventByUUID?: Maybe<(
2221    { __typename?: 'Event' }
2222    & EventFieldsFragment
2223  )> }
2224);
2225
2226export type SettingQueryVariables = Exact<{ [key: string]: never; }>;
2227
2228
2229export type SettingQuery = (
2230  { __typename?: 'Query' }
2231  & { setting?: Maybe<(
2232    { __typename?: 'Settings' }
2233    & Pick<Settings, 'id' | 'gtm_id' | 'about_link'>
2234  )> }
2235);
2236
2237export type TravelFieldsFragment = (
2238  { __typename?: 'Travel' }
2239  & Pick<Travel, 'id' | 'meeting' | 'departure' | 'details'>
2240  & { vehicle?: Maybe<(
2241    { __typename?: 'Vehicle' }
2242    & Pick<Vehicle, 'id' | 'name' | 'phone_number' | 'seats'>
2243  )>, passengers?: Maybe<Array<Maybe<(
2244    { __typename?: 'ComponentPassengerPassenger' }
2245    & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2246    & { user?: Maybe<(
2247      { __typename?: 'UsersPermissionsUser' }
2248      & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2249    )> }
2250  )>>> }
2251);
2252
2253export type CreateTravelMutationVariables = Exact<{
2254  travel: TravelInput;
2255}>;
2256
2257
2258export type CreateTravelMutation = (
2259  { __typename?: 'Mutation' }
2260  & { createTravel?: Maybe<(
2261    { __typename?: 'createTravelPayload' }
2262    & { travel?: Maybe<(
2263      { __typename?: 'Travel' }
2264      & TravelFieldsFragment
2265    )> }
2266  )> }
2267);
2268
2269export type UpdateTravelMutationVariables = Exact<{
2270  id: Scalars['ID'];
2271  travelUpdate: EditTravelInput;
2272}>;
2273
2274
2275export type UpdateTravelMutation = (
2276  { __typename?: 'Mutation' }
2277  & { updateTravel?: Maybe<(
2278    { __typename?: 'updateTravelPayload' }
2279    & { travel?: Maybe<(
2280      { __typename?: 'Travel' }
2281      & TravelFieldsFragment
2282    )> }
2283  )> }
2284);
2285
2286export type DeleteTravelMutationVariables = Exact<{
2287  id: Scalars['ID'];
2288}>;
2289
2290
2291export type DeleteTravelMutation = (
2292  { __typename?: 'Mutation' }
2293  & { deleteTravel?: Maybe<(
2294    { __typename?: 'deleteTravelPayload' }
2295    & { travel?: Maybe<(
2296      { __typename?: 'Travel' }
2297      & Pick<Travel, 'id'>
2298    )> }
2299  )> }
2300);
2301
2302export type UserFieldsFragment = (
2303  { __typename?: 'UsersPermissionsUser' }
2304  & Pick<UsersPermissionsUser, 'id' | 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName' | 'lang' | 'onboardingUser' | 'onboardingCreator'>
2305  & { events?: Maybe<Array<Maybe<(
2306    { __typename?: 'Event' }
2307    & Pick<Event, 'id' | 'uuid' | 'name' | 'date' | 'address'>
2308  )>>> }
2309);
2310
2311export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
2312
2313
2314export type ProfileQuery = (
2315  { __typename?: 'Query' }
2316  & { me?: Maybe<(
2317    { __typename?: 'UsersPermissionsMe' }
2318    & Pick<UsersPermissionsMe, 'id' | 'username'>
2319    & { profile?: Maybe<(
2320      { __typename?: 'UsersPermissionsUser' }
2321      & UserFieldsFragment
2322    )> }
2323  )> }
2324);
2325
2326export type UpdateMeMutationVariables = Exact<{
2327  userUpdate: EditUserInput;
2328}>;
2329
2330
2331export type UpdateMeMutation = (
2332  { __typename?: 'Mutation' }
2333  & { updateMe: (
2334    { __typename?: 'updateUserPayload' }
2335    & { user?: Maybe<(
2336      { __typename?: 'UsersPermissionsUser' }
2337      & UserFieldsFragment
2338    )> }
2339  ) }
2340);
2341
2342export type VehicleFieldsFragment = (
2343  { __typename?: 'Vehicle' }
2344  & Pick<Vehicle, 'id' | 'name' | 'seats' | 'phone_number'>
2345);
2346
2347export type CreateVehicleMutationVariables = Exact<{
2348  vehicle: VehicleInput;
2349}>;
2350
2351
2352export type CreateVehicleMutation = (
2353  { __typename?: 'Mutation' }
2354  & { createVehicle?: Maybe<(
2355    { __typename?: 'createVehiclePayload' }
2356    & { vehicle?: Maybe<(
2357      { __typename?: 'Vehicle' }
2358      & VehicleFieldsFragment
2359    )> }
2360  )> }
2361);
2362
2363export type UpdateVehicleMutationVariables = Exact<{
2364  id: Scalars['ID'];
2365  vehicleUpdate: EditVehicleInput;
2366}>;
2367
2368
2369export type UpdateVehicleMutation = (
2370  { __typename?: 'Mutation' }
2371  & { updateVehicle?: Maybe<(
2372    { __typename?: 'updateVehiclePayload' }
2373    & { vehicle?: Maybe<(
2374      { __typename?: 'Vehicle' }
2375      & VehicleFieldsFragment
2376    )> }
2377  )> }
2378);
2379
2380export type DeleteVehicleMutationVariables = Exact<{
2381  id: Scalars['ID'];
2382}>;
2383
2384
2385export type DeleteVehicleMutation = (
2386  { __typename?: 'Mutation' }
2387  & { deleteVehicle?: Maybe<(
2388    { __typename?: 'deleteVehiclePayload' }
2389    & { vehicle?: Maybe<(
2390      { __typename?: 'Vehicle' }
2391      & Pick<Vehicle, 'id' | 'name'>
2392    )> }
2393  )> }
2394);
2395
2396export const MeFieldsFragmentDoc = gql`
2397    fragment MeFields on UsersPermissionsMe {
2398  id
2399  username
2400  email
2401  confirmed
2402}
2403    `;
2404export const EventFieldsFragmentDoc = gql`
2405    fragment EventFields on Event {
2406  id
2407  uuid
2408  name
2409  email
2410  date
2411  address
2412  position
2413  waitingList {
2414    id
2415    name
2416    location
2417    user {
2418      id
2419      firstName
2420      lastName
2421    }
2422  }
2423  travels {
2424    id
2425    meeting
2426    departure
2427    details
2428    vehicle {
2429      id
2430      name
2431      phone_number
2432      seats
2433    }
2434    passengers {
2435      id
2436      name
2437      location
2438      user {
2439        id
2440        firstName
2441        lastName
2442      }
2443    }
2444  }
2445}
2446    `;
2447export const TravelFieldsFragmentDoc = gql`
2448    fragment TravelFields on Travel {
2449  id
2450  meeting
2451  departure
2452  details
2453  vehicle {
2454    id
2455    name
2456    phone_number
2457    seats
2458  }
2459  passengers {
2460    id
2461    name
2462    location
2463    user {
2464      id
2465      firstName
2466      lastName
2467    }
2468  }
2469}
2470    `;
2471export const UserFieldsFragmentDoc = gql`
2472    fragment UserFields on UsersPermissionsUser {
2473  id
2474  username
2475  email
2476  confirmed
2477  lastName
2478  firstName
2479  lang
2480  onboardingUser
2481  onboardingCreator
2482  events {
2483    id
2484    uuid
2485    name
2486    date
2487    address
2488  }
2489}
2490    `;
2491export const VehicleFieldsFragmentDoc = gql`
2492    fragment VehicleFields on Vehicle {
2493  id
2494  name
2495  seats
2496  phone_number
2497}
2498    `;
2499export const RegisterDocument = gql`
2500    mutation register($user: UsersPermissionsRegisterInput!) {
2501  register(input: $user) {
2502    jwt
2503    user {
2504      ...MeFields
2505    }
2506  }
2507}
2508    ${MeFieldsFragmentDoc}`;
2509export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
2510
2511/**
2512 * __useRegisterMutation__
2513 *
2514 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
2515 * When your component renders, `useRegisterMutation` returns a tuple that includes:
2516 * - A mutate function that you can call at any time to execute the mutation
2517 * - An object with fields that represent the current status of the mutation's execution
2518 *
2519 * @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;
2520 *
2521 * @example
2522 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
2523 *   variables: {
2524 *      user: // value for 'user'
2525 *   },
2526 * });
2527 */
2528export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
2529        return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
2530      }
2531export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
2532export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
2533export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
2534export const LoginDocument = gql`
2535    mutation login($identifier: String!, $password: String!) {
2536  login(input: {identifier: $identifier, password: $password}) {
2537    jwt
2538    user {
2539      ...MeFields
2540    }
2541  }
2542}
2543    ${MeFieldsFragmentDoc}`;
2544export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
2545
2546/**
2547 * __useLoginMutation__
2548 *
2549 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
2550 * When your component renders, `useLoginMutation` returns a tuple that includes:
2551 * - A mutate function that you can call at any time to execute the mutation
2552 * - An object with fields that represent the current status of the mutation's execution
2553 *
2554 * @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;
2555 *
2556 * @example
2557 * const [loginMutation, { data, loading, error }] = useLoginMutation({
2558 *   variables: {
2559 *      identifier: // value for 'identifier'
2560 *      password: // value for 'password'
2561 *   },
2562 * });
2563 */
2564export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
2565        return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
2566      }
2567export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
2568export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
2569export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
2570export const ForgotPasswordDocument = gql`
2571    mutation forgotPassword($email: String!) {
2572  forgotPassword(email: $email) {
2573    ok
2574  }
2575}
2576    `;
2577export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2578
2579/**
2580 * __useForgotPasswordMutation__
2581 *
2582 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
2583 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
2584 * - A mutate function that you can call at any time to execute the mutation
2585 * - An object with fields that represent the current status of the mutation's execution
2586 *
2587 * @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;
2588 *
2589 * @example
2590 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
2591 *   variables: {
2592 *      email: // value for 'email'
2593 *   },
2594 * });
2595 */
2596export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
2597        return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
2598      }
2599export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
2600export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
2601export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2602export const ResetPasswordDocument = gql`
2603    mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
2604  resetPassword(
2605    password: $password
2606    passwordConfirmation: $passwordConfirmation
2607    code: $code
2608  ) {
2609    jwt
2610    user {
2611      ...MeFields
2612    }
2613  }
2614}
2615    ${MeFieldsFragmentDoc}`;
2616export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
2617
2618/**
2619 * __useResetPasswordMutation__
2620 *
2621 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
2622 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
2623 * - A mutate function that you can call at any time to execute the mutation
2624 * - An object with fields that represent the current status of the mutation's execution
2625 *
2626 * @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;
2627 *
2628 * @example
2629 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
2630 *   variables: {
2631 *      password: // value for 'password'
2632 *      passwordConfirmation: // value for 'passwordConfirmation'
2633 *      code: // value for 'code'
2634 *   },
2635 * });
2636 */
2637export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
2638        return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
2639      }
2640export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
2641export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
2642export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
2643export const CreateEventDocument = gql`
2644    mutation createEvent($name: String!, $email: String!, $date: Date, $address: String, $newsletter: Boolean) {
2645  createEvent(
2646    input: {data: {name: $name, email: $email, date: $date, address: $address, newsletter: $newsletter}}
2647  ) {
2648    event {
2649      ...EventFields
2650    }
2651  }
2652}
2653    ${EventFieldsFragmentDoc}`;
2654export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2655
2656/**
2657 * __useCreateEventMutation__
2658 *
2659 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2660 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2661 * - A mutate function that you can call at any time to execute the mutation
2662 * - An object with fields that represent the current status of the mutation's execution
2663 *
2664 * @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;
2665 *
2666 * @example
2667 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2668 *   variables: {
2669 *      name: // value for 'name'
2670 *      email: // value for 'email'
2671 *      date: // value for 'date'
2672 *      address: // value for 'address'
2673 *      newsletter: // value for 'newsletter'
2674 *   },
2675 * });
2676 */
2677export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2678        return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2679      }
2680export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2681export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2682export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2683export const UpdateEventDocument = gql`
2684    mutation updateEvent($uuid: String!, $eventUpdate: editEventInput) {
2685  updateEventByUUID(input: {where: {uuid: $uuid}, data: $eventUpdate}) {
2686    event {
2687      ...EventFields
2688    }
2689  }
2690}
2691    ${EventFieldsFragmentDoc}`;
2692export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2693
2694/**
2695 * __useUpdateEventMutation__
2696 *
2697 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2698 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2699 * - A mutate function that you can call at any time to execute the mutation
2700 * - An object with fields that represent the current status of the mutation's execution
2701 *
2702 * @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;
2703 *
2704 * @example
2705 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2706 *   variables: {
2707 *      uuid: // value for 'uuid'
2708 *      eventUpdate: // value for 'eventUpdate'
2709 *   },
2710 * });
2711 */
2712export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2713        return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2714      }
2715export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2716export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2717export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2718export const EventByUuidDocument = gql`
2719    query eventByUUID($uuid: String!) {
2720  eventByUUID(uuid: $uuid) {
2721    ...EventFields
2722  }
2723}
2724    ${EventFieldsFragmentDoc}`;
2725
2726/**
2727 * __useEventByUuidQuery__
2728 *
2729 * To run a query within a React component, call `useEventByUuidQuery` and pass it any options that fit your needs.
2730 * When your component renders, `useEventByUuidQuery` returns an object from Apollo Client that contains loading, error, and data properties
2731 * you can use to render your UI.
2732 *
2733 * @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;
2734 *
2735 * @example
2736 * const { data, loading, error } = useEventByUuidQuery({
2737 *   variables: {
2738 *      uuid: // value for 'uuid'
2739 *   },
2740 * });
2741 */
2742export function useEventByUuidQuery(baseOptions: Apollo.QueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2743        return Apollo.useQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2744      }
2745export function useEventByUuidLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2746          return Apollo.useLazyQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2747        }
2748export type EventByUuidQueryHookResult = ReturnType<typeof useEventByUuidQuery>;
2749export type EventByUuidLazyQueryHookResult = ReturnType<typeof useEventByUuidLazyQuery>;
2750export type EventByUuidQueryResult = Apollo.QueryResult<EventByUuidQuery, EventByUuidQueryVariables>;
2751export const SettingDocument = gql`
2752    query setting {
2753  setting {
2754    id
2755    gtm_id
2756    about_link
2757  }
2758}
2759    `;
2760
2761/**
2762 * __useSettingQuery__
2763 *
2764 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2765 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2766 * you can use to render your UI.
2767 *
2768 * @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;
2769 *
2770 * @example
2771 * const { data, loading, error } = useSettingQuery({
2772 *   variables: {
2773 *   },
2774 * });
2775 */
2776export function useSettingQuery(baseOptions?: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2777        return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2778      }
2779export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2780          return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2781        }
2782export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2783export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2784export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2785export const CreateTravelDocument = gql`
2786    mutation createTravel($travel: TravelInput!) {
2787  createTravel(input: {data: $travel}) {
2788    travel {
2789      ...TravelFields
2790    }
2791  }
2792}
2793    ${TravelFieldsFragmentDoc}`;
2794export type CreateTravelMutationFn = Apollo.MutationFunction<CreateTravelMutation, CreateTravelMutationVariables>;
2795
2796/**
2797 * __useCreateTravelMutation__
2798 *
2799 * To run a mutation, you first call `useCreateTravelMutation` within a React component and pass it any options that fit your needs.
2800 * When your component renders, `useCreateTravelMutation` returns a tuple that includes:
2801 * - A mutate function that you can call at any time to execute the mutation
2802 * - An object with fields that represent the current status of the mutation's execution
2803 *
2804 * @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;
2805 *
2806 * @example
2807 * const [createTravelMutation, { data, loading, error }] = useCreateTravelMutation({
2808 *   variables: {
2809 *      travel: // value for 'travel'
2810 *   },
2811 * });
2812 */
2813export function useCreateTravelMutation(baseOptions?: Apollo.MutationHookOptions<CreateTravelMutation, CreateTravelMutationVariables>) {
2814        return Apollo.useMutation<CreateTravelMutation, CreateTravelMutationVariables>(CreateTravelDocument, baseOptions);
2815      }
2816export type CreateTravelMutationHookResult = ReturnType<typeof useCreateTravelMutation>;
2817export type CreateTravelMutationResult = Apollo.MutationResult<CreateTravelMutation>;
2818export type CreateTravelMutationOptions = Apollo.BaseMutationOptions<CreateTravelMutation, CreateTravelMutationVariables>;
2819export const UpdateTravelDocument = gql`
2820    mutation updateTravel($id: ID!, $travelUpdate: editTravelInput!) {
2821  updateTravel(input: {where: {id: $id}, data: $travelUpdate}) {
2822    travel {
2823      ...TravelFields
2824    }
2825  }
2826}
2827    ${TravelFieldsFragmentDoc}`;
2828export type UpdateTravelMutationFn = Apollo.MutationFunction<UpdateTravelMutation, UpdateTravelMutationVariables>;
2829
2830/**
2831 * __useUpdateTravelMutation__
2832 *
2833 * To run a mutation, you first call `useUpdateTravelMutation` within a React component and pass it any options that fit your needs.
2834 * When your component renders, `useUpdateTravelMutation` returns a tuple that includes:
2835 * - A mutate function that you can call at any time to execute the mutation
2836 * - An object with fields that represent the current status of the mutation's execution
2837 *
2838 * @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;
2839 *
2840 * @example
2841 * const [updateTravelMutation, { data, loading, error }] = useUpdateTravelMutation({
2842 *   variables: {
2843 *      id: // value for 'id'
2844 *      travelUpdate: // value for 'travelUpdate'
2845 *   },
2846 * });
2847 */
2848export function useUpdateTravelMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTravelMutation, UpdateTravelMutationVariables>) {
2849        return Apollo.useMutation<UpdateTravelMutation, UpdateTravelMutationVariables>(UpdateTravelDocument, baseOptions);
2850      }
2851export type UpdateTravelMutationHookResult = ReturnType<typeof useUpdateTravelMutation>;
2852export type UpdateTravelMutationResult = Apollo.MutationResult<UpdateTravelMutation>;
2853export type UpdateTravelMutationOptions = Apollo.BaseMutationOptions<UpdateTravelMutation, UpdateTravelMutationVariables>;
2854export const DeleteTravelDocument = gql`
2855    mutation deleteTravel($id: ID!) {
2856  deleteTravel(input: {where: {id: $id}}) {
2857    travel {
2858      id
2859    }
2860  }
2861}
2862    `;
2863export type DeleteTravelMutationFn = Apollo.MutationFunction<DeleteTravelMutation, DeleteTravelMutationVariables>;
2864
2865/**
2866 * __useDeleteTravelMutation__
2867 *
2868 * To run a mutation, you first call `useDeleteTravelMutation` within a React component and pass it any options that fit your needs.
2869 * When your component renders, `useDeleteTravelMutation` returns a tuple that includes:
2870 * - A mutate function that you can call at any time to execute the mutation
2871 * - An object with fields that represent the current status of the mutation's execution
2872 *
2873 * @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;
2874 *
2875 * @example
2876 * const [deleteTravelMutation, { data, loading, error }] = useDeleteTravelMutation({
2877 *   variables: {
2878 *      id: // value for 'id'
2879 *   },
2880 * });
2881 */
2882export function useDeleteTravelMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTravelMutation, DeleteTravelMutationVariables>) {
2883        return Apollo.useMutation<DeleteTravelMutation, DeleteTravelMutationVariables>(DeleteTravelDocument, baseOptions);
2884      }
2885export type DeleteTravelMutationHookResult = ReturnType<typeof useDeleteTravelMutation>;
2886export type DeleteTravelMutationResult = Apollo.MutationResult<DeleteTravelMutation>;
2887export type DeleteTravelMutationOptions = Apollo.BaseMutationOptions<DeleteTravelMutation, DeleteTravelMutationVariables>;
2888export const ProfileDocument = gql`
2889    query profile {
2890  me {
2891    id
2892    username
2893    profile {
2894      ...UserFields
2895    }
2896  }
2897}
2898    ${UserFieldsFragmentDoc}`;
2899
2900/**
2901 * __useProfileQuery__
2902 *
2903 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2904 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2905 * you can use to render your UI.
2906 *
2907 * @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;
2908 *
2909 * @example
2910 * const { data, loading, error } = useProfileQuery({
2911 *   variables: {
2912 *   },
2913 * });
2914 */
2915export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2916        return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2917      }
2918export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2919          return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2920        }
2921export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2922export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2923export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2924export const UpdateMeDocument = gql`
2925    mutation updateMe($userUpdate: editUserInput!) {
2926  updateMe(input: $userUpdate) {
2927    user {
2928      ...UserFields
2929    }
2930  }
2931}
2932    ${UserFieldsFragmentDoc}`;
2933export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2934
2935/**
2936 * __useUpdateMeMutation__
2937 *
2938 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2939 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2940 * - A mutate function that you can call at any time to execute the mutation
2941 * - An object with fields that represent the current status of the mutation's execution
2942 *
2943 * @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;
2944 *
2945 * @example
2946 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2947 *   variables: {
2948 *      userUpdate: // value for 'userUpdate'
2949 *   },
2950 * });
2951 */
2952export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2953        return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2954      }
2955export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2956export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2957export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;
2958export const CreateVehicleDocument = gql`
2959    mutation createVehicle($vehicle: VehicleInput!) {
2960  createVehicle(input: {data: $vehicle}) {
2961    vehicle {
2962      ...VehicleFields
2963    }
2964  }
2965}
2966    ${VehicleFieldsFragmentDoc}`;
2967export type CreateVehicleMutationFn = Apollo.MutationFunction<CreateVehicleMutation, CreateVehicleMutationVariables>;
2968
2969/**
2970 * __useCreateVehicleMutation__
2971 *
2972 * To run a mutation, you first call `useCreateVehicleMutation` within a React component and pass it any options that fit your needs.
2973 * When your component renders, `useCreateVehicleMutation` returns a tuple that includes:
2974 * - A mutate function that you can call at any time to execute the mutation
2975 * - An object with fields that represent the current status of the mutation's execution
2976 *
2977 * @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;
2978 *
2979 * @example
2980 * const [createVehicleMutation, { data, loading, error }] = useCreateVehicleMutation({
2981 *   variables: {
2982 *      vehicle: // value for 'vehicle'
2983 *   },
2984 * });
2985 */
2986export function useCreateVehicleMutation(baseOptions?: Apollo.MutationHookOptions<CreateVehicleMutation, CreateVehicleMutationVariables>) {
2987        return Apollo.useMutation<CreateVehicleMutation, CreateVehicleMutationVariables>(CreateVehicleDocument, baseOptions);
2988      }
2989export type CreateVehicleMutationHookResult = ReturnType<typeof useCreateVehicleMutation>;
2990export type CreateVehicleMutationResult = Apollo.MutationResult<CreateVehicleMutation>;
2991export type CreateVehicleMutationOptions = Apollo.BaseMutationOptions<CreateVehicleMutation, CreateVehicleMutationVariables>;
2992export const UpdateVehicleDocument = gql`
2993    mutation updateVehicle($id: ID!, $vehicleUpdate: editVehicleInput!) {
2994  updateVehicle(input: {where: {id: $id}, data: $vehicleUpdate}) {
2995    vehicle {
2996      ...VehicleFields
2997    }
2998  }
2999}
3000    ${VehicleFieldsFragmentDoc}`;
3001export type UpdateVehicleMutationFn = Apollo.MutationFunction<UpdateVehicleMutation, UpdateVehicleMutationVariables>;
3002
3003/**
3004 * __useUpdateVehicleMutation__
3005 *
3006 * To run a mutation, you first call `useUpdateVehicleMutation` within a React component and pass it any options that fit your needs.
3007 * When your component renders, `useUpdateVehicleMutation` returns a tuple that includes:
3008 * - A mutate function that you can call at any time to execute the mutation
3009 * - An object with fields that represent the current status of the mutation's execution
3010 *
3011 * @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;
3012 *
3013 * @example
3014 * const [updateVehicleMutation, { data, loading, error }] = useUpdateVehicleMutation({
3015 *   variables: {
3016 *      id: // value for 'id'
3017 *      vehicleUpdate: // value for 'vehicleUpdate'
3018 *   },
3019 * });
3020 */
3021export function useUpdateVehicleMutation(baseOptions?: Apollo.MutationHookOptions<UpdateVehicleMutation, UpdateVehicleMutationVariables>) {
3022        return Apollo.useMutation<UpdateVehicleMutation, UpdateVehicleMutationVariables>(UpdateVehicleDocument, baseOptions);
3023      }
3024export type UpdateVehicleMutationHookResult = ReturnType<typeof useUpdateVehicleMutation>;
3025export type UpdateVehicleMutationResult = Apollo.MutationResult<UpdateVehicleMutation>;
3026export type UpdateVehicleMutationOptions = Apollo.BaseMutationOptions<UpdateVehicleMutation, UpdateVehicleMutationVariables>;
3027export const DeleteVehicleDocument = gql`
3028    mutation deleteVehicle($id: ID!) {
3029  deleteVehicle(input: {where: {id: $id}}) {
3030    vehicle {
3031      id
3032      name
3033    }
3034  }
3035}
3036    `;
3037export type DeleteVehicleMutationFn = Apollo.MutationFunction<DeleteVehicleMutation, DeleteVehicleMutationVariables>;
3038
3039/**
3040 * __useDeleteVehicleMutation__
3041 *
3042 * To run a mutation, you first call `useDeleteVehicleMutation` within a React component and pass it any options that fit your needs.
3043 * When your component renders, `useDeleteVehicleMutation` returns a tuple that includes:
3044 * - A mutate function that you can call at any time to execute the mutation
3045 * - An object with fields that represent the current status of the mutation's execution
3046 *
3047 * @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;
3048 *
3049 * @example
3050 * const [deleteVehicleMutation, { data, loading, error }] = useDeleteVehicleMutation({
3051 *   variables: {
3052 *      id: // value for 'id'
3053 *   },
3054 * });
3055 */
3056export function useDeleteVehicleMutation(baseOptions?: Apollo.MutationHookOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>) {
3057        return Apollo.useMutation<DeleteVehicleMutation, DeleteVehicleMutationVariables>(DeleteVehicleDocument, baseOptions);
3058      }
3059export type DeleteVehicleMutationHookResult = ReturnType<typeof useDeleteVehicleMutation>;
3060export type DeleteVehicleMutationResult = Apollo.MutationResult<DeleteVehicleMutation>;
3061export type DeleteVehicleMutationOptions = Apollo.BaseMutationOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>;