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