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