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