backstage

1
apiVersion: backstage.io/v1alpha1
2
kind: API
3
metadata:
4
  name: starwars-graphql
5
  description: SWAPI GraphQL Schema
6
  links:
7
    - url: https://github.com/graphql/swapi-graphql
8
      title: GitHub Repo
9
      icon: github
10
spec:
11
  type: graphql
12
  lifecycle: production
13
  owner: team-b
14
  definition: |
15
    schema {
16
      query: Root
17
    }
18

19
    """A single film."""
20
    type Film implements Node {
21
      """The title of this film."""
22
      title: String
23

24
      """The episode number of this film."""
25
      episodeID: Int
26

27
      """The opening paragraphs at the beginning of this film."""
28
      openingCrawl: String
29

30
      """The name of the director of this film."""
31
      director: String
32

33
      """The name(s) of the producer(s) of this film."""
34
      producers: [String]
35

36
      """The ISO 8601 date format of film release at original creator country."""
37
      releaseDate: String
38
      speciesConnection(after: String, first: Int, before: String, last: Int): FilmSpeciesConnection
39
      starshipConnection(after: String, first: Int, before: String, last: Int): FilmStarshipsConnection
40
      vehicleConnection(after: String, first: Int, before: String, last: Int): FilmVehiclesConnection
41
      characterConnection(after: String, first: Int, before: String, last: Int): FilmCharactersConnection
42
      planetConnection(after: String, first: Int, before: String, last: Int): FilmPlanetsConnection
43

44
      """The ISO 8601 date format of the time that this resource was created."""
45
      created: String
46

47
      """The ISO 8601 date format of the time that this resource was edited."""
48
      edited: String
49

50
      """The ID of an object"""
51
      id: ID!
52
    }
53

54
    """A connection to a list of items."""
55
    type FilmCharactersConnection {
56
      """Information to aid in pagination."""
57
      pageInfo: PageInfo!
58

59
      """A list of edges."""
60
      edges: [FilmCharactersEdge]
61

62
      """
63
      A count of the total number of objects in this connection, ignoring pagination.
64
      This allows a client to fetch the first five objects by passing "5" as the
65
      argument to "first", then fetch the total count so it could display "5 of 83",
66
      for example.
67
      """
68
      totalCount: Int
69

70
      """
71
      A list of all of the objects returned in the connection. This is a convenience
72
      field provided for quickly exploring the API; rather than querying for
73
      "{ edges { node } }" when no edge data is needed, this field can be be used
74
      instead. Note that when clients like Relay need to fetch the "cursor" field on
75
      the edge to enable efficient pagination, this shortcut cannot be used, and the
76
      full "{ edges { node } }" version should be used instead.
77
      """
78
      characters: [Person]
79
    }
80

81
    """An edge in a connection."""
82
    type FilmCharactersEdge {
83
      """The item at the end of the edge"""
84
      node: Person
85

86
      """A cursor for use in pagination"""
87
      cursor: String!
88
    }
89

90
    """A connection to a list of items."""
91
    type FilmPlanetsConnection {
92
      """Information to aid in pagination."""
93
      pageInfo: PageInfo!
94

95
      """A list of edges."""
96
      edges: [FilmPlanetsEdge]
97

98
      """
99
      A count of the total number of objects in this connection, ignoring pagination.
100
      This allows a client to fetch the first five objects by passing "5" as the
101
      argument to "first", then fetch the total count so it could display "5 of 83",
102
      for example.
103
      """
104
      totalCount: Int
105

106
      """
107
      A list of all of the objects returned in the connection. This is a convenience
108
      field provided for quickly exploring the API; rather than querying for
109
      "{ edges { node } }" when no edge data is needed, this field can be be used
110
      instead. Note that when clients like Relay need to fetch the "cursor" field on
111
      the edge to enable efficient pagination, this shortcut cannot be used, and the
112
      full "{ edges { node } }" version should be used instead.
113
      """
114
      planets: [Planet]
115
    }
116

117
    """An edge in a connection."""
118
    type FilmPlanetsEdge {
119
      """The item at the end of the edge"""
120
      node: Planet
121

122
      """A cursor for use in pagination"""
123
      cursor: String!
124
    }
125

126
    """A connection to a list of items."""
127
    type FilmsConnection {
128
      """Information to aid in pagination."""
129
      pageInfo: PageInfo!
130

131
      """A list of edges."""
132
      edges: [FilmsEdge]
133

134
      """
135
      A count of the total number of objects in this connection, ignoring pagination.
136
      This allows a client to fetch the first five objects by passing "5" as the
137
      argument to "first", then fetch the total count so it could display "5 of 83",
138
      for example.
139
      """
140
      totalCount: Int
141

142
      """
143
      A list of all of the objects returned in the connection. This is a convenience
144
      field provided for quickly exploring the API; rather than querying for
145
      "{ edges { node } }" when no edge data is needed, this field can be be used
146
      instead. Note that when clients like Relay need to fetch the "cursor" field on
147
      the edge to enable efficient pagination, this shortcut cannot be used, and the
148
      full "{ edges { node } }" version should be used instead.
149
      """
150
      films: [Film]
151
    }
152

153
    """An edge in a connection."""
154
    type FilmsEdge {
155
      """The item at the end of the edge"""
156
      node: Film
157

158
      """A cursor for use in pagination"""
159
      cursor: String!
160
    }
161

162
    """A connection to a list of items."""
163
    type FilmSpeciesConnection {
164
      """Information to aid in pagination."""
165
      pageInfo: PageInfo!
166

167
      """A list of edges."""
168
      edges: [FilmSpeciesEdge]
169

170
      """
171
      A count of the total number of objects in this connection, ignoring pagination.
172
      This allows a client to fetch the first five objects by passing "5" as the
173
      argument to "first", then fetch the total count so it could display "5 of 83",
174
      for example.
175
      """
176
      totalCount: Int
177

178
      """
179
      A list of all of the objects returned in the connection. This is a convenience
180
      field provided for quickly exploring the API; rather than querying for
181
      "{ edges { node } }" when no edge data is needed, this field can be be used
182
      instead. Note that when clients like Relay need to fetch the "cursor" field on
183
      the edge to enable efficient pagination, this shortcut cannot be used, and the
184
      full "{ edges { node } }" version should be used instead.
185
      """
186
      species: [Species]
187
    }
188

189
    """An edge in a connection."""
190
    type FilmSpeciesEdge {
191
      """The item at the end of the edge"""
192
      node: Species
193

194
      """A cursor for use in pagination"""
195
      cursor: String!
196
    }
197

198
    """A connection to a list of items."""
199
    type FilmStarshipsConnection {
200
      """Information to aid in pagination."""
201
      pageInfo: PageInfo!
202

203
      """A list of edges."""
204
      edges: [FilmStarshipsEdge]
205

206
      """
207
      A count of the total number of objects in this connection, ignoring pagination.
208
      This allows a client to fetch the first five objects by passing "5" as the
209
      argument to "first", then fetch the total count so it could display "5 of 83",
210
      for example.
211
      """
212
      totalCount: Int
213

214
      """
215
      A list of all of the objects returned in the connection. This is a convenience
216
      field provided for quickly exploring the API; rather than querying for
217
      "{ edges { node } }" when no edge data is needed, this field can be be used
218
      instead. Note that when clients like Relay need to fetch the "cursor" field on
219
      the edge to enable efficient pagination, this shortcut cannot be used, and the
220
      full "{ edges { node } }" version should be used instead.
221
      """
222
      starships: [Starship]
223
    }
224

225
    """An edge in a connection."""
226
    type FilmStarshipsEdge {
227
      """The item at the end of the edge"""
228
      node: Starship
229

230
      """A cursor for use in pagination"""
231
      cursor: String!
232
    }
233

234
    """A connection to a list of items."""
235
    type FilmVehiclesConnection {
236
      """Information to aid in pagination."""
237
      pageInfo: PageInfo!
238

239
      """A list of edges."""
240
      edges: [FilmVehiclesEdge]
241

242
      """
243
      A count of the total number of objects in this connection, ignoring pagination.
244
      This allows a client to fetch the first five objects by passing "5" as the
245
      argument to "first", then fetch the total count so it could display "5 of 83",
246
      for example.
247
      """
248
      totalCount: Int
249

250
      """
251
      A list of all of the objects returned in the connection. This is a convenience
252
      field provided for quickly exploring the API; rather than querying for
253
      "{ edges { node } }" when no edge data is needed, this field can be be used
254
      instead. Note that when clients like Relay need to fetch the "cursor" field on
255
      the edge to enable efficient pagination, this shortcut cannot be used, and the
256
      full "{ edges { node } }" version should be used instead.
257
      """
258
      vehicles: [Vehicle]
259
    }
260

261
    """An edge in a connection."""
262
    type FilmVehiclesEdge {
263
      """The item at the end of the edge"""
264
      node: Vehicle
265

266
      """A cursor for use in pagination"""
267
      cursor: String!
268
    }
269

270
    """An object with an ID"""
271
    interface Node {
272
      """The id of the object."""
273
      id: ID!
274
    }
275

276
    """Information about pagination in a connection."""
277
    type PageInfo {
278
      """When paginating forwards, are there more items?"""
279
      hasNextPage: Boolean!
280

281
      """When paginating backwards, are there more items?"""
282
      hasPreviousPage: Boolean!
283

284
      """When paginating backwards, the cursor to continue."""
285
      startCursor: String
286

287
      """When paginating forwards, the cursor to continue."""
288
      endCursor: String
289
    }
290

291
    """A connection to a list of items."""
292
    type PeopleConnection {
293
      """Information to aid in pagination."""
294
      pageInfo: PageInfo!
295

296
      """A list of edges."""
297
      edges: [PeopleEdge]
298

299
      """
300
      A count of the total number of objects in this connection, ignoring pagination.
301
      This allows a client to fetch the first five objects by passing "5" as the
302
      argument to "first", then fetch the total count so it could display "5 of 83",
303
      for example.
304
      """
305
      totalCount: Int
306

307
      """
308
      A list of all of the objects returned in the connection. This is a convenience
309
      field provided for quickly exploring the API; rather than querying for
310
      "{ edges { node } }" when no edge data is needed, this field can be be used
311
      instead. Note that when clients like Relay need to fetch the "cursor" field on
312
      the edge to enable efficient pagination, this shortcut cannot be used, and the
313
      full "{ edges { node } }" version should be used instead.
314
      """
315
      people: [Person]
316
    }
317

318
    """An edge in a connection."""
319
    type PeopleEdge {
320
      """The item at the end of the edge"""
321
      node: Person
322

323
      """A cursor for use in pagination"""
324
      cursor: String!
325
    }
326

327
    """An individual person or character within the Star Wars universe."""
328
    type Person implements Node {
329
      """The name of this person."""
330
      name: String
331

332
      """
333
      The birth year of the person, using the in-universe standard of BBY or ABY -
334
      Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
335
      a battle that occurs at the end of Star Wars episode IV: A New Hope.
336
      """
337
      birthYear: String
338

339
      """
340
      The eye color of this person. Will be "unknown" if not known or "n/a" if the
341
      person does not have an eye.
342
      """
343
      eyeColor: String
344

345
      """
346
      The gender of this person. Either "Male", "Female" or "unknown",
347
      "n/a" if the person does not have a gender.
348
      """
349
      gender: String
350

351
      """
352
      The hair color of this person. Will be "unknown" if not known or "n/a" if the
353
      person does not have hair.
354
      """
355
      hairColor: String
356

357
      """The height of the person in centimeters."""
358
      height: Int
359

360
      """The mass of the person in kilograms."""
361
      mass: Float
362

363
      """The skin color of this person."""
364
      skinColor: String
365

366
      """A planet that this person was born on or inhabits."""
367
      homeworld: Planet
368
      filmConnection(after: String, first: Int, before: String, last: Int): PersonFilmsConnection
369

370
      """The species that this person belongs to, or null if unknown."""
371
      species: Species
372
      starshipConnection(after: String, first: Int, before: String, last: Int): PersonStarshipsConnection
373
      vehicleConnection(after: String, first: Int, before: String, last: Int): PersonVehiclesConnection
374

375
      """The ISO 8601 date format of the time that this resource was created."""
376
      created: String
377

378
      """The ISO 8601 date format of the time that this resource was edited."""
379
      edited: String
380

381
      """The ID of an object"""
382
      id: ID!
383
    }
384

385
    """A connection to a list of items."""
386
    type PersonFilmsConnection {
387
      """Information to aid in pagination."""
388
      pageInfo: PageInfo!
389

390
      """A list of edges."""
391
      edges: [PersonFilmsEdge]
392

393
      """
394
      A count of the total number of objects in this connection, ignoring pagination.
395
      This allows a client to fetch the first five objects by passing "5" as the
396
      argument to "first", then fetch the total count so it could display "5 of 83",
397
      for example.
398
      """
399
      totalCount: Int
400

401
      """
402
      A list of all of the objects returned in the connection. This is a convenience
403
      field provided for quickly exploring the API; rather than querying for
404
      "{ edges { node } }" when no edge data is needed, this field can be be used
405
      instead. Note that when clients like Relay need to fetch the "cursor" field on
406
      the edge to enable efficient pagination, this shortcut cannot be used, and the
407
      full "{ edges { node } }" version should be used instead.
408
      """
409
      films: [Film]
410
    }
411

412
    """An edge in a connection."""
413
    type PersonFilmsEdge {
414
      """The item at the end of the edge"""
415
      node: Film
416

417
      """A cursor for use in pagination"""
418
      cursor: String!
419
    }
420

421
    """A connection to a list of items."""
422
    type PersonStarshipsConnection {
423
      """Information to aid in pagination."""
424
      pageInfo: PageInfo!
425

426
      """A list of edges."""
427
      edges: [PersonStarshipsEdge]
428

429
      """
430
      A count of the total number of objects in this connection, ignoring pagination.
431
      This allows a client to fetch the first five objects by passing "5" as the
432
      argument to "first", then fetch the total count so it could display "5 of 83",
433
      for example.
434
      """
435
      totalCount: Int
436

437
      """
438
      A list of all of the objects returned in the connection. This is a convenience
439
      field provided for quickly exploring the API; rather than querying for
440
      "{ edges { node } }" when no edge data is needed, this field can be be used
441
      instead. Note that when clients like Relay need to fetch the "cursor" field on
442
      the edge to enable efficient pagination, this shortcut cannot be used, and the
443
      full "{ edges { node } }" version should be used instead.
444
      """
445
      starships: [Starship]
446
    }
447

448
    """An edge in a connection."""
449
    type PersonStarshipsEdge {
450
      """The item at the end of the edge"""
451
      node: Starship
452

453
      """A cursor for use in pagination"""
454
      cursor: String!
455
    }
456

457
    """A connection to a list of items."""
458
    type PersonVehiclesConnection {
459
      """Information to aid in pagination."""
460
      pageInfo: PageInfo!
461

462
      """A list of edges."""
463
      edges: [PersonVehiclesEdge]
464

465
      """
466
      A count of the total number of objects in this connection, ignoring pagination.
467
      This allows a client to fetch the first five objects by passing "5" as the
468
      argument to "first", then fetch the total count so it could display "5 of 83",
469
      for example.
470
      """
471
      totalCount: Int
472

473
      """
474
      A list of all of the objects returned in the connection. This is a convenience
475
      field provided for quickly exploring the API; rather than querying for
476
      "{ edges { node } }" when no edge data is needed, this field can be be used
477
      instead. Note that when clients like Relay need to fetch the "cursor" field on
478
      the edge to enable efficient pagination, this shortcut cannot be used, and the
479
      full "{ edges { node } }" version should be used instead.
480
      """
481
      vehicles: [Vehicle]
482
    }
483

484
    """An edge in a connection."""
485
    type PersonVehiclesEdge {
486
      """The item at the end of the edge"""
487
      node: Vehicle
488

489
      """A cursor for use in pagination"""
490
      cursor: String!
491
    }
492

493
    """
494
    A large mass, planet or planetoid in the Star Wars Universe, at the time of
495
    0 ABY.
496
    """
497
    type Planet implements Node {
498
      """The name of this planet."""
499
      name: String
500

501
      """The diameter of this planet in kilometers."""
502
      diameter: Int
503

504
      """
505
      The number of standard hours it takes for this planet to complete a single
506
      rotation on its axis.
507
      """
508
      rotationPeriod: Int
509

510
      """
511
      The number of standard days it takes for this planet to complete a single orbit
512
      of its local star.
513
      """
514
      orbitalPeriod: Int
515

516
      """
517
      A number denoting the gravity of this planet, where "1" is normal or 1 standard
518
      G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
519
      """
520
      gravity: String
521

522
      """The average population of sentient beings inhabiting this planet."""
523
      population: Float
524

525
      """The climates of this planet."""
526
      climates: [String]
527

528
      """The terrains of this planet."""
529
      terrains: [String]
530

531
      """
532
      The percentage of the planet surface that is naturally occurring water or bodies
533
      of water.
534
      """
535
      surfaceWater: Float
536
      residentConnection(after: String, first: Int, before: String, last: Int): PlanetResidentsConnection
537
      filmConnection(after: String, first: Int, before: String, last: Int): PlanetFilmsConnection
538

539
      """The ISO 8601 date format of the time that this resource was created."""
540
      created: String
541

542
      """The ISO 8601 date format of the time that this resource was edited."""
543
      edited: String
544

545
      """The ID of an object"""
546
      id: ID!
547
    }
548

549
    """A connection to a list of items."""
550
    type PlanetFilmsConnection {
551
      """Information to aid in pagination."""
552
      pageInfo: PageInfo!
553

554
      """A list of edges."""
555
      edges: [PlanetFilmsEdge]
556

557
      """
558
      A count of the total number of objects in this connection, ignoring pagination.
559
      This allows a client to fetch the first five objects by passing "5" as the
560
      argument to "first", then fetch the total count so it could display "5 of 83",
561
      for example.
562
      """
563
      totalCount: Int
564

565
      """
566
      A list of all of the objects returned in the connection. This is a convenience
567
      field provided for quickly exploring the API; rather than querying for
568
      "{ edges { node } }" when no edge data is needed, this field can be be used
569
      instead. Note that when clients like Relay need to fetch the "cursor" field on
570
      the edge to enable efficient pagination, this shortcut cannot be used, and the
571
      full "{ edges { node } }" version should be used instead.
572
      """
573
      films: [Film]
574
    }
575

576
    """An edge in a connection."""
577
    type PlanetFilmsEdge {
578
      """The item at the end of the edge"""
579
      node: Film
580

581
      """A cursor for use in pagination"""
582
      cursor: String!
583
    }
584

585
    """A connection to a list of items."""
586
    type PlanetResidentsConnection {
587
      """Information to aid in pagination."""
588
      pageInfo: PageInfo!
589

590
      """A list of edges."""
591
      edges: [PlanetResidentsEdge]
592

593
      """
594
      A count of the total number of objects in this connection, ignoring pagination.
595
      This allows a client to fetch the first five objects by passing "5" as the
596
      argument to "first", then fetch the total count so it could display "5 of 83",
597
      for example.
598
      """
599
      totalCount: Int
600

601
      """
602
      A list of all of the objects returned in the connection. This is a convenience
603
      field provided for quickly exploring the API; rather than querying for
604
      "{ edges { node } }" when no edge data is needed, this field can be be used
605
      instead. Note that when clients like Relay need to fetch the "cursor" field on
606
      the edge to enable efficient pagination, this shortcut cannot be used, and the
607
      full "{ edges { node } }" version should be used instead.
608
      """
609
      residents: [Person]
610
    }
611

612
    """An edge in a connection."""
613
    type PlanetResidentsEdge {
614
      """The item at the end of the edge"""
615
      node: Person
616

617
      """A cursor for use in pagination"""
618
      cursor: String!
619
    }
620

621
    """A connection to a list of items."""
622
    type PlanetsConnection {
623
      """Information to aid in pagination."""
624
      pageInfo: PageInfo!
625

626
      """A list of edges."""
627
      edges: [PlanetsEdge]
628

629
      """
630
      A count of the total number of objects in this connection, ignoring pagination.
631
      This allows a client to fetch the first five objects by passing "5" as the
632
      argument to "first", then fetch the total count so it could display "5 of 83",
633
      for example.
634
      """
635
      totalCount: Int
636

637
      """
638
      A list of all of the objects returned in the connection. This is a convenience
639
      field provided for quickly exploring the API; rather than querying for
640
      "{ edges { node } }" when no edge data is needed, this field can be be used
641
      instead. Note that when clients like Relay need to fetch the "cursor" field on
642
      the edge to enable efficient pagination, this shortcut cannot be used, and the
643
      full "{ edges { node } }" version should be used instead.
644
      """
645
      planets: [Planet]
646
    }
647

648
    """An edge in a connection."""
649
    type PlanetsEdge {
650
      """The item at the end of the edge"""
651
      node: Planet
652

653
      """A cursor for use in pagination"""
654
      cursor: String!
655
    }
656

657
    type Root {
658
      allFilms(after: String, first: Int, before: String, last: Int): FilmsConnection
659
      film(id: ID, filmID: ID): Film
660
      allPeople(after: String, first: Int, before: String, last: Int): PeopleConnection
661
      person(id: ID, personID: ID): Person
662
      allPlanets(after: String, first: Int, before: String, last: Int): PlanetsConnection
663
      planet(id: ID, planetID: ID): Planet
664
      allSpecies(after: String, first: Int, before: String, last: Int): SpeciesConnection
665
      species(id: ID, speciesID: ID): Species
666
      allStarships(after: String, first: Int, before: String, last: Int): StarshipsConnection
667
      starship(id: ID, starshipID: ID): Starship
668
      allVehicles(after: String, first: Int, before: String, last: Int): VehiclesConnection
669
      vehicle(id: ID, vehicleID: ID): Vehicle
670

671
      """Fetches an object given its ID"""
672
      node(
673
        """The ID of an object"""
674
        id: ID!
675
      ): Node
676
    }
677

678
    """A type of person or character within the Star Wars Universe."""
679
    type Species implements Node {
680
      """The name of this species."""
681
      name: String
682

683
      """The classification of this species, such as "mammal" or "reptile"."""
684
      classification: String
685

686
      """The designation of this species, such as "sentient"."""
687
      designation: String
688

689
      """The average height of this species in centimeters."""
690
      averageHeight: Float
691

692
      """The average lifespan of this species in years, null if unknown."""
693
      averageLifespan: Int
694

695
      """
696
      Common eye colors for this species, null if this species does not typically
697
      have eyes.
698
      """
699
      eyeColors: [String]
700

701
      """
702
      Common hair colors for this species, null if this species does not typically
703
      have hair.
704
      """
705
      hairColors: [String]
706

707
      """
708
      Common skin colors for this species, null if this species does not typically
709
      have skin.
710
      """
711
      skinColors: [String]
712

713
      """The language commonly spoken by this species."""
714
      language: String
715

716
      """A planet that this species originates from."""
717
      homeworld: Planet
718
      personConnection(after: String, first: Int, before: String, last: Int): SpeciesPeopleConnection
719
      filmConnection(after: String, first: Int, before: String, last: Int): SpeciesFilmsConnection
720

721
      """The ISO 8601 date format of the time that this resource was created."""
722
      created: String
723

724
      """The ISO 8601 date format of the time that this resource was edited."""
725
      edited: String
726

727
      """The ID of an object"""
728
      id: ID!
729
    }
730

731
    """A connection to a list of items."""
732
    type SpeciesConnection {
733
      """Information to aid in pagination."""
734
      pageInfo: PageInfo!
735

736
      """A list of edges."""
737
      edges: [SpeciesEdge]
738

739
      """
740
      A count of the total number of objects in this connection, ignoring pagination.
741
      This allows a client to fetch the first five objects by passing "5" as the
742
      argument to "first", then fetch the total count so it could display "5 of 83",
743
      for example.
744
      """
745
      totalCount: Int
746

747
      """
748
      A list of all of the objects returned in the connection. This is a convenience
749
      field provided for quickly exploring the API; rather than querying for
750
      "{ edges { node } }" when no edge data is needed, this field can be be used
751
      instead. Note that when clients like Relay need to fetch the "cursor" field on
752
      the edge to enable efficient pagination, this shortcut cannot be used, and the
753
      full "{ edges { node } }" version should be used instead.
754
      """
755
      species: [Species]
756
    }
757

758
    """An edge in a connection."""
759
    type SpeciesEdge {
760
      """The item at the end of the edge"""
761
      node: Species
762

763
      """A cursor for use in pagination"""
764
      cursor: String!
765
    }
766

767
    """A connection to a list of items."""
768
    type SpeciesFilmsConnection {
769
      """Information to aid in pagination."""
770
      pageInfo: PageInfo!
771

772
      """A list of edges."""
773
      edges: [SpeciesFilmsEdge]
774

775
      """
776
      A count of the total number of objects in this connection, ignoring pagination.
777
      This allows a client to fetch the first five objects by passing "5" as the
778
      argument to "first", then fetch the total count so it could display "5 of 83",
779
      for example.
780
      """
781
      totalCount: Int
782

783
      """
784
      A list of all of the objects returned in the connection. This is a convenience
785
      field provided for quickly exploring the API; rather than querying for
786
      "{ edges { node } }" when no edge data is needed, this field can be be used
787
      instead. Note that when clients like Relay need to fetch the "cursor" field on
788
      the edge to enable efficient pagination, this shortcut cannot be used, and the
789
      full "{ edges { node } }" version should be used instead.
790
      """
791
      films: [Film]
792
    }
793

794
    """An edge in a connection."""
795
    type SpeciesFilmsEdge {
796
      """The item at the end of the edge"""
797
      node: Film
798

799
      """A cursor for use in pagination"""
800
      cursor: String!
801
    }
802

803
    """A connection to a list of items."""
804
    type SpeciesPeopleConnection {
805
      """Information to aid in pagination."""
806
      pageInfo: PageInfo!
807

808
      """A list of edges."""
809
      edges: [SpeciesPeopleEdge]
810

811
      """
812
      A count of the total number of objects in this connection, ignoring pagination.
813
      This allows a client to fetch the first five objects by passing "5" as the
814
      argument to "first", then fetch the total count so it could display "5 of 83",
815
      for example.
816
      """
817
      totalCount: Int
818

819
      """
820
      A list of all of the objects returned in the connection. This is a convenience
821
      field provided for quickly exploring the API; rather than querying for
822
      "{ edges { node } }" when no edge data is needed, this field can be be used
823
      instead. Note that when clients like Relay need to fetch the "cursor" field on
824
      the edge to enable efficient pagination, this shortcut cannot be used, and the
825
      full "{ edges { node } }" version should be used instead.
826
      """
827
      people: [Person]
828
    }
829

830
    """An edge in a connection."""
831
    type SpeciesPeopleEdge {
832
      """The item at the end of the edge"""
833
      node: Person
834

835
      """A cursor for use in pagination"""
836
      cursor: String!
837
    }
838

839
    """A single transport craft that has hyperdrive capability."""
840
    type Starship implements Node {
841
      """The name of this starship. The common name, such as "Death Star"."""
842
      name: String
843

844
      """
845
      The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
846
      Orbital Battle Station".
847
      """
848
      model: String
849

850
      """
851
      The class of this starship, such as "Starfighter" or "Deep Space Mobile
852
      Battlestation"
853
      """
854
      starshipClass: String
855

856
      """The manufacturers of this starship."""
857
      manufacturers: [String]
858

859
      """The cost of this starship new, in galactic credits."""
860
      costInCredits: Float
861

862
      """The length of this starship in meters."""
863
      length: Float
864

865
      """The number of personnel needed to run or pilot this starship."""
866
      crew: String
867

868
      """The number of non-essential people this starship can transport."""
869
      passengers: String
870

871
      """
872
      The maximum speed of this starship in atmosphere. null if this starship is
873
      incapable of atmosphering flight.
874
      """
875
      maxAtmospheringSpeed: Int
876

877
      """The class of this starships hyperdrive."""
878
      hyperdriveRating: Float
879

880
      """
881
      The Maximum number of Megalights this starship can travel in a standard hour.
882
      A "Megalight" is a standard unit of distance and has never been defined before
883
      within the Star Wars universe. This figure is only really useful for measuring
884
      the difference in speed of starships. We can assume it is similar to AU, the
885
      distance between our Sun (Sol) and Earth.
886
      """
887
      MGLT: Int
888

889
      """The maximum number of kilograms that this starship can transport."""
890
      cargoCapacity: Float
891

892
      """
893
      The maximum length of time that this starship can provide consumables for its
894
      entire crew without having to resupply.
895
      """
896
      consumables: String
897
      pilotConnection(after: String, first: Int, before: String, last: Int): StarshipPilotsConnection
898
      filmConnection(after: String, first: Int, before: String, last: Int): StarshipFilmsConnection
899

900
      """The ISO 8601 date format of the time that this resource was created."""
901
      created: String
902

903
      """The ISO 8601 date format of the time that this resource was edited."""
904
      edited: String
905

906
      """The ID of an object"""
907
      id: ID!
908
    }
909

910
    """A connection to a list of items."""
911
    type StarshipFilmsConnection {
912
      """Information to aid in pagination."""
913
      pageInfo: PageInfo!
914

915
      """A list of edges."""
916
      edges: [StarshipFilmsEdge]
917

918
      """
919
      A count of the total number of objects in this connection, ignoring pagination.
920
      This allows a client to fetch the first five objects by passing "5" as the
921
      argument to "first", then fetch the total count so it could display "5 of 83",
922
      for example.
923
      """
924
      totalCount: Int
925

926
      """
927
      A list of all of the objects returned in the connection. This is a convenience
928
      field provided for quickly exploring the API; rather than querying for
929
      "{ edges { node } }" when no edge data is needed, this field can be be used
930
      instead. Note that when clients like Relay need to fetch the "cursor" field on
931
      the edge to enable efficient pagination, this shortcut cannot be used, and the
932
      full "{ edges { node } }" version should be used instead.
933
      """
934
      films: [Film]
935
    }
936

937
    """An edge in a connection."""
938
    type StarshipFilmsEdge {
939
      """The item at the end of the edge"""
940
      node: Film
941

942
      """A cursor for use in pagination"""
943
      cursor: String!
944
    }
945

946
    """A connection to a list of items."""
947
    type StarshipPilotsConnection {
948
      """Information to aid in pagination."""
949
      pageInfo: PageInfo!
950

951
      """A list of edges."""
952
      edges: [StarshipPilotsEdge]
953

954
      """
955
      A count of the total number of objects in this connection, ignoring pagination.
956
      This allows a client to fetch the first five objects by passing "5" as the
957
      argument to "first", then fetch the total count so it could display "5 of 83",
958
      for example.
959
      """
960
      totalCount: Int
961

962
      """
963
      A list of all of the objects returned in the connection. This is a convenience
964
      field provided for quickly exploring the API; rather than querying for
965
      "{ edges { node } }" when no edge data is needed, this field can be be used
966
      instead. Note that when clients like Relay need to fetch the "cursor" field on
967
      the edge to enable efficient pagination, this shortcut cannot be used, and the
968
      full "{ edges { node } }" version should be used instead.
969
      """
970
      pilots: [Person]
971
    }
972

973
    """An edge in a connection."""
974
    type StarshipPilotsEdge {
975
      """The item at the end of the edge"""
976
      node: Person
977

978
      """A cursor for use in pagination"""
979
      cursor: String!
980
    }
981

982
    """A connection to a list of items."""
983
    type StarshipsConnection {
984
      """Information to aid in pagination."""
985
      pageInfo: PageInfo!
986

987
      """A list of edges."""
988
      edges: [StarshipsEdge]
989

990
      """
991
      A count of the total number of objects in this connection, ignoring pagination.
992
      This allows a client to fetch the first five objects by passing "5" as the
993
      argument to "first", then fetch the total count so it could display "5 of 83",
994
      for example.
995
      """
996
      totalCount: Int
997

998
      """
999
      A list of all of the objects returned in the connection. This is a convenience
1000
      field provided for quickly exploring the API; rather than querying for
1001
      "{ edges { node } }" when no edge data is needed, this field can be be used
1002
      instead. Note that when clients like Relay need to fetch the "cursor" field on
1003
      the edge to enable efficient pagination, this shortcut cannot be used, and the
1004
      full "{ edges { node } }" version should be used instead.
1005
      """
1006
      starships: [Starship]
1007
    }
1008

1009
    """An edge in a connection."""
1010
    type StarshipsEdge {
1011
      """The item at the end of the edge"""
1012
      node: Starship
1013

1014
      """A cursor for use in pagination"""
1015
      cursor: String!
1016
    }
1017

1018
    """A single transport craft that does not have hyperdrive capability"""
1019
    type Vehicle implements Node {
1020
      """
1021
      The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
1022
      bike".
1023
      """
1024
      name: String
1025

1026
      """
1027
      The model or official name of this vehicle. Such as "All-Terrain Attack
1028
      Transport".
1029
      """
1030
      model: String
1031

1032
      """The class of this vehicle, such as "Wheeled" or "Repulsorcraft"."""
1033
      vehicleClass: String
1034

1035
      """The manufacturers of this vehicle."""
1036
      manufacturers: [String]
1037

1038
      """The cost of this vehicle new, in Galactic Credits."""
1039
      costInCredits: Float
1040

1041
      """The length of this vehicle in meters."""
1042
      length: Float
1043

1044
      """The number of personnel needed to run or pilot this vehicle."""
1045
      crew: String
1046

1047
      """The number of non-essential people this vehicle can transport."""
1048
      passengers: String
1049

1050
      """The maximum speed of this vehicle in atmosphere."""
1051
      maxAtmospheringSpeed: Int
1052

1053
      """The maximum number of kilograms that this vehicle can transport."""
1054
      cargoCapacity: Float
1055

1056
      """
1057
      The maximum length of time that this vehicle can provide consumables for its
1058
      entire crew without having to resupply.
1059
      """
1060
      consumables: String
1061
      pilotConnection(after: String, first: Int, before: String, last: Int): VehiclePilotsConnection
1062
      filmConnection(after: String, first: Int, before: String, last: Int): VehicleFilmsConnection
1063

1064
      """The ISO 8601 date format of the time that this resource was created."""
1065
      created: String
1066

1067
      """The ISO 8601 date format of the time that this resource was edited."""
1068
      edited: String
1069

1070
      """The ID of an object"""
1071
      id: ID!
1072
    }
1073

1074
    """A connection to a list of items."""
1075
    type VehicleFilmsConnection {
1076
      """Information to aid in pagination."""
1077
      pageInfo: PageInfo!
1078

1079
      """A list of edges."""
1080
      edges: [VehicleFilmsEdge]
1081

1082
      """
1083
      A count of the total number of objects in this connection, ignoring pagination.
1084
      This allows a client to fetch the first five objects by passing "5" as the
1085
      argument to "first", then fetch the total count so it could display "5 of 83",
1086
      for example.
1087
      """
1088
      totalCount: Int
1089

1090
      """
1091
      A list of all of the objects returned in the connection. This is a convenience
1092
      field provided for quickly exploring the API; rather than querying for
1093
      "{ edges { node } }" when no edge data is needed, this field can be be used
1094
      instead. Note that when clients like Relay need to fetch the "cursor" field on
1095
      the edge to enable efficient pagination, this shortcut cannot be used, and the
1096
      full "{ edges { node } }" version should be used instead.
1097
      """
1098
      films: [Film]
1099
    }
1100

1101
    """An edge in a connection."""
1102
    type VehicleFilmsEdge {
1103
      """The item at the end of the edge"""
1104
      node: Film
1105

1106
      """A cursor for use in pagination"""
1107
      cursor: String!
1108
    }
1109

1110
    """A connection to a list of items."""
1111
    type VehiclePilotsConnection {
1112
      """Information to aid in pagination."""
1113
      pageInfo: PageInfo!
1114

1115
      """A list of edges."""
1116
      edges: [VehiclePilotsEdge]
1117

1118
      """
1119
      A count of the total number of objects in this connection, ignoring pagination.
1120
      This allows a client to fetch the first five objects by passing "5" as the
1121
      argument to "first", then fetch the total count so it could display "5 of 83",
1122
      for example.
1123
      """
1124
      totalCount: Int
1125

1126
      """
1127
      A list of all of the objects returned in the connection. This is a convenience
1128
      field provided for quickly exploring the API; rather than querying for
1129
      "{ edges { node } }" when no edge data is needed, this field can be be used
1130
      instead. Note that when clients like Relay need to fetch the "cursor" field on
1131
      the edge to enable efficient pagination, this shortcut cannot be used, and the
1132
      full "{ edges { node } }" version should be used instead.
1133
      """
1134
      pilots: [Person]
1135
    }
1136

1137
    """An edge in a connection."""
1138
    type VehiclePilotsEdge {
1139
      """The item at the end of the edge"""
1140
      node: Person
1141

1142
      """A cursor for use in pagination"""
1143
      cursor: String!
1144
    }
1145

1146
    """A connection to a list of items."""
1147
    type VehiclesConnection {
1148
      """Information to aid in pagination."""
1149
      pageInfo: PageInfo!
1150

1151
      """A list of edges."""
1152
      edges: [VehiclesEdge]
1153

1154
      """
1155
      A count of the total number of objects in this connection, ignoring pagination.
1156
      This allows a client to fetch the first five objects by passing "5" as the
1157
      argument to "first", then fetch the total count so it could display "5 of 83",
1158
      for example.
1159
      """
1160
      totalCount: Int
1161

1162
      """
1163
      A list of all of the objects returned in the connection. This is a convenience
1164
      field provided for quickly exploring the API; rather than querying for
1165
      "{ edges { node } }" when no edge data is needed, this field can be be used
1166
      instead. Note that when clients like Relay need to fetch the "cursor" field on
1167
      the edge to enable efficient pagination, this shortcut cannot be used, and the
1168
      full "{ edges { node } }" version should be used instead.
1169
      """
1170
      vehicles: [Vehicle]
1171
    }
1172

1173
    """An edge in a connection."""
1174
    type VehiclesEdge {
1175
      """The item at the end of the edge"""
1176
      node: Vehicle
1177

1178
      """A cursor for use in pagination"""
1179
      cursor: String!
1180
    }
1181