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  created_by?: Maybe<Scalars['ID']>;
 783  updated_by?: Maybe<Scalars['ID']>;
 784};
 785
 786export type Settings = {
 787  __typename?: 'Settings';
 788  id: Scalars['ID'];
 789  created_at: Scalars['DateTime'];
 790  updated_at: Scalars['DateTime'];
 791  gtm_id?: Maybe<Scalars['String']>;
 792  about_link?: Maybe<Scalars['String']>;
 793};
 794
 795
 796export type Travel = {
 797  __typename?: 'Travel';
 798  id: Scalars['ID'];
 799  created_at: Scalars['DateTime'];
 800  updated_at: Scalars['DateTime'];
 801  meeting?: Maybe<Scalars['String']>;
 802  departure?: Maybe<Scalars['DateTime']>;
 803  details?: Maybe<Scalars['String']>;
 804  passengers?: Maybe<Array<Maybe<ComponentPassengerPassenger>>>;
 805  event?: Maybe<Event>;
 806  vehicleName?: Maybe<Scalars['String']>;
 807  seats?: Maybe<Scalars['Int']>;
 808  phone_number?: Maybe<Scalars['String']>;
 809};
 810
 811export type TravelAggregator = {
 812  __typename?: 'TravelAggregator';
 813  count?: Maybe<Scalars['Int']>;
 814  totalCount?: Maybe<Scalars['Int']>;
 815  sum?: Maybe<TravelAggregatorSum>;
 816  avg?: Maybe<TravelAggregatorAvg>;
 817  min?: Maybe<TravelAggregatorMin>;
 818  max?: Maybe<TravelAggregatorMax>;
 819};
 820
 821export type TravelAggregatorAvg = {
 822  __typename?: 'TravelAggregatorAvg';
 823  seats?: Maybe<Scalars['Float']>;
 824};
 825
 826export type TravelAggregatorMax = {
 827  __typename?: 'TravelAggregatorMax';
 828  seats?: Maybe<Scalars['Float']>;
 829};
 830
 831export type TravelAggregatorMin = {
 832  __typename?: 'TravelAggregatorMin';
 833  seats?: Maybe<Scalars['Float']>;
 834};
 835
 836export type TravelAggregatorSum = {
 837  __typename?: 'TravelAggregatorSum';
 838  seats?: Maybe<Scalars['Float']>;
 839};
 840
 841export type TravelConnection = {
 842  __typename?: 'TravelConnection';
 843  values?: Maybe<Array<Maybe<Travel>>>;
 844  groupBy?: Maybe<TravelGroupBy>;
 845  aggregate?: Maybe<TravelAggregator>;
 846};
 847
 848export type TravelConnectionCreated_At = {
 849  __typename?: 'TravelConnectionCreated_at';
 850  key?: Maybe<Scalars['DateTime']>;
 851  connection?: Maybe<TravelConnection>;
 852};
 853
 854export type TravelConnectionDeparture = {
 855  __typename?: 'TravelConnectionDeparture';
 856  key?: Maybe<Scalars['DateTime']>;
 857  connection?: Maybe<TravelConnection>;
 858};
 859
 860export type TravelConnectionDetails = {
 861  __typename?: 'TravelConnectionDetails';
 862  key?: Maybe<Scalars['String']>;
 863  connection?: Maybe<TravelConnection>;
 864};
 865
 866export type TravelConnectionEvent = {
 867  __typename?: 'TravelConnectionEvent';
 868  key?: Maybe<Scalars['ID']>;
 869  connection?: Maybe<TravelConnection>;
 870};
 871
 872export type TravelConnectionId = {
 873  __typename?: 'TravelConnectionId';
 874  key?: Maybe<Scalars['ID']>;
 875  connection?: Maybe<TravelConnection>;
 876};
 877
 878export type TravelConnectionMeeting = {
 879  __typename?: 'TravelConnectionMeeting';
 880  key?: Maybe<Scalars['String']>;
 881  connection?: Maybe<TravelConnection>;
 882};
 883
 884export type TravelConnectionPhone_Number = {
 885  __typename?: 'TravelConnectionPhone_number';
 886  key?: Maybe<Scalars['String']>;
 887  connection?: Maybe<TravelConnection>;
 888};
 889
 890export type TravelConnectionSeats = {
 891  __typename?: 'TravelConnectionSeats';
 892  key?: Maybe<Scalars['Int']>;
 893  connection?: Maybe<TravelConnection>;
 894};
 895
 896export type TravelConnectionUpdated_At = {
 897  __typename?: 'TravelConnectionUpdated_at';
 898  key?: Maybe<Scalars['DateTime']>;
 899  connection?: Maybe<TravelConnection>;
 900};
 901
 902export type TravelConnectionVehicleName = {
 903  __typename?: 'TravelConnectionVehicleName';
 904  key?: Maybe<Scalars['String']>;
 905  connection?: Maybe<TravelConnection>;
 906};
 907
 908export type TravelGroupBy = {
 909  __typename?: 'TravelGroupBy';
 910  id?: Maybe<Array<Maybe<TravelConnectionId>>>;
 911  created_at?: Maybe<Array<Maybe<TravelConnectionCreated_At>>>;
 912  updated_at?: Maybe<Array<Maybe<TravelConnectionUpdated_At>>>;
 913  meeting?: Maybe<Array<Maybe<TravelConnectionMeeting>>>;
 914  departure?: Maybe<Array<Maybe<TravelConnectionDeparture>>>;
 915  details?: Maybe<Array<Maybe<TravelConnectionDetails>>>;
 916  event?: Maybe<Array<Maybe<TravelConnectionEvent>>>;
 917  vehicleName?: Maybe<Array<Maybe<TravelConnectionVehicleName>>>;
 918  seats?: Maybe<Array<Maybe<TravelConnectionSeats>>>;
 919  phone_number?: Maybe<Array<Maybe<TravelConnectionPhone_Number>>>;
 920};
 921
 922export type TravelInput = {
 923  meeting?: Maybe<Scalars['String']>;
 924  departure?: Maybe<Scalars['DateTime']>;
 925  details?: Maybe<Scalars['String']>;
 926  passengers?: Maybe<Array<Maybe<ComponentPassengerPassengerInput>>>;
 927  event?: Maybe<Scalars['ID']>;
 928  vehicleName?: Maybe<Scalars['String']>;
 929  seats?: Maybe<Scalars['Int']>;
 930  phone_number?: Maybe<Scalars['String']>;
 931  created_by?: Maybe<Scalars['ID']>;
 932  updated_by?: Maybe<Scalars['ID']>;
 933  createVehicle?: Maybe<Scalars['Boolean']>;
 934};
 935
 936
 937export type UploadFile = {
 938  __typename?: 'UploadFile';
 939  id: Scalars['ID'];
 940  created_at: Scalars['DateTime'];
 941  updated_at: Scalars['DateTime'];
 942  name: Scalars['String'];
 943  alternativeText?: Maybe<Scalars['String']>;
 944  caption?: Maybe<Scalars['String']>;
 945  width?: Maybe<Scalars['Int']>;
 946  height?: Maybe<Scalars['Int']>;
 947  formats?: Maybe<Scalars['JSON']>;
 948  hash: Scalars['String'];
 949  ext?: Maybe<Scalars['String']>;
 950  mime: Scalars['String'];
 951  size: Scalars['Float'];
 952  url: Scalars['String'];
 953  previewUrl?: Maybe<Scalars['String']>;
 954  provider: Scalars['String'];
 955  provider_metadata?: Maybe<Scalars['JSON']>;
 956  related?: Maybe<Array<Maybe<Morph>>>;
 957};
 958
 959
 960export type UploadFileRelatedArgs = {
 961  sort?: Maybe<Scalars['String']>;
 962  limit?: Maybe<Scalars['Int']>;
 963  start?: Maybe<Scalars['Int']>;
 964  where?: Maybe<Scalars['JSON']>;
 965};
 966
 967export type UploadFileAggregator = {
 968  __typename?: 'UploadFileAggregator';
 969  count?: Maybe<Scalars['Int']>;
 970  totalCount?: Maybe<Scalars['Int']>;
 971  sum?: Maybe<UploadFileAggregatorSum>;
 972  avg?: Maybe<UploadFileAggregatorAvg>;
 973  min?: Maybe<UploadFileAggregatorMin>;
 974  max?: Maybe<UploadFileAggregatorMax>;
 975};
 976
 977export type UploadFileAggregatorAvg = {
 978  __typename?: 'UploadFileAggregatorAvg';
 979  width?: Maybe<Scalars['Float']>;
 980  height?: Maybe<Scalars['Float']>;
 981  size?: Maybe<Scalars['Float']>;
 982};
 983
 984export type UploadFileAggregatorMax = {
 985  __typename?: 'UploadFileAggregatorMax';
 986  width?: Maybe<Scalars['Float']>;
 987  height?: Maybe<Scalars['Float']>;
 988  size?: Maybe<Scalars['Float']>;
 989};
 990
 991export type UploadFileAggregatorMin = {
 992  __typename?: 'UploadFileAggregatorMin';
 993  width?: Maybe<Scalars['Float']>;
 994  height?: Maybe<Scalars['Float']>;
 995  size?: Maybe<Scalars['Float']>;
 996};
 997
 998export type UploadFileAggregatorSum = {
 999  __typename?: 'UploadFileAggregatorSum';
1000  width?: Maybe<Scalars['Float']>;
1001  height?: Maybe<Scalars['Float']>;
1002  size?: Maybe<Scalars['Float']>;
1003};
1004
1005export type UploadFileConnection = {
1006  __typename?: 'UploadFileConnection';
1007  values?: Maybe<Array<Maybe<UploadFile>>>;
1008  groupBy?: Maybe<UploadFileGroupBy>;
1009  aggregate?: Maybe<UploadFileAggregator>;
1010};
1011
1012export type UploadFileConnectionAlternativeText = {
1013  __typename?: 'UploadFileConnectionAlternativeText';
1014  key?: Maybe<Scalars['String']>;
1015  connection?: Maybe<UploadFileConnection>;
1016};
1017
1018export type UploadFileConnectionCaption = {
1019  __typename?: 'UploadFileConnectionCaption';
1020  key?: Maybe<Scalars['String']>;
1021  connection?: Maybe<UploadFileConnection>;
1022};
1023
1024export type UploadFileConnectionCreated_At = {
1025  __typename?: 'UploadFileConnectionCreated_at';
1026  key?: Maybe<Scalars['DateTime']>;
1027  connection?: Maybe<UploadFileConnection>;
1028};
1029
1030export type UploadFileConnectionExt = {
1031  __typename?: 'UploadFileConnectionExt';
1032  key?: Maybe<Scalars['String']>;
1033  connection?: Maybe<UploadFileConnection>;
1034};
1035
1036export type UploadFileConnectionFormats = {
1037  __typename?: 'UploadFileConnectionFormats';
1038  key?: Maybe<Scalars['JSON']>;
1039  connection?: Maybe<UploadFileConnection>;
1040};
1041
1042export type UploadFileConnectionHash = {
1043  __typename?: 'UploadFileConnectionHash';
1044  key?: Maybe<Scalars['String']>;
1045  connection?: Maybe<UploadFileConnection>;
1046};
1047
1048export type UploadFileConnectionHeight = {
1049  __typename?: 'UploadFileConnectionHeight';
1050  key?: Maybe<Scalars['Int']>;
1051  connection?: Maybe<UploadFileConnection>;
1052};
1053
1054export type UploadFileConnectionId = {
1055  __typename?: 'UploadFileConnectionId';
1056  key?: Maybe<Scalars['ID']>;
1057  connection?: Maybe<UploadFileConnection>;
1058};
1059
1060export type UploadFileConnectionMime = {
1061  __typename?: 'UploadFileConnectionMime';
1062  key?: Maybe<Scalars['String']>;
1063  connection?: Maybe<UploadFileConnection>;
1064};
1065
1066export type UploadFileConnectionName = {
1067  __typename?: 'UploadFileConnectionName';
1068  key?: Maybe<Scalars['String']>;
1069  connection?: Maybe<UploadFileConnection>;
1070};
1071
1072export type UploadFileConnectionPreviewUrl = {
1073  __typename?: 'UploadFileConnectionPreviewUrl';
1074  key?: Maybe<Scalars['String']>;
1075  connection?: Maybe<UploadFileConnection>;
1076};
1077
1078export type UploadFileConnectionProvider = {
1079  __typename?: 'UploadFileConnectionProvider';
1080  key?: Maybe<Scalars['String']>;
1081  connection?: Maybe<UploadFileConnection>;
1082};
1083
1084export type UploadFileConnectionProvider_Metadata = {
1085  __typename?: 'UploadFileConnectionProvider_metadata';
1086  key?: Maybe<Scalars['JSON']>;
1087  connection?: Maybe<UploadFileConnection>;
1088};
1089
1090export type UploadFileConnectionSize = {
1091  __typename?: 'UploadFileConnectionSize';
1092  key?: Maybe<Scalars['Float']>;
1093  connection?: Maybe<UploadFileConnection>;
1094};
1095
1096export type UploadFileConnectionUpdated_At = {
1097  __typename?: 'UploadFileConnectionUpdated_at';
1098  key?: Maybe<Scalars['DateTime']>;
1099  connection?: Maybe<UploadFileConnection>;
1100};
1101
1102export type UploadFileConnectionUrl = {
1103  __typename?: 'UploadFileConnectionUrl';
1104  key?: Maybe<Scalars['String']>;
1105  connection?: Maybe<UploadFileConnection>;
1106};
1107
1108export type UploadFileConnectionWidth = {
1109  __typename?: 'UploadFileConnectionWidth';
1110  key?: Maybe<Scalars['Int']>;
1111  connection?: Maybe<UploadFileConnection>;
1112};
1113
1114export type UploadFileGroupBy = {
1115  __typename?: 'UploadFileGroupBy';
1116  id?: Maybe<Array<Maybe<UploadFileConnectionId>>>;
1117  created_at?: Maybe<Array<Maybe<UploadFileConnectionCreated_At>>>;
1118  updated_at?: Maybe<Array<Maybe<UploadFileConnectionUpdated_At>>>;
1119  name?: Maybe<Array<Maybe<UploadFileConnectionName>>>;
1120  alternativeText?: Maybe<Array<Maybe<UploadFileConnectionAlternativeText>>>;
1121  caption?: Maybe<Array<Maybe<UploadFileConnectionCaption>>>;
1122  width?: Maybe<Array<Maybe<UploadFileConnectionWidth>>>;
1123  height?: Maybe<Array<Maybe<UploadFileConnectionHeight>>>;
1124  formats?: Maybe<Array<Maybe<UploadFileConnectionFormats>>>;
1125  hash?: Maybe<Array<Maybe<UploadFileConnectionHash>>>;
1126  ext?: Maybe<Array<Maybe<UploadFileConnectionExt>>>;
1127  mime?: Maybe<Array<Maybe<UploadFileConnectionMime>>>;
1128  size?: Maybe<Array<Maybe<UploadFileConnectionSize>>>;
1129  url?: Maybe<Array<Maybe<UploadFileConnectionUrl>>>;
1130  previewUrl?: Maybe<Array<Maybe<UploadFileConnectionPreviewUrl>>>;
1131  provider?: Maybe<Array<Maybe<UploadFileConnectionProvider>>>;
1132  provider_metadata?: Maybe<Array<Maybe<UploadFileConnectionProvider_Metadata>>>;
1133};
1134
1135export type UserInput = {
1136  username: Scalars['String'];
1137  firstName?: Maybe<Scalars['String']>;
1138  lastName?: Maybe<Scalars['String']>;
1139  email: Scalars['String'];
1140  provider?: Maybe<Scalars['String']>;
1141  password?: Maybe<Scalars['String']>;
1142  resetPasswordToken?: Maybe<Scalars['String']>;
1143  confirmed?: Maybe<Scalars['Boolean']>;
1144  blocked?: Maybe<Scalars['Boolean']>;
1145  role?: Maybe<Scalars['ID']>;
1146  confirmationToken?: Maybe<Scalars['String']>;
1147  events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1148  onboardingUser?: Maybe<Scalars['Boolean']>;
1149  onboardingCreator?: Maybe<Scalars['Boolean']>;
1150  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1151  vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1152  created_by?: Maybe<Scalars['ID']>;
1153  updated_by?: Maybe<Scalars['ID']>;
1154};
1155
1156export type UserPermissionsPasswordPayload = {
1157  __typename?: 'UserPermissionsPasswordPayload';
1158  ok: Scalars['Boolean'];
1159};
1160
1161export type UsersPermissionsLoginInput = {
1162  identifier: Scalars['String'];
1163  password: Scalars['String'];
1164  provider?: Maybe<Scalars['String']>;
1165};
1166
1167export type UsersPermissionsLoginPayload = {
1168  __typename?: 'UsersPermissionsLoginPayload';
1169  jwt?: Maybe<Scalars['String']>;
1170  user: UsersPermissionsMe;
1171};
1172
1173export type UsersPermissionsMe = {
1174  __typename?: 'UsersPermissionsMe';
1175  id: Scalars['ID'];
1176  username: Scalars['String'];
1177  email: Scalars['String'];
1178  confirmed?: Maybe<Scalars['Boolean']>;
1179  blocked?: Maybe<Scalars['Boolean']>;
1180  role?: Maybe<UsersPermissionsMeRole>;
1181  profile?: Maybe<UsersPermissionsUser>;
1182};
1183
1184export type UsersPermissionsMeRole = {
1185  __typename?: 'UsersPermissionsMeRole';
1186  id: Scalars['ID'];
1187  name: Scalars['String'];
1188  description?: Maybe<Scalars['String']>;
1189  type?: Maybe<Scalars['String']>;
1190};
1191
1192export type UsersPermissionsPermission = {
1193  __typename?: 'UsersPermissionsPermission';
1194  id: Scalars['ID'];
1195  type: Scalars['String'];
1196  controller: Scalars['String'];
1197  action: Scalars['String'];
1198  enabled: Scalars['Boolean'];
1199  policy?: Maybe<Scalars['String']>;
1200  role?: Maybe<UsersPermissionsRole>;
1201};
1202
1203export type UsersPermissionsRegisterInput = {
1204  username: Scalars['String'];
1205  email: Scalars['String'];
1206  password: Scalars['String'];
1207  firstName?: Maybe<Scalars['String']>;
1208  lastName?: Maybe<Scalars['String']>;
1209  lang?: Maybe<Scalars['String']>;
1210};
1211
1212export type UsersPermissionsRole = {
1213  __typename?: 'UsersPermissionsRole';
1214  id: Scalars['ID'];
1215  name: Scalars['String'];
1216  description?: Maybe<Scalars['String']>;
1217  type?: Maybe<Scalars['String']>;
1218  permissions?: Maybe<Array<Maybe<UsersPermissionsPermission>>>;
1219  users?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1220};
1221
1222
1223export type UsersPermissionsRolePermissionsArgs = {
1224  sort?: Maybe<Scalars['String']>;
1225  limit?: Maybe<Scalars['Int']>;
1226  start?: Maybe<Scalars['Int']>;
1227  where?: Maybe<Scalars['JSON']>;
1228};
1229
1230
1231export type UsersPermissionsRoleUsersArgs = {
1232  sort?: Maybe<Scalars['String']>;
1233  limit?: Maybe<Scalars['Int']>;
1234  start?: Maybe<Scalars['Int']>;
1235  where?: Maybe<Scalars['JSON']>;
1236};
1237
1238export type UsersPermissionsRoleAggregator = {
1239  __typename?: 'UsersPermissionsRoleAggregator';
1240  count?: Maybe<Scalars['Int']>;
1241  totalCount?: Maybe<Scalars['Int']>;
1242};
1243
1244export type UsersPermissionsRoleConnection = {
1245  __typename?: 'UsersPermissionsRoleConnection';
1246  values?: Maybe<Array<Maybe<UsersPermissionsRole>>>;
1247  groupBy?: Maybe<UsersPermissionsRoleGroupBy>;
1248  aggregate?: Maybe<UsersPermissionsRoleAggregator>;
1249};
1250
1251export type UsersPermissionsRoleConnectionDescription = {
1252  __typename?: 'UsersPermissionsRoleConnectionDescription';
1253  key?: Maybe<Scalars['String']>;
1254  connection?: Maybe<UsersPermissionsRoleConnection>;
1255};
1256
1257export type UsersPermissionsRoleConnectionId = {
1258  __typename?: 'UsersPermissionsRoleConnectionId';
1259  key?: Maybe<Scalars['ID']>;
1260  connection?: Maybe<UsersPermissionsRoleConnection>;
1261};
1262
1263export type UsersPermissionsRoleConnectionName = {
1264  __typename?: 'UsersPermissionsRoleConnectionName';
1265  key?: Maybe<Scalars['String']>;
1266  connection?: Maybe<UsersPermissionsRoleConnection>;
1267};
1268
1269export type UsersPermissionsRoleConnectionType = {
1270  __typename?: 'UsersPermissionsRoleConnectionType';
1271  key?: Maybe<Scalars['String']>;
1272  connection?: Maybe<UsersPermissionsRoleConnection>;
1273};
1274
1275export type UsersPermissionsRoleGroupBy = {
1276  __typename?: 'UsersPermissionsRoleGroupBy';
1277  id?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionId>>>;
1278  name?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionName>>>;
1279  description?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionDescription>>>;
1280  type?: Maybe<Array<Maybe<UsersPermissionsRoleConnectionType>>>;
1281};
1282
1283export type UsersPermissionsUser = {
1284  __typename?: 'UsersPermissionsUser';
1285  id: Scalars['ID'];
1286  created_at: Scalars['DateTime'];
1287  updated_at: Scalars['DateTime'];
1288  username: Scalars['String'];
1289  firstName?: Maybe<Scalars['String']>;
1290  lastName?: Maybe<Scalars['String']>;
1291  email: Scalars['String'];
1292  provider?: Maybe<Scalars['String']>;
1293  confirmed?: Maybe<Scalars['Boolean']>;
1294  blocked?: Maybe<Scalars['Boolean']>;
1295  role?: Maybe<UsersPermissionsRole>;
1296  onboardingUser?: Maybe<Scalars['Boolean']>;
1297  onboardingCreator?: Maybe<Scalars['Boolean']>;
1298  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1299  events?: Maybe<Array<Maybe<Event>>>;
1300  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
1301};
1302
1303
1304export type UsersPermissionsUserEventsArgs = {
1305  sort?: Maybe<Scalars['String']>;
1306  limit?: Maybe<Scalars['Int']>;
1307  start?: Maybe<Scalars['Int']>;
1308  where?: Maybe<Scalars['JSON']>;
1309};
1310
1311
1312export type UsersPermissionsUserVehiclesArgs = {
1313  sort?: Maybe<Scalars['String']>;
1314  limit?: Maybe<Scalars['Int']>;
1315  start?: Maybe<Scalars['Int']>;
1316  where?: Maybe<Scalars['JSON']>;
1317};
1318
1319export type UsersPermissionsUserAggregator = {
1320  __typename?: 'UsersPermissionsUserAggregator';
1321  count?: Maybe<Scalars['Int']>;
1322  totalCount?: Maybe<Scalars['Int']>;
1323};
1324
1325export type UsersPermissionsUserConnection = {
1326  __typename?: 'UsersPermissionsUserConnection';
1327  values?: Maybe<Array<Maybe<UsersPermissionsUser>>>;
1328  groupBy?: Maybe<UsersPermissionsUserGroupBy>;
1329  aggregate?: Maybe<UsersPermissionsUserAggregator>;
1330};
1331
1332export type UsersPermissionsUserConnectionBlocked = {
1333  __typename?: 'UsersPermissionsUserConnectionBlocked';
1334  key?: Maybe<Scalars['Boolean']>;
1335  connection?: Maybe<UsersPermissionsUserConnection>;
1336};
1337
1338export type UsersPermissionsUserConnectionConfirmed = {
1339  __typename?: 'UsersPermissionsUserConnectionConfirmed';
1340  key?: Maybe<Scalars['Boolean']>;
1341  connection?: Maybe<UsersPermissionsUserConnection>;
1342};
1343
1344export type UsersPermissionsUserConnectionCreated_At = {
1345  __typename?: 'UsersPermissionsUserConnectionCreated_at';
1346  key?: Maybe<Scalars['DateTime']>;
1347  connection?: Maybe<UsersPermissionsUserConnection>;
1348};
1349
1350export type UsersPermissionsUserConnectionEmail = {
1351  __typename?: 'UsersPermissionsUserConnectionEmail';
1352  key?: Maybe<Scalars['String']>;
1353  connection?: Maybe<UsersPermissionsUserConnection>;
1354};
1355
1356export type UsersPermissionsUserConnectionFirstName = {
1357  __typename?: 'UsersPermissionsUserConnectionFirstName';
1358  key?: Maybe<Scalars['String']>;
1359  connection?: Maybe<UsersPermissionsUserConnection>;
1360};
1361
1362export type UsersPermissionsUserConnectionId = {
1363  __typename?: 'UsersPermissionsUserConnectionId';
1364  key?: Maybe<Scalars['ID']>;
1365  connection?: Maybe<UsersPermissionsUserConnection>;
1366};
1367
1368export type UsersPermissionsUserConnectionLang = {
1369  __typename?: 'UsersPermissionsUserConnectionLang';
1370  key?: Maybe<Scalars['String']>;
1371  connection?: Maybe<UsersPermissionsUserConnection>;
1372};
1373
1374export type UsersPermissionsUserConnectionLastName = {
1375  __typename?: 'UsersPermissionsUserConnectionLastName';
1376  key?: Maybe<Scalars['String']>;
1377  connection?: Maybe<UsersPermissionsUserConnection>;
1378};
1379
1380export type UsersPermissionsUserConnectionOnboardingCreator = {
1381  __typename?: 'UsersPermissionsUserConnectionOnboardingCreator';
1382  key?: Maybe<Scalars['Boolean']>;
1383  connection?: Maybe<UsersPermissionsUserConnection>;
1384};
1385
1386export type UsersPermissionsUserConnectionOnboardingUser = {
1387  __typename?: 'UsersPermissionsUserConnectionOnboardingUser';
1388  key?: Maybe<Scalars['Boolean']>;
1389  connection?: Maybe<UsersPermissionsUserConnection>;
1390};
1391
1392export type UsersPermissionsUserConnectionProvider = {
1393  __typename?: 'UsersPermissionsUserConnectionProvider';
1394  key?: Maybe<Scalars['String']>;
1395  connection?: Maybe<UsersPermissionsUserConnection>;
1396};
1397
1398export type UsersPermissionsUserConnectionRole = {
1399  __typename?: 'UsersPermissionsUserConnectionRole';
1400  key?: Maybe<Scalars['ID']>;
1401  connection?: Maybe<UsersPermissionsUserConnection>;
1402};
1403
1404export type UsersPermissionsUserConnectionUpdated_At = {
1405  __typename?: 'UsersPermissionsUserConnectionUpdated_at';
1406  key?: Maybe<Scalars['DateTime']>;
1407  connection?: Maybe<UsersPermissionsUserConnection>;
1408};
1409
1410export type UsersPermissionsUserConnectionUsername = {
1411  __typename?: 'UsersPermissionsUserConnectionUsername';
1412  key?: Maybe<Scalars['String']>;
1413  connection?: Maybe<UsersPermissionsUserConnection>;
1414};
1415
1416export type UsersPermissionsUserGroupBy = {
1417  __typename?: 'UsersPermissionsUserGroupBy';
1418  id?: Maybe<Array<Maybe<UsersPermissionsUserConnectionId>>>;
1419  created_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionCreated_At>>>;
1420  updated_at?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUpdated_At>>>;
1421  username?: Maybe<Array<Maybe<UsersPermissionsUserConnectionUsername>>>;
1422  firstName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionFirstName>>>;
1423  lastName?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLastName>>>;
1424  email?: Maybe<Array<Maybe<UsersPermissionsUserConnectionEmail>>>;
1425  provider?: Maybe<Array<Maybe<UsersPermissionsUserConnectionProvider>>>;
1426  confirmed?: Maybe<Array<Maybe<UsersPermissionsUserConnectionConfirmed>>>;
1427  blocked?: Maybe<Array<Maybe<UsersPermissionsUserConnectionBlocked>>>;
1428  role?: Maybe<Array<Maybe<UsersPermissionsUserConnectionRole>>>;
1429  onboardingUser?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingUser>>>;
1430  onboardingCreator?: Maybe<Array<Maybe<UsersPermissionsUserConnectionOnboardingCreator>>>;
1431  lang?: Maybe<Array<Maybe<UsersPermissionsUserConnectionLang>>>;
1432};
1433
1434export type Vehicle = {
1435  __typename?: 'Vehicle';
1436  id: Scalars['ID'];
1437  created_at: Scalars['DateTime'];
1438  updated_at: Scalars['DateTime'];
1439  name: Scalars['String'];
1440  seats?: Maybe<Scalars['Int']>;
1441  phone_number?: Maybe<Scalars['String']>;
1442  user?: Maybe<UsersPermissionsUser>;
1443};
1444
1445export type VehicleAggregator = {
1446  __typename?: 'VehicleAggregator';
1447  count?: Maybe<Scalars['Int']>;
1448  totalCount?: Maybe<Scalars['Int']>;
1449  sum?: Maybe<VehicleAggregatorSum>;
1450  avg?: Maybe<VehicleAggregatorAvg>;
1451  min?: Maybe<VehicleAggregatorMin>;
1452  max?: Maybe<VehicleAggregatorMax>;
1453};
1454
1455export type VehicleAggregatorAvg = {
1456  __typename?: 'VehicleAggregatorAvg';
1457  seats?: Maybe<Scalars['Float']>;
1458};
1459
1460export type VehicleAggregatorMax = {
1461  __typename?: 'VehicleAggregatorMax';
1462  seats?: Maybe<Scalars['Float']>;
1463};
1464
1465export type VehicleAggregatorMin = {
1466  __typename?: 'VehicleAggregatorMin';
1467  seats?: Maybe<Scalars['Float']>;
1468};
1469
1470export type VehicleAggregatorSum = {
1471  __typename?: 'VehicleAggregatorSum';
1472  seats?: Maybe<Scalars['Float']>;
1473};
1474
1475export type VehicleConnection = {
1476  __typename?: 'VehicleConnection';
1477  values?: Maybe<Array<Maybe<Vehicle>>>;
1478  groupBy?: Maybe<VehicleGroupBy>;
1479  aggregate?: Maybe<VehicleAggregator>;
1480};
1481
1482export type VehicleConnectionCreated_At = {
1483  __typename?: 'VehicleConnectionCreated_at';
1484  key?: Maybe<Scalars['DateTime']>;
1485  connection?: Maybe<VehicleConnection>;
1486};
1487
1488export type VehicleConnectionId = {
1489  __typename?: 'VehicleConnectionId';
1490  key?: Maybe<Scalars['ID']>;
1491  connection?: Maybe<VehicleConnection>;
1492};
1493
1494export type VehicleConnectionName = {
1495  __typename?: 'VehicleConnectionName';
1496  key?: Maybe<Scalars['String']>;
1497  connection?: Maybe<VehicleConnection>;
1498};
1499
1500export type VehicleConnectionPhone_Number = {
1501  __typename?: 'VehicleConnectionPhone_number';
1502  key?: Maybe<Scalars['String']>;
1503  connection?: Maybe<VehicleConnection>;
1504};
1505
1506export type VehicleConnectionSeats = {
1507  __typename?: 'VehicleConnectionSeats';
1508  key?: Maybe<Scalars['Int']>;
1509  connection?: Maybe<VehicleConnection>;
1510};
1511
1512export type VehicleConnectionUpdated_At = {
1513  __typename?: 'VehicleConnectionUpdated_at';
1514  key?: Maybe<Scalars['DateTime']>;
1515  connection?: Maybe<VehicleConnection>;
1516};
1517
1518export type VehicleConnectionUser = {
1519  __typename?: 'VehicleConnectionUser';
1520  key?: Maybe<Scalars['ID']>;
1521  connection?: Maybe<VehicleConnection>;
1522};
1523
1524export type VehicleGroupBy = {
1525  __typename?: 'VehicleGroupBy';
1526  id?: Maybe<Array<Maybe<VehicleConnectionId>>>;
1527  created_at?: Maybe<Array<Maybe<VehicleConnectionCreated_At>>>;
1528  updated_at?: Maybe<Array<Maybe<VehicleConnectionUpdated_At>>>;
1529  name?: Maybe<Array<Maybe<VehicleConnectionName>>>;
1530  seats?: Maybe<Array<Maybe<VehicleConnectionSeats>>>;
1531  phone_number?: Maybe<Array<Maybe<VehicleConnectionPhone_Number>>>;
1532  user?: Maybe<Array<Maybe<VehicleConnectionUser>>>;
1533};
1534
1535export type VehicleInput = {
1536  name: Scalars['String'];
1537  seats?: Maybe<Scalars['Int']>;
1538  phone_number?: Maybe<Scalars['String']>;
1539  user?: Maybe<Scalars['ID']>;
1540  created_by?: Maybe<Scalars['ID']>;
1541  updated_by?: Maybe<Scalars['ID']>;
1542};
1543
1544export type CreateEventInput = {
1545  data?: Maybe<EventInput>;
1546};
1547
1548export type CreateEventPayload = {
1549  __typename?: 'createEventPayload';
1550  event?: Maybe<Event>;
1551};
1552
1553export type CreatePageInput = {
1554  data?: Maybe<PageInput>;
1555};
1556
1557export type CreatePagePayload = {
1558  __typename?: 'createPagePayload';
1559  page?: Maybe<Page>;
1560};
1561
1562export type CreateRoleInput = {
1563  data?: Maybe<RoleInput>;
1564};
1565
1566export type CreateRolePayload = {
1567  __typename?: 'createRolePayload';
1568  role?: Maybe<UsersPermissionsRole>;
1569};
1570
1571export type CreateTravelInput = {
1572  data?: Maybe<TravelInput>;
1573};
1574
1575export type CreateTravelPayload = {
1576  __typename?: 'createTravelPayload';
1577  travel?: Maybe<Travel>;
1578};
1579
1580export type CreateUserInput = {
1581  data?: Maybe<UserInput>;
1582};
1583
1584export type CreateUserPayload = {
1585  __typename?: 'createUserPayload';
1586  user?: Maybe<UsersPermissionsUser>;
1587};
1588
1589export type CreateVehicleInput = {
1590  data?: Maybe<VehicleInput>;
1591};
1592
1593export type CreateVehiclePayload = {
1594  __typename?: 'createVehiclePayload';
1595  vehicle?: Maybe<Vehicle>;
1596};
1597
1598export type DeleteEventInput = {
1599  where?: Maybe<InputId>;
1600};
1601
1602export type DeleteEventPayload = {
1603  __typename?: 'deleteEventPayload';
1604  event?: Maybe<Event>;
1605};
1606
1607export type DeleteFileInput = {
1608  where?: Maybe<InputId>;
1609};
1610
1611export type DeleteFilePayload = {
1612  __typename?: 'deleteFilePayload';
1613  file?: Maybe<UploadFile>;
1614};
1615
1616export type DeletePageInput = {
1617  where?: Maybe<InputId>;
1618};
1619
1620export type DeletePagePayload = {
1621  __typename?: 'deletePagePayload';
1622  page?: Maybe<Page>;
1623};
1624
1625export type DeleteRoleInput = {
1626  where?: Maybe<InputId>;
1627};
1628
1629export type DeleteRolePayload = {
1630  __typename?: 'deleteRolePayload';
1631  role?: Maybe<UsersPermissionsRole>;
1632};
1633
1634export type DeleteSettingPayload = {
1635  __typename?: 'deleteSettingPayload';
1636  setting?: Maybe<Settings>;
1637};
1638
1639export type DeleteTravelInput = {
1640  where?: Maybe<InputId>;
1641};
1642
1643export type DeleteTravelPayload = {
1644  __typename?: 'deleteTravelPayload';
1645  travel?: Maybe<Travel>;
1646};
1647
1648export type DeleteUserInput = {
1649  where?: Maybe<InputId>;
1650};
1651
1652export type DeleteUserPayload = {
1653  __typename?: 'deleteUserPayload';
1654  user?: Maybe<UsersPermissionsUser>;
1655};
1656
1657export type DeleteVehicleInput = {
1658  where?: Maybe<InputId>;
1659};
1660
1661export type DeleteVehiclePayload = {
1662  __typename?: 'deleteVehiclePayload';
1663  vehicle?: Maybe<Vehicle>;
1664};
1665
1666export type EditComponentPassengerPassengerInput = {
1667  id?: Maybe<Scalars['ID']>;
1668  name?: Maybe<Scalars['String']>;
1669  email?: Maybe<Scalars['String']>;
1670  location?: Maybe<Scalars['String']>;
1671  user?: Maybe<Scalars['ID']>;
1672};
1673
1674export type EditEmailTemplateInput = {
1675  sourceCodeToTemplateId?: Maybe<Scalars['Int']>;
1676  design?: Maybe<Scalars['JSON']>;
1677  name?: Maybe<Scalars['String']>;
1678  subject?: Maybe<Scalars['String']>;
1679  bodyHtml?: Maybe<Scalars['String']>;
1680  bodyText?: Maybe<Scalars['String']>;
1681  enabled?: Maybe<Scalars['Boolean']>;
1682  tags?: Maybe<Scalars['JSON']>;
1683  created_by?: Maybe<Scalars['ID']>;
1684  updated_by?: Maybe<Scalars['ID']>;
1685};
1686
1687export type EditEventInput = {
1688  name?: Maybe<Scalars['String']>;
1689  email?: Maybe<Scalars['String']>;
1690  date?: Maybe<Scalars['Date']>;
1691  address?: Maybe<Scalars['String']>;
1692  position?: Maybe<Scalars['JSON']>;
1693  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1694  uuid?: Maybe<Scalars['String']>;
1695  waitingList?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1696  travels?: Maybe<Array<Maybe<Scalars['ID']>>>;
1697  description?: Maybe<Scalars['String']>;
1698  created_by?: Maybe<Scalars['ID']>;
1699  updated_by?: Maybe<Scalars['ID']>;
1700};
1701
1702export type EditFileInput = {
1703  name?: Maybe<Scalars['String']>;
1704  alternativeText?: Maybe<Scalars['String']>;
1705  caption?: Maybe<Scalars['String']>;
1706  width?: Maybe<Scalars['Int']>;
1707  height?: Maybe<Scalars['Int']>;
1708  formats?: Maybe<Scalars['JSON']>;
1709  hash?: Maybe<Scalars['String']>;
1710  ext?: Maybe<Scalars['String']>;
1711  mime?: Maybe<Scalars['String']>;
1712  size?: Maybe<Scalars['Float']>;
1713  url?: Maybe<Scalars['String']>;
1714  previewUrl?: Maybe<Scalars['String']>;
1715  provider?: Maybe<Scalars['String']>;
1716  provider_metadata?: Maybe<Scalars['JSON']>;
1717  related?: Maybe<Array<Maybe<Scalars['ID']>>>;
1718  created_by?: Maybe<Scalars['ID']>;
1719  updated_by?: Maybe<Scalars['ID']>;
1720};
1721
1722export type EditPageInput = {
1723  name?: Maybe<Scalars['String']>;
1724  content?: Maybe<Scalars['String']>;
1725  type?: Maybe<Enum_Page_Type>;
1726  created_by?: Maybe<Scalars['ID']>;
1727  updated_by?: Maybe<Scalars['ID']>;
1728};
1729
1730export type EditRoleInput = {
1731  name?: Maybe<Scalars['String']>;
1732  description?: Maybe<Scalars['String']>;
1733  type?: Maybe<Scalars['String']>;
1734  permissions?: Maybe<Array<Maybe<Scalars['ID']>>>;
1735  users?: Maybe<Array<Maybe<Scalars['ID']>>>;
1736  created_by?: Maybe<Scalars['ID']>;
1737  updated_by?: Maybe<Scalars['ID']>;
1738};
1739
1740export type EditSettingInput = {
1741  gtm_id?: Maybe<Scalars['String']>;
1742  about_link?: Maybe<Scalars['String']>;
1743  created_by?: Maybe<Scalars['ID']>;
1744  updated_by?: Maybe<Scalars['ID']>;
1745};
1746
1747export type EditTravelInput = {
1748  meeting?: Maybe<Scalars['String']>;
1749  departure?: Maybe<Scalars['DateTime']>;
1750  details?: Maybe<Scalars['String']>;
1751  passengers?: Maybe<Array<Maybe<EditComponentPassengerPassengerInput>>>;
1752  event?: Maybe<Scalars['ID']>;
1753  vehicleName?: Maybe<Scalars['String']>;
1754  seats?: Maybe<Scalars['Int']>;
1755  phone_number?: Maybe<Scalars['String']>;
1756  created_by?: Maybe<Scalars['ID']>;
1757  updated_by?: Maybe<Scalars['ID']>;
1758};
1759
1760export type EditUserInput = {
1761  username?: Maybe<Scalars['String']>;
1762  firstName?: Maybe<Scalars['String']>;
1763  lastName?: Maybe<Scalars['String']>;
1764  email?: Maybe<Scalars['String']>;
1765  provider?: Maybe<Scalars['String']>;
1766  password?: Maybe<Scalars['String']>;
1767  resetPasswordToken?: Maybe<Scalars['String']>;
1768  confirmed?: Maybe<Scalars['Boolean']>;
1769  blocked?: Maybe<Scalars['Boolean']>;
1770  role?: Maybe<Scalars['ID']>;
1771  confirmationToken?: Maybe<Scalars['String']>;
1772  events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1773  onboardingUser?: Maybe<Scalars['Boolean']>;
1774  onboardingCreator?: Maybe<Scalars['Boolean']>;
1775  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1776  vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1777  created_by?: Maybe<Scalars['ID']>;
1778  updated_by?: Maybe<Scalars['ID']>;
1779  old_password?: Maybe<Scalars['String']>;
1780};
1781
1782export type EditVehicleInput = {
1783  name?: Maybe<Scalars['String']>;
1784  seats?: Maybe<Scalars['Int']>;
1785  phone_number?: Maybe<Scalars['String']>;
1786  user?: Maybe<Scalars['ID']>;
1787  created_by?: Maybe<Scalars['ID']>;
1788  updated_by?: Maybe<Scalars['ID']>;
1789};
1790
1791export type UpdateEventByUuidInput = {
1792  where?: Maybe<InputUuid>;
1793  data?: Maybe<EditEventInput>;
1794};
1795
1796export type UpdateEventInput = {
1797  where?: Maybe<InputId>;
1798  data?: Maybe<EditEventInput>;
1799};
1800
1801export type UpdateEventPayload = {
1802  __typename?: 'updateEventPayload';
1803  event?: Maybe<Event>;
1804};
1805
1806export type UpdatePageInput = {
1807  where?: Maybe<InputId>;
1808  data?: Maybe<EditPageInput>;
1809};
1810
1811export type UpdatePagePayload = {
1812  __typename?: 'updatePagePayload';
1813  page?: Maybe<Page>;
1814};
1815
1816export type UpdateRoleInput = {
1817  where?: Maybe<InputId>;
1818  data?: Maybe<EditRoleInput>;
1819};
1820
1821export type UpdateRolePayload = {
1822  __typename?: 'updateRolePayload';
1823  role?: Maybe<UsersPermissionsRole>;
1824};
1825
1826export type UpdateSettingInput = {
1827  data?: Maybe<EditSettingInput>;
1828};
1829
1830export type UpdateSettingPayload = {
1831  __typename?: 'updateSettingPayload';
1832  setting?: Maybe<Settings>;
1833};
1834
1835export type UpdateTravelInput = {
1836  where?: Maybe<InputId>;
1837  data?: Maybe<EditTravelInput>;
1838};
1839
1840export type UpdateTravelPayload = {
1841  __typename?: 'updateTravelPayload';
1842  travel?: Maybe<Travel>;
1843};
1844
1845export type UpdateUserInput = {
1846  where?: Maybe<InputId>;
1847  data?: Maybe<EditUserInput>;
1848};
1849
1850export type UpdateUserPayload = {
1851  __typename?: 'updateUserPayload';
1852  user?: Maybe<UsersPermissionsUser>;
1853};
1854
1855export type UpdateVehicleInput = {
1856  where?: Maybe<InputId>;
1857  data?: Maybe<EditVehicleInput>;
1858};
1859
1860export type UpdateVehiclePayload = {
1861  __typename?: 'updateVehiclePayload';
1862  vehicle?: Maybe<Vehicle>;
1863};
1864
1865export type MeFieldsFragment = (
1866  { __typename?: 'UsersPermissionsMe' }
1867  & Pick<UsersPermissionsMe, 'id' | 'username' | 'email' | 'confirmed'>
1868);
1869
1870export type RegisterMutationVariables = Exact<{
1871  user: UsersPermissionsRegisterInput;
1872}>;
1873
1874
1875export type RegisterMutation = (
1876  { __typename?: 'Mutation' }
1877  & { register: (
1878    { __typename?: 'UsersPermissionsLoginPayload' }
1879    & Pick<UsersPermissionsLoginPayload, 'jwt'>
1880    & { user: (
1881      { __typename?: 'UsersPermissionsMe' }
1882      & MeFieldsFragment
1883    ) }
1884  ) }
1885);
1886
1887export type LoginMutationVariables = Exact<{
1888  identifier: Scalars['String'];
1889  password: Scalars['String'];
1890}>;
1891
1892
1893export type LoginMutation = (
1894  { __typename?: 'Mutation' }
1895  & { login: (
1896    { __typename?: 'UsersPermissionsLoginPayload' }
1897    & Pick<UsersPermissionsLoginPayload, 'jwt'>
1898    & { user: (
1899      { __typename?: 'UsersPermissionsMe' }
1900      & MeFieldsFragment
1901    ) }
1902  ) }
1903);
1904
1905export type ForgotPasswordMutationVariables = Exact<{
1906  email: Scalars['String'];
1907}>;
1908
1909
1910export type ForgotPasswordMutation = (
1911  { __typename?: 'Mutation' }
1912  & { forgotPassword?: Maybe<(
1913    { __typename?: 'UserPermissionsPasswordPayload' }
1914    & Pick<UserPermissionsPasswordPayload, 'ok'>
1915  )> }
1916);
1917
1918export type ResetPasswordMutationVariables = Exact<{
1919  password: Scalars['String'];
1920  passwordConfirmation: Scalars['String'];
1921  code: Scalars['String'];
1922}>;
1923
1924
1925export type ResetPasswordMutation = (
1926  { __typename?: 'Mutation' }
1927  & { resetPassword?: Maybe<(
1928    { __typename?: 'UsersPermissionsLoginPayload' }
1929    & Pick<UsersPermissionsLoginPayload, 'jwt'>
1930    & { user: (
1931      { __typename?: 'UsersPermissionsMe' }
1932      & MeFieldsFragment
1933    ) }
1934  )> }
1935);
1936
1937export type EventFieldsFragment = (
1938  { __typename?: 'Event' }
1939  & Pick<Event, 'id' | 'uuid' | 'name' | 'description' | 'email' | 'date' | 'address' | 'position'>
1940  & { waitingList?: Maybe<Array<Maybe<(
1941    { __typename?: 'ComponentPassengerPassenger' }
1942    & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
1943    & { user?: Maybe<(
1944      { __typename?: 'UsersPermissionsUser' }
1945      & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
1946    )> }
1947  )>>>, travels?: Maybe<Array<Maybe<(
1948    { __typename?: 'Travel' }
1949    & Pick<Travel, 'id' | 'meeting' | 'departure' | 'details' | 'vehicleName' | 'phone_number' | 'seats'>
1950    & { passengers?: Maybe<Array<Maybe<(
1951      { __typename?: 'ComponentPassengerPassenger' }
1952      & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
1953      & { user?: Maybe<(
1954        { __typename?: 'UsersPermissionsUser' }
1955        & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
1956      )> }
1957    )>>> }
1958  )>>> }
1959);
1960
1961export type CreateEventMutationVariables = Exact<{
1962  name: Scalars['String'];
1963  email: Scalars['String'];
1964  date?: Maybe<Scalars['Date']>;
1965  address?: Maybe<Scalars['String']>;
1966  description?: Maybe<Scalars['String']>;
1967  newsletter?: Maybe<Scalars['Boolean']>;
1968}>;
1969
1970
1971export type CreateEventMutation = (
1972  { __typename?: 'Mutation' }
1973  & { createEvent?: Maybe<(
1974    { __typename?: 'createEventPayload' }
1975    & { event?: Maybe<(
1976      { __typename?: 'Event' }
1977      & EventFieldsFragment
1978    )> }
1979  )> }
1980);
1981
1982export type UpdateEventMutationVariables = Exact<{
1983  uuid: Scalars['String'];
1984  eventUpdate?: Maybe<EditEventInput>;
1985}>;
1986
1987
1988export type UpdateEventMutation = (
1989  { __typename?: 'Mutation' }
1990  & { updateEventByUUID?: Maybe<(
1991    { __typename?: 'updateEventPayload' }
1992    & { event?: Maybe<(
1993      { __typename?: 'Event' }
1994      & EventFieldsFragment
1995    )> }
1996  )> }
1997);
1998
1999export type EventByUuidQueryVariables = Exact<{
2000  uuid: Scalars['String'];
2001}>;
2002
2003
2004export type EventByUuidQuery = (
2005  { __typename?: 'Query' }
2006  & { eventByUUID?: Maybe<(
2007    { __typename?: 'Event' }
2008    & EventFieldsFragment
2009  )> }
2010);
2011
2012export type SettingQueryVariables = Exact<{ [key: string]: never; }>;
2013
2014
2015export type SettingQuery = (
2016  { __typename?: 'Query' }
2017  & { setting?: Maybe<(
2018    { __typename?: 'Settings' }
2019    & Pick<Settings, 'id' | 'gtm_id' | 'about_link'>
2020  )> }
2021);
2022
2023export type TravelFieldsFragment = (
2024  { __typename?: 'Travel' }
2025  & Pick<Travel, 'id' | 'meeting' | 'departure' | 'details' | 'vehicleName' | 'phone_number' | 'seats'>
2026  & { passengers?: Maybe<Array<Maybe<(
2027    { __typename?: 'ComponentPassengerPassenger' }
2028    & Pick<ComponentPassengerPassenger, 'id' | 'name' | 'location'>
2029    & { user?: Maybe<(
2030      { __typename?: 'UsersPermissionsUser' }
2031      & Pick<UsersPermissionsUser, 'id' | 'firstName' | 'lastName'>
2032    )> }
2033  )>>> }
2034);
2035
2036export type CreateTravelMutationVariables = Exact<{
2037  travel: TravelInput;
2038}>;
2039
2040
2041export type CreateTravelMutation = (
2042  { __typename?: 'Mutation' }
2043  & { createTravel?: Maybe<(
2044    { __typename?: 'createTravelPayload' }
2045    & { travel?: Maybe<(
2046      { __typename?: 'Travel' }
2047      & TravelFieldsFragment
2048    )> }
2049  )> }
2050);
2051
2052export type UpdateTravelMutationVariables = Exact<{
2053  id: Scalars['ID'];
2054  travelUpdate: EditTravelInput;
2055}>;
2056
2057
2058export type UpdateTravelMutation = (
2059  { __typename?: 'Mutation' }
2060  & { updateTravel?: Maybe<(
2061    { __typename?: 'updateTravelPayload' }
2062    & { travel?: Maybe<(
2063      { __typename?: 'Travel' }
2064      & TravelFieldsFragment
2065    )> }
2066  )> }
2067);
2068
2069export type DeleteTravelMutationVariables = Exact<{
2070  id: Scalars['ID'];
2071}>;
2072
2073
2074export type DeleteTravelMutation = (
2075  { __typename?: 'Mutation' }
2076  & { deleteTravel?: Maybe<(
2077    { __typename?: 'deleteTravelPayload' }
2078    & { travel?: Maybe<(
2079      { __typename?: 'Travel' }
2080      & Pick<Travel, 'id'>
2081    )> }
2082  )> }
2083);
2084
2085export type UserFieldsFragment = (
2086  { __typename?: 'UsersPermissionsUser' }
2087  & Pick<UsersPermissionsUser, 'id' | 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName' | 'lang' | 'onboardingUser' | 'onboardingCreator'>
2088  & { events?: Maybe<Array<Maybe<(
2089    { __typename?: 'Event' }
2090    & Pick<Event, 'id' | 'uuid' | 'name' | 'date' | 'address'>
2091  )>>> }
2092);
2093
2094export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
2095
2096
2097export type ProfileQuery = (
2098  { __typename?: 'Query' }
2099  & { me?: Maybe<(
2100    { __typename?: 'UsersPermissionsMe' }
2101    & Pick<UsersPermissionsMe, 'id' | 'username'>
2102    & { profile?: Maybe<(
2103      { __typename?: 'UsersPermissionsUser' }
2104      & UserFieldsFragment
2105    )> }
2106  )> }
2107);
2108
2109export type UpdateMeMutationVariables = Exact<{
2110  userUpdate: EditUserInput;
2111}>;
2112
2113
2114export type UpdateMeMutation = (
2115  { __typename?: 'Mutation' }
2116  & { updateMe: (
2117    { __typename?: 'updateUserPayload' }
2118    & { user?: Maybe<(
2119      { __typename?: 'UsersPermissionsUser' }
2120      & UserFieldsFragment
2121    )> }
2122  ) }
2123);
2124
2125export type VehicleFieldsFragment = (
2126  { __typename?: 'Vehicle' }
2127  & Pick<Vehicle, 'id' | 'name' | 'seats' | 'phone_number'>
2128);
2129
2130export type FindUserVehiclesQueryVariables = Exact<{ [key: string]: never; }>;
2131
2132
2133export type FindUserVehiclesQuery = (
2134  { __typename?: 'Query' }
2135  & { me?: Maybe<(
2136    { __typename?: 'UsersPermissionsMe' }
2137    & Pick<UsersPermissionsMe, 'id' | 'username'>
2138    & { profile?: Maybe<(
2139      { __typename?: 'UsersPermissionsUser' }
2140      & { vehicles?: Maybe<Array<Maybe<(
2141        { __typename?: 'Vehicle' }
2142        & VehicleFieldsFragment
2143      )>>> }
2144    )> }
2145  )> }
2146);
2147
2148export type DeleteVehicleMutationVariables = Exact<{
2149  id: Scalars['ID'];
2150}>;
2151
2152
2153export type DeleteVehicleMutation = (
2154  { __typename?: 'Mutation' }
2155  & { deleteVehicle?: Maybe<(
2156    { __typename?: 'deleteVehiclePayload' }
2157    & { vehicle?: Maybe<(
2158      { __typename?: 'Vehicle' }
2159      & Pick<Vehicle, 'id' | 'name'>
2160    )> }
2161  )> }
2162);
2163
2164export const MeFieldsFragmentDoc = gql`
2165    fragment MeFields on UsersPermissionsMe {
2166  id
2167  username
2168  email
2169  confirmed
2170}
2171    `;
2172export const EventFieldsFragmentDoc = gql`
2173    fragment EventFields on Event {
2174  id
2175  uuid
2176  name
2177  description
2178  email
2179  date
2180  address
2181  position
2182  waitingList {
2183    id
2184    name
2185    location
2186    user {
2187      id
2188      firstName
2189      lastName
2190    }
2191  }
2192  travels {
2193    id
2194    meeting
2195    departure
2196    details
2197    vehicleName
2198    phone_number
2199    seats
2200    passengers {
2201      id
2202      name
2203      location
2204      user {
2205        id
2206        firstName
2207        lastName
2208      }
2209    }
2210  }
2211}
2212    `;
2213export const TravelFieldsFragmentDoc = gql`
2214    fragment TravelFields on Travel {
2215  id
2216  meeting
2217  departure
2218  details
2219  vehicleName
2220  phone_number
2221  seats
2222  passengers {
2223    id
2224    name
2225    location
2226    user {
2227      id
2228      firstName
2229      lastName
2230    }
2231  }
2232}
2233    `;
2234export const UserFieldsFragmentDoc = gql`
2235    fragment UserFields on UsersPermissionsUser {
2236  id
2237  username
2238  email
2239  confirmed
2240  lastName
2241  firstName
2242  lang
2243  onboardingUser
2244  onboardingCreator
2245  events {
2246    id
2247    uuid
2248    name
2249    date
2250    address
2251  }
2252}
2253    `;
2254export const VehicleFieldsFragmentDoc = gql`
2255    fragment VehicleFields on Vehicle {
2256  id
2257  name
2258  seats
2259  phone_number
2260}
2261    `;
2262export const RegisterDocument = gql`
2263    mutation register($user: UsersPermissionsRegisterInput!) {
2264  register(input: $user) {
2265    jwt
2266    user {
2267      ...MeFields
2268    }
2269  }
2270}
2271    ${MeFieldsFragmentDoc}`;
2272export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
2273
2274/**
2275 * __useRegisterMutation__
2276 *
2277 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
2278 * When your component renders, `useRegisterMutation` returns a tuple that includes:
2279 * - A mutate function that you can call at any time to execute the mutation
2280 * - An object with fields that represent the current status of the mutation's execution
2281 *
2282 * @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;
2283 *
2284 * @example
2285 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
2286 *   variables: {
2287 *      user: // value for 'user'
2288 *   },
2289 * });
2290 */
2291export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
2292        return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
2293      }
2294export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
2295export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
2296export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
2297export const LoginDocument = gql`
2298    mutation login($identifier: String!, $password: String!) {
2299  login(input: {identifier: $identifier, password: $password}) {
2300    jwt
2301    user {
2302      ...MeFields
2303    }
2304  }
2305}
2306    ${MeFieldsFragmentDoc}`;
2307export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
2308
2309/**
2310 * __useLoginMutation__
2311 *
2312 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
2313 * When your component renders, `useLoginMutation` returns a tuple that includes:
2314 * - A mutate function that you can call at any time to execute the mutation
2315 * - An object with fields that represent the current status of the mutation's execution
2316 *
2317 * @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;
2318 *
2319 * @example
2320 * const [loginMutation, { data, loading, error }] = useLoginMutation({
2321 *   variables: {
2322 *      identifier: // value for 'identifier'
2323 *      password: // value for 'password'
2324 *   },
2325 * });
2326 */
2327export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
2328        return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
2329      }
2330export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
2331export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
2332export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
2333export const ForgotPasswordDocument = gql`
2334    mutation forgotPassword($email: String!) {
2335  forgotPassword(email: $email) {
2336    ok
2337  }
2338}
2339    `;
2340export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2341
2342/**
2343 * __useForgotPasswordMutation__
2344 *
2345 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
2346 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
2347 * - A mutate function that you can call at any time to execute the mutation
2348 * - An object with fields that represent the current status of the mutation's execution
2349 *
2350 * @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;
2351 *
2352 * @example
2353 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
2354 *   variables: {
2355 *      email: // value for 'email'
2356 *   },
2357 * });
2358 */
2359export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
2360        return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
2361      }
2362export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
2363export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
2364export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2365export const ResetPasswordDocument = gql`
2366    mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
2367  resetPassword(
2368    password: $password
2369    passwordConfirmation: $passwordConfirmation
2370    code: $code
2371  ) {
2372    jwt
2373    user {
2374      ...MeFields
2375    }
2376  }
2377}
2378    ${MeFieldsFragmentDoc}`;
2379export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
2380
2381/**
2382 * __useResetPasswordMutation__
2383 *
2384 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
2385 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
2386 * - A mutate function that you can call at any time to execute the mutation
2387 * - An object with fields that represent the current status of the mutation's execution
2388 *
2389 * @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;
2390 *
2391 * @example
2392 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
2393 *   variables: {
2394 *      password: // value for 'password'
2395 *      passwordConfirmation: // value for 'passwordConfirmation'
2396 *      code: // value for 'code'
2397 *   },
2398 * });
2399 */
2400export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
2401        return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
2402      }
2403export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
2404export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
2405export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
2406export const CreateEventDocument = gql`
2407    mutation createEvent($name: String!, $email: String!, $date: Date, $address: String, $description: String, $newsletter: Boolean) {
2408  createEvent(
2409    input: {data: {name: $name, email: $email, date: $date, address: $address, description: $description, newsletter: $newsletter}}
2410  ) {
2411    event {
2412      ...EventFields
2413    }
2414  }
2415}
2416    ${EventFieldsFragmentDoc}`;
2417export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2418
2419/**
2420 * __useCreateEventMutation__
2421 *
2422 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2423 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2424 * - A mutate function that you can call at any time to execute the mutation
2425 * - An object with fields that represent the current status of the mutation's execution
2426 *
2427 * @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;
2428 *
2429 * @example
2430 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2431 *   variables: {
2432 *      name: // value for 'name'
2433 *      email: // value for 'email'
2434 *      date: // value for 'date'
2435 *      address: // value for 'address'
2436 *      description: // value for 'description'
2437 *      newsletter: // value for 'newsletter'
2438 *   },
2439 * });
2440 */
2441export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2442        return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2443      }
2444export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2445export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2446export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2447export const UpdateEventDocument = gql`
2448    mutation updateEvent($uuid: String!, $eventUpdate: editEventInput) {
2449  updateEventByUUID(input: {where: {uuid: $uuid}, data: $eventUpdate}) {
2450    event {
2451      ...EventFields
2452    }
2453  }
2454}
2455    ${EventFieldsFragmentDoc}`;
2456export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2457
2458/**
2459 * __useUpdateEventMutation__
2460 *
2461 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2462 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2463 * - A mutate function that you can call at any time to execute the mutation
2464 * - An object with fields that represent the current status of the mutation's execution
2465 *
2466 * @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;
2467 *
2468 * @example
2469 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2470 *   variables: {
2471 *      uuid: // value for 'uuid'
2472 *      eventUpdate: // value for 'eventUpdate'
2473 *   },
2474 * });
2475 */
2476export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2477        return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2478      }
2479export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2480export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2481export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2482export const EventByUuidDocument = gql`
2483    query eventByUUID($uuid: String!) {
2484  eventByUUID(uuid: $uuid) {
2485    ...EventFields
2486  }
2487}
2488    ${EventFieldsFragmentDoc}`;
2489
2490/**
2491 * __useEventByUuidQuery__
2492 *
2493 * To run a query within a React component, call `useEventByUuidQuery` and pass it any options that fit your needs.
2494 * When your component renders, `useEventByUuidQuery` returns an object from Apollo Client that contains loading, error, and data properties
2495 * you can use to render your UI.
2496 *
2497 * @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;
2498 *
2499 * @example
2500 * const { data, loading, error } = useEventByUuidQuery({
2501 *   variables: {
2502 *      uuid: // value for 'uuid'
2503 *   },
2504 * });
2505 */
2506export function useEventByUuidQuery(baseOptions: Apollo.QueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2507        return Apollo.useQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2508      }
2509export function useEventByUuidLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2510          return Apollo.useLazyQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2511        }
2512export type EventByUuidQueryHookResult = ReturnType<typeof useEventByUuidQuery>;
2513export type EventByUuidLazyQueryHookResult = ReturnType<typeof useEventByUuidLazyQuery>;
2514export type EventByUuidQueryResult = Apollo.QueryResult<EventByUuidQuery, EventByUuidQueryVariables>;
2515export const SettingDocument = gql`
2516    query setting {
2517  setting {
2518    id
2519    gtm_id
2520    about_link
2521  }
2522}
2523    `;
2524
2525/**
2526 * __useSettingQuery__
2527 *
2528 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2529 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2530 * you can use to render your UI.
2531 *
2532 * @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;
2533 *
2534 * @example
2535 * const { data, loading, error } = useSettingQuery({
2536 *   variables: {
2537 *   },
2538 * });
2539 */
2540export function useSettingQuery(baseOptions?: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2541        return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2542      }
2543export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2544          return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2545        }
2546export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2547export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2548export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2549export const CreateTravelDocument = gql`
2550    mutation createTravel($travel: TravelInput!) {
2551  createTravel(input: {data: $travel}) {
2552    travel {
2553      ...TravelFields
2554    }
2555  }
2556}
2557    ${TravelFieldsFragmentDoc}`;
2558export type CreateTravelMutationFn = Apollo.MutationFunction<CreateTravelMutation, CreateTravelMutationVariables>;
2559
2560/**
2561 * __useCreateTravelMutation__
2562 *
2563 * To run a mutation, you first call `useCreateTravelMutation` within a React component and pass it any options that fit your needs.
2564 * When your component renders, `useCreateTravelMutation` returns a tuple that includes:
2565 * - A mutate function that you can call at any time to execute the mutation
2566 * - An object with fields that represent the current status of the mutation's execution
2567 *
2568 * @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;
2569 *
2570 * @example
2571 * const [createTravelMutation, { data, loading, error }] = useCreateTravelMutation({
2572 *   variables: {
2573 *      travel: // value for 'travel'
2574 *   },
2575 * });
2576 */
2577export function useCreateTravelMutation(baseOptions?: Apollo.MutationHookOptions<CreateTravelMutation, CreateTravelMutationVariables>) {
2578        return Apollo.useMutation<CreateTravelMutation, CreateTravelMutationVariables>(CreateTravelDocument, baseOptions);
2579      }
2580export type CreateTravelMutationHookResult = ReturnType<typeof useCreateTravelMutation>;
2581export type CreateTravelMutationResult = Apollo.MutationResult<CreateTravelMutation>;
2582export type CreateTravelMutationOptions = Apollo.BaseMutationOptions<CreateTravelMutation, CreateTravelMutationVariables>;
2583export const UpdateTravelDocument = gql`
2584    mutation updateTravel($id: ID!, $travelUpdate: editTravelInput!) {
2585  updateTravel(input: {where: {id: $id}, data: $travelUpdate}) {
2586    travel {
2587      ...TravelFields
2588    }
2589  }
2590}
2591    ${TravelFieldsFragmentDoc}`;
2592export type UpdateTravelMutationFn = Apollo.MutationFunction<UpdateTravelMutation, UpdateTravelMutationVariables>;
2593
2594/**
2595 * __useUpdateTravelMutation__
2596 *
2597 * To run a mutation, you first call `useUpdateTravelMutation` within a React component and pass it any options that fit your needs.
2598 * When your component renders, `useUpdateTravelMutation` returns a tuple that includes:
2599 * - A mutate function that you can call at any time to execute the mutation
2600 * - An object with fields that represent the current status of the mutation's execution
2601 *
2602 * @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;
2603 *
2604 * @example
2605 * const [updateTravelMutation, { data, loading, error }] = useUpdateTravelMutation({
2606 *   variables: {
2607 *      id: // value for 'id'
2608 *      travelUpdate: // value for 'travelUpdate'
2609 *   },
2610 * });
2611 */
2612export function useUpdateTravelMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTravelMutation, UpdateTravelMutationVariables>) {
2613        return Apollo.useMutation<UpdateTravelMutation, UpdateTravelMutationVariables>(UpdateTravelDocument, baseOptions);
2614      }
2615export type UpdateTravelMutationHookResult = ReturnType<typeof useUpdateTravelMutation>;
2616export type UpdateTravelMutationResult = Apollo.MutationResult<UpdateTravelMutation>;
2617export type UpdateTravelMutationOptions = Apollo.BaseMutationOptions<UpdateTravelMutation, UpdateTravelMutationVariables>;
2618export const DeleteTravelDocument = gql`
2619    mutation deleteTravel($id: ID!) {
2620  deleteTravel(input: {where: {id: $id}}) {
2621    travel {
2622      id
2623    }
2624  }
2625}
2626    `;
2627export type DeleteTravelMutationFn = Apollo.MutationFunction<DeleteTravelMutation, DeleteTravelMutationVariables>;
2628
2629/**
2630 * __useDeleteTravelMutation__
2631 *
2632 * To run a mutation, you first call `useDeleteTravelMutation` within a React component and pass it any options that fit your needs.
2633 * When your component renders, `useDeleteTravelMutation` returns a tuple that includes:
2634 * - A mutate function that you can call at any time to execute the mutation
2635 * - An object with fields that represent the current status of the mutation's execution
2636 *
2637 * @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;
2638 *
2639 * @example
2640 * const [deleteTravelMutation, { data, loading, error }] = useDeleteTravelMutation({
2641 *   variables: {
2642 *      id: // value for 'id'
2643 *   },
2644 * });
2645 */
2646export function useDeleteTravelMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTravelMutation, DeleteTravelMutationVariables>) {
2647        return Apollo.useMutation<DeleteTravelMutation, DeleteTravelMutationVariables>(DeleteTravelDocument, baseOptions);
2648      }
2649export type DeleteTravelMutationHookResult = ReturnType<typeof useDeleteTravelMutation>;
2650export type DeleteTravelMutationResult = Apollo.MutationResult<DeleteTravelMutation>;
2651export type DeleteTravelMutationOptions = Apollo.BaseMutationOptions<DeleteTravelMutation, DeleteTravelMutationVariables>;
2652export const ProfileDocument = gql`
2653    query profile {
2654  me {
2655    id
2656    username
2657    profile {
2658      ...UserFields
2659    }
2660  }
2661}
2662    ${UserFieldsFragmentDoc}`;
2663
2664/**
2665 * __useProfileQuery__
2666 *
2667 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2668 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2669 * you can use to render your UI.
2670 *
2671 * @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;
2672 *
2673 * @example
2674 * const { data, loading, error } = useProfileQuery({
2675 *   variables: {
2676 *   },
2677 * });
2678 */
2679export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2680        return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2681      }
2682export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2683          return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2684        }
2685export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2686export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2687export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2688export const UpdateMeDocument = gql`
2689    mutation updateMe($userUpdate: editUserInput!) {
2690  updateMe(input: $userUpdate) {
2691    user {
2692      ...UserFields
2693    }
2694  }
2695}
2696    ${UserFieldsFragmentDoc}`;
2697export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2698
2699/**
2700 * __useUpdateMeMutation__
2701 *
2702 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2703 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2704 * - A mutate function that you can call at any time to execute the mutation
2705 * - An object with fields that represent the current status of the mutation's execution
2706 *
2707 * @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;
2708 *
2709 * @example
2710 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2711 *   variables: {
2712 *      userUpdate: // value for 'userUpdate'
2713 *   },
2714 * });
2715 */
2716export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2717        return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2718      }
2719export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2720export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2721export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;
2722export const FindUserVehiclesDocument = gql`
2723    query findUserVehicles {
2724  me {
2725    id
2726    username
2727    profile {
2728      vehicles {
2729        ...VehicleFields
2730      }
2731    }
2732  }
2733}
2734    ${VehicleFieldsFragmentDoc}`;
2735
2736/**
2737 * __useFindUserVehiclesQuery__
2738 *
2739 * To run a query within a React component, call `useFindUserVehiclesQuery` and pass it any options that fit your needs.
2740 * When your component renders, `useFindUserVehiclesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2741 * you can use to render your UI.
2742 *
2743 * @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;
2744 *
2745 * @example
2746 * const { data, loading, error } = useFindUserVehiclesQuery({
2747 *   variables: {
2748 *   },
2749 * });
2750 */
2751export function useFindUserVehiclesQuery(baseOptions?: Apollo.QueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
2752        return Apollo.useQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
2753      }
2754export function useFindUserVehiclesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
2755          return Apollo.useLazyQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
2756        }
2757export type FindUserVehiclesQueryHookResult = ReturnType<typeof useFindUserVehiclesQuery>;
2758export type FindUserVehiclesLazyQueryHookResult = ReturnType<typeof useFindUserVehiclesLazyQuery>;
2759export type FindUserVehiclesQueryResult = Apollo.QueryResult<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>;
2760export const DeleteVehicleDocument = gql`
2761    mutation deleteVehicle($id: ID!) {
2762  deleteVehicle(input: {where: {id: $id}}) {
2763    vehicle {
2764      id
2765      name
2766    }
2767  }
2768}
2769    `;
2770export type DeleteVehicleMutationFn = Apollo.MutationFunction<DeleteVehicleMutation, DeleteVehicleMutationVariables>;
2771
2772/**
2773 * __useDeleteVehicleMutation__
2774 *
2775 * To run a mutation, you first call `useDeleteVehicleMutation` within a React component and pass it any options that fit your needs.
2776 * When your component renders, `useDeleteVehicleMutation` returns a tuple that includes:
2777 * - A mutate function that you can call at any time to execute the mutation
2778 * - An object with fields that represent the current status of the mutation's execution
2779 *
2780 * @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;
2781 *
2782 * @example
2783 * const [deleteVehicleMutation, { data, loading, error }] = useDeleteVehicleMutation({
2784 *   variables: {
2785 *      id: // value for 'id'
2786 *   },
2787 * });
2788 */
2789export function useDeleteVehicleMutation(baseOptions?: Apollo.MutationHookOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>) {
2790        return Apollo.useMutation<DeleteVehicleMutation, DeleteVehicleMutationVariables>(DeleteVehicleDocument, baseOptions);
2791      }
2792export type DeleteVehicleMutationHookResult = ReturnType<typeof useDeleteVehicleMutation>;
2793export type DeleteVehicleMutationResult = Apollo.MutationResult<DeleteVehicleMutation>;
2794export type DeleteVehicleMutationOptions = Apollo.BaseMutationOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>;