1import { gql } from '@apollo/client';
   2import * as Apollo from '@apollo/client';
   3export type Maybe<T> = T | null;
   4export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
   5export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
   6export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
   7/** All built-in and custom scalars, mapped to their actual values */
   8export type Scalars = {
   9  ID: string;
  10  String: string;
  11  Boolean: boolean;
  12  Int: number;
  13  Float: number;
  14  /** A date string, such as 2007-12-03, compliant with the `full-date` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
  15  Date: any;
  16  /** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
  17  DateTime: any;
  18  /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
  19  JSON: any;
  20  /** The `Long` scalar type represents 52-bit integers */
  21  Long: any;
  22  /** A time string with format: HH:mm:ss.SSS */
  23  Time: any;
  24  /** The `Upload` scalar type represents a file upload. */
  25  Upload: any;
  26};
  27
  28export type AdminUser = {
  29  __typename?: 'AdminUser';
  30  id: Scalars['ID'];
  31  username?: Maybe<Scalars['String']>;
  32  firstname: Scalars['String'];
  33  lastname: Scalars['String'];
  34};
  35
  36export type Car = {
  37  __typename?: 'Car';
  38  id: Scalars['ID'];
  39  created_at: Scalars['DateTime'];
  40  updated_at: Scalars['DateTime'];
  41  name: Scalars['String'];
  42  seats: Scalars['Int'];
  43  meeting?: Maybe<Scalars['String']>;
  44  departure?: Maybe<Scalars['DateTime']>;
  45  phone_number?: Maybe<Scalars['String']>;
  46  details?: Maybe<Scalars['String']>;
  47  event?: Maybe<Event>;
  48  passengers?: Maybe<Array<Maybe<ComponentPassengerPassenger>>>;
  49};
  50
  51export type CarAggregator = {
  52  __typename?: 'CarAggregator';
  53  count?: Maybe<Scalars['Int']>;
  54  totalCount?: Maybe<Scalars['Int']>;
  55  sum?: Maybe<CarAggregatorSum>;
  56  avg?: Maybe<CarAggregatorAvg>;
  57  min?: Maybe<CarAggregatorMin>;
  58  max?: Maybe<CarAggregatorMax>;
  59};
  60
  61export type CarAggregatorAvg = {
  62  __typename?: 'CarAggregatorAvg';
  63  seats?: Maybe<Scalars['Float']>;
  64};
  65
  66export type CarAggregatorMax = {
  67  __typename?: 'CarAggregatorMax';
  68  seats?: Maybe<Scalars['Float']>;
  69};
  70
  71export type CarAggregatorMin = {
  72  __typename?: 'CarAggregatorMin';
  73  seats?: Maybe<Scalars['Float']>;
  74};
  75
  76export type CarAggregatorSum = {
  77  __typename?: 'CarAggregatorSum';
  78  seats?: Maybe<Scalars['Float']>;
  79};
  80
  81export type CarConnection = {
  82  __typename?: 'CarConnection';
  83  values?: Maybe<Array<Maybe<Car>>>;
  84  groupBy?: Maybe<CarGroupBy>;
  85  aggregate?: Maybe<CarAggregator>;
  86};
  87
  88export type CarConnectionCreated_At = {
  89  __typename?: 'CarConnectionCreated_at';
  90  key?: Maybe<Scalars['DateTime']>;
  91  connection?: Maybe<CarConnection>;
  92};
  93
  94export type CarConnectionDeparture = {
  95  __typename?: 'CarConnectionDeparture';
  96  key?: Maybe<Scalars['DateTime']>;
  97  connection?: Maybe<CarConnection>;
  98};
  99
 100export type CarConnectionDetails = {
 101  __typename?: 'CarConnectionDetails';
 102  key?: Maybe<Scalars['String']>;
 103  connection?: Maybe<CarConnection>;
 104};
 105
 106export type CarConnectionEvent = {
 107  __typename?: 'CarConnectionEvent';
 108  key?: Maybe<Scalars['ID']>;
 109  connection?: Maybe<CarConnection>;
 110};
 111
 112export type CarConnectionId = {
 113  __typename?: 'CarConnectionId';
 114  key?: Maybe<Scalars['ID']>;
 115  connection?: Maybe<CarConnection>;
 116};
 117
 118export type CarConnectionMeeting = {
 119  __typename?: 'CarConnectionMeeting';
 120  key?: Maybe<Scalars['String']>;
 121  connection?: Maybe<CarConnection>;
 122};
 123
 124export type CarConnectionName = {
 125  __typename?: 'CarConnectionName';
 126  key?: Maybe<Scalars['String']>;
 127  connection?: Maybe<CarConnection>;
 128};
 129
 130export type CarConnectionPhone_Number = {
 131  __typename?: 'CarConnectionPhone_number';
 132  key?: Maybe<Scalars['String']>;
 133  connection?: Maybe<CarConnection>;
 134};
 135
 136export type CarConnectionSeats = {
 137  __typename?: 'CarConnectionSeats';
 138  key?: Maybe<Scalars['Int']>;
 139  connection?: Maybe<CarConnection>;
 140};
 141
 142export type CarConnectionUpdated_At = {
 143  __typename?: 'CarConnectionUpdated_at';
 144  key?: Maybe<Scalars['DateTime']>;
 145  connection?: Maybe<CarConnection>;
 146};
 147
 148export type CarGroupBy = {
 149  __typename?: 'CarGroupBy';
 150  id?: Maybe<Array<Maybe<CarConnectionId>>>;
 151  created_at?: Maybe<Array<Maybe<CarConnectionCreated_At>>>;
 152  updated_at?: Maybe<Array<Maybe<CarConnectionUpdated_At>>>;
 153  name?: Maybe<Array<Maybe<CarConnectionName>>>;
 154  seats?: Maybe<Array<Maybe<CarConnectionSeats>>>;
 155  meeting?: Maybe<Array<Maybe<CarConnectionMeeting>>>;
 156  departure?: Maybe<Array<Maybe<CarConnectionDeparture>>>;
 157  phone_number?: Maybe<Array<Maybe<CarConnectionPhone_Number>>>;
 158  details?: Maybe<Array<Maybe<CarConnectionDetails>>>;
 159  event?: Maybe<Array<Maybe<CarConnectionEvent>>>;
 160};
 161
 162export type CarInput = {
 163  name: Scalars['String'];
 164  seats: Scalars['Int'];
 165  meeting?: Maybe<Scalars['String']>;
 166  departure?: Maybe<Scalars['DateTime']>;
 167  phone_number?: Maybe<Scalars['String']>;
 168  details?: Maybe<Scalars['String']>;
 169  event?: Maybe<Scalars['ID']>;
 170  passengers?: Maybe<Array<Maybe<ComponentPassengerPassengerInput>>>;
 171  created_by?: Maybe<Scalars['ID']>;
 172  updated_by?: Maybe<Scalars['ID']>;
 173};
 174
 175export type ComponentPassengerPassenger = {
 176  __typename?: 'ComponentPassengerPassenger';
 177  id: Scalars['ID'];
 178  name: Scalars['String'];
 179  email?: Maybe<Scalars['String']>;
 180  location?: Maybe<Scalars['String']>;
 181  user?: Maybe<UsersPermissionsUser>;
 182};
 183
 184export type ComponentPassengerPassengerInput = {
 185  name: Scalars['String'];
 186  email?: Maybe<Scalars['String']>;
 187  location?: Maybe<Scalars['String']>;
 188  user?: Maybe<Scalars['ID']>;
 189};
 190
 191
 192
 193export type Dependency = {
 194  __typename?: 'Dependency';
 195  name: Scalars['String'];
 196  version: Scalars['String'];
 197};
 198
 199export enum Enum_Page_Type {
 200  Tos = 'tos'
 201}
 202
 203export enum Enum_Userspermissionsuser_Lang {
 204  Fr = 'FR',
 205  En = 'EN'
 206}
 207
 208export type EmailDesignerEmailTemplate = {
 209  __typename?: 'EmailDesignerEmailTemplate';
 210  id: Scalars['ID'];
 211  created_at: Scalars['DateTime'];
 212  updated_at: Scalars['DateTime'];
 213  sourceCodeToTemplateId?: Maybe<Scalars['Int']>;
 214  design?: Maybe<Scalars['JSON']>;
 215  name?: Maybe<Scalars['String']>;
 216  subject?: Maybe<Scalars['String']>;
 217  bodyHtml?: Maybe<Scalars['String']>;
 218  bodyText?: Maybe<Scalars['String']>;
 219  enabled?: Maybe<Scalars['Boolean']>;
 220  tags?: Maybe<Scalars['JSON']>;
 221};
 222
 223export type EmailTemplateInput = {
 224  sourceCodeToTemplateId?: Maybe<Scalars['Int']>;
 225  design?: Maybe<Scalars['JSON']>;
 226  name?: Maybe<Scalars['String']>;
 227  subject?: Maybe<Scalars['String']>;
 228  bodyHtml?: Maybe<Scalars['String']>;
 229  bodyText?: Maybe<Scalars['String']>;
 230  enabled?: Maybe<Scalars['Boolean']>;
 231  tags?: Maybe<Scalars['JSON']>;
 232  created_by?: Maybe<Scalars['ID']>;
 233  updated_by?: Maybe<Scalars['ID']>;
 234};
 235
 236export type Event = {
 237  __typename?: 'Event';
 238  id: Scalars['ID'];
 239  created_at: Scalars['DateTime'];
 240  updated_at: Scalars['DateTime'];
 241  name: Scalars['String'];
 242  email: Scalars['String'];
 243  date?: Maybe<Scalars['Date']>;
 244  address?: Maybe<Scalars['String']>;
 245  position?: Maybe<Scalars['JSON']>;
 246  uuid?: Maybe<Scalars['String']>;
 247  waitingList?: Maybe<Array<Maybe<ComponentPassengerPassenger>>>;
 248  description?: Maybe<Scalars['String']>;
 249  cars?: Maybe<Array<Maybe<Car>>>;
 250  users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
 251  travels?: Maybe<Array<Maybe<Travel>>>;
 252};
 253
 254
 255export type EventCarsArgs = {
 256  sort?: Maybe<Scalars['String']>;
 257  limit?: Maybe<Scalars['Int']>;
 258  start?: Maybe<Scalars['Int']>;
 259  where?: Maybe<Scalars['JSON']>;
 260};
 261
 262
 263export type EventUsersArgs = {
 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 EventTravelsArgs = {
 272  sort?: Maybe<Scalars['String']>;
 273  limit?: Maybe<Scalars['Int']>;
 274  start?: Maybe<Scalars['Int']>;
 275  where?: Maybe<Scalars['JSON']>;
 276};
 277
 278export type EventAggregator = {
 279  __typename?: 'EventAggregator';
 280  count?: Maybe<Scalars['Int']>;
 281  totalCount?: Maybe<Scalars['Int']>;
 282};
 283
 284export type EventConnection = {
 285  __typename?: 'EventConnection';
 286  values?: Maybe<Array<Maybe<Event>>>;
 287  groupBy?: Maybe<EventGroupBy>;
 288  aggregate?: Maybe<EventAggregator>;
 289};
 290
 291export type EventConnectionAddress = {
 292  __typename?: 'EventConnectionAddress';
 293  key?: Maybe<Scalars['String']>;
 294  connection?: Maybe<EventConnection>;
 295};
 296
 297export type EventConnectionCreated_At = {
 298  __typename?: 'EventConnectionCreated_at';
 299  key?: Maybe<Scalars['DateTime']>;
 300  connection?: Maybe<EventConnection>;
 301};
 302
 303export type EventConnectionDate = {
 304  __typename?: 'EventConnectionDate';
 305  key?: Maybe<Scalars['ID']>;
 306  connection?: Maybe<EventConnection>;
 307};
 308
 309export type EventConnectionDescription = {
 310  __typename?: 'EventConnectionDescription';
 311  key?: Maybe<Scalars['String']>;
 312  connection?: Maybe<EventConnection>;
 313};
 314
 315export type EventConnectionEmail = {
 316  __typename?: 'EventConnectionEmail';
 317  key?: Maybe<Scalars['String']>;
 318  connection?: Maybe<EventConnection>;
 319};
 320
 321export type EventConnectionId = {
 322  __typename?: 'EventConnectionId';
 323  key?: Maybe<Scalars['ID']>;
 324  connection?: Maybe<EventConnection>;
 325};
 326
 327export type EventConnectionName = {
 328  __typename?: 'EventConnectionName';
 329  key?: Maybe<Scalars['String']>;
 330  connection?: Maybe<EventConnection>;
 331};
 332
 333export type EventConnectionPosition = {
 334  __typename?: 'EventConnectionPosition';
 335  key?: Maybe<Scalars['JSON']>;
 336  connection?: Maybe<EventConnection>;
 337};
 338
 339export type EventConnectionUpdated_At = {
 340  __typename?: 'EventConnectionUpdated_at';
 341  key?: Maybe<Scalars['DateTime']>;
 342  connection?: Maybe<EventConnection>;
 343};
 344
 345export type EventConnectionUuid = {
 346  __typename?: 'EventConnectionUuid';
 347  key?: Maybe<Scalars['String']>;
 348  connection?: Maybe<EventConnection>;
 349};
 350
 351export type EventGroupBy = {
 352  __typename?: 'EventGroupBy';
 353  id?: Maybe<Array<Maybe<EventConnectionId>>>;
 354  created_at?: Maybe<Array<Maybe<EventConnectionCreated_At>>>;
 355  updated_at?: Maybe<Array<Maybe<EventConnectionUpdated_At>>>;
 356  name?: Maybe<Array<Maybe<EventConnectionName>>>;
 357  email?: Maybe<Array<Maybe<EventConnectionEmail>>>;
 358  date?: Maybe<Array<Maybe<EventConnectionDate>>>;
 359  address?: Maybe<Array<Maybe<EventConnectionAddress>>>;
 360  position?: Maybe<Array<Maybe<EventConnectionPosition>>>;
 361  uuid?: Maybe<Array<Maybe<EventConnectionUuid>>>;
 362  description?: Maybe<Array<Maybe<EventConnectionDescription>>>;
 363};
 364
 365export type EventInput = {
 366  name: Scalars['String'];
 367  email: Scalars['String'];
 368  date?: Maybe<Scalars['Date']>;
 369  address?: Maybe<Scalars['String']>;
 370  cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
 371  position?: Maybe<Scalars['JSON']>;
 372  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
 373  uuid?: Maybe<Scalars['String']>;
 374  waitingList?: Maybe<Array<Maybe<ComponentPassengerPassengerInput>>>;
 375  travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
 376  description?: Maybe<Scalars['String']>;
 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 | CreateCarPayload | UpdateCarPayload | DeleteCarPayload | Event | EventConnection | EventAggregator | EventGroupBy | EventConnectionId | EventConnectionCreated_At | EventConnectionUpdated_At | EventConnectionName | EventConnectionEmail | EventConnectionDate | EventConnectionAddress | EventConnectionPosition | EventConnectionUuid | EventConnectionDescription | 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 | VehicleConnectionPhone_Number | VehicleConnectionUser | 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  vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1302  created_by?: Maybe<Scalars['ID']>;
1303  updated_by?: Maybe<Scalars['ID']>;
1304};
1305
1306export type UserPermissionsPasswordPayload = {
1307  __typename?: 'UserPermissionsPasswordPayload';
1308  ok: Scalars['Boolean'];
1309};
1310
1311export type UsersPermissionsLoginInput = {
1312  identifier: Scalars['String'];
1313  password: Scalars['String'];
1314  provider?: Maybe<Scalars['String']>;
1315};
1316
1317export type UsersPermissionsLoginPayload = {
1318  __typename?: 'UsersPermissionsLoginPayload';
1319  jwt?: Maybe<Scalars['String']>;
1320  user: UsersPermissionsMe;
1321};
1322
1323export type UsersPermissionsMe = {
1324  __typename?: 'UsersPermissionsMe';
1325  id: Scalars['ID'];
1326  username: Scalars['String'];
1327  email: Scalars['String'];
1328  confirmed?: Maybe<Scalars['Boolean']>;
1329  blocked?: Maybe<Scalars['Boolean']>;
1330  role?: Maybe<UsersPermissionsMeRole>;
1331  profile?: Maybe<UsersPermissionsUser>;
1332};
1333
1334export type UsersPermissionsMeRole = {
1335  __typename?: 'UsersPermissionsMeRole';
1336  id: Scalars['ID'];
1337  name: Scalars['String'];
1338  description?: Maybe<Scalars['String']>;
1339  type?: Maybe<Scalars['String']>;
1340};
1341
1342export type UsersPermissionsPermission = {
1343  __typename?: 'UsersPermissionsPermission';
1344  id: Scalars['ID'];
1345  type: Scalars['String'];
1346  controller: Scalars['String'];
1347  action: Scalars['String'];
1348  enabled: Scalars['Boolean'];
1349  policy?: Maybe<Scalars['String']>;
1350  role?: Maybe<UsersPermissionsRole>;
1351};
1352
1353export type UsersPermissionsRegisterInput = {
1354  username: Scalars['String'];
1355  email: Scalars['String'];
1356  password: Scalars['String'];
1357  firstName?: Maybe<Scalars['String']>;
1358  lastName?: Maybe<Scalars['String']>;
1359  lang?: Maybe<Scalars['String']>;
1360};
1361
1362export type UsersPermissionsRole = {
1363  __typename?: 'UsersPermissionsRole';
1364  id: Scalars['ID'];
1365  name: Scalars['String'];
1366  description?: Maybe<Scalars['String']>;
1367  type?: Maybe<Scalars['String']>;
1368  permissions?: Maybe<Array<Maybe<UsersPermissionsPermission>>>;
1369  users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1370};
1371
1372
1373export type UsersPermissionsRolePermissionsArgs = {
1374  sort?: Maybe<Scalars['String']>;
1375  limit?: Maybe<Scalars['Int']>;
1376  start?: Maybe<Scalars['Int']>;
1377  where?: Maybe<Scalars['JSON']>;
1378};
1379
1380
1381export type UsersPermissionsRoleUsersArgs = {
1382  sort?: Maybe<Scalars['String']>;
1383  limit?: Maybe<Scalars['Int']>;
1384  start?: Maybe<Scalars['Int']>;
1385  where?: Maybe<Scalars['JSON']>;
1386};
1387
1388export type UsersPermissionsRoleAggregator = {
1389  __typename?: 'UsersPermissionsRoleAggregator';
1390  count?: Maybe<Scalars['Int']>;
1391  totalCount?: Maybe<Scalars['Int']>;
1392};
1393
1394export type UsersPermissionsRoleConnection = {
1395  __typename?: 'UsersPermissionsRoleConnection';
1396  values?: Maybe<Array<Maybe<UsersPermissionsRole>>>;
1397  groupBy?: Maybe<UsersPermissionsRoleGroupBy>;
1398  aggregate?: Maybe<UsersPermissionsRoleAggregator>;
1399};
1400
1401export type UsersPermissionsRoleConnectionDescription = {
1402  __typename?: 'UsersPermissionsRoleConnectionDescription';
1403  key?: Maybe<Scalars['String']>;
1404  connection?: Maybe<UsersPermissionsRoleConnection>;
1405};
1406
1407export type UsersPermissionsRoleConnectionId = {
1408  __typename?: 'UsersPermissionsRoleConnectionId';
1409  key?: Maybe<Scalars['ID']>;
1410  connection?: Maybe<UsersPermissionsRoleConnection>;
1411};
1412
1413export type UsersPermissionsRoleConnectionName = {
1414  __typename?: 'UsersPermissionsRoleConnectionName';
1415  key?: Maybe<Scalars['String']>;
1416  connection?: Maybe<UsersPermissionsRoleConnection>;
1417};
1418
1419export type UsersPermissionsRoleConnectionType = {
1420  __typename?: 'UsersPermissionsRoleConnectionType';
1421  key?: Maybe<Scalars['String']>;
1422  connection?: Maybe<UsersPermissionsRoleConnection>;
1423};
1424
1425export type UsersPermissionsRoleGroupBy = {
1426  __typename?: 'UsersPermissionsRoleGroupBy';
1427  id?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionId>>>;
1428  name?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionName>>>;
1429  description?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionDescription>>>;
1430  type?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionType>>>;
1431};
1432
1433export type UsersPermissionsUser = {
1434  __typename?: 'UsersPermissionsUser';
1435  id: Scalars['ID'];
1436  created_at: Scalars['DateTime'];
1437  updated_at: Scalars['DateTime'];
1438  username: Scalars['String'];
1439  firstName?: Maybe<Scalars['String']>;
1440  lastName?: Maybe<Scalars['String']>;
1441  email: Scalars['String'];
1442  provider?: Maybe<Scalars['String']>;
1443  confirmed?: Maybe<Scalars['Boolean']>;
1444  blocked?: Maybe<Scalars['Boolean']>;
1445  role?: Maybe<UsersPermissionsRole>;
1446  onboardingUser?: Maybe<Scalars['Boolean']>;
1447  onboardingCreator?: Maybe<Scalars['Boolean']>;
1448  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1449  events?: Maybe<Array<Maybe<Event>>>;
1450  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
1451};
1452
1453
1454export type UsersPermissionsUserEventsArgs = {
1455  sort?: Maybe<Scalars['String']>;
1456  limit?: Maybe<Scalars['Int']>;
1457  start?: Maybe<Scalars['Int']>;
1458  where?: Maybe<Scalars['JSON']>;
1459};
1460
1461
1462export type UsersPermissionsUserVehiclesArgs = {
1463  sort?: Maybe<Scalars['String']>;
1464  limit?: Maybe<Scalars['Int']>;
1465  start?: Maybe<Scalars['Int']>;
1466  where?: Maybe<Scalars['JSON']>;
1467};
1468
1469export type UsersPermissionsUserAggregator = {
1470  __typename?: 'UsersPermissionsUserAggregator';
1471  count?: Maybe<Scalars['Int']>;
1472  totalCount?: Maybe<Scalars['Int']>;
1473};
1474
1475export type UsersPermissionsUserConnection = {
1476  __typename?: 'UsersPermissionsUserConnection';
1477  values?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1478  groupBy?: Maybe<UsersPermissionsUserGroupBy>;
1479  aggregate?: Maybe<UsersPermissionsUserAggregator>;
1480};
1481
1482export type UsersPermissionsUserConnectionBlocked = {
1483  __typename?: 'UsersPermissionsUserConnectionBlocked';
1484  key?: Maybe<Scalars['Boolean']>;
1485  connection?: Maybe<UsersPermissionsUserConnection>;
1486};
1487
1488export type UsersPermissionsUserConnectionConfirmed = {
1489  __typename?: 'UsersPermissionsUserConnectionConfirmed';
1490  key?: Maybe<Scalars['Boolean']>;
1491  connection?: Maybe<UsersPermissionsUserConnection>;
1492};
1493
1494export type UsersPermissionsUserConnectionCreated_At = {
1495  __typename?: 'UsersPermissionsUserConnectionCreated_at';
1496  key?: Maybe<Scalars['DateTime']>;
1497  connection?: Maybe<UsersPermissionsUserConnection>;
1498};
1499
1500export type UsersPermissionsUserConnectionEmail = {
1501  __typename?: 'UsersPermissionsUserConnectionEmail';
1502  key?: Maybe<Scalars['String']>;
1503  connection?: Maybe<UsersPermissionsUserConnection>;
1504};
1505
1506export type UsersPermissionsUserConnectionFirstName = {
1507  __typename?: 'UsersPermissionsUserConnectionFirstName';
1508  key?: Maybe<Scalars['String']>;
1509  connection?: Maybe<UsersPermissionsUserConnection>;
1510};
1511
1512export type UsersPermissionsUserConnectionId = {
1513  __typename?: 'UsersPermissionsUserConnectionId';
1514  key?: Maybe<Scalars['ID']>;
1515  connection?: Maybe<UsersPermissionsUserConnection>;
1516};
1517
1518export type UsersPermissionsUserConnectionLang = {
1519  __typename?: 'UsersPermissionsUserConnectionLang';
1520  key?: Maybe<Scalars['String']>;
1521  connection?: Maybe<UsersPermissionsUserConnection>;
1522};
1523
1524export type UsersPermissionsUserConnectionLastName = {
1525  __typename?: 'UsersPermissionsUserConnectionLastName';
1526  key?: Maybe<Scalars['String']>;
1527  connection?: Maybe<UsersPermissionsUserConnection>;
1528};
1529
1530export type UsersPermissionsUserConnectionOnboardingCreator = {
1531  __typename?: 'UsersPermissionsUserConnectionOnboardingCreator';
1532  key?: Maybe<Scalars['Boolean']>;
1533  connection?: Maybe<UsersPermissionsUserConnection>;
1534};
1535
1536export type UsersPermissionsUserConnectionOnboardingUser = {
1537  __typename?: 'UsersPermissionsUserConnectionOnboardingUser';
1538  key?: Maybe<Scalars['Boolean']>;
1539  connection?: Maybe<UsersPermissionsUserConnection>;
1540};
1541
1542export type UsersPermissionsUserConnectionProvider = {
1543  __typename?: 'UsersPermissionsUserConnectionProvider';
1544  key?: Maybe<Scalars['String']>;
1545  connection?: Maybe<UsersPermissionsUserConnection>;
1546};
1547
1548export type UsersPermissionsUserConnectionRole = {
1549  __typename?: 'UsersPermissionsUserConnectionRole';
1550  key?: Maybe<Scalars['ID']>;
1551  connection?: Maybe<UsersPermissionsUserConnection>;
1552};
1553
1554export type UsersPermissionsUserConnectionUpdated_At = {
1555  __typename?: 'UsersPermissionsUserConnectionUpdated_at';
1556  key?: Maybe<Scalars['DateTime']>;
1557  connection?: Maybe<UsersPermissionsUserConnection>;
1558};
1559
1560export type UsersPermissionsUserConnectionUsername = {
1561  __typename?: 'UsersPermissionsUserConnectionUsername';
1562  key?: Maybe<Scalars['String']>;
1563  connection?: Maybe<UsersPermissionsUserConnection>;
1564};
1565
1566export type UsersPermissionsUserGroupBy = {
1567  __typename?: 'UsersPermissionsUserGroupBy';
1568  id?: Maybe<Array<Maybe<UsersPermissionsUserConnectionId>>>;
1569  created_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionCreated_At>>>;
1570  updated_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUpdated_At>>>;
1571  username?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUsername>>>;
1572  firstName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionFirstName>>>;
1573  lastName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLastName>>>;
1574  email?: Maybe<Array<Maybe<UsersPermissionsUserConnectionEmail>>>;
1575  provider?: Maybe<Array<Maybe<UsersPermissionsUserConnectionProvider>>>;
1576  confirmed?: Maybe<Array<Maybe<UsersPermissionsUserConnectionConfirmed>>>;
1577  blocked?: Maybe<Array<Maybe<UsersPermissionsUserConnectionBlocked>>>;
1578  role?: Maybe<Array<Maybe<UsersPermissionsUserConnectionRole>>>;
1579  onboardingUser?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingUser>>>;
1580  onboardingCreator?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingCreator>>>;
1581  lang?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLang>>>;
1582};
1583
1584export type Vehicle = {
1585  __typename?: 'Vehicle';
1586  id: Scalars['ID'];
1587  created_at: Scalars['DateTime'];
1588  updated_at: Scalars['DateTime'];
1589  name: Scalars['String'];
1590  seats?: Maybe<Scalars['Int']>;
1591  phone_number?: Maybe<Scalars['String']>;
1592  user?: Maybe<UsersPermissionsUser>;
1593  travels?: Maybe<Array<Maybe<Travel>>>;
1594};
1595
1596
1597export type VehicleTravelsArgs = {
1598  sort?: Maybe<Scalars['String']>;
1599  limit?: Maybe<Scalars['Int']>;
1600  start?: Maybe<Scalars['Int']>;
1601  where?: Maybe<Scalars['JSON']>;
1602};
1603
1604export type VehicleAggregator = {
1605  __typename?: 'VehicleAggregator';
1606  count?: Maybe<Scalars['Int']>;
1607  totalCount?: Maybe<Scalars['Int']>;
1608  sum?: Maybe<VehicleAggregatorSum>;
1609  avg?: Maybe<VehicleAggregatorAvg>;
1610  min?: Maybe<VehicleAggregatorMin>;
1611  max?: Maybe<VehicleAggregatorMax>;
1612};
1613
1614export type VehicleAggregatorAvg = {
1615  __typename?: 'VehicleAggregatorAvg';
1616  seats?: Maybe<Scalars['Float']>;
1617};
1618
1619export type VehicleAggregatorMax = {
1620  __typename?: 'VehicleAggregatorMax';
1621  seats?: Maybe<Scalars['Float']>;
1622};
1623
1624export type VehicleAggregatorMin = {
1625  __typename?: 'VehicleAggregatorMin';
1626  seats?: Maybe<Scalars['Float']>;
1627};
1628
1629export type VehicleAggregatorSum = {
1630  __typename?: 'VehicleAggregatorSum';
1631  seats?: Maybe<Scalars['Float']>;
1632};
1633
1634export type VehicleConnection = {
1635  __typename?: 'VehicleConnection';
1636  values?: Maybe<Array<Maybe<Vehicle>>>;
1637  groupBy?: Maybe<VehicleGroupBy>;
1638  aggregate?: Maybe<VehicleAggregator>;
1639};
1640
1641export type VehicleConnectionCreated_At = {
1642  __typename?: 'VehicleConnectionCreated_at';
1643  key?: Maybe<Scalars['DateTime']>;
1644  connection?: Maybe<VehicleConnection>;
1645};
1646
1647export type VehicleConnectionId = {
1648  __typename?: 'VehicleConnectionId';
1649  key?: Maybe<Scalars['ID']>;
1650  connection?: Maybe<VehicleConnection>;
1651};
1652
1653export type VehicleConnectionName = {
1654  __typename?: 'VehicleConnectionName';
1655  key?: Maybe<Scalars['String']>;
1656  connection?: Maybe<VehicleConnection>;
1657};
1658
1659export type VehicleConnectionPhone_Number = {
1660  __typename?: 'VehicleConnectionPhone_number';
1661  key?: Maybe<Scalars['String']>;
1662  connection?: Maybe<VehicleConnection>;
1663};
1664
1665export type VehicleConnectionSeats = {
1666  __typename?: 'VehicleConnectionSeats';
1667  key?: Maybe<Scalars['Int']>;
1668  connection?: Maybe<VehicleConnection>;
1669};
1670
1671export type VehicleConnectionUpdated_At = {
1672  __typename?: 'VehicleConnectionUpdated_at';
1673  key?: Maybe<Scalars['DateTime']>;
1674  connection?: Maybe<VehicleConnection>;
1675};
1676
1677export type VehicleConnectionUser = {
1678  __typename?: 'VehicleConnectionUser';
1679  key?: Maybe<Scalars['ID']>;
1680  connection?: Maybe<VehicleConnection>;
1681};
1682
1683export type VehicleGroupBy = {
1684  __typename?: 'VehicleGroupBy';
1685  id?: Maybe<Array<Maybe<VehicleConnectionId>>>;
1686  created_at?: Maybe<Array<Maybe<VehicleConnectionCreated_At>>>;
1687  updated_at?: Maybe<Array<Maybe<VehicleConnectionUpdated_At>>>;
1688  name?: Maybe<Array<Maybe<VehicleConnectionName>>>;
1689  seats?: Maybe<Array<Maybe<VehicleConnectionSeats>>>;
1690  phone_number?: Maybe<Array<Maybe<VehicleConnectionPhone_Number>>>;
1691  user?: Maybe<Array<Maybe<VehicleConnectionUser>>>;
1692};
1693
1694export type VehicleInput = {
1695  name: Scalars['String'];
1696  seats?: Maybe<Scalars['Int']>;
1697  travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1698  phone_number?: Maybe<Scalars['String']>;
1699  user?: Maybe<Scalars['ID']>;
1700  created_by?: Maybe<Scalars['ID']>;
1701  updated_by?: Maybe<Scalars['ID']>;
1702};
1703
1704export type CreateCarInput = {
1705  data?: Maybe<CarInput>;
1706};
1707
1708export type CreateCarPayload = {
1709  __typename?: 'createCarPayload';
1710  car?: Maybe<Car>;
1711};
1712
1713export type CreateEventInput = {
1714  data?: Maybe<EventInput>;
1715};
1716
1717export type CreateEventPayload = {
1718  __typename?: 'createEventPayload';
1719  event?: Maybe<Event>;
1720};
1721
1722export type CreatePageInput = {
1723  data?: Maybe<PageInput>;
1724};
1725
1726export type CreatePagePayload = {
1727  __typename?: 'createPagePayload';
1728  page?: Maybe<Page>;
1729};
1730
1731export type CreateRoleInput = {
1732  data?: Maybe<RoleInput>;
1733};
1734
1735export type CreateRolePayload = {
1736  __typename?: 'createRolePayload';
1737  role?: Maybe<UsersPermissionsRole>;
1738};
1739
1740export type CreateTravelInput = {
1741  data?: Maybe<TravelInput>;
1742};
1743
1744export type CreateTravelPayload = {
1745  __typename?: 'createTravelPayload';
1746  travel?: Maybe<Travel>;
1747};
1748
1749export type CreateUserInput = {
1750  data?: Maybe<UserInput>;
1751};
1752
1753export type CreateUserPayload = {
1754  __typename?: 'createUserPayload';
1755  user?: Maybe<UsersPermissionsUser>;
1756};
1757
1758export type CreateVehicleInput = {
1759  data?: Maybe<VehicleInput>;
1760};
1761
1762export type CreateVehiclePayload = {
1763  __typename?: 'createVehiclePayload';
1764  vehicle?: Maybe<Vehicle>;
1765};
1766
1767export type DeleteCarInput = {
1768  where?: Maybe<InputId>;
1769};
1770
1771export type DeleteCarPayload = {
1772  __typename?: 'deleteCarPayload';
1773  car?: Maybe<Car>;
1774};
1775
1776export type DeleteEventInput = {
1777  where?: Maybe<InputId>;
1778};
1779
1780export type DeleteEventPayload = {
1781  __typename?: 'deleteEventPayload';
1782  event?: Maybe<Event>;
1783};
1784
1785export type DeleteFileInput = {
1786  where?: Maybe<InputId>;
1787};
1788
1789export type DeleteFilePayload = {
1790  __typename?: 'deleteFilePayload';
1791  file?: Maybe<UploadFile>;
1792};
1793
1794export type DeletePageInput = {
1795  where?: Maybe<InputId>;
1796};
1797
1798export type DeletePagePayload = {
1799  __typename?: 'deletePagePayload';
1800  page?: Maybe<Page>;
1801};
1802
1803export type DeleteRoleInput = {
1804  where?: Maybe<InputId>;
1805};
1806
1807export type DeleteRolePayload = {
1808  __typename?: 'deleteRolePayload';
1809  role?: Maybe<UsersPermissionsRole>;
1810};
1811
1812export type DeleteSettingPayload = {
1813  __typename?: 'deleteSettingPayload';
1814  setting?: Maybe<Settings>;
1815};
1816
1817export type DeleteTravelInput = {
1818  where?: Maybe<InputId>;
1819};
1820
1821export type DeleteTravelPayload = {
1822  __typename?: 'deleteTravelPayload';
1823  travel?: Maybe<Travel>;
1824};
1825
1826export type DeleteUserInput = {
1827  where?: Maybe<InputId>;
1828};
1829
1830export type DeleteUserPayload = {
1831  __typename?: 'deleteUserPayload';
1832  user?: Maybe<UsersPermissionsUser>;
1833};
1834
1835export type DeleteVehicleInput = {
1836  where?: Maybe<InputId>;
1837};
1838
1839export type DeleteVehiclePayload = {
1840  __typename?: 'deleteVehiclePayload';
1841  vehicle?: Maybe<Vehicle>;
1842};
1843
1844export type EditCarInput = {
1845  name?: Maybe<Scalars['String']>;
1846  seats?: Maybe<Scalars['Int']>;
1847  meeting?: Maybe<Scalars['String']>;
1848  departure?: Maybe<Scalars['DateTime']>;
1849  phone_number?: Maybe<Scalars['String']>;
1850  details?: Maybe<Scalars['String']>;
1851  event?: Maybe<Scalars['ID']>;
1852  passengers?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1853  created_by?: Maybe<Scalars['ID']>;
1854  updated_by?: Maybe<Scalars['ID']>;
1855};
1856
1857export type EditComponentPassengerPassengerInput = {
1858  id?: Maybe<Scalars['ID']>;
1859  name?: Maybe<Scalars['String']>;
1860  email?: Maybe<Scalars['String']>;
1861  location?: Maybe<Scalars['String']>;
1862  user?: Maybe<Scalars['ID']>;
1863};
1864
1865export type EditEmailTemplateInput = {
1866  sourceCodeToTemplateId?: Maybe<Scalars['Int']>;
1867  design?: Maybe<Scalars['JSON']>;
1868  name?: Maybe<Scalars['String']>;
1869  subject?: Maybe<Scalars['String']>;
1870  bodyHtml?: Maybe<Scalars['String']>;
1871  bodyText?: Maybe<Scalars['String']>;
1872  enabled?: Maybe<Scalars['Boolean']>;
1873  tags?: Maybe<Scalars['JSON']>;
1874  created_by?: Maybe<Scalars['ID']>;
1875  updated_by?: Maybe<Scalars['ID']>;
1876};
1877
1878export type EditEventInput = {
1879  name?: Maybe<Scalars['String']>;
1880  email?: Maybe<Scalars['String']>;
1881  date?: Maybe<Scalars['Date']>;
1882  address?: Maybe<Scalars['String']>;
1883  cars?: Maybe<Array<Maybe<Scalars['ID']>>>;
1884  position?: Maybe<Scalars['JSON']>;
1885  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1886  uuid?: Maybe<Scalars['String']>;
1887  waitingList?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1888  travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1889  description?: Maybe<Scalars['String']>;
1890  created_by?: Maybe<Scalars['ID']>;
1891  updated_by?: Maybe<Scalars['ID']>;
1892};
1893
1894export type EditFileInput = {
1895  name?: Maybe<Scalars['String']>;
1896  alternativeText?: Maybe<Scalars['String']>;
1897  caption?: Maybe<Scalars['String']>;
1898  width?: Maybe<Scalars['Int']>;
1899  height?: Maybe<Scalars['Int']>;
1900  formats?: Maybe<Scalars['JSON']>;
1901  hash?: Maybe<Scalars['String']>;
1902  ext?: Maybe<Scalars['String']>;
1903  mime?: Maybe<Scalars['String']>;
1904  size?: Maybe<Scalars['Float']>;
1905  url?: Maybe<Scalars['String']>;
1906  previewUrl?: Maybe<Scalars['String']>;
1907  provider?: Maybe<Scalars['String']>;
1908  provider_metadata?: Maybe<Scalars['JSON']>;
1909  related?: Maybe<Array<Maybe<Scalars['ID']>>>;
1910  created_by?: Maybe<Scalars['ID']>;
1911  updated_by?: Maybe<Scalars['ID']>;
1912};
1913
1914export type EditPageInput = {
1915  name?: Maybe<Scalars['String']>;
1916  content?: Maybe<Scalars['String']>;
1917  type?: Maybe<Enum_Page_Type>;
1918  created_by?: Maybe<Scalars['ID']>;
1919  updated_by?: Maybe<Scalars['ID']>;
1920};
1921
1922export type EditRoleInput = {
1923  name?: Maybe<Scalars['String']>;
1924  description?: Maybe<Scalars['String']>;
1925  type?: Maybe<Scalars['String']>;
1926  permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
1927  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1928  created_by?: Maybe<Scalars['ID']>;
1929  updated_by?: Maybe<Scalars['ID']>;
1930};
1931
1932export type EditSettingInput = {
1933  gtm_id?: Maybe<Scalars['String']>;
1934  about_link?: Maybe<Scalars['String']>;
1935  created_by?: Maybe<Scalars['ID']>;
1936  updated_by?: Maybe<Scalars['ID']>;
1937};
1938
1939export type EditTravelInput = {
1940  meeting?: Maybe<Scalars['String']>;
1941  departure?: Maybe<Scalars['DateTime']>;
1942  details?: Maybe<Scalars['String']>;
1943  passengers?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1944  event?: Maybe<Scalars['ID']>;
1945  vehicle?: Maybe<Scalars['ID']>;
1946  created_by?: Maybe<Scalars['ID']>;
1947  updated_by?: Maybe<Scalars['ID']>;
1948};
1949
1950export type EditUserInput = {
1951  username?: Maybe<Scalars['String']>;
1952  firstName?: Maybe<Scalars['String']>;
1953  lastName?: Maybe<Scalars['String']>;
1954  email?: Maybe<Scalars['String']>;
1955  provider?: Maybe<Scalars['String']>;
1956  password?: Maybe<Scalars['String']>;
1957  resetPasswordToken?: Maybe<Scalars['String']>;
1958  confirmed?: Maybe<Scalars['Boolean']>;
1959  blocked?: Maybe<Scalars['Boolean']>;
1960  role?: Maybe<Scalars['ID']>;
1961  confirmationToken?: Maybe<Scalars['String']>;
1962  events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1963  onboardingUser?: Maybe<Scalars['Boolean']>;
1964  onboardingCreator?: Maybe<Scalars['Boolean']>;
1965  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1966  vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1967  created_by?: Maybe<Scalars['ID']>;
1968  updated_by?: Maybe<Scalars['ID']>;
1969  old_password?: Maybe<Scalars['String']>;
1970};
1971
1972export type EditVehicleInput = {
1973  name?: Maybe<Scalars['String']>;
1974  seats?: Maybe<Scalars['Int']>;
1975  travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1976  phone_number?: Maybe<Scalars['String']>;
1977  user?: Maybe<Scalars['ID']>;
1978  created_by?: Maybe<Scalars['ID']>;
1979  updated_by?: Maybe<Scalars['ID']>;
1980};
1981
1982export type UpdateCarInput = {
1983  where?: Maybe<InputId>;
1984  data?: Maybe<EditCarInput>;
1985};
1986
1987export type UpdateCarPayload = {
1988  __typename?: 'updateCarPayload';
1989  car?: Maybe<Car>;
1990};
1991
1992export type UpdateEventByUuidInput = {
1993  where?: Maybe<InputUuid>;
1994  data?: Maybe<EditEventInput>;
1995};
1996
1997export type UpdateEventInput = {
1998  where?: Maybe<InputId>;
1999  data?: Maybe<EditEventInput>;
2000};
2001
2002export type UpdateEventPayload = {
2003  __typename?: 'updateEventPayload';
2004  event?: Maybe<Event>;
2005};
2006
2007export type UpdatePageInput = {
2008  where?: Maybe<InputId>;
2009  data?: Maybe<EditPageInput>;
2010};
2011
2012export type UpdatePagePayload = {
2013  __typename?: 'updatePagePayload';
2014  page?: Maybe<Page>;
2015};
2016
2017export type UpdateRoleInput = {
2018  where?: Maybe<InputId>;
2019  data?: Maybe<EditRoleInput>;
2020};
2021
2022export type UpdateRolePayload = {
2023  __typename?: 'updateRolePayload';
2024  role?: Maybe<UsersPermissionsRole>;
2025};
2026
2027export type UpdateSettingInput = {
2028  data?: Maybe<EditSettingInput>;
2029};
2030
2031export type UpdateSettingPayload = {
2032  __typename?: 'updateSettingPayload';
2033  setting?: Maybe<Settings>;
2034};
2035
2036export type UpdateTravelInput = {
2037  where?: Maybe<InputId>;
2038  data?: Maybe<EditTravelInput>;
2039};
2040
2041export type UpdateTravelPayload = {
2042  __typename?: 'updateTravelPayload';
2043  travel?: Maybe<Travel>;
2044};
2045
2046export type UpdateUserInput = {
2047  where?: Maybe<InputId>;
2048  data?: Maybe<EditUserInput>;
2049};
2050
2051export type UpdateUserPayload = {
2052  __typename?: 'updateUserPayload';
2053  user?: Maybe<UsersPermissionsUser>;
2054};
2055
2056export type UpdateVehicleInput = {
2057  where?: Maybe<InputId>;
2058  data?: Maybe<EditVehicleInput>;
2059};
2060
2061export type UpdateVehiclePayload = {
2062  __typename?: 'updateVehiclePayload';
2063  vehicle?: Maybe<Vehicle>;
2064};
2065
2066export type MeFieldsFragment = (
2067  { __typename?: 'UsersPermissionsMe' }
2068  & Pick<UsersPermissionsMe, 'id' | 'username' | 'email' | 'confirmed'>
2069);
2070
2071export type RegisterMutationVariables = Exact<{
2072  user: UsersPermissionsRegisterInput;
2073}>;
2074
2075
2076export type RegisterMutation = (
2077  { __typename?: 'Mutation' }
2078  & { register: (
2079    { __typename?: 'UsersPermissionsLoginPayload' }
2080    & Pick<UsersPermissionsLoginPayload, 'jwt'>
2081    & { user: (
2082      { __typename?: 'UsersPermissionsMe' }
2083      & MeFieldsFragment
2084    ) }
2085  ) }
2086);
2087
2088export type LoginMutationVariables = Exact<{
2089  identifier: Scalars['String'];
2090  password: Scalars['String'];
2091}>;
2092
2093
2094export type LoginMutation = (
2095  { __typename?: 'Mutation' }
2096  & { login: (
2097    { __typename?: 'UsersPermissionsLoginPayload' }
2098    & Pick<UsersPermissionsLoginPayload, 'jwt'>
2099    & { user: (
2100      { __typename?: 'UsersPermissionsMe' }
2101      & MeFieldsFragment
2102    ) }
2103  ) }
2104);
2105
2106export type ForgotPasswordMutationVariables = Exact<{
2107  email: Scalars['String'];
2108}>;
2109
2110
2111export type ForgotPasswordMutation = (
2112  { __typename?: 'Mutation' }
2113  & { forgotPassword?: Maybe<(
2114    { __typename?: 'UserPermissionsPasswordPayload' }
2115    & Pick<UserPermissionsPasswordPayload, 'ok'>
2116  )> }
2117);
2118
2119export type ResetPasswordMutationVariables = Exact<{
2120  password: Scalars['String'];
2121  passwordConfirmation: Scalars['String'];
2122  code: Scalars['String'];
2123}>;
2124
2125
2126export type ResetPasswordMutation = (
2127  { __typename?: 'Mutation' }
2128  & { resetPassword?: Maybe<(
2129    { __typename?: 'UsersPermissionsLoginPayload' }
2130    & Pick<UsersPermissionsLoginPayload, 'jwt'>
2131    & { user: (
2132      { __typename?: 'UsersPermissionsMe' }
2133      & MeFieldsFragment
2134    ) }
2135  )> }
2136);
2137
2138export type EventFieldsFragment = (
2139  { __typename?: 'Event' }
2140  & Pick<Event, 'id' | 'uuid' | 'name' | 'description' | 'email' | 'date' | 'address' | 'position'>
2141  & { waitingList?: Maybe<Array<Maybe<(
2142    { __typename?: 'ComponentPassengerPassenger' }
2143    & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2144    & { user?: Maybe<(
2145      { __typename?: 'UsersPermissionsUser' }
2146      & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2147    )> }
2148  )>>>, travels?: Maybe<Array<Maybe<(
2149    { __typename?: 'Travel' }
2150    & Pick<Travel, 'id' | 'meeting' | 'departure' | 'details'>
2151    & { vehicle?: Maybe<(
2152      { __typename?: 'Vehicle' }
2153      & Pick<Vehicle, 'id' | 'name' | 'phone_number' | 'seats'>
2154    )>, passengers?: Maybe<Array<Maybe<(
2155      { __typename?: 'ComponentPassengerPassenger' }
2156      & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2157      & { user?: Maybe<(
2158        { __typename?: 'UsersPermissionsUser' }
2159        & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2160      )> }
2161    )>>> }
2162  )>>> }
2163);
2164
2165export type CreateEventMutationVariables = Exact<{
2166  name: Scalars['String'];
2167  email: Scalars['String'];
2168  date?: Maybe<Scalars['Date']>;
2169  address?: Maybe<Scalars['String']>;
2170  description?: Maybe<Scalars['String']>;
2171  newsletter?: Maybe<Scalars['Boolean']>;
2172}>;
2173
2174
2175export type CreateEventMutation = (
2176  { __typename?: 'Mutation' }
2177  & { createEvent?: Maybe<(
2178    { __typename?: 'createEventPayload' }
2179    & { event?: Maybe<(
2180      { __typename?: 'Event' }
2181      & EventFieldsFragment
2182    )> }
2183  )> }
2184);
2185
2186export type UpdateEventMutationVariables = Exact<{
2187  uuid: Scalars['String'];
2188  eventUpdate?: Maybe<EditEventInput>;
2189}>;
2190
2191
2192export type UpdateEventMutation = (
2193  { __typename?: 'Mutation' }
2194  & { updateEventByUUID?: Maybe<(
2195    { __typename?: 'updateEventPayload' }
2196    & { event?: Maybe<(
2197      { __typename?: 'Event' }
2198      & EventFieldsFragment
2199    )> }
2200  )> }
2201);
2202
2203export type EventByUuidQueryVariables = Exact<{
2204  uuid: Scalars['String'];
2205}>;
2206
2207
2208export type EventByUuidQuery = (
2209  { __typename?: 'Query' }
2210  & { eventByUUID?: Maybe<(
2211    { __typename?: 'Event' }
2212    & EventFieldsFragment
2213  )> }
2214);
2215
2216export type SettingQueryVariables = Exact<{ [key: string]: never; }>;
2217
2218
2219export type SettingQuery = (
2220  { __typename?: 'Query' }
2221  & { setting?: Maybe<(
2222    { __typename?: 'Settings' }
2223    & Pick<Settings, 'id' | 'gtm_id' | 'about_link'>
2224  )> }
2225);
2226
2227export type TravelFieldsFragment = (
2228  { __typename?: 'Travel' }
2229  & Pick<Travel, 'id' | 'meeting' | 'departure' | 'details'>
2230  & { vehicle?: Maybe<(
2231    { __typename?: 'Vehicle' }
2232    & Pick<Vehicle, 'id' | 'name' | 'phone_number' | 'seats'>
2233  )>, passengers?: Maybe<Array<Maybe<(
2234    { __typename?: 'ComponentPassengerPassenger' }
2235    & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2236    & { user?: Maybe<(
2237      { __typename?: 'UsersPermissionsUser' }
2238      & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2239    )> }
2240  )>>> }
2241);
2242
2243export type CreateTravelMutationVariables = Exact<{
2244  travel: TravelInput;
2245}>;
2246
2247
2248export type CreateTravelMutation = (
2249  { __typename?: 'Mutation' }
2250  & { createTravel?: Maybe<(
2251    { __typename?: 'createTravelPayload' }
2252    & { travel?: Maybe<(
2253      { __typename?: 'Travel' }
2254      & TravelFieldsFragment
2255    )> }
2256  )> }
2257);
2258
2259export type UpdateTravelMutationVariables = Exact<{
2260  id: Scalars['ID'];
2261  travelUpdate: EditTravelInput;
2262}>;
2263
2264
2265export type UpdateTravelMutation = (
2266  { __typename?: 'Mutation' }
2267  & { updateTravel?: Maybe<(
2268    { __typename?: 'updateTravelPayload' }
2269    & { travel?: Maybe<(
2270      { __typename?: 'Travel' }
2271      & TravelFieldsFragment
2272    )> }
2273  )> }
2274);
2275
2276export type DeleteTravelMutationVariables = Exact<{
2277  id: Scalars['ID'];
2278}>;
2279
2280
2281export type DeleteTravelMutation = (
2282  { __typename?: 'Mutation' }
2283  & { deleteTravel?: Maybe<(
2284    { __typename?: 'deleteTravelPayload' }
2285    & { travel?: Maybe<(
2286      { __typename?: 'Travel' }
2287      & Pick<Travel, 'id'>
2288    )> }
2289  )> }
2290);
2291
2292export type UserFieldsFragment = (
2293  { __typename?: 'UsersPermissionsUser' }
2294  & Pick<UsersPermissionsUser, 'id' | 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName' | 'lang' | 'onboardingUser' | 'onboardingCreator'>
2295  & { events?: Maybe<Array<Maybe<(
2296    { __typename?: 'Event' }
2297    & Pick<Event, 'id' | 'uuid' | 'name' | 'date' | 'address'>
2298  )>>> }
2299);
2300
2301export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
2302
2303
2304export type ProfileQuery = (
2305  { __typename?: 'Query' }
2306  & { me?: Maybe<(
2307    { __typename?: 'UsersPermissionsMe' }
2308    & Pick<UsersPermissionsMe, 'id' | 'username'>
2309    & { profile?: Maybe<(
2310      { __typename?: 'UsersPermissionsUser' }
2311      & UserFieldsFragment
2312    )> }
2313  )> }
2314);
2315
2316export type UpdateMeMutationVariables = Exact<{
2317  userUpdate: EditUserInput;
2318}>;
2319
2320
2321export type UpdateMeMutation = (
2322  { __typename?: 'Mutation' }
2323  & { updateMe: (
2324    { __typename?: 'updateUserPayload' }
2325    & { user?: Maybe<(
2326      { __typename?: 'UsersPermissionsUser' }
2327      & UserFieldsFragment
2328    )> }
2329  ) }
2330);
2331
2332export type VehicleFieldsFragment = (
2333  { __typename?: 'Vehicle' }
2334  & Pick<Vehicle, 'id' | 'name' | 'seats' | 'phone_number'>
2335);
2336
2337export type CreateVehicleMutationVariables = Exact<{
2338  vehicle: VehicleInput;
2339}>;
2340
2341
2342export type CreateVehicleMutation = (
2343  { __typename?: 'Mutation' }
2344  & { createVehicle?: Maybe<(
2345    { __typename?: 'createVehiclePayload' }
2346    & { vehicle?: Maybe<(
2347      { __typename?: 'Vehicle' }
2348      & VehicleFieldsFragment
2349    )> }
2350  )> }
2351);
2352
2353export type UpdateVehicleMutationVariables = Exact<{
2354  id: Scalars['ID'];
2355  vehicleUpdate: EditVehicleInput;
2356}>;
2357
2358
2359export type UpdateVehicleMutation = (
2360  { __typename?: 'Mutation' }
2361  & { updateVehicle?: Maybe<(
2362    { __typename?: 'updateVehiclePayload' }
2363    & { vehicle?: Maybe<(
2364      { __typename?: 'Vehicle' }
2365      & VehicleFieldsFragment
2366    )> }
2367  )> }
2368);
2369
2370export type DeleteVehicleMutationVariables = Exact<{
2371  id: Scalars['ID'];
2372}>;
2373
2374
2375export type DeleteVehicleMutation = (
2376  { __typename?: 'Mutation' }
2377  & { deleteVehicle?: Maybe<(
2378    { __typename?: 'deleteVehiclePayload' }
2379    & { vehicle?: Maybe<(
2380      { __typename?: 'Vehicle' }
2381      & Pick<Vehicle, 'id' | 'name'>
2382    )> }
2383  )> }
2384);
2385
2386export const MeFieldsFragmentDoc = gql`
2387    fragment MeFields on UsersPermissionsMe {
2388  id
2389  username
2390  email
2391  confirmed
2392}
2393    `;
2394export const EventFieldsFragmentDoc = gql`
2395    fragment EventFields on Event {
2396  id
2397  uuid
2398  name
2399  description
2400  email
2401  date
2402  address
2403  position
2404  waitingList {
2405    id
2406    name
2407    location
2408    user {
2409      id
2410      firstName
2411      lastName
2412    }
2413  }
2414  travels {
2415    id
2416    meeting
2417    departure
2418    details
2419    vehicle {
2420      id
2421      name
2422      phone_number
2423      seats
2424    }
2425    passengers {
2426      id
2427      name
2428      location
2429      user {
2430        id
2431        firstName
2432        lastName
2433      }
2434    }
2435  }
2436}
2437    `;
2438export const TravelFieldsFragmentDoc = gql`
2439    fragment TravelFields on Travel {
2440  id
2441  meeting
2442  departure
2443  details
2444  vehicle {
2445    id
2446    name
2447    phone_number
2448    seats
2449  }
2450  passengers {
2451    id
2452    name
2453    location
2454    user {
2455      id
2456      firstName
2457      lastName
2458    }
2459  }
2460}
2461    `;
2462export const UserFieldsFragmentDoc = gql`
2463    fragment UserFields on UsersPermissionsUser {
2464  id
2465  username
2466  email
2467  confirmed
2468  lastName
2469  firstName
2470  lang
2471  onboardingUser
2472  onboardingCreator
2473  events {
2474    id
2475    uuid
2476    name
2477    date
2478    address
2479  }
2480}
2481    `;
2482export const VehicleFieldsFragmentDoc = gql`
2483    fragment VehicleFields on Vehicle {
2484  id
2485  name
2486  seats
2487  phone_number
2488}
2489    `;
2490export const RegisterDocument = gql`
2491    mutation register($user: UsersPermissionsRegisterInput!) {
2492  register(input: $user) {
2493    jwt
2494    user {
2495      ...MeFields
2496    }
2497  }
2498}
2499    ${MeFieldsFragmentDoc}`;
2500export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
2501
2502/**
2503 * __useRegisterMutation__
2504 *
2505 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
2506 * When your component renders, `useRegisterMutation` returns a tuple that includes:
2507 * - A mutate function that you can call at any time to execute the mutation
2508 * - An object with fields that represent the current status of the mutation's execution
2509 *
2510 * @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;
2511 *
2512 * @example
2513 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
2514 *   variables: {
2515 *      user: // value for 'user'
2516 *   },
2517 * });
2518 */
2519export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
2520        return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
2521      }
2522export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
2523export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
2524export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
2525export const LoginDocument = gql`
2526    mutation login($identifier: String!, $password: String!) {
2527  login(input: {identifier: $identifier, password: $password}) {
2528    jwt
2529    user {
2530      ...MeFields
2531    }
2532  }
2533}
2534    ${MeFieldsFragmentDoc}`;
2535export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
2536
2537/**
2538 * __useLoginMutation__
2539 *
2540 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
2541 * When your component renders, `useLoginMutation` returns a tuple that includes:
2542 * - A mutate function that you can call at any time to execute the mutation
2543 * - An object with fields that represent the current status of the mutation's execution
2544 *
2545 * @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;
2546 *
2547 * @example
2548 * const [loginMutation, { data, loading, error }] = useLoginMutation({
2549 *   variables: {
2550 *      identifier: // value for 'identifier'
2551 *      password: // value for 'password'
2552 *   },
2553 * });
2554 */
2555export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
2556        return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
2557      }
2558export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
2559export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
2560export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
2561export const ForgotPasswordDocument = gql`
2562    mutation forgotPassword($email: String!) {
2563  forgotPassword(email: $email) {
2564    ok
2565  }
2566}
2567    `;
2568export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2569
2570/**
2571 * __useForgotPasswordMutation__
2572 *
2573 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
2574 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
2575 * - A mutate function that you can call at any time to execute the mutation
2576 * - An object with fields that represent the current status of the mutation's execution
2577 *
2578 * @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;
2579 *
2580 * @example
2581 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
2582 *   variables: {
2583 *      email: // value for 'email'
2584 *   },
2585 * });
2586 */
2587export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
2588        return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
2589      }
2590export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
2591export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
2592export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2593export const ResetPasswordDocument = gql`
2594    mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
2595  resetPassword(
2596    password: $password
2597    passwordConfirmation: $passwordConfirmation
2598    code: $code
2599  ) {
2600    jwt
2601    user {
2602      ...MeFields
2603    }
2604  }
2605}
2606    ${MeFieldsFragmentDoc}`;
2607export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
2608
2609/**
2610 * __useResetPasswordMutation__
2611 *
2612 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
2613 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
2614 * - A mutate function that you can call at any time to execute the mutation
2615 * - An object with fields that represent the current status of the mutation's execution
2616 *
2617 * @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;
2618 *
2619 * @example
2620 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
2621 *   variables: {
2622 *      password: // value for 'password'
2623 *      passwordConfirmation: // value for 'passwordConfirmation'
2624 *      code: // value for 'code'
2625 *   },
2626 * });
2627 */
2628export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
2629        return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
2630      }
2631export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
2632export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
2633export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
2634export const CreateEventDocument = gql`
2635    mutation createEvent($name: String!, $email: String!, $date: Date, $address: String, $description: String, $newsletter: Boolean) {
2636  createEvent(
2637    input: {data: {name: $name, email: $email, date: $date, address: $address, description: $description, newsletter: $newsletter}}
2638  ) {
2639    event {
2640      ...EventFields
2641    }
2642  }
2643}
2644    ${EventFieldsFragmentDoc}`;
2645export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2646
2647/**
2648 * __useCreateEventMutation__
2649 *
2650 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2651 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2652 * - A mutate function that you can call at any time to execute the mutation
2653 * - An object with fields that represent the current status of the mutation's execution
2654 *
2655 * @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;
2656 *
2657 * @example
2658 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2659 *   variables: {
2660 *      name: // value for 'name'
2661 *      email: // value for 'email'
2662 *      date: // value for 'date'
2663 *      address: // value for 'address'
2664 *      description: // value for 'description'
2665 *      newsletter: // value for 'newsletter'
2666 *   },
2667 * });
2668 */
2669export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2670        return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2671      }
2672export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2673export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2674export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2675export const UpdateEventDocument = gql`
2676    mutation updateEvent($uuid: String!, $eventUpdate: editEventInput) {
2677  updateEventByUUID(input: {where: {uuid: $uuid}, data: $eventUpdate}) {
2678    event {
2679      ...EventFields
2680    }
2681  }
2682}
2683    ${EventFieldsFragmentDoc}`;
2684export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2685
2686/**
2687 * __useUpdateEventMutation__
2688 *
2689 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2690 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2691 * - A mutate function that you can call at any time to execute the mutation
2692 * - An object with fields that represent the current status of the mutation's execution
2693 *
2694 * @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;
2695 *
2696 * @example
2697 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2698 *   variables: {
2699 *      uuid: // value for 'uuid'
2700 *      eventUpdate: // value for 'eventUpdate'
2701 *   },
2702 * });
2703 */
2704export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2705        return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2706      }
2707export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2708export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2709export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2710export const EventByUuidDocument = gql`
2711    query eventByUUID($uuid: String!) {
2712  eventByUUID(uuid: $uuid) {
2713    ...EventFields
2714  }
2715}
2716    ${EventFieldsFragmentDoc}`;
2717
2718/**
2719 * __useEventByUuidQuery__
2720 *
2721 * To run a query within a React component, call `useEventByUuidQuery` and pass it any options that fit your needs.
2722 * When your component renders, `useEventByUuidQuery` returns an object from Apollo Client that contains loading, error, and data properties
2723 * you can use to render your UI.
2724 *
2725 * @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;
2726 *
2727 * @example
2728 * const { data, loading, error } = useEventByUuidQuery({
2729 *   variables: {
2730 *      uuid: // value for 'uuid'
2731 *   },
2732 * });
2733 */
2734export function useEventByUuidQuery(baseOptions: Apollo.QueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2735        return Apollo.useQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2736      }
2737export function useEventByUuidLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2738          return Apollo.useLazyQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2739        }
2740export type EventByUuidQueryHookResult = ReturnType<typeof useEventByUuidQuery>;
2741export type EventByUuidLazyQueryHookResult = ReturnType<typeof useEventByUuidLazyQuery>;
2742export type EventByUuidQueryResult = Apollo.QueryResult<EventByUuidQuery, EventByUuidQueryVariables>;
2743export const SettingDocument = gql`
2744    query setting {
2745  setting {
2746    id
2747    gtm_id
2748    about_link
2749  }
2750}
2751    `;
2752
2753/**
2754 * __useSettingQuery__
2755 *
2756 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2757 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2758 * you can use to render your UI.
2759 *
2760 * @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;
2761 *
2762 * @example
2763 * const { data, loading, error } = useSettingQuery({
2764 *   variables: {
2765 *   },
2766 * });
2767 */
2768export function useSettingQuery(baseOptions?: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2769        return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2770      }
2771export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2772          return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2773        }
2774export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2775export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2776export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2777export const CreateTravelDocument = gql`
2778    mutation createTravel($travel: TravelInput!) {
2779  createTravel(input: {data: $travel}) {
2780    travel {
2781      ...TravelFields
2782    }
2783  }
2784}
2785    ${TravelFieldsFragmentDoc}`;
2786export type CreateTravelMutationFn = Apollo.MutationFunction<CreateTravelMutation, CreateTravelMutationVariables>;
2787
2788/**
2789 * __useCreateTravelMutation__
2790 *
2791 * To run a mutation, you first call `useCreateTravelMutation` within a React component and pass it any options that fit your needs.
2792 * When your component renders, `useCreateTravelMutation` returns a tuple that includes:
2793 * - A mutate function that you can call at any time to execute the mutation
2794 * - An object with fields that represent the current status of the mutation's execution
2795 *
2796 * @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;
2797 *
2798 * @example
2799 * const [createTravelMutation, { data, loading, error }] = useCreateTravelMutation({
2800 *   variables: {
2801 *      travel: // value for 'travel'
2802 *   },
2803 * });
2804 */
2805export function useCreateTravelMutation(baseOptions?: Apollo.MutationHookOptions<CreateTravelMutation, CreateTravelMutationVariables>) {
2806        return Apollo.useMutation<CreateTravelMutation, CreateTravelMutationVariables>(CreateTravelDocument, baseOptions);
2807      }
2808export type CreateTravelMutationHookResult = ReturnType<typeof useCreateTravelMutation>;
2809export type CreateTravelMutationResult = Apollo.MutationResult<CreateTravelMutation>;
2810export type CreateTravelMutationOptions = Apollo.BaseMutationOptions<CreateTravelMutation, CreateTravelMutationVariables>;
2811export const UpdateTravelDocument = gql`
2812    mutation updateTravel($id: ID!, $travelUpdate: editTravelInput!) {
2813  updateTravel(input: {where: {id: $id}, data: $travelUpdate}) {
2814    travel {
2815      ...TravelFields
2816    }
2817  }
2818}
2819    ${TravelFieldsFragmentDoc}`;
2820export type UpdateTravelMutationFn = Apollo.MutationFunction<UpdateTravelMutation, UpdateTravelMutationVariables>;
2821
2822/**
2823 * __useUpdateTravelMutation__
2824 *
2825 * To run a mutation, you first call `useUpdateTravelMutation` within a React component and pass it any options that fit your needs.
2826 * When your component renders, `useUpdateTravelMutation` returns a tuple that includes:
2827 * - A mutate function that you can call at any time to execute the mutation
2828 * - An object with fields that represent the current status of the mutation's execution
2829 *
2830 * @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;
2831 *
2832 * @example
2833 * const [updateTravelMutation, { data, loading, error }] = useUpdateTravelMutation({
2834 *   variables: {
2835 *      id: // value for 'id'
2836 *      travelUpdate: // value for 'travelUpdate'
2837 *   },
2838 * });
2839 */
2840export function useUpdateTravelMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTravelMutation, UpdateTravelMutationVariables>) {
2841        return Apollo.useMutation<UpdateTravelMutation, UpdateTravelMutationVariables>(UpdateTravelDocument, baseOptions);
2842      }
2843export type UpdateTravelMutationHookResult = ReturnType<typeof useUpdateTravelMutation>;
2844export type UpdateTravelMutationResult = Apollo.MutationResult<UpdateTravelMutation>;
2845export type UpdateTravelMutationOptions = Apollo.BaseMutationOptions<UpdateTravelMutation, UpdateTravelMutationVariables>;
2846export const DeleteTravelDocument = gql`
2847    mutation deleteTravel($id: ID!) {
2848  deleteTravel(input: {where: {id: $id}}) {
2849    travel {
2850      id
2851    }
2852  }
2853}
2854    `;
2855export type DeleteTravelMutationFn = Apollo.MutationFunction<DeleteTravelMutation, DeleteTravelMutationVariables>;
2856
2857/**
2858 * __useDeleteTravelMutation__
2859 *
2860 * To run a mutation, you first call `useDeleteTravelMutation` within a React component and pass it any options that fit your needs.
2861 * When your component renders, `useDeleteTravelMutation` returns a tuple that includes:
2862 * - A mutate function that you can call at any time to execute the mutation
2863 * - An object with fields that represent the current status of the mutation's execution
2864 *
2865 * @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;
2866 *
2867 * @example
2868 * const [deleteTravelMutation, { data, loading, error }] = useDeleteTravelMutation({
2869 *   variables: {
2870 *      id: // value for 'id'
2871 *   },
2872 * });
2873 */
2874export function useDeleteTravelMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTravelMutation, DeleteTravelMutationVariables>) {
2875        return Apollo.useMutation<DeleteTravelMutation, DeleteTravelMutationVariables>(DeleteTravelDocument, baseOptions);
2876      }
2877export type DeleteTravelMutationHookResult = ReturnType<typeof useDeleteTravelMutation>;
2878export type DeleteTravelMutationResult = Apollo.MutationResult<DeleteTravelMutation>;
2879export type DeleteTravelMutationOptions = Apollo.BaseMutationOptions<DeleteTravelMutation, DeleteTravelMutationVariables>;
2880export const ProfileDocument = gql`
2881    query profile {
2882  me {
2883    id
2884    username
2885    profile {
2886      ...UserFields
2887    }
2888  }
2889}
2890    ${UserFieldsFragmentDoc}`;
2891
2892/**
2893 * __useProfileQuery__
2894 *
2895 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2896 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2897 * you can use to render your UI.
2898 *
2899 * @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;
2900 *
2901 * @example
2902 * const { data, loading, error } = useProfileQuery({
2903 *   variables: {
2904 *   },
2905 * });
2906 */
2907export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2908        return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2909      }
2910export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2911          return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2912        }
2913export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2914export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2915export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2916export const UpdateMeDocument = gql`
2917    mutation updateMe($userUpdate: editUserInput!) {
2918  updateMe(input: $userUpdate) {
2919    user {
2920      ...UserFields
2921    }
2922  }
2923}
2924    ${UserFieldsFragmentDoc}`;
2925export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2926
2927/**
2928 * __useUpdateMeMutation__
2929 *
2930 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2931 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2932 * - A mutate function that you can call at any time to execute the mutation
2933 * - An object with fields that represent the current status of the mutation's execution
2934 *
2935 * @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;
2936 *
2937 * @example
2938 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2939 *   variables: {
2940 *      userUpdate: // value for 'userUpdate'
2941 *   },
2942 * });
2943 */
2944export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2945        return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2946      }
2947export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2948export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2949export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;
2950export const CreateVehicleDocument = gql`
2951    mutation createVehicle($vehicle: VehicleInput!) {
2952  createVehicle(input: {data: $vehicle}) {
2953    vehicle {
2954      ...VehicleFields
2955    }
2956  }
2957}
2958    ${VehicleFieldsFragmentDoc}`;
2959export type CreateVehicleMutationFn = Apollo.MutationFunction<CreateVehicleMutation, CreateVehicleMutationVariables>;
2960
2961/**
2962 * __useCreateVehicleMutation__
2963 *
2964 * To run a mutation, you first call `useCreateVehicleMutation` within a React component and pass it any options that fit your needs.
2965 * When your component renders, `useCreateVehicleMutation` returns a tuple that includes:
2966 * - A mutate function that you can call at any time to execute the mutation
2967 * - An object with fields that represent the current status of the mutation's execution
2968 *
2969 * @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;
2970 *
2971 * @example
2972 * const [createVehicleMutation, { data, loading, error }] = useCreateVehicleMutation({
2973 *   variables: {
2974 *      vehicle: // value for 'vehicle'
2975 *   },
2976 * });
2977 */
2978export function useCreateVehicleMutation(baseOptions?: Apollo.MutationHookOptions<CreateVehicleMutation, CreateVehicleMutationVariables>) {
2979        return Apollo.useMutation<CreateVehicleMutation, CreateVehicleMutationVariables>(CreateVehicleDocument, baseOptions);
2980      }
2981export type CreateVehicleMutationHookResult = ReturnType<typeof useCreateVehicleMutation>;
2982export type CreateVehicleMutationResult = Apollo.MutationResult<CreateVehicleMutation>;
2983export type CreateVehicleMutationOptions = Apollo.BaseMutationOptions<CreateVehicleMutation, CreateVehicleMutationVariables>;
2984export const UpdateVehicleDocument = gql`
2985    mutation updateVehicle($id: ID!, $vehicleUpdate: editVehicleInput!) {
2986  updateVehicle(input: {where: {id: $id}, data: $vehicleUpdate}) {
2987    vehicle {
2988      ...VehicleFields
2989    }
2990  }
2991}
2992    ${VehicleFieldsFragmentDoc}`;
2993export type UpdateVehicleMutationFn = Apollo.MutationFunction<UpdateVehicleMutation, UpdateVehicleMutationVariables>;
2994
2995/**
2996 * __useUpdateVehicleMutation__
2997 *
2998 * To run a mutation, you first call `useUpdateVehicleMutation` within a React component and pass it any options that fit your needs.
2999 * When your component renders, `useUpdateVehicleMutation` returns a tuple that includes:
3000 * - A mutate function that you can call at any time to execute the mutation
3001 * - An object with fields that represent the current status of the mutation's execution
3002 *
3003 * @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;
3004 *
3005 * @example
3006 * const [updateVehicleMutation, { data, loading, error }] = useUpdateVehicleMutation({
3007 *   variables: {
3008 *      id: // value for 'id'
3009 *      vehicleUpdate: // value for 'vehicleUpdate'
3010 *   },
3011 * });
3012 */
3013export function useUpdateVehicleMutation(baseOptions?: Apollo.MutationHookOptions<UpdateVehicleMutation, UpdateVehicleMutationVariables>) {
3014        return Apollo.useMutation<UpdateVehicleMutation, UpdateVehicleMutationVariables>(UpdateVehicleDocument, baseOptions);
3015      }
3016export type UpdateVehicleMutationHookResult = ReturnType<typeof useUpdateVehicleMutation>;
3017export type UpdateVehicleMutationResult = Apollo.MutationResult<UpdateVehicleMutation>;
3018export type UpdateVehicleMutationOptions = Apollo.BaseMutationOptions<UpdateVehicleMutation, UpdateVehicleMutationVariables>;
3019export const DeleteVehicleDocument = gql`
3020    mutation deleteVehicle($id: ID!) {
3021  deleteVehicle(input: {where: {id: $id}}) {
3022    vehicle {
3023      id
3024      name
3025    }
3026  }
3027}
3028    `;
3029export type DeleteVehicleMutationFn = Apollo.MutationFunction<DeleteVehicleMutation, DeleteVehicleMutationVariables>;
3030
3031/**
3032 * __useDeleteVehicleMutation__
3033 *
3034 * To run a mutation, you first call `useDeleteVehicleMutation` within a React component and pass it any options that fit your needs.
3035 * When your component renders, `useDeleteVehicleMutation` returns a tuple that includes:
3036 * - A mutate function that you can call at any time to execute the mutation
3037 * - An object with fields that represent the current status of the mutation's execution
3038 *
3039 * @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;
3040 *
3041 * @example
3042 * const [deleteVehicleMutation, { data, loading, error }] = useDeleteVehicleMutation({
3043 *   variables: {
3044 *      id: // value for 'id'
3045 *   },
3046 * });
3047 */
3048export function useDeleteVehicleMutation(baseOptions?: Apollo.MutationHookOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>) {
3049        return Apollo.useMutation<DeleteVehicleMutation, DeleteVehicleMutationVariables>(DeleteVehicleDocument, baseOptions);
3050      }
3051export type DeleteVehicleMutationHookResult = ReturnType<typeof useDeleteVehicleMutation>;
3052export type DeleteVehicleMutationResult = Apollo.MutationResult<DeleteVehicleMutation>;
3053export type DeleteVehicleMutationOptions = Apollo.BaseMutationOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>;