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