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