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  provider?: Maybe<Scalars['String']>;
1395  confirmed?: Maybe<Scalars['Boolean']>;
1396  role?: Maybe<UsersPermissionsRoleEntityResponse>;
1397  events?: Maybe<EventRelationResponseCollection>;
1398  vehicles?: Maybe<VehicleRelationResponseCollection>;
1399  firstName?: Maybe<Scalars['String']>;
1400  lastName?: Maybe<Scalars['String']>;
1401  onboardingUser?: Maybe<Scalars['Boolean']>;
1402  onboardingCreator?: Maybe<Scalars['Boolean']>;
1403  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1404  createdAt?: Maybe<Scalars['DateTime']>;
1405  updatedAt?: Maybe<Scalars['DateTime']>;
1406};
1407
1408
1409export type UsersPermissionsUserEventsArgs = {
1410  filters?: Maybe<EventFiltersInput>;
1411  pagination?: Maybe<PaginationArg>;
1412  sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1413};
1414
1415
1416export type UsersPermissionsUserVehiclesArgs = {
1417  filters?: Maybe<VehicleFiltersInput>;
1418  pagination?: Maybe<PaginationArg>;
1419  sort?: Maybe<Array<Maybe<Scalars['String']>>>;
1420};
1421
1422export type UsersPermissionsUserEntity = {
1423  __typename?: 'UsersPermissionsUserEntity';
1424  id?: Maybe<Scalars['ID']>;
1425  attributes?: Maybe<UsersPermissionsUser>;
1426};
1427
1428export type UsersPermissionsUserEntityResponse = {
1429  __typename?: 'UsersPermissionsUserEntityResponse';
1430  data?: Maybe<UsersPermissionsUserEntity>;
1431};
1432
1433export type UsersPermissionsUserFiltersInput = {
1434  id?: Maybe<IdFilterInput>;
1435  username?: Maybe<StringFilterInput>;
1436  email?: Maybe<StringFilterInput>;
1437  provider?: Maybe<StringFilterInput>;
1438  password?: Maybe<StringFilterInput>;
1439  resetPasswordToken?: Maybe<StringFilterInput>;
1440  confirmationToken?: Maybe<StringFilterInput>;
1441  confirmed?: Maybe<BooleanFilterInput>;
1442  blocked?: Maybe<BooleanFilterInput>;
1443  role?: Maybe<UsersPermissionsRoleFiltersInput>;
1444  events?: Maybe<EventFiltersInput>;
1445  passengers?: Maybe<PassengerFiltersInput>;
1446  vehicles?: Maybe<VehicleFiltersInput>;
1447  firstName?: Maybe<StringFilterInput>;
1448  lastName?: Maybe<StringFilterInput>;
1449  onboardingUser?: Maybe<BooleanFilterInput>;
1450  onboardingCreator?: Maybe<BooleanFilterInput>;
1451  lang?: Maybe<StringFilterInput>;
1452  createdAt?: Maybe<DateTimeFilterInput>;
1453  updatedAt?: Maybe<DateTimeFilterInput>;
1454  and?: Maybe<Array<Maybe<UsersPermissionsUserFiltersInput>>>;
1455  or?: Maybe<Array<Maybe<UsersPermissionsUserFiltersInput>>>;
1456  not?: Maybe<UsersPermissionsUserFiltersInput>;
1457};
1458
1459export type UsersPermissionsUserInput = {
1460  username?: Maybe<Scalars['String']>;
1461  email?: Maybe<Scalars['String']>;
1462  provider?: Maybe<Scalars['String']>;
1463  password?: Maybe<Scalars['String']>;
1464  resetPasswordToken?: Maybe<Scalars['String']>;
1465  confirmationToken?: Maybe<Scalars['String']>;
1466  confirmed?: Maybe<Scalars['Boolean']>;
1467  blocked?: Maybe<Scalars['Boolean']>;
1468  role?: Maybe<Scalars['ID']>;
1469  events?: Maybe<Array<Maybe<Scalars['ID']>>>;
1470  passengers?: Maybe<Array<Maybe<Scalars['ID']>>>;
1471  vehicles?: Maybe<Array<Maybe<Scalars['ID']>>>;
1472  firstName?: Maybe<Scalars['String']>;
1473  lastName?: Maybe<Scalars['String']>;
1474  onboardingUser?: Maybe<Scalars['Boolean']>;
1475  onboardingCreator?: Maybe<Scalars['Boolean']>;
1476  lang?: Maybe<Enum_Userspermissionsuser_Lang>;
1477  oldPassword?: Maybe<Scalars['String']>;
1478};
1479
1480export type UsersPermissionsUserRelationResponseCollection = {
1481  __typename?: 'UsersPermissionsUserRelationResponseCollection';
1482  data: Array<UsersPermissionsUserEntity>;
1483};
1484
1485export type Vehicle = {
1486  __typename?: 'Vehicle';
1487  name: Scalars['String'];
1488  seats?: Maybe<Scalars['Int']>;
1489  phone_number?: Maybe<Scalars['String']>;
1490  user?: Maybe<UsersPermissionsUserEntityResponse>;
1491  createdAt?: Maybe<Scalars['DateTime']>;
1492  updatedAt?: Maybe<Scalars['DateTime']>;
1493};
1494
1495export type VehicleEntity = {
1496  __typename?: 'VehicleEntity';
1497  id?: Maybe<Scalars['ID']>;
1498  attributes?: Maybe<Vehicle>;
1499};
1500
1501export type VehicleEntityResponse = {
1502  __typename?: 'VehicleEntityResponse';
1503  data?: Maybe<VehicleEntity>;
1504};
1505
1506export type VehicleFiltersInput = {
1507  id?: Maybe<IdFilterInput>;
1508  name?: Maybe<StringFilterInput>;
1509  seats?: Maybe<IntFilterInput>;
1510  phone_number?: Maybe<StringFilterInput>;
1511  user?: Maybe<UsersPermissionsUserFiltersInput>;
1512  createdAt?: Maybe<DateTimeFilterInput>;
1513  updatedAt?: Maybe<DateTimeFilterInput>;
1514  and?: Maybe<Array<Maybe<VehicleFiltersInput>>>;
1515  or?: Maybe<Array<Maybe<VehicleFiltersInput>>>;
1516  not?: Maybe<VehicleFiltersInput>;
1517};
1518
1519export type VehicleInput = {
1520  name?: Maybe<Scalars['String']>;
1521  seats?: Maybe<Scalars['Int']>;
1522  phone_number?: Maybe<Scalars['String']>;
1523  user?: Maybe<Scalars['ID']>;
1524};
1525
1526export type VehicleRelationResponseCollection = {
1527  __typename?: 'VehicleRelationResponseCollection';
1528  data: Array<VehicleEntity>;
1529};
1530
1531export type MeFieldsFragment = (
1532  { __typename?: 'UsersPermissionsMe' }
1533  & Pick<UsersPermissionsMe, 'id' | 'username' | 'email' | 'confirmed'>
1534);
1535
1536export type RegisterMutationVariables = Exact<{
1537  user: UsersPermissionsRegisterInput;
1538}>;
1539
1540
1541export type RegisterMutation = (
1542  { __typename?: 'Mutation' }
1543  & { register: (
1544    { __typename?: 'UsersPermissionsLoginPayload' }
1545    & Pick<UsersPermissionsLoginPayload, 'jwt'>
1546    & { user: (
1547      { __typename?: 'UsersPermissionsMe' }
1548      & MeFieldsFragment
1549    ) }
1550  ) }
1551);
1552
1553export type LoginMutationVariables = Exact<{
1554  identifier: Scalars['String'];
1555  password: Scalars['String'];
1556}>;
1557
1558
1559export type LoginMutation = (
1560  { __typename?: 'Mutation' }
1561  & { login: (
1562    { __typename?: 'UsersPermissionsLoginPayload' }
1563    & Pick<UsersPermissionsLoginPayload, 'jwt'>
1564    & { user: (
1565      { __typename?: 'UsersPermissionsMe' }
1566      & MeFieldsFragment
1567    ) }
1568  ) }
1569);
1570
1571export type ForgotPasswordMutationVariables = Exact<{
1572  email: Scalars['String'];
1573}>;
1574
1575
1576export type ForgotPasswordMutation = (
1577  { __typename?: 'Mutation' }
1578  & { forgotPassword?: Maybe<(
1579    { __typename?: 'UsersPermissionsPasswordPayload' }
1580    & Pick<UsersPermissionsPasswordPayload, 'ok'>
1581  )> }
1582);
1583
1584export type ResetPasswordMutationVariables = Exact<{
1585  password: Scalars['String'];
1586  passwordConfirmation: Scalars['String'];
1587  code: Scalars['String'];
1588}>;
1589
1590
1591export type ResetPasswordMutation = (
1592  { __typename?: 'Mutation' }
1593  & { resetPassword?: Maybe<(
1594    { __typename?: 'UsersPermissionsLoginPayload' }
1595    & Pick<UsersPermissionsLoginPayload, 'jwt'>
1596    & { user: (
1597      { __typename?: 'UsersPermissionsMe' }
1598      & MeFieldsFragment
1599    ) }
1600  )> }
1601);
1602
1603export type EventFieldsFragment = (
1604  { __typename?: 'EventEntity' }
1605  & Pick<EventEntity, 'id'>
1606  & { attributes?: Maybe<(
1607    { __typename?: 'Event' }
1608    & Pick<Event, 'uuid' | 'name' | 'description' | 'email' | 'date' | 'address' | 'position'>
1609    & { waitingPassengers?: Maybe<(
1610      { __typename?: 'PassengerRelationResponseCollection' }
1611      & { data: Array<(
1612        { __typename?: 'PassengerEntity' }
1613        & Pick<PassengerEntity, 'id'>
1614        & { attributes?: Maybe<(
1615          { __typename?: 'Passenger' }
1616          & Pick<Passenger, 'name' | 'email' | 'location'>
1617          & { user?: Maybe<(
1618            { __typename?: 'UsersPermissionsUserEntityResponse' }
1619            & { data?: Maybe<(
1620              { __typename?: 'UsersPermissionsUserEntity' }
1621              & Pick<UsersPermissionsUserEntity, 'id'>
1622              & { attributes?: Maybe<(
1623                { __typename?: 'UsersPermissionsUser' }
1624                & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1625              )> }
1626            )> }
1627          )> }
1628        )> }
1629      )> }
1630    )>, travels?: Maybe<(
1631      { __typename?: 'TravelRelationResponseCollection' }
1632      & { data: Array<(
1633        { __typename?: 'TravelEntity' }
1634        & Pick<TravelEntity, 'id'>
1635        & { attributes?: Maybe<(
1636          { __typename?: 'Travel' }
1637          & Pick<Travel, 'meeting' | 'departure' | 'details' | 'vehicleName' | 'phone_number' | 'seats'>
1638          & { passengers?: Maybe<(
1639            { __typename?: 'PassengerRelationResponseCollection' }
1640            & { data: Array<(
1641              { __typename?: 'PassengerEntity' }
1642              & Pick<PassengerEntity, 'id'>
1643              & { attributes?: Maybe<(
1644                { __typename?: 'Passenger' }
1645                & Pick<Passenger, 'name' | 'location'>
1646                & { user?: Maybe<(
1647                  { __typename?: 'UsersPermissionsUserEntityResponse' }
1648                  & { data?: Maybe<(
1649                    { __typename?: 'UsersPermissionsUserEntity' }
1650                    & Pick<UsersPermissionsUserEntity, 'id'>
1651                    & { attributes?: Maybe<(
1652                      { __typename?: 'UsersPermissionsUser' }
1653                      & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1654                    )> }
1655                  )> }
1656                )> }
1657              )> }
1658            )> }
1659          )> }
1660        )> }
1661      )> }
1662    )> }
1663  )> }
1664);
1665
1666export type CreateEventMutationVariables = Exact<{
1667  name: Scalars['String'];
1668  email: Scalars['String'];
1669  date?: Maybe<Scalars['Date']>;
1670  address?: Maybe<Scalars['String']>;
1671  description?: Maybe<Scalars['String']>;
1672  newsletter?: Maybe<Scalars['Boolean']>;
1673}>;
1674
1675
1676export type CreateEventMutation = (
1677  { __typename?: 'Mutation' }
1678  & { createEvent?: Maybe<(
1679    { __typename?: 'EventEntityResponse' }
1680    & { data?: Maybe<(
1681      { __typename?: 'EventEntity' }
1682      & EventFieldsFragment
1683    )> }
1684  )> }
1685);
1686
1687export type UpdateEventMutationVariables = Exact<{
1688  uuid: Scalars['String'];
1689  eventUpdate: EventInput;
1690}>;
1691
1692
1693export type UpdateEventMutation = (
1694  { __typename?: 'Mutation' }
1695  & { updateEventByUUID?: Maybe<(
1696    { __typename?: 'EventEntityResponse' }
1697    & { data?: Maybe<(
1698      { __typename?: 'EventEntity' }
1699      & EventFieldsFragment
1700    )> }
1701  )> }
1702);
1703
1704export type EventByUuidQueryVariables = Exact<{
1705  uuid: Scalars['String'];
1706}>;
1707
1708
1709export type EventByUuidQuery = (
1710  { __typename?: 'Query' }
1711  & { eventByUUID?: Maybe<(
1712    { __typename?: 'EventEntityResponse' }
1713    & { data?: Maybe<(
1714      { __typename?: 'EventEntity' }
1715      & EventFieldsFragment
1716    )> }
1717  )> }
1718);
1719
1720export type PassengerFieldsFragment = (
1721  { __typename?: 'PassengerEntity' }
1722  & Pick<PassengerEntity, 'id'>
1723  & { attributes?: Maybe<(
1724    { __typename?: 'Passenger' }
1725    & Pick<Passenger, 'name' | 'location' | 'email'>
1726    & { user?: Maybe<(
1727      { __typename?: 'UsersPermissionsUserEntityResponse' }
1728      & { data?: Maybe<(
1729        { __typename?: 'UsersPermissionsUserEntity' }
1730        & Pick<UsersPermissionsUserEntity, 'id'>
1731        & { attributes?: Maybe<(
1732          { __typename?: 'UsersPermissionsUser' }
1733          & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1734        )> }
1735      )> }
1736    )> }
1737  )> }
1738);
1739
1740export type CreatePassengerMutationVariables = Exact<{
1741  passenger: PassengerInput;
1742}>;
1743
1744
1745export type CreatePassengerMutation = (
1746  { __typename?: 'Mutation' }
1747  & { createPassenger?: Maybe<(
1748    { __typename?: 'PassengerEntityResponse' }
1749    & { data?: Maybe<(
1750      { __typename?: 'PassengerEntity' }
1751      & PassengerFieldsFragment
1752    )> }
1753  )> }
1754);
1755
1756export type UpdatePassengerMutationVariables = Exact<{
1757  id: Scalars['ID'];
1758  passengerUpdate: PassengerInput;
1759}>;
1760
1761
1762export type UpdatePassengerMutation = (
1763  { __typename?: 'Mutation' }
1764  & { updatePassenger?: Maybe<(
1765    { __typename?: 'PassengerEntityResponse' }
1766    & { data?: Maybe<(
1767      { __typename?: 'PassengerEntity' }
1768      & PassengerFieldsFragment
1769    )> }
1770  )> }
1771);
1772
1773export type DeletePassengerMutationVariables = Exact<{
1774  id: Scalars['ID'];
1775}>;
1776
1777
1778export type DeletePassengerMutation = (
1779  { __typename?: 'Mutation' }
1780  & { deletePassenger?: Maybe<(
1781    { __typename?: 'PassengerEntityResponse' }
1782    & { data?: Maybe<(
1783      { __typename?: 'PassengerEntity' }
1784      & Pick<PassengerEntity, 'id'>
1785    )> }
1786  )> }
1787);
1788
1789export type SettingQueryVariables = Exact<{
1790  locale: Scalars['I18NLocaleCode'];
1791}>;
1792
1793
1794export type SettingQuery = (
1795  { __typename?: 'Query' }
1796  & { setting?: Maybe<(
1797    { __typename?: 'SettingEntityResponse' }
1798    & { data?: Maybe<(
1799      { __typename?: 'SettingEntity' }
1800      & Pick<SettingEntity, 'id'>
1801      & { attributes?: Maybe<(
1802        { __typename?: 'Setting' }
1803        & Pick<Setting, 'gtm_id' | 'about_link' | 'faq_link' | 'announcement' | 'matomo_script_url'>
1804      )> }
1805    )> }
1806  )> }
1807);
1808
1809export type TravelFieldsFragment = (
1810  { __typename?: 'TravelEntity' }
1811  & Pick<TravelEntity, 'id'>
1812  & { attributes?: Maybe<(
1813    { __typename?: 'Travel' }
1814    & Pick<Travel, 'meeting' | 'departure' | 'details' | 'vehicleName' | 'phone_number' | 'seats'>
1815    & { passengers?: Maybe<(
1816      { __typename?: 'PassengerRelationResponseCollection' }
1817      & { data: Array<(
1818        { __typename?: 'PassengerEntity' }
1819        & Pick<PassengerEntity, 'id'>
1820        & { attributes?: Maybe<(
1821          { __typename?: 'Passenger' }
1822          & Pick<Passenger, 'name' | 'location'>
1823          & { user?: Maybe<(
1824            { __typename?: 'UsersPermissionsUserEntityResponse' }
1825            & { data?: Maybe<(
1826              { __typename?: 'UsersPermissionsUserEntity' }
1827              & Pick<UsersPermissionsUserEntity, 'id'>
1828              & { attributes?: Maybe<(
1829                { __typename?: 'UsersPermissionsUser' }
1830                & Pick<UsersPermissionsUser, 'firstName' | 'lastName'>
1831              )> }
1832            )> }
1833          )> }
1834        )> }
1835      )> }
1836    )> }
1837  )> }
1838);
1839
1840export type CreateTravelMutationVariables = Exact<{
1841  travel: TravelInput;
1842  createVehicle?: Maybe<Scalars['Boolean']>;
1843}>;
1844
1845
1846export type CreateTravelMutation = (
1847  { __typename?: 'Mutation' }
1848  & { createTravel?: Maybe<(
1849    { __typename?: 'TravelEntityResponse' }
1850    & { data?: Maybe<(
1851      { __typename?: 'TravelEntity' }
1852      & TravelFieldsFragment
1853    )> }
1854  )> }
1855);
1856
1857export type UpdateTravelMutationVariables = Exact<{
1858  id: Scalars['ID'];
1859  travelUpdate: TravelInput;
1860}>;
1861
1862
1863export type UpdateTravelMutation = (
1864  { __typename?: 'Mutation' }
1865  & { updateTravel?: Maybe<(
1866    { __typename?: 'TravelEntityResponse' }
1867    & { data?: Maybe<(
1868      { __typename?: 'TravelEntity' }
1869      & TravelFieldsFragment
1870    )> }
1871  )> }
1872);
1873
1874export type DeleteTravelMutationVariables = Exact<{
1875  id: Scalars['ID'];
1876}>;
1877
1878
1879export type DeleteTravelMutation = (
1880  { __typename?: 'Mutation' }
1881  & { deleteTravel?: Maybe<(
1882    { __typename?: 'TravelEntityResponse' }
1883    & { data?: Maybe<(
1884      { __typename?: 'TravelEntity' }
1885      & Pick<TravelEntity, 'id'>
1886    )> }
1887  )> }
1888);
1889
1890export type UserFieldsFragment = (
1891  { __typename?: 'UsersPermissionsUser' }
1892  & Pick<UsersPermissionsUser, 'username' | 'email' | 'confirmed' | 'lastName' | 'firstName' | 'lang' | 'onboardingUser' | 'onboardingCreator' | 'provider'>
1893  & { events?: Maybe<(
1894    { __typename?: 'EventRelationResponseCollection' }
1895    & { data: Array<(
1896      { __typename?: 'EventEntity' }
1897      & Pick<EventEntity, 'id'>
1898      & { attributes?: Maybe<(
1899        { __typename?: 'Event' }
1900        & Pick<Event, 'uuid' | 'name' | 'date' | 'address'>
1901      )> }
1902    )> }
1903  )> }
1904);
1905
1906export type ProfileQueryVariables = Exact<{ [key: string]: never; }>;
1907
1908
1909export type ProfileQuery = (
1910  { __typename?: 'Query' }
1911  & { me?: Maybe<(
1912    { __typename?: 'UsersPermissionsMe' }
1913    & Pick<UsersPermissionsMe, 'id' | 'username'>
1914    & { profile?: Maybe<(
1915      { __typename?: 'UsersPermissionsUser' }
1916      & UserFieldsFragment
1917    )> }
1918  )> }
1919);
1920
1921export type UpdateMeMutationVariables = Exact<{
1922  userUpdate: UsersPermissionsUserInput;
1923}>;
1924
1925
1926export type UpdateMeMutation = (
1927  { __typename?: 'Mutation' }
1928  & { updateMe: (
1929    { __typename?: 'UsersPermissionsUserEntityResponse' }
1930    & { data?: Maybe<(
1931      { __typename?: 'UsersPermissionsUserEntity' }
1932      & Pick<UsersPermissionsUserEntity, 'id'>
1933      & { attributes?: Maybe<(
1934        { __typename?: 'UsersPermissionsUser' }
1935        & UserFieldsFragment
1936      )> }
1937    )> }
1938  ) }
1939);
1940
1941export type VehicleFieldsFragment = (
1942  { __typename?: 'VehicleEntity' }
1943  & Pick<VehicleEntity, 'id'>
1944  & { attributes?: Maybe<(
1945    { __typename?: 'Vehicle' }
1946    & Pick<Vehicle, 'name' | 'seats' | 'phone_number'>
1947  )> }
1948);
1949
1950export type FindUserVehiclesQueryVariables = Exact<{ [key: string]: never; }>;
1951
1952
1953export type FindUserVehiclesQuery = (
1954  { __typename?: 'Query' }
1955  & { me?: Maybe<(
1956    { __typename?: 'UsersPermissionsMe' }
1957    & Pick<UsersPermissionsMe, 'id' | 'username'>
1958    & { profile?: Maybe<(
1959      { __typename?: 'UsersPermissionsUser' }
1960      & { vehicles?: Maybe<(
1961        { __typename?: 'VehicleRelationResponseCollection' }
1962        & { data: Array<(
1963          { __typename?: 'VehicleEntity' }
1964          & VehicleFieldsFragment
1965        )> }
1966      )> }
1967    )> }
1968  )> }
1969);
1970
1971export type DeleteVehicleMutationVariables = Exact<{
1972  id: Scalars['ID'];
1973}>;
1974
1975
1976export type DeleteVehicleMutation = (
1977  { __typename?: 'Mutation' }
1978  & { deleteVehicle?: Maybe<(
1979    { __typename?: 'VehicleEntityResponse' }
1980    & { data?: Maybe<(
1981      { __typename?: 'VehicleEntity' }
1982      & Pick<VehicleEntity, 'id'>
1983      & { attributes?: Maybe<(
1984        { __typename?: 'Vehicle' }
1985        & Pick<Vehicle, 'name'>
1986      )> }
1987    )> }
1988  )> }
1989);
1990
1991export const MeFieldsFragmentDoc = gql`
1992    fragment MeFields on UsersPermissionsMe {
1993  id
1994  username
1995  email
1996  confirmed
1997}
1998    `;
1999export const EventFieldsFragmentDoc = gql`
2000    fragment EventFields on EventEntity {
2001  id
2002  attributes {
2003    uuid
2004    name
2005    description
2006    email
2007    date
2008    address
2009    position
2010    waitingPassengers {
2011      data {
2012        id
2013        attributes {
2014          name
2015          email
2016          location
2017          user {
2018            data {
2019              id
2020              attributes {
2021                firstName
2022                lastName
2023              }
2024            }
2025          }
2026        }
2027      }
2028    }
2029    travels {
2030      data {
2031        id
2032        attributes {
2033          meeting
2034          departure
2035          details
2036          vehicleName
2037          phone_number
2038          seats
2039          passengers {
2040            data {
2041              id
2042              attributes {
2043                name
2044                location
2045                user {
2046                  data {
2047                    id
2048                    attributes {
2049                      firstName
2050                      lastName
2051                    }
2052                  }
2053                }
2054              }
2055            }
2056          }
2057        }
2058      }
2059    }
2060  }
2061}
2062    `;
2063export const PassengerFieldsFragmentDoc = gql`
2064    fragment PassengerFields on PassengerEntity {
2065  id
2066  attributes {
2067    name
2068    location
2069    email
2070    user {
2071      data {
2072        id
2073        attributes {
2074          firstName
2075          lastName
2076        }
2077      }
2078    }
2079  }
2080}
2081    `;
2082export const TravelFieldsFragmentDoc = gql`
2083    fragment TravelFields on TravelEntity {
2084  id
2085  attributes {
2086    meeting
2087    departure
2088    details
2089    vehicleName
2090    phone_number
2091    seats
2092    passengers {
2093      data {
2094        id
2095        attributes {
2096          name
2097          location
2098          user {
2099            data {
2100              id
2101              attributes {
2102                firstName
2103                lastName
2104              }
2105            }
2106          }
2107        }
2108      }
2109    }
2110  }
2111}
2112    `;
2113export const UserFieldsFragmentDoc = gql`
2114    fragment UserFields on UsersPermissionsUser {
2115  username
2116  email
2117  confirmed
2118  lastName
2119  firstName
2120  lang
2121  onboardingUser
2122  onboardingCreator
2123  provider
2124  events {
2125    data {
2126      id
2127      attributes {
2128        uuid
2129        name
2130        date
2131        address
2132      }
2133    }
2134  }
2135}
2136    `;
2137export const VehicleFieldsFragmentDoc = gql`
2138    fragment VehicleFields on VehicleEntity {
2139  id
2140  attributes {
2141    name
2142    seats
2143    phone_number
2144  }
2145}
2146    `;
2147export const RegisterDocument = gql`
2148    mutation register($user: UsersPermissionsRegisterInput!) {
2149  register(input: $user) {
2150    jwt
2151    user {
2152      ...MeFields
2153    }
2154  }
2155}
2156    ${MeFieldsFragmentDoc}`;
2157export type RegisterMutationFn = Apollo.MutationFunction<RegisterMutation, RegisterMutationVariables>;
2158
2159/**
2160 * __useRegisterMutation__
2161 *
2162 * To run a mutation, you first call `useRegisterMutation` within a React component and pass it any options that fit your needs.
2163 * When your component renders, `useRegisterMutation` returns a tuple that includes:
2164 * - A mutate function that you can call at any time to execute the mutation
2165 * - An object with fields that represent the current status of the mutation's execution
2166 *
2167 * @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;
2168 *
2169 * @example
2170 * const [registerMutation, { data, loading, error }] = useRegisterMutation({
2171 *   variables: {
2172 *      user: // value for 'user'
2173 *   },
2174 * });
2175 */
2176export function useRegisterMutation(baseOptions?: Apollo.MutationHookOptions<RegisterMutation, RegisterMutationVariables>) {
2177        return Apollo.useMutation<RegisterMutation, RegisterMutationVariables>(RegisterDocument, baseOptions);
2178      }
2179export type RegisterMutationHookResult = ReturnType<typeof useRegisterMutation>;
2180export type RegisterMutationResult = Apollo.MutationResult<RegisterMutation>;
2181export type RegisterMutationOptions = Apollo.BaseMutationOptions<RegisterMutation, RegisterMutationVariables>;
2182export const LoginDocument = gql`
2183    mutation login($identifier: String!, $password: String!) {
2184  login(input: {identifier: $identifier, password: $password}) {
2185    jwt
2186    user {
2187      ...MeFields
2188    }
2189  }
2190}
2191    ${MeFieldsFragmentDoc}`;
2192export type LoginMutationFn = Apollo.MutationFunction<LoginMutation, LoginMutationVariables>;
2193
2194/**
2195 * __useLoginMutation__
2196 *
2197 * To run a mutation, you first call `useLoginMutation` within a React component and pass it any options that fit your needs.
2198 * When your component renders, `useLoginMutation` returns a tuple that includes:
2199 * - A mutate function that you can call at any time to execute the mutation
2200 * - An object with fields that represent the current status of the mutation's execution
2201 *
2202 * @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;
2203 *
2204 * @example
2205 * const [loginMutation, { data, loading, error }] = useLoginMutation({
2206 *   variables: {
2207 *      identifier: // value for 'identifier'
2208 *      password: // value for 'password'
2209 *   },
2210 * });
2211 */
2212export function useLoginMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutation, LoginMutationVariables>) {
2213        return Apollo.useMutation<LoginMutation, LoginMutationVariables>(LoginDocument, baseOptions);
2214      }
2215export type LoginMutationHookResult = ReturnType<typeof useLoginMutation>;
2216export type LoginMutationResult = Apollo.MutationResult<LoginMutation>;
2217export type LoginMutationOptions = Apollo.BaseMutationOptions<LoginMutation, LoginMutationVariables>;
2218export const ForgotPasswordDocument = gql`
2219    mutation forgotPassword($email: String!) {
2220  forgotPassword(email: $email) {
2221    ok
2222  }
2223}
2224    `;
2225export type ForgotPasswordMutationFn = Apollo.MutationFunction<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2226
2227/**
2228 * __useForgotPasswordMutation__
2229 *
2230 * To run a mutation, you first call `useForgotPasswordMutation` within a React component and pass it any options that fit your needs.
2231 * When your component renders, `useForgotPasswordMutation` returns a tuple that includes:
2232 * - A mutate function that you can call at any time to execute the mutation
2233 * - An object with fields that represent the current status of the mutation's execution
2234 *
2235 * @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;
2236 *
2237 * @example
2238 * const [forgotPasswordMutation, { data, loading, error }] = useForgotPasswordMutation({
2239 *   variables: {
2240 *      email: // value for 'email'
2241 *   },
2242 * });
2243 */
2244export function useForgotPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>) {
2245        return Apollo.useMutation<ForgotPasswordMutation, ForgotPasswordMutationVariables>(ForgotPasswordDocument, baseOptions);
2246      }
2247export type ForgotPasswordMutationHookResult = ReturnType<typeof useForgotPasswordMutation>;
2248export type ForgotPasswordMutationResult = Apollo.MutationResult<ForgotPasswordMutation>;
2249export type ForgotPasswordMutationOptions = Apollo.BaseMutationOptions<ForgotPasswordMutation, ForgotPasswordMutationVariables>;
2250export const ResetPasswordDocument = gql`
2251    mutation resetPassword($password: String!, $passwordConfirmation: String!, $code: String!) {
2252  resetPassword(
2253    password: $password
2254    passwordConfirmation: $passwordConfirmation
2255    code: $code
2256  ) {
2257    jwt
2258    user {
2259      ...MeFields
2260    }
2261  }
2262}
2263    ${MeFieldsFragmentDoc}`;
2264export type ResetPasswordMutationFn = Apollo.MutationFunction<ResetPasswordMutation, ResetPasswordMutationVariables>;
2265
2266/**
2267 * __useResetPasswordMutation__
2268 *
2269 * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
2270 * When your component renders, `useResetPasswordMutation` returns a tuple that includes:
2271 * - A mutate function that you can call at any time to execute the mutation
2272 * - An object with fields that represent the current status of the mutation's execution
2273 *
2274 * @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;
2275 *
2276 * @example
2277 * const [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
2278 *   variables: {
2279 *      password: // value for 'password'
2280 *      passwordConfirmation: // value for 'passwordConfirmation'
2281 *      code: // value for 'code'
2282 *   },
2283 * });
2284 */
2285export function useResetPasswordMutation(baseOptions?: Apollo.MutationHookOptions<ResetPasswordMutation, ResetPasswordMutationVariables>) {
2286        return Apollo.useMutation<ResetPasswordMutation, ResetPasswordMutationVariables>(ResetPasswordDocument, baseOptions);
2287      }
2288export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
2289export type ResetPasswordMutationResult = Apollo.MutationResult<ResetPasswordMutation>;
2290export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<ResetPasswordMutation, ResetPasswordMutationVariables>;
2291export const CreateEventDocument = gql`
2292    mutation createEvent($name: String!, $email: String!, $date: Date, $address: String, $description: String, $newsletter: Boolean) {
2293  createEvent(
2294    data: {name: $name, email: $email, date: $date, address: $address, description: $description, newsletter: $newsletter}
2295  ) {
2296    data {
2297      ...EventFields
2298    }
2299  }
2300}
2301    ${EventFieldsFragmentDoc}`;
2302export type CreateEventMutationFn = Apollo.MutationFunction<CreateEventMutation, CreateEventMutationVariables>;
2303
2304/**
2305 * __useCreateEventMutation__
2306 *
2307 * To run a mutation, you first call `useCreateEventMutation` within a React component and pass it any options that fit your needs.
2308 * When your component renders, `useCreateEventMutation` returns a tuple that includes:
2309 * - A mutate function that you can call at any time to execute the mutation
2310 * - An object with fields that represent the current status of the mutation's execution
2311 *
2312 * @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;
2313 *
2314 * @example
2315 * const [createEventMutation, { data, loading, error }] = useCreateEventMutation({
2316 *   variables: {
2317 *      name: // value for 'name'
2318 *      email: // value for 'email'
2319 *      date: // value for 'date'
2320 *      address: // value for 'address'
2321 *      description: // value for 'description'
2322 *      newsletter: // value for 'newsletter'
2323 *   },
2324 * });
2325 */
2326export function useCreateEventMutation(baseOptions?: Apollo.MutationHookOptions<CreateEventMutation, CreateEventMutationVariables>) {
2327        return Apollo.useMutation<CreateEventMutation, CreateEventMutationVariables>(CreateEventDocument, baseOptions);
2328      }
2329export type CreateEventMutationHookResult = ReturnType<typeof useCreateEventMutation>;
2330export type CreateEventMutationResult = Apollo.MutationResult<CreateEventMutation>;
2331export type CreateEventMutationOptions = Apollo.BaseMutationOptions<CreateEventMutation, CreateEventMutationVariables>;
2332export const UpdateEventDocument = gql`
2333    mutation updateEvent($uuid: String!, $eventUpdate: EventInput!) {
2334  updateEventByUUID(uuid: $uuid, data: $eventUpdate) {
2335    data {
2336      ...EventFields
2337    }
2338  }
2339}
2340    ${EventFieldsFragmentDoc}`;
2341export type UpdateEventMutationFn = Apollo.MutationFunction<UpdateEventMutation, UpdateEventMutationVariables>;
2342
2343/**
2344 * __useUpdateEventMutation__
2345 *
2346 * To run a mutation, you first call `useUpdateEventMutation` within a React component and pass it any options that fit your needs.
2347 * When your component renders, `useUpdateEventMutation` returns a tuple that includes:
2348 * - A mutate function that you can call at any time to execute the mutation
2349 * - An object with fields that represent the current status of the mutation's execution
2350 *
2351 * @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;
2352 *
2353 * @example
2354 * const [updateEventMutation, { data, loading, error }] = useUpdateEventMutation({
2355 *   variables: {
2356 *      uuid: // value for 'uuid'
2357 *      eventUpdate: // value for 'eventUpdate'
2358 *   },
2359 * });
2360 */
2361export function useUpdateEventMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEventMutation, UpdateEventMutationVariables>) {
2362        return Apollo.useMutation<UpdateEventMutation, UpdateEventMutationVariables>(UpdateEventDocument, baseOptions);
2363      }
2364export type UpdateEventMutationHookResult = ReturnType<typeof useUpdateEventMutation>;
2365export type UpdateEventMutationResult = Apollo.MutationResult<UpdateEventMutation>;
2366export type UpdateEventMutationOptions = Apollo.BaseMutationOptions<UpdateEventMutation, UpdateEventMutationVariables>;
2367export const EventByUuidDocument = gql`
2368    query eventByUUID($uuid: String!) {
2369  eventByUUID(uuid: $uuid) {
2370    data {
2371      ...EventFields
2372    }
2373  }
2374}
2375    ${EventFieldsFragmentDoc}`;
2376
2377/**
2378 * __useEventByUuidQuery__
2379 *
2380 * To run a query within a React component, call `useEventByUuidQuery` and pass it any options that fit your needs.
2381 * When your component renders, `useEventByUuidQuery` returns an object from Apollo Client that contains loading, error, and data properties
2382 * you can use to render your UI.
2383 *
2384 * @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;
2385 *
2386 * @example
2387 * const { data, loading, error } = useEventByUuidQuery({
2388 *   variables: {
2389 *      uuid: // value for 'uuid'
2390 *   },
2391 * });
2392 */
2393export function useEventByUuidQuery(baseOptions: Apollo.QueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2394        return Apollo.useQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2395      }
2396export function useEventByUuidLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EventByUuidQuery, EventByUuidQueryVariables>) {
2397          return Apollo.useLazyQuery<EventByUuidQuery, EventByUuidQueryVariables>(EventByUuidDocument, baseOptions);
2398        }
2399export type EventByUuidQueryHookResult = ReturnType<typeof useEventByUuidQuery>;
2400export type EventByUuidLazyQueryHookResult = ReturnType<typeof useEventByUuidLazyQuery>;
2401export type EventByUuidQueryResult = Apollo.QueryResult<EventByUuidQuery, EventByUuidQueryVariables>;
2402export const CreatePassengerDocument = gql`
2403    mutation createPassenger($passenger: PassengerInput!) {
2404  createPassenger(data: $passenger) {
2405    data {
2406      ...PassengerFields
2407    }
2408  }
2409}
2410    ${PassengerFieldsFragmentDoc}`;
2411export type CreatePassengerMutationFn = Apollo.MutationFunction<CreatePassengerMutation, CreatePassengerMutationVariables>;
2412
2413/**
2414 * __useCreatePassengerMutation__
2415 *
2416 * To run a mutation, you first call `useCreatePassengerMutation` within a React component and pass it any options that fit your needs.
2417 * When your component renders, `useCreatePassengerMutation` returns a tuple that includes:
2418 * - A mutate function that you can call at any time to execute the mutation
2419 * - An object with fields that represent the current status of the mutation's execution
2420 *
2421 * @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;
2422 *
2423 * @example
2424 * const [createPassengerMutation, { data, loading, error }] = useCreatePassengerMutation({
2425 *   variables: {
2426 *      passenger: // value for 'passenger'
2427 *   },
2428 * });
2429 */
2430export function useCreatePassengerMutation(baseOptions?: Apollo.MutationHookOptions<CreatePassengerMutation, CreatePassengerMutationVariables>) {
2431        return Apollo.useMutation<CreatePassengerMutation, CreatePassengerMutationVariables>(CreatePassengerDocument, baseOptions);
2432      }
2433export type CreatePassengerMutationHookResult = ReturnType<typeof useCreatePassengerMutation>;
2434export type CreatePassengerMutationResult = Apollo.MutationResult<CreatePassengerMutation>;
2435export type CreatePassengerMutationOptions = Apollo.BaseMutationOptions<CreatePassengerMutation, CreatePassengerMutationVariables>;
2436export const UpdatePassengerDocument = gql`
2437    mutation updatePassenger($id: ID!, $passengerUpdate: PassengerInput!) {
2438  updatePassenger(id: $id, data: $passengerUpdate) {
2439    data {
2440      ...PassengerFields
2441    }
2442  }
2443}
2444    ${PassengerFieldsFragmentDoc}`;
2445export type UpdatePassengerMutationFn = Apollo.MutationFunction<UpdatePassengerMutation, UpdatePassengerMutationVariables>;
2446
2447/**
2448 * __useUpdatePassengerMutation__
2449 *
2450 * To run a mutation, you first call `useUpdatePassengerMutation` within a React component and pass it any options that fit your needs.
2451 * When your component renders, `useUpdatePassengerMutation` returns a tuple that includes:
2452 * - A mutate function that you can call at any time to execute the mutation
2453 * - An object with fields that represent the current status of the mutation's execution
2454 *
2455 * @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;
2456 *
2457 * @example
2458 * const [updatePassengerMutation, { data, loading, error }] = useUpdatePassengerMutation({
2459 *   variables: {
2460 *      id: // value for 'id'
2461 *      passengerUpdate: // value for 'passengerUpdate'
2462 *   },
2463 * });
2464 */
2465export function useUpdatePassengerMutation(baseOptions?: Apollo.MutationHookOptions<UpdatePassengerMutation, UpdatePassengerMutationVariables>) {
2466        return Apollo.useMutation<UpdatePassengerMutation, UpdatePassengerMutationVariables>(UpdatePassengerDocument, baseOptions);
2467      }
2468export type UpdatePassengerMutationHookResult = ReturnType<typeof useUpdatePassengerMutation>;
2469export type UpdatePassengerMutationResult = Apollo.MutationResult<UpdatePassengerMutation>;
2470export type UpdatePassengerMutationOptions = Apollo.BaseMutationOptions<UpdatePassengerMutation, UpdatePassengerMutationVariables>;
2471export const DeletePassengerDocument = gql`
2472    mutation deletePassenger($id: ID!) {
2473  deletePassenger(id: $id) {
2474    data {
2475      id
2476    }
2477  }
2478}
2479    `;
2480export type DeletePassengerMutationFn = Apollo.MutationFunction<DeletePassengerMutation, DeletePassengerMutationVariables>;
2481
2482/**
2483 * __useDeletePassengerMutation__
2484 *
2485 * To run a mutation, you first call `useDeletePassengerMutation` within a React component and pass it any options that fit your needs.
2486 * When your component renders, `useDeletePassengerMutation` returns a tuple that includes:
2487 * - A mutate function that you can call at any time to execute the mutation
2488 * - An object with fields that represent the current status of the mutation's execution
2489 *
2490 * @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;
2491 *
2492 * @example
2493 * const [deletePassengerMutation, { data, loading, error }] = useDeletePassengerMutation({
2494 *   variables: {
2495 *      id: // value for 'id'
2496 *   },
2497 * });
2498 */
2499export function useDeletePassengerMutation(baseOptions?: Apollo.MutationHookOptions<DeletePassengerMutation, DeletePassengerMutationVariables>) {
2500        return Apollo.useMutation<DeletePassengerMutation, DeletePassengerMutationVariables>(DeletePassengerDocument, baseOptions);
2501      }
2502export type DeletePassengerMutationHookResult = ReturnType<typeof useDeletePassengerMutation>;
2503export type DeletePassengerMutationResult = Apollo.MutationResult<DeletePassengerMutation>;
2504export type DeletePassengerMutationOptions = Apollo.BaseMutationOptions<DeletePassengerMutation, DeletePassengerMutationVariables>;
2505export const SettingDocument = gql`
2506    query setting($locale: I18NLocaleCode!) {
2507  setting(locale: $locale) {
2508    data {
2509      id
2510      attributes {
2511        gtm_id
2512        about_link
2513        faq_link
2514        announcement
2515        matomo_script_url
2516      }
2517    }
2518  }
2519}
2520    `;
2521
2522/**
2523 * __useSettingQuery__
2524 *
2525 * To run a query within a React component, call `useSettingQuery` and pass it any options that fit your needs.
2526 * When your component renders, `useSettingQuery` returns an object from Apollo Client that contains loading, error, and data properties
2527 * you can use to render your UI.
2528 *
2529 * @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;
2530 *
2531 * @example
2532 * const { data, loading, error } = useSettingQuery({
2533 *   variables: {
2534 *      locale: // value for 'locale'
2535 *   },
2536 * });
2537 */
2538export function useSettingQuery(baseOptions: Apollo.QueryHookOptions<SettingQuery, SettingQueryVariables>) {
2539        return Apollo.useQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2540      }
2541export function useSettingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SettingQuery, SettingQueryVariables>) {
2542          return Apollo.useLazyQuery<SettingQuery, SettingQueryVariables>(SettingDocument, baseOptions);
2543        }
2544export type SettingQueryHookResult = ReturnType<typeof useSettingQuery>;
2545export type SettingLazyQueryHookResult = ReturnType<typeof useSettingLazyQuery>;
2546export type SettingQueryResult = Apollo.QueryResult<SettingQuery, SettingQueryVariables>;
2547export const CreateTravelDocument = gql`
2548    mutation createTravel($travel: TravelInput!, $createVehicle: Boolean) {
2549  createTravel(data: $travel, createVehicle: $createVehicle) {
2550    data {
2551      ...TravelFields
2552    }
2553  }
2554}
2555    ${TravelFieldsFragmentDoc}`;
2556export type CreateTravelMutationFn = Apollo.MutationFunction<CreateTravelMutation, CreateTravelMutationVariables>;
2557
2558/**
2559 * __useCreateTravelMutation__
2560 *
2561 * To run a mutation, you first call `useCreateTravelMutation` within a React component and pass it any options that fit your needs.
2562 * When your component renders, `useCreateTravelMutation` returns a tuple that includes:
2563 * - A mutate function that you can call at any time to execute the mutation
2564 * - An object with fields that represent the current status of the mutation's execution
2565 *
2566 * @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;
2567 *
2568 * @example
2569 * const [createTravelMutation, { data, loading, error }] = useCreateTravelMutation({
2570 *   variables: {
2571 *      travel: // value for 'travel'
2572 *      createVehicle: // value for 'createVehicle'
2573 *   },
2574 * });
2575 */
2576export function useCreateTravelMutation(baseOptions?: Apollo.MutationHookOptions<CreateTravelMutation, CreateTravelMutationVariables>) {
2577        return Apollo.useMutation<CreateTravelMutation, CreateTravelMutationVariables>(CreateTravelDocument, baseOptions);
2578      }
2579export type CreateTravelMutationHookResult = ReturnType<typeof useCreateTravelMutation>;
2580export type CreateTravelMutationResult = Apollo.MutationResult<CreateTravelMutation>;
2581export type CreateTravelMutationOptions = Apollo.BaseMutationOptions<CreateTravelMutation, CreateTravelMutationVariables>;
2582export const UpdateTravelDocument = gql`
2583    mutation updateTravel($id: ID!, $travelUpdate: TravelInput!) {
2584  updateTravel(id: $id, data: $travelUpdate) {
2585    data {
2586      ...TravelFields
2587    }
2588  }
2589}
2590    ${TravelFieldsFragmentDoc}`;
2591export type UpdateTravelMutationFn = Apollo.MutationFunction<UpdateTravelMutation, UpdateTravelMutationVariables>;
2592
2593/**
2594 * __useUpdateTravelMutation__
2595 *
2596 * To run a mutation, you first call `useUpdateTravelMutation` within a React component and pass it any options that fit your needs.
2597 * When your component renders, `useUpdateTravelMutation` returns a tuple that includes:
2598 * - A mutate function that you can call at any time to execute the mutation
2599 * - An object with fields that represent the current status of the mutation's execution
2600 *
2601 * @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;
2602 *
2603 * @example
2604 * const [updateTravelMutation, { data, loading, error }] = useUpdateTravelMutation({
2605 *   variables: {
2606 *      id: // value for 'id'
2607 *      travelUpdate: // value for 'travelUpdate'
2608 *   },
2609 * });
2610 */
2611export function useUpdateTravelMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTravelMutation, UpdateTravelMutationVariables>) {
2612        return Apollo.useMutation<UpdateTravelMutation, UpdateTravelMutationVariables>(UpdateTravelDocument, baseOptions);
2613      }
2614export type UpdateTravelMutationHookResult = ReturnType<typeof useUpdateTravelMutation>;
2615export type UpdateTravelMutationResult = Apollo.MutationResult<UpdateTravelMutation>;
2616export type UpdateTravelMutationOptions = Apollo.BaseMutationOptions<UpdateTravelMutation, UpdateTravelMutationVariables>;
2617export const DeleteTravelDocument = gql`
2618    mutation deleteTravel($id: ID!) {
2619  deleteTravel(id: $id) {
2620    data {
2621      id
2622    }
2623  }
2624}
2625    `;
2626export type DeleteTravelMutationFn = Apollo.MutationFunction<DeleteTravelMutation, DeleteTravelMutationVariables>;
2627
2628/**
2629 * __useDeleteTravelMutation__
2630 *
2631 * To run a mutation, you first call `useDeleteTravelMutation` within a React component and pass it any options that fit your needs.
2632 * When your component renders, `useDeleteTravelMutation` returns a tuple that includes:
2633 * - A mutate function that you can call at any time to execute the mutation
2634 * - An object with fields that represent the current status of the mutation's execution
2635 *
2636 * @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;
2637 *
2638 * @example
2639 * const [deleteTravelMutation, { data, loading, error }] = useDeleteTravelMutation({
2640 *   variables: {
2641 *      id: // value for 'id'
2642 *   },
2643 * });
2644 */
2645export function useDeleteTravelMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTravelMutation, DeleteTravelMutationVariables>) {
2646        return Apollo.useMutation<DeleteTravelMutation, DeleteTravelMutationVariables>(DeleteTravelDocument, baseOptions);
2647      }
2648export type DeleteTravelMutationHookResult = ReturnType<typeof useDeleteTravelMutation>;
2649export type DeleteTravelMutationResult = Apollo.MutationResult<DeleteTravelMutation>;
2650export type DeleteTravelMutationOptions = Apollo.BaseMutationOptions<DeleteTravelMutation, DeleteTravelMutationVariables>;
2651export const ProfileDocument = gql`
2652    query profile {
2653  me {
2654    id
2655    username
2656    profile {
2657      ...UserFields
2658    }
2659  }
2660}
2661    ${UserFieldsFragmentDoc}`;
2662
2663/**
2664 * __useProfileQuery__
2665 *
2666 * To run a query within a React component, call `useProfileQuery` and pass it any options that fit your needs.
2667 * When your component renders, `useProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
2668 * you can use to render your UI.
2669 *
2670 * @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;
2671 *
2672 * @example
2673 * const { data, loading, error } = useProfileQuery({
2674 *   variables: {
2675 *   },
2676 * });
2677 */
2678export function useProfileQuery(baseOptions?: Apollo.QueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2679        return Apollo.useQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2680      }
2681export function useProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ProfileQuery, ProfileQueryVariables>) {
2682          return Apollo.useLazyQuery<ProfileQuery, ProfileQueryVariables>(ProfileDocument, baseOptions);
2683        }
2684export type ProfileQueryHookResult = ReturnType<typeof useProfileQuery>;
2685export type ProfileLazyQueryHookResult = ReturnType<typeof useProfileLazyQuery>;
2686export type ProfileQueryResult = Apollo.QueryResult<ProfileQuery, ProfileQueryVariables>;
2687export const UpdateMeDocument = gql`
2688    mutation updateMe($userUpdate: UsersPermissionsUserInput!) {
2689  updateMe(data: $userUpdate) {
2690    data {
2691      id
2692      attributes {
2693        ...UserFields
2694      }
2695    }
2696  }
2697}
2698    ${UserFieldsFragmentDoc}`;
2699export type UpdateMeMutationFn = Apollo.MutationFunction<UpdateMeMutation, UpdateMeMutationVariables>;
2700
2701/**
2702 * __useUpdateMeMutation__
2703 *
2704 * To run a mutation, you first call `useUpdateMeMutation` within a React component and pass it any options that fit your needs.
2705 * When your component renders, `useUpdateMeMutation` returns a tuple that includes:
2706 * - A mutate function that you can call at any time to execute the mutation
2707 * - An object with fields that represent the current status of the mutation's execution
2708 *
2709 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2710 *
2711 * @example
2712 * const [updateMeMutation, { data, loading, error }] = useUpdateMeMutation({
2713 *   variables: {
2714 *      userUpdate: // value for 'userUpdate'
2715 *   },
2716 * });
2717 */
2718export function useUpdateMeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMeMutation, UpdateMeMutationVariables>) {
2719        return Apollo.useMutation<UpdateMeMutation, UpdateMeMutationVariables>(UpdateMeDocument, baseOptions);
2720      }
2721export type UpdateMeMutationHookResult = ReturnType<typeof useUpdateMeMutation>;
2722export type UpdateMeMutationResult = Apollo.MutationResult<UpdateMeMutation>;
2723export type UpdateMeMutationOptions = Apollo.BaseMutationOptions<UpdateMeMutation, UpdateMeMutationVariables>;
2724export const FindUserVehiclesDocument = gql`
2725    query findUserVehicles {
2726  me {
2727    id
2728    username
2729    profile {
2730      vehicles {
2731        data {
2732          ...VehicleFields
2733        }
2734      }
2735    }
2736  }
2737}
2738    ${VehicleFieldsFragmentDoc}`;
2739
2740/**
2741 * __useFindUserVehiclesQuery__
2742 *
2743 * To run a query within a React component, call `useFindUserVehiclesQuery` and pass it any options that fit your needs.
2744 * When your component renders, `useFindUserVehiclesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2745 * you can use to render your UI.
2746 *
2747 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
2748 *
2749 * @example
2750 * const { data, loading, error } = useFindUserVehiclesQuery({
2751 *   variables: {
2752 *   },
2753 * });
2754 */
2755export function useFindUserVehiclesQuery(baseOptions?: Apollo.QueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
2756        return Apollo.useQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
2757      }
2758export function useFindUserVehiclesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>) {
2759          return Apollo.useLazyQuery<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>(FindUserVehiclesDocument, baseOptions);
2760        }
2761export type FindUserVehiclesQueryHookResult = ReturnType<typeof useFindUserVehiclesQuery>;
2762export type FindUserVehiclesLazyQueryHookResult = ReturnType<typeof useFindUserVehiclesLazyQuery>;
2763export type FindUserVehiclesQueryResult = Apollo.QueryResult<FindUserVehiclesQuery, FindUserVehiclesQueryVariables>;
2764export const DeleteVehicleDocument = gql`
2765    mutation deleteVehicle($id: ID!) {
2766  deleteVehicle(id: $id) {
2767    data {
2768      id
2769      attributes {
2770        name
2771      }
2772    }
2773  }
2774}
2775    `;
2776export type DeleteVehicleMutationFn = Apollo.MutationFunction<DeleteVehicleMutation, DeleteVehicleMutationVariables>;
2777
2778/**
2779 * __useDeleteVehicleMutation__
2780 *
2781 * To run a mutation, you first call `useDeleteVehicleMutation` within a React component and pass it any options that fit your needs.
2782 * When your component renders, `useDeleteVehicleMutation` returns a tuple that includes:
2783 * - A mutate function that you can call at any time to execute the mutation
2784 * - An object with fields that represent the current status of the mutation's execution
2785 *
2786 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
2787 *
2788 * @example
2789 * const [deleteVehicleMutation, { data, loading, error }] = useDeleteVehicleMutation({
2790 *   variables: {
2791 *      id: // value for 'id'
2792 *   },
2793 * });
2794 */
2795export function useDeleteVehicleMutation(baseOptions?: Apollo.MutationHookOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>) {
2796        return Apollo.useMutation<DeleteVehicleMutation, DeleteVehicleMutationVariables>(DeleteVehicleDocument, baseOptions);
2797      }
2798export type DeleteVehicleMutationHookResult = ReturnType<typeof useDeleteVehicleMutation>;
2799export type DeleteVehicleMutationResult = Apollo.MutationResult<DeleteVehicleMutation>;
2800export type DeleteVehicleMutationOptions = Apollo.BaseMutationOptions<DeleteVehicleMutation, DeleteVehicleMutationVariables>;