diff --git a/.changeset/shy-berries-shop.md b/.changeset/shy-berries-shop.md
new file mode 100644
index 00000000000..8fb21f26ba0
--- /dev/null
+++ b/.changeset/shy-berries-shop.md
@@ -0,0 +1,5 @@
+---
+'@graphql-codegen/client-preset': patch
+---
+
+Revert slimmer client preset output
diff --git a/dev-test/gql-tag-operations-masking/gql/graphql.ts b/dev-test/gql-tag-operations-masking/gql/graphql.ts
index 35f4d1f9485..750eb2d88cd 100644
--- a/dev-test/gql-tag-operations-masking/gql/graphql.ts
+++ b/dev-test/gql-tag-operations-masking/gql/graphql.ts
@@ -18,6 +18,95 @@ export type Scalars = {
   Url: { input: any; output: any };
 };
 
+export type Meta = {
+  __typename?: 'Meta';
+  count?: Maybe<Scalars['Int']['output']>;
+};
+
+export type Mutation = {
+  __typename?: 'Mutation';
+  createTweet?: Maybe<Tweet>;
+  deleteTweet?: Maybe<Tweet>;
+  markTweetRead?: Maybe<Scalars['Boolean']['output']>;
+};
+
+export type MutationCreateTweetArgs = {
+  body?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type MutationDeleteTweetArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type MutationMarkTweetReadArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type Notification = {
+  __typename?: 'Notification';
+  date?: Maybe<Scalars['Date']['output']>;
+  id?: Maybe<Scalars['ID']['output']>;
+  type?: Maybe<Scalars['String']['output']>;
+};
+
+export type Query = {
+  __typename?: 'Query';
+  Notifications?: Maybe<Array<Maybe<Notification>>>;
+  NotificationsMeta?: Maybe<Meta>;
+  Tweet?: Maybe<Tweet>;
+  Tweets?: Maybe<Array<Tweet>>;
+  TweetsMeta?: Maybe<Meta>;
+  User?: Maybe<User>;
+};
+
+export type QueryNotificationsArgs = {
+  limit?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type QueryTweetArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type QueryTweetsArgs = {
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  skip?: InputMaybe<Scalars['Int']['input']>;
+  sort_field?: InputMaybe<Scalars['String']['input']>;
+  sort_order?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type QueryUserArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type Stat = {
+  __typename?: 'Stat';
+  likes?: Maybe<Scalars['Int']['output']>;
+  responses?: Maybe<Scalars['Int']['output']>;
+  retweets?: Maybe<Scalars['Int']['output']>;
+  views?: Maybe<Scalars['Int']['output']>;
+};
+
+export type Tweet = {
+  __typename?: 'Tweet';
+  Stats?: Maybe<Stat>;
+  author: User;
+  body: Scalars['String']['output'];
+  date?: Maybe<Scalars['Date']['output']>;
+  id: Scalars['ID']['output'];
+};
+
+export type User = {
+  __typename?: 'User';
+  avatar_url?: Maybe<Scalars['Url']['output']>;
+  first_name?: Maybe<Scalars['String']['output']>;
+  full_name?: Maybe<Scalars['String']['output']>;
+  id: Scalars['ID']['output'];
+  last_name?: Maybe<Scalars['String']['output']>;
+  /** @deprecated Field no longer supported */
+  name?: Maybe<Scalars['String']['output']>;
+  username?: Maybe<Scalars['String']['output']>;
+};
+
 export type TweetFragmentFragment = ({ __typename?: 'Tweet'; id: string; body: string } & {
   ' $fragmentRefs'?: { TweetAuthorFragmentFragment: TweetAuthorFragmentFragment };
 }) & { ' $fragmentName'?: 'TweetFragmentFragment' };
diff --git a/dev-test/gql-tag-operations-urql/gql/graphql.ts b/dev-test/gql-tag-operations-urql/gql/graphql.ts
index 57a9d9536d6..bd2bb802314 100644
--- a/dev-test/gql-tag-operations-urql/gql/graphql.ts
+++ b/dev-test/gql-tag-operations-urql/gql/graphql.ts
@@ -18,6 +18,95 @@ export type Scalars = {
   Url: { input: any; output: any };
 };
 
+export type Meta = {
+  __typename?: 'Meta';
+  count?: Maybe<Scalars['Int']['output']>;
+};
+
+export type Mutation = {
+  __typename?: 'Mutation';
+  createTweet?: Maybe<Tweet>;
+  deleteTweet?: Maybe<Tweet>;
+  markTweetRead?: Maybe<Scalars['Boolean']['output']>;
+};
+
+export type MutationCreateTweetArgs = {
+  body?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type MutationDeleteTweetArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type MutationMarkTweetReadArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type Notification = {
+  __typename?: 'Notification';
+  date?: Maybe<Scalars['Date']['output']>;
+  id?: Maybe<Scalars['ID']['output']>;
+  type?: Maybe<Scalars['String']['output']>;
+};
+
+export type Query = {
+  __typename?: 'Query';
+  Notifications?: Maybe<Array<Maybe<Notification>>>;
+  NotificationsMeta?: Maybe<Meta>;
+  Tweet?: Maybe<Tweet>;
+  Tweets?: Maybe<Array<Maybe<Tweet>>>;
+  TweetsMeta?: Maybe<Meta>;
+  User?: Maybe<User>;
+};
+
+export type QueryNotificationsArgs = {
+  limit?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type QueryTweetArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type QueryTweetsArgs = {
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  skip?: InputMaybe<Scalars['Int']['input']>;
+  sort_field?: InputMaybe<Scalars['String']['input']>;
+  sort_order?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type QueryUserArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type Stat = {
+  __typename?: 'Stat';
+  likes?: Maybe<Scalars['Int']['output']>;
+  responses?: Maybe<Scalars['Int']['output']>;
+  retweets?: Maybe<Scalars['Int']['output']>;
+  views?: Maybe<Scalars['Int']['output']>;
+};
+
+export type Tweet = {
+  __typename?: 'Tweet';
+  Author?: Maybe<User>;
+  Stats?: Maybe<Stat>;
+  body?: Maybe<Scalars['String']['output']>;
+  date?: Maybe<Scalars['Date']['output']>;
+  id: Scalars['ID']['output'];
+};
+
+export type User = {
+  __typename?: 'User';
+  avatar_url?: Maybe<Scalars['Url']['output']>;
+  first_name?: Maybe<Scalars['String']['output']>;
+  full_name?: Maybe<Scalars['String']['output']>;
+  id: Scalars['ID']['output'];
+  last_name?: Maybe<Scalars['String']['output']>;
+  /** @deprecated Field no longer supported */
+  name?: Maybe<Scalars['String']['output']>;
+  username?: Maybe<Scalars['String']['output']>;
+};
+
 export type FooQueryVariables = Exact<{ [key: string]: never }>;
 
 export type FooQuery = { __typename?: 'Query'; Tweets?: Array<{ __typename?: 'Tweet'; id: string } | null> | null };
diff --git a/dev-test/gql-tag-operations/gql/graphql.ts b/dev-test/gql-tag-operations/gql/graphql.ts
index 57a9d9536d6..bd2bb802314 100644
--- a/dev-test/gql-tag-operations/gql/graphql.ts
+++ b/dev-test/gql-tag-operations/gql/graphql.ts
@@ -18,6 +18,95 @@ export type Scalars = {
   Url: { input: any; output: any };
 };
 
+export type Meta = {
+  __typename?: 'Meta';
+  count?: Maybe<Scalars['Int']['output']>;
+};
+
+export type Mutation = {
+  __typename?: 'Mutation';
+  createTweet?: Maybe<Tweet>;
+  deleteTweet?: Maybe<Tweet>;
+  markTweetRead?: Maybe<Scalars['Boolean']['output']>;
+};
+
+export type MutationCreateTweetArgs = {
+  body?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type MutationDeleteTweetArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type MutationMarkTweetReadArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type Notification = {
+  __typename?: 'Notification';
+  date?: Maybe<Scalars['Date']['output']>;
+  id?: Maybe<Scalars['ID']['output']>;
+  type?: Maybe<Scalars['String']['output']>;
+};
+
+export type Query = {
+  __typename?: 'Query';
+  Notifications?: Maybe<Array<Maybe<Notification>>>;
+  NotificationsMeta?: Maybe<Meta>;
+  Tweet?: Maybe<Tweet>;
+  Tweets?: Maybe<Array<Maybe<Tweet>>>;
+  TweetsMeta?: Maybe<Meta>;
+  User?: Maybe<User>;
+};
+
+export type QueryNotificationsArgs = {
+  limit?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type QueryTweetArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type QueryTweetsArgs = {
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  skip?: InputMaybe<Scalars['Int']['input']>;
+  sort_field?: InputMaybe<Scalars['String']['input']>;
+  sort_order?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type QueryUserArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type Stat = {
+  __typename?: 'Stat';
+  likes?: Maybe<Scalars['Int']['output']>;
+  responses?: Maybe<Scalars['Int']['output']>;
+  retweets?: Maybe<Scalars['Int']['output']>;
+  views?: Maybe<Scalars['Int']['output']>;
+};
+
+export type Tweet = {
+  __typename?: 'Tweet';
+  Author?: Maybe<User>;
+  Stats?: Maybe<Stat>;
+  body?: Maybe<Scalars['String']['output']>;
+  date?: Maybe<Scalars['Date']['output']>;
+  id: Scalars['ID']['output'];
+};
+
+export type User = {
+  __typename?: 'User';
+  avatar_url?: Maybe<Scalars['Url']['output']>;
+  first_name?: Maybe<Scalars['String']['output']>;
+  full_name?: Maybe<Scalars['String']['output']>;
+  id: Scalars['ID']['output'];
+  last_name?: Maybe<Scalars['String']['output']>;
+  /** @deprecated Field no longer supported */
+  name?: Maybe<Scalars['String']['output']>;
+  username?: Maybe<Scalars['String']['output']>;
+};
+
 export type FooQueryVariables = Exact<{ [key: string]: never }>;
 
 export type FooQuery = { __typename?: 'Query'; Tweets?: Array<{ __typename?: 'Tweet'; id: string } | null> | null };
diff --git a/dev-test/gql-tag-operations/graphql/graphql.ts b/dev-test/gql-tag-operations/graphql/graphql.ts
index 57a9d9536d6..bd2bb802314 100644
--- a/dev-test/gql-tag-operations/graphql/graphql.ts
+++ b/dev-test/gql-tag-operations/graphql/graphql.ts
@@ -18,6 +18,95 @@ export type Scalars = {
   Url: { input: any; output: any };
 };
 
+export type Meta = {
+  __typename?: 'Meta';
+  count?: Maybe<Scalars['Int']['output']>;
+};
+
+export type Mutation = {
+  __typename?: 'Mutation';
+  createTweet?: Maybe<Tweet>;
+  deleteTweet?: Maybe<Tweet>;
+  markTweetRead?: Maybe<Scalars['Boolean']['output']>;
+};
+
+export type MutationCreateTweetArgs = {
+  body?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type MutationDeleteTweetArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type MutationMarkTweetReadArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type Notification = {
+  __typename?: 'Notification';
+  date?: Maybe<Scalars['Date']['output']>;
+  id?: Maybe<Scalars['ID']['output']>;
+  type?: Maybe<Scalars['String']['output']>;
+};
+
+export type Query = {
+  __typename?: 'Query';
+  Notifications?: Maybe<Array<Maybe<Notification>>>;
+  NotificationsMeta?: Maybe<Meta>;
+  Tweet?: Maybe<Tweet>;
+  Tweets?: Maybe<Array<Maybe<Tweet>>>;
+  TweetsMeta?: Maybe<Meta>;
+  User?: Maybe<User>;
+};
+
+export type QueryNotificationsArgs = {
+  limit?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type QueryTweetArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type QueryTweetsArgs = {
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  skip?: InputMaybe<Scalars['Int']['input']>;
+  sort_field?: InputMaybe<Scalars['String']['input']>;
+  sort_order?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type QueryUserArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type Stat = {
+  __typename?: 'Stat';
+  likes?: Maybe<Scalars['Int']['output']>;
+  responses?: Maybe<Scalars['Int']['output']>;
+  retweets?: Maybe<Scalars['Int']['output']>;
+  views?: Maybe<Scalars['Int']['output']>;
+};
+
+export type Tweet = {
+  __typename?: 'Tweet';
+  Author?: Maybe<User>;
+  Stats?: Maybe<Stat>;
+  body?: Maybe<Scalars['String']['output']>;
+  date?: Maybe<Scalars['Date']['output']>;
+  id: Scalars['ID']['output'];
+};
+
+export type User = {
+  __typename?: 'User';
+  avatar_url?: Maybe<Scalars['Url']['output']>;
+  first_name?: Maybe<Scalars['String']['output']>;
+  full_name?: Maybe<Scalars['String']['output']>;
+  id: Scalars['ID']['output'];
+  last_name?: Maybe<Scalars['String']['output']>;
+  /** @deprecated Field no longer supported */
+  name?: Maybe<Scalars['String']['output']>;
+  username?: Maybe<Scalars['String']['output']>;
+};
+
 export type FooQueryVariables = Exact<{ [key: string]: never }>;
 
 export type FooQuery = { __typename?: 'Query'; Tweets?: Array<{ __typename?: 'Tweet'; id: string } | null> | null };
diff --git a/examples/persisted-documents-string-mode/src/gql/graphql.ts b/examples/persisted-documents-string-mode/src/gql/graphql.ts
index 674ba29a226..25761327758 100644
--- a/examples/persisted-documents-string-mode/src/gql/graphql.ts
+++ b/examples/persisted-documents-string-mode/src/gql/graphql.ts
@@ -16,6 +16,20 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+export type Mutation = {
+  __typename?: 'Mutation';
+  echo: Scalars['String']['output'];
+};
+
+export type MutationEchoArgs = {
+  message: Scalars['String']['input'];
+};
+
+export type Query = {
+  __typename?: 'Query';
+  hello: Scalars['String']['output'];
+};
+
 export type HelloQueryQueryVariables = Exact<{ [key: string]: never }>;
 
 export type HelloQueryQuery = { __typename?: 'Query'; hello: string };
diff --git a/examples/persisted-documents/src/gql/graphql.ts b/examples/persisted-documents/src/gql/graphql.ts
index 8c3a2fb892d..6b7a4ca84f4 100644
--- a/examples/persisted-documents/src/gql/graphql.ts
+++ b/examples/persisted-documents/src/gql/graphql.ts
@@ -16,6 +16,20 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+export type Mutation = {
+  __typename?: 'Mutation';
+  echo: Scalars['String']['output'];
+};
+
+export type MutationEchoArgs = {
+  message: Scalars['String']['input'];
+};
+
+export type Query = {
+  __typename?: 'Query';
+  hello: Scalars['String']['output'];
+};
+
 export type HelloQueryQueryVariables = Exact<{ [key: string]: never }>;
 
 export type HelloQueryQuery = { __typename?: 'Query'; hello: string };
diff --git a/examples/react/apollo-client-defer/src/gql/graphql.ts b/examples/react/apollo-client-defer/src/gql/graphql.ts
index d37b8ab60be..990b301a152 100644
--- a/examples/react/apollo-client-defer/src/gql/graphql.ts
+++ b/examples/react/apollo-client-defer/src/gql/graphql.ts
@@ -16,6 +16,22 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+export type Query = {
+  __typename?: 'Query';
+  alphabet: Array<Scalars['String']['output']>;
+  /** A field that resolves fast. */
+  fastField: Scalars['String']['output'];
+  /**
+   * A field that resolves slowly.
+   * Maybe you want to @defer this field ;)
+   */
+  slowField: Scalars['String']['output'];
+};
+
+export type QuerySlowFieldArgs = {
+  waitFor?: Scalars['Int']['input'];
+};
+
 export type SlowFieldFragmentFragment = { __typename?: 'Query'; slowField: string } & {
   ' $fragmentName'?: 'SlowFieldFragmentFragment';
 };
diff --git a/examples/react/apollo-client-swc-plugin/src/gql/graphql.ts b/examples/react/apollo-client-swc-plugin/src/gql/graphql.ts
index e1ec3945bdd..08a4e82ceef 100644
--- a/examples/react/apollo-client-swc-plugin/src/gql/graphql.ts
+++ b/examples/react/apollo-client-swc-plugin/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllFilmsWithVariablesQueryQueryVariables = Exact<{
   first: Scalars['Int']['input'];
 }>;
diff --git a/examples/react/apollo-client/src/gql/graphql.ts b/examples/react/apollo-client/src/gql/graphql.ts
index e1ec3945bdd..08a4e82ceef 100644
--- a/examples/react/apollo-client/src/gql/graphql.ts
+++ b/examples/react/apollo-client/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllFilmsWithVariablesQueryQueryVariables = Exact<{
   first: Scalars['Int']['input'];
 }>;
diff --git a/examples/react/http-executor/src/gql/graphql.ts b/examples/react/http-executor/src/gql/graphql.ts
index e1ec3945bdd..08a4e82ceef 100644
--- a/examples/react/http-executor/src/gql/graphql.ts
+++ b/examples/react/http-executor/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllFilmsWithVariablesQueryQueryVariables = Exact<{
   first: Scalars['Int']['input'];
 }>;
diff --git a/examples/react/nextjs-swr/gql/graphql.ts b/examples/react/nextjs-swr/gql/graphql.ts
index 79331d3022d..98a06071016 100644
--- a/examples/react/nextjs-swr/gql/graphql.ts
+++ b/examples/react/nextjs-swr/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type FilmItemFragment = {
   __typename?: 'Film';
   id: string;
diff --git a/examples/react/tanstack-react-query/src/gql/graphql.ts b/examples/react/tanstack-react-query/src/gql/graphql.ts
index 6c7767d51ce..9a58befacc3 100644
--- a/examples/react/tanstack-react-query/src/gql/graphql.ts
+++ b/examples/react/tanstack-react-query/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllFilmsWithVariablesQueryQueryVariables = Exact<{
   first: Scalars['Int']['input'];
 }>;
diff --git a/examples/react/urql/src/gql/graphql.ts b/examples/react/urql/src/gql/graphql.ts
index 6eba06af517..13e37915712 100644
--- a/examples/react/urql/src/gql/graphql.ts
+++ b/examples/react/urql/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllFilmsWithVariablesQuery199QueryVariables = Exact<{
   first: Scalars['Int']['input'];
 }>;
diff --git a/examples/typescript-esm/src/gql/graphql.ts b/examples/typescript-esm/src/gql/graphql.ts
index 963a3da971c..c3de60651c9 100644
--- a/examples/typescript-esm/src/gql/graphql.ts
+++ b/examples/typescript-esm/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllPeopleQueryQueryVariables = Exact<{ [key: string]: never }>;
 
 export type AllPeopleQueryQuery = {
diff --git a/examples/typescript-graphql-request/src/gql/graphql.ts b/examples/typescript-graphql-request/src/gql/graphql.ts
index ee1fba17f9a..597280822a8 100644
--- a/examples/typescript-graphql-request/src/gql/graphql.ts
+++ b/examples/typescript-graphql-request/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllPeopleQueryQueryVariables = Exact<{ [key: string]: never }>;
 
 export type AllPeopleQueryQuery = {
diff --git a/examples/vite/vite-react-cts/src/gql/graphql.ts b/examples/vite/vite-react-cts/src/gql/graphql.ts
index 79331d3022d..98a06071016 100644
--- a/examples/vite/vite-react-cts/src/gql/graphql.ts
+++ b/examples/vite/vite-react-cts/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type FilmItemFragment = {
   __typename?: 'Film';
   id: string;
diff --git a/examples/vite/vite-react-mts/src/gql/graphql.ts b/examples/vite/vite-react-mts/src/gql/graphql.ts
index 79331d3022d..98a06071016 100644
--- a/examples/vite/vite-react-mts/src/gql/graphql.ts
+++ b/examples/vite/vite-react-mts/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type FilmItemFragment = {
   __typename?: 'Film';
   id: string;
diff --git a/examples/vite/vite-react-ts/src/gql/graphql.ts b/examples/vite/vite-react-ts/src/gql/graphql.ts
index 79331d3022d..98a06071016 100644
--- a/examples/vite/vite-react-ts/src/gql/graphql.ts
+++ b/examples/vite/vite-react-ts/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type FilmItemFragment = {
   __typename?: 'Film';
   id: string;
diff --git a/examples/vue/apollo-composable/src/gql/graphql.ts b/examples/vue/apollo-composable/src/gql/graphql.ts
index 3bf2569b1a2..1826496b745 100644
--- a/examples/vue/apollo-composable/src/gql/graphql.ts
+++ b/examples/vue/apollo-composable/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllFilmsWithVariablesQueryQueryVariables = Exact<{
   first: Scalars['Int']['input'];
 }>;
diff --git a/examples/vue/urql/src/gql/graphql.ts b/examples/vue/urql/src/gql/graphql.ts
index 3bf2569b1a2..1826496b745 100644
--- a/examples/vue/urql/src/gql/graphql.ts
+++ b/examples/vue/urql/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllFilmsWithVariablesQueryQueryVariables = Exact<{
   first: Scalars['Int']['input'];
 }>;
diff --git a/examples/vue/villus/src/gql/graphql.ts b/examples/vue/villus/src/gql/graphql.ts
index 3bf2569b1a2..1826496b745 100644
--- a/examples/vue/villus/src/gql/graphql.ts
+++ b/examples/vue/villus/src/gql/graphql.ts
@@ -16,6 +16,1265 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+/** A single film. */
+export type Film = Node & {
+  __typename?: 'Film';
+  characterConnection?: Maybe<FilmCharactersConnection>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The name of the director of this film. */
+  director?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /** The episode number of this film. */
+  episodeID?: Maybe<Scalars['Int']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The opening paragraphs at the beginning of this film. */
+  openingCrawl?: Maybe<Scalars['String']['output']>;
+  planetConnection?: Maybe<FilmPlanetsConnection>;
+  /** The name(s) of the producer(s) of this film. */
+  producers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of film release at original creator country. */
+  releaseDate?: Maybe<Scalars['String']['output']>;
+  speciesConnection?: Maybe<FilmSpeciesConnection>;
+  starshipConnection?: Maybe<FilmStarshipsConnection>;
+  /** The title of this film. */
+  title?: Maybe<Scalars['String']['output']>;
+  vehicleConnection?: Maybe<FilmVehiclesConnection>;
+};
+
+/** A single film. */
+export type FilmCharacterConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmPlanetConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmSpeciesConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single film. */
+export type FilmVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type FilmCharactersConnection = {
+  __typename?: 'FilmCharactersConnection';
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  characters?: Maybe<Array<Maybe<Person>>>;
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmCharactersEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmCharactersEdge = {
+  __typename?: 'FilmCharactersEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type FilmPlanetsConnection = {
+  __typename?: 'FilmPlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmPlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmPlanetsEdge = {
+  __typename?: 'FilmPlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+/** A connection to a list of items. */
+export type FilmSpeciesConnection = {
+  __typename?: 'FilmSpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmSpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmSpeciesEdge = {
+  __typename?: 'FilmSpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type FilmStarshipsConnection = {
+  __typename?: 'FilmStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmStarshipsEdge = {
+  __typename?: 'FilmStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type FilmVehiclesConnection = {
+  __typename?: 'FilmVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type FilmVehiclesEdge = {
+  __typename?: 'FilmVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/** A connection to a list of items. */
+export type FilmsConnection = {
+  __typename?: 'FilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<FilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type FilmsEdge = {
+  __typename?: 'FilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** An object with an ID */
+export type Node = {
+  /** The id of the object. */
+  id: Scalars['ID']['output'];
+};
+
+/** Information about pagination in a connection. */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** A connection to a list of items. */
+export type PeopleConnection = {
+  __typename?: 'PeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PeopleEdge = {
+  __typename?: 'PeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type Person = Node & {
+  __typename?: 'Person';
+  /**
+   * The birth year of the person, using the in-universe standard of BBY or ABY -
+   * Before the Battle of Yavin or After the Battle of Yavin. The Battle of Yavin is
+   * a battle that occurs at the end of Star Wars episode IV: A New Hope.
+   */
+  birthYear?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * The eye color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have an eye.
+   */
+  eyeColor?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PersonFilmsConnection>;
+  /**
+   * The gender of this person. Either "Male", "Female" or "unknown",
+   * "n/a" if the person does not have a gender.
+   */
+  gender?: Maybe<Scalars['String']['output']>;
+  /**
+   * The hair color of this person. Will be "unknown" if not known or "n/a" if the
+   * person does not have hair.
+   */
+  hairColor?: Maybe<Scalars['String']['output']>;
+  /** The height of the person in centimeters. */
+  height?: Maybe<Scalars['Int']['output']>;
+  /** A planet that this person was born on or inhabits. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The mass of the person in kilograms. */
+  mass?: Maybe<Scalars['Float']['output']>;
+  /** The name of this person. */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The skin color of this person. */
+  skinColor?: Maybe<Scalars['String']['output']>;
+  /** The species that this person belongs to, or null if unknown. */
+  species?: Maybe<Species>;
+  starshipConnection?: Maybe<PersonStarshipsConnection>;
+  vehicleConnection?: Maybe<PersonVehiclesConnection>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonStarshipConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** An individual person or character within the Star Wars universe. */
+export type PersonVehicleConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PersonFilmsConnection = {
+  __typename?: 'PersonFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonFilmsEdge = {
+  __typename?: 'PersonFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PersonStarshipsConnection = {
+  __typename?: 'PersonStarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonStarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PersonStarshipsEdge = {
+  __typename?: 'PersonStarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A connection to a list of items. */
+export type PersonVehiclesConnection = {
+  __typename?: 'PersonVehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PersonVehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type PersonVehiclesEdge = {
+  __typename?: 'PersonVehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type Planet = Node & {
+  __typename?: 'Planet';
+  /** The climates of this planet. */
+  climates?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The diameter of this planet in kilometers. */
+  diameter?: Maybe<Scalars['Int']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<PlanetFilmsConnection>;
+  /**
+   * A number denoting the gravity of this planet, where "1" is normal or 1 standard
+   * G. "2" is twice or 2 standard Gs. "0.5" is half or 0.5 standard Gs.
+   */
+  gravity?: Maybe<Scalars['String']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The name of this planet. */
+  name?: Maybe<Scalars['String']['output']>;
+  /**
+   * The number of standard days it takes for this planet to complete a single orbit
+   * of its local star.
+   */
+  orbitalPeriod?: Maybe<Scalars['Int']['output']>;
+  /** The average population of sentient beings inhabiting this planet. */
+  population?: Maybe<Scalars['Float']['output']>;
+  residentConnection?: Maybe<PlanetResidentsConnection>;
+  /**
+   * The number of standard hours it takes for this planet to complete a single
+   * rotation on its axis.
+   */
+  rotationPeriod?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The percentage of the planet surface that is naturally occurring water or bodies
+   * of water.
+   */
+  surfaceWater?: Maybe<Scalars['Float']['output']>;
+  /** The terrains of this planet. */
+  terrains?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/**
+ * A large mass, planet or planetoid in the Star Wars Universe, at the time of
+ * 0 ABY.
+ */
+export type PlanetResidentConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type PlanetFilmsConnection = {
+  __typename?: 'PlanetFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetFilmsEdge = {
+  __typename?: 'PlanetFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type PlanetResidentsConnection = {
+  __typename?: 'PlanetResidentsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetResidentsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  residents?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetResidentsEdge = {
+  __typename?: 'PlanetResidentsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type PlanetsConnection = {
+  __typename?: 'PlanetsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<PlanetsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  planets?: Maybe<Array<Maybe<Planet>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type PlanetsEdge = {
+  __typename?: 'PlanetsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Planet>;
+};
+
+export type Root = {
+  __typename?: 'Root';
+  allFilms?: Maybe<FilmsConnection>;
+  allPeople?: Maybe<PeopleConnection>;
+  allPlanets?: Maybe<PlanetsConnection>;
+  allSpecies?: Maybe<SpeciesConnection>;
+  allStarships?: Maybe<StarshipsConnection>;
+  allVehicles?: Maybe<VehiclesConnection>;
+  film?: Maybe<Film>;
+  /** Fetches an object given its ID */
+  node?: Maybe<Node>;
+  person?: Maybe<Person>;
+  planet?: Maybe<Planet>;
+  species?: Maybe<Species>;
+  starship?: Maybe<Starship>;
+  vehicle?: Maybe<Vehicle>;
+};
+
+export type RootAllFilmsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPeopleArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllPlanetsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllSpeciesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllStarshipsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootAllVehiclesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type RootFilmArgs = {
+  filmID?: InputMaybe<Scalars['ID']['input']>;
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootNodeArgs = {
+  id: Scalars['ID']['input'];
+};
+
+export type RootPersonArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  personID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootPlanetArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  planetID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootSpeciesArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  speciesID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootStarshipArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  starshipID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type RootVehicleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  vehicleID?: InputMaybe<Scalars['ID']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type Species = Node & {
+  __typename?: 'Species';
+  /** The average height of this species in centimeters. */
+  averageHeight?: Maybe<Scalars['Float']['output']>;
+  /** The average lifespan of this species in years, null if unknown. */
+  averageLifespan?: Maybe<Scalars['Int']['output']>;
+  /** The classification of this species, such as "mammal" or "reptile". */
+  classification?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The designation of this species, such as "sentient". */
+  designation?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  /**
+   * Common eye colors for this species, null if this species does not typically
+   * have eyes.
+   */
+  eyeColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  filmConnection?: Maybe<SpeciesFilmsConnection>;
+  /**
+   * Common hair colors for this species, null if this species does not typically
+   * have hair.
+   */
+  hairColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** A planet that this species originates from. */
+  homeworld?: Maybe<Planet>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The language commonly spoken by this species. */
+  language?: Maybe<Scalars['String']['output']>;
+  /** The name of this species. */
+  name?: Maybe<Scalars['String']['output']>;
+  personConnection?: Maybe<SpeciesPeopleConnection>;
+  /**
+   * Common skin colors for this species, null if this species does not typically
+   * have skin.
+   */
+  skinColors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A type of person or character within the Star Wars Universe. */
+export type SpeciesPersonConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesConnection = {
+  __typename?: 'SpeciesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  species?: Maybe<Array<Maybe<Species>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesEdge = {
+  __typename?: 'SpeciesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Species>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesFilmsConnection = {
+  __typename?: 'SpeciesFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesFilmsEdge = {
+  __typename?: 'SpeciesFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type SpeciesPeopleConnection = {
+  __typename?: 'SpeciesPeopleConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<SpeciesPeopleEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  people?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type SpeciesPeopleEdge = {
+  __typename?: 'SpeciesPeopleEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type Starship = Node & {
+  __typename?: 'Starship';
+  /**
+   * The Maximum number of Megalights this starship can travel in a standard hour.
+   * A "Megalight" is a standard unit of distance and has never been defined before
+   * within the Star Wars universe. This figure is only really useful for measuring
+   * the difference in speed of starships. We can assume it is similar to AU, the
+   * distance between our Sun (Sol) and Earth.
+   */
+  MGLT?: Maybe<Scalars['Int']['output']>;
+  /** The maximum number of kilograms that this starship can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this starship can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this starship new, in galactic credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this starship. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<StarshipFilmsConnection>;
+  /** The class of this starships hyperdrive. */
+  hyperdriveRating?: Maybe<Scalars['Float']['output']>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this starship in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this starship. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /**
+   * The maximum speed of this starship in atmosphere. null if this starship is
+   * incapable of atmosphering flight.
+   */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this starship. Such as "T-65 X-wing" or "DS-1
+   * Orbital Battle Station".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /** The name of this starship. The common name, such as "Death Star". */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this starship can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<StarshipPilotsConnection>;
+  /**
+   * The class of this starship, such as "Starfighter" or "Deep Space Mobile
+   * Battlestation"
+   */
+  starshipClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that has hyperdrive capability. */
+export type StarshipPilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type StarshipFilmsConnection = {
+  __typename?: 'StarshipFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipFilmsEdge = {
+  __typename?: 'StarshipFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type StarshipPilotsConnection = {
+  __typename?: 'StarshipPilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipPilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipPilotsEdge = {
+  __typename?: 'StarshipPilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type StarshipsConnection = {
+  __typename?: 'StarshipsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<StarshipsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  starships?: Maybe<Array<Maybe<Starship>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type StarshipsEdge = {
+  __typename?: 'StarshipsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Starship>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type Vehicle = Node & {
+  __typename?: 'Vehicle';
+  /** The maximum number of kilograms that this vehicle can transport. */
+  cargoCapacity?: Maybe<Scalars['Float']['output']>;
+  /**
+   * The maximum length of time that this vehicle can provide consumables for its
+   * entire crew without having to resupply.
+   */
+  consumables?: Maybe<Scalars['String']['output']>;
+  /** The cost of this vehicle new, in Galactic Credits. */
+  costInCredits?: Maybe<Scalars['Float']['output']>;
+  /** The ISO 8601 date format of the time that this resource was created. */
+  created?: Maybe<Scalars['String']['output']>;
+  /** The number of personnel needed to run or pilot this vehicle. */
+  crew?: Maybe<Scalars['String']['output']>;
+  /** The ISO 8601 date format of the time that this resource was edited. */
+  edited?: Maybe<Scalars['String']['output']>;
+  filmConnection?: Maybe<VehicleFilmsConnection>;
+  /** The ID of an object */
+  id: Scalars['ID']['output'];
+  /** The length of this vehicle in meters. */
+  length?: Maybe<Scalars['Float']['output']>;
+  /** The manufacturers of this vehicle. */
+  manufacturers?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  /** The maximum speed of this vehicle in atmosphere. */
+  maxAtmospheringSpeed?: Maybe<Scalars['Int']['output']>;
+  /**
+   * The model or official name of this vehicle. Such as "All-Terrain Attack
+   * Transport".
+   */
+  model?: Maybe<Scalars['String']['output']>;
+  /**
+   * The name of this vehicle. The common name, such as "Sand Crawler" or "Speeder
+   * bike".
+   */
+  name?: Maybe<Scalars['String']['output']>;
+  /** The number of non-essential people this vehicle can transport. */
+  passengers?: Maybe<Scalars['String']['output']>;
+  pilotConnection?: Maybe<VehiclePilotsConnection>;
+  /** The class of this vehicle, such as "Wheeled" or "Repulsorcraft". */
+  vehicleClass?: Maybe<Scalars['String']['output']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehicleFilmConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A single transport craft that does not have hyperdrive capability */
+export type VehiclePilotConnectionArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+/** A connection to a list of items. */
+export type VehicleFilmsConnection = {
+  __typename?: 'VehicleFilmsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehicleFilmsEdge>>>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  films?: Maybe<Array<Maybe<Film>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehicleFilmsEdge = {
+  __typename?: 'VehicleFilmsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Film>;
+};
+
+/** A connection to a list of items. */
+export type VehiclePilotsConnection = {
+  __typename?: 'VehiclePilotsConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclePilotsEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  pilots?: Maybe<Array<Maybe<Person>>>;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+};
+
+/** An edge in a connection. */
+export type VehiclePilotsEdge = {
+  __typename?: 'VehiclePilotsEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Person>;
+};
+
+/** A connection to a list of items. */
+export type VehiclesConnection = {
+  __typename?: 'VehiclesConnection';
+  /** A list of edges. */
+  edges?: Maybe<Array<Maybe<VehiclesEdge>>>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  /**
+   * A count of the total number of objects in this connection, ignoring pagination.
+   * This allows a client to fetch the first five objects by passing "5" as the
+   * argument to "first", then fetch the total count so it could display "5 of 83",
+   * for example.
+   */
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  /**
+   * A list of all of the objects returned in the connection. This is a convenience
+   * field provided for quickly exploring the API; rather than querying for
+   * "{ edges { node } }" when no edge data is needed, this field can be be used
+   * instead. Note that when clients like Relay need to fetch the "cursor" field on
+   * the edge to enable efficient pagination, this shortcut cannot be used, and the
+   * full "{ edges { node } }" version should be used instead.
+   */
+  vehicles?: Maybe<Array<Maybe<Vehicle>>>;
+};
+
+/** An edge in a connection. */
+export type VehiclesEdge = {
+  __typename?: 'VehiclesEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node?: Maybe<Vehicle>;
+};
+
 export type AllFilmsWithVariablesQueryQueryVariables = Exact<{
   first: Scalars['Int']['input'];
 }>;
diff --git a/examples/yoga-tests/src/gql/graphql.ts b/examples/yoga-tests/src/gql/graphql.ts
index f23b3bc92f3..db6761f132f 100644
--- a/examples/yoga-tests/src/gql/graphql.ts
+++ b/examples/yoga-tests/src/gql/graphql.ts
@@ -16,6 +16,20 @@ export type Scalars = {
   Float: { input: number; output: number };
 };
 
+export type Mutation = {
+  __typename?: 'Mutation';
+  echo: Scalars['String']['output'];
+};
+
+export type MutationEchoArgs = {
+  message: Scalars['String']['input'];
+};
+
+export type Query = {
+  __typename?: 'Query';
+  hello: Scalars['String']['output'];
+};
+
 export type HelloQueryQueryVariables = Exact<{ [key: string]: never }>;
 
 export type HelloQueryQuery = { __typename?: 'Query'; hello: string };
diff --git a/packages/presets/client/src/index.ts b/packages/presets/client/src/index.ts
index 8765e013e8a..81c492b2578 100644
--- a/packages/presets/client/src/index.ts
+++ b/packages/presets/client/src/index.ts
@@ -212,12 +212,7 @@ export const preset: Types.OutputPreset<ClientPresetConfig> = {
 
     const plugins: Array<Types.ConfiguredPlugin> = [
       { [`add`]: { content: `/* eslint-disable */` } },
-      {
-        [`typescript`]: {
-          onlyEnumTypes: true,
-          onlyOperationTypes: true,
-        },
-      },
+      { [`typescript`]: {} },
       { [`typescript-operations`]: {} },
       {
         [`typed-document-node`]: {
diff --git a/packages/presets/client/tests/client-preset.spec.ts b/packages/presets/client/tests/client-preset.spec.ts
index 7a4ba647911..08316aa3433 100644
--- a/packages/presets/client/tests/client-preset.spec.ts
+++ b/packages/presets/client/tests/client-preset.spec.ts
@@ -359,6 +359,13 @@ export * from "./gql";`);
         Float: { input: number; output: number; }
       };
 
+      export type Query = {
+        __typename?: 'Query';
+        a?: Maybe<Scalars['String']['output']>;
+        b?: Maybe<Scalars['String']['output']>;
+        c?: Maybe<Scalars['String']['output']>;
+      };
+
       export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -483,6 +490,13 @@ export * from "./gql";`);
         Float: { input: number; output: number; }
       };
 
+      export type Query = {
+        __typename: 'Query';
+        a?: Maybe<Scalars['String']['output']>;
+        b?: Maybe<Scalars['String']['output']>;
+        c?: Maybe<Scalars['String']['output']>;
+      };
+
       export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -500,7 +514,7 @@ export * from "./gql";`);
       export const BDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"B"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"b"}}]}}]} as unknown as DocumentNode<BQuery, BQueryVariables>;"
     `);
 
-    expect(graphqlFile.content).toContain("__typename: 'Query',");
+    expect(graphqlFile.content).toContain("__typename: 'Query';");
   });
 
   it('prevent duplicate operations', async () => {
@@ -590,6 +604,11 @@ export * from "./gql";`);
         Float: { input: number; output: number; }
       };
 
+      export type Query = {
+        __typename?: 'Query';
+        a?: Maybe<Scalars['String']['output']>;
+      };
+
       export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1281,6 +1300,13 @@ export * from "./gql.js";`);
         Float: { input: number; output: number; }
       };
 
+      export type Query = {
+        __typename?: 'Query';
+        a?: Maybe<Scalars['String']['output']>;
+        b?: Maybe<Scalars['String']['output']>;
+        c?: Maybe<Scalars['String']['output']>;
+      };
+
       export type BbbQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1352,6 +1378,13 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Query = {
+          __typename?: 'Query';
+          a?: Maybe<Scalars['String']['output']>;
+          b?: Maybe<Scalars['String']['output']>;
+          c?: Maybe<Scalars['String']['output']>;
+        };
+
         export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1426,6 +1459,13 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Query = {
+          __typename?: 'Query';
+          a?: Maybe<Scalars['String']['output']>;
+          b?: Maybe<Scalars['String']['output']>;
+          c?: Maybe<Scalars['String']['output']>;
+        };
+
         export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1500,6 +1540,13 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Query = {
+          __typename?: 'Query';
+          a?: Maybe<Scalars['String']['output']>;
+          b?: Maybe<Scalars['String']['output']>;
+          c?: Maybe<Scalars['String']['output']>;
+        };
+
         export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1576,6 +1623,13 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Query = {
+          __typename?: 'Query';
+          a?: Maybe<Scalars['String']['output']>;
+          b?: Maybe<Scalars['String']['output']>;
+          c?: Maybe<Scalars['String']['output']>;
+        };
+
         export type AaaQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1648,6 +1702,13 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Query = {
+          __typename?: 'Query';
+          a?: Maybe<Scalars['String']['output']>;
+          b?: Maybe<Scalars['String']['output']>;
+          c?: Maybe<Scalars['String']['output']>;
+        };
+
         export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1726,6 +1787,13 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Query = {
+          __typename?: 'Query';
+          a?: Maybe<Scalars['String']['output']>;
+          b?: Maybe<Scalars['String']['output']>;
+          c?: Maybe<Scalars['String']['output']>;
+        };
+
         export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1805,6 +1873,13 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Query = {
+          __typename?: 'Query';
+          a?: Maybe<Scalars['String']['output']>;
+          b?: Maybe<Scalars['String']['output']>;
+          c?: Maybe<Scalars['String']['output']>;
+        };
+
         export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1884,6 +1959,13 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Query = {
+          __typename?: 'Query';
+          a?: Maybe<Scalars['String']['output']>;
+          b?: Maybe<Scalars['String']['output']>;
+          c?: Maybe<Scalars['String']['output']>;
+        };
+
         export type AQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -1969,6 +2051,17 @@ export * from "./gql.js";`);
         Float: { input: number; output: number; }
       };
 
+      export type A = {
+        __typename?: 'A';
+        a: A;
+        b: Scalars['String']['output'];
+      };
+
+      export type Query = {
+        __typename?: 'Query';
+        a: A;
+      };
+
       export type AbFragment = (
         { __typename?: 'A', b: string }
         & { ' $fragmentRefs'?: { 'AcFragment': AcFragment;'AaFragment': AaFragment } }
@@ -2037,6 +2130,18 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Foo = {
+          __typename?: 'Foo';
+          id?: Maybe<Scalars['String']['output']>;
+          value?: Maybe<Scalars['String']['output']>;
+        };
+
+        export type Query = {
+          __typename?: 'Query';
+          foo?: Maybe<Foo>;
+          foos?: Maybe<Array<Maybe<Foo>>>;
+        };
+
         export type FooQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -2110,6 +2215,18 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Foo = {
+          __typename?: 'Foo';
+          id?: Maybe<Scalars['String']['output']>;
+          value?: Maybe<Scalars['String']['output']>;
+        };
+
+        export type Query = {
+          __typename?: 'Query';
+          foo?: Maybe<Foo>;
+          foos?: Maybe<Array<Maybe<Foo>>>;
+        };
+
         export type FooQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -2183,6 +2300,18 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Foo = {
+          __typename?: 'Foo';
+          id?: Maybe<Scalars['String']['output']>;
+          value?: Maybe<Scalars['String']['output']>;
+        };
+
+        export type Query = {
+          __typename?: 'Query';
+          foo?: Maybe<Foo>;
+          foos?: Maybe<Array<Maybe<Foo>>>;
+        };
+
         export type FooQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -2312,6 +2441,18 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Foo = {
+          __typename?: 'Foo';
+          id?: Maybe<Scalars['String']['output']>;
+          value?: Maybe<Scalars['String']['output']>;
+        };
+
+        export type Query = {
+          __typename?: 'Query';
+          foo?: Maybe<Foo>;
+          foos?: Maybe<Array<Maybe<Foo>>>;
+        };
+
         export type FooQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -2439,6 +2580,17 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Foo = {
+          __typename?: 'Foo';
+          value?: Maybe<Scalars['String']['output']>;
+        };
+
+        export type Query = {
+          __typename?: 'Query';
+          foo?: Maybe<Foo>;
+          foos?: Maybe<Array<Maybe<Foo>>>;
+        };
+
         export type FooQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -2716,6 +2868,32 @@ export * from "./gql.js";`);
           Float: { input: number; output: number; }
         };
 
+        export type Mutation = {
+          __typename?: 'Mutation';
+          createRegion?: Maybe<Region>;
+        };
+
+
+        export type MutationCreateRegionArgs = {
+          regionDescription: Scalars['String']['input'];
+        };
+
+        export type Query = {
+          __typename?: 'Query';
+          regions?: Maybe<Array<Maybe<Region>>>;
+        };
+
+        export type Region = {
+          __typename?: 'Region';
+          regionDescription: Scalars['String']['output'];
+          regionId: Scalars['Int']['output'];
+        };
+
+        export type Subscription = {
+          __typename?: 'Subscription';
+          onRegionCreated: Region;
+        };
+
         export type OnRegionCreatedSubscriptionVariables = Exact<{ [key: string]: never; }>;