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