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