refactor: make artemis config clean

build.yaml

@@ -25,33 +25,8 @@ targets:
         options:
           schema_mapping:
             - schema: lib/github.schema.json
-              output: lib/graphql/github_user.dart
+              output: lib/graphql/gh.dart
-              queries_glob: lib/graphql/github_user.graphql
+              queries_glob: lib/graphql/gh_*.graphql
-              resolve_type_field: __typename
-              add_query_prefix: true
-            - schema: lib/github.schema.json
-              output: lib/graphql/github_repository.dart
-              queries_glob: lib/graphql/github_repository.graphql
-              resolve_type_field: __typename
-              add_query_prefix: true
-            - schema: lib/github.schema.json
-              output: lib/graphql/github_object.dart
-              queries_glob: lib/graphql/github_object.graphql
-              resolve_type_field: __typename
-              add_query_prefix: true
-            - schema: lib/github.schema.json
-              output: lib/graphql/github_repositories.dart
-              queries_glob: lib/graphql/github_repositories.graphql
-              resolve_type_field: __typename
-              add_query_prefix: true
-            - schema: lib/github.schema.json
-              output: lib/graphql/github_users.dart
-              queries_glob: lib/graphql/github_users.graphql
-              resolve_type_field: __typename
-              add_query_prefix: true
-            - schema: lib/github.schema.json
-              output: lib/graphql/github_commits.dart
-              queries_glob: lib/graphql/github_commits.graphql
               resolve_type_field: __typename
               add_query_prefix: true
           scalar_mapping:

lib/graphql/gh_commits.graphql

@@ -42,7 +42,7 @@ fragment T on Ref {
   }
 }
 
-query(
+query GhCommits(
   $owner: String!
   $name: String!
   $ref: String!

lib/graphql/gh_object.graphql

@@ -1,4 +1,4 @@
-query($owner: String!, $name: String!, $expression: String!) {
+query GhObject($owner: String!, $name: String!, $expression: String!) {
   repository(owner: $owner, name: $name) {
     object(expression: $expression) {
       __typename

lib/graphql/gh_repo.graphql

@@ -1,4 +1,4 @@
-query(
+query GhRepo(
   $owner: String!
   $name: String!
   $branchSpecified: Boolean!

lib/graphql/gh_repos.graphql

@@ -1,4 +1,4 @@
-query($owner: String!, $after: String, $isStar: Boolean!) {
+query GhRepos($owner: String!, $after: String, $isStar: Boolean!) {
   repositoryOwner(login: $owner) {
     __typename
     login

lib/graphql/gh_user.graphql

@@ -1,4 +1,4 @@
-query($login: String!, $isViewer: Boolean!) {
+query GhUser($login: String!, $isViewer: Boolean!) {
   repositoryOwner(login: $login) @skip(if: $isViewer) {
     __typename
     login

lib/graphql/gh_users.graphql

@@ -1,4 +1,4 @@
-query(
+query GhUsers(
   $login: String!
   $repoName: String!
   $after: String

lib/graphql/github_commits.dart

@@ -1,828 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-import 'package:artemis/artemis.dart';
-import 'package:json_annotation/json_annotation.dart';
-import 'package:equatable/equatable.dart';
-import 'package:gql/ast.dart';
-part 'github_commits.g.dart';
-
-mixin TMixin {
-  GithubCommitsGitObject target;
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommits with EquatableMixin {
-  GithubCommits();
-
-  factory GithubCommits.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsFromJson(json);
-
-  GithubCommitsRepository repository;
-
-  @override
-  List<Object> get props => [repository];
-  Map<String, dynamic> toJson() => _$GithubCommitsToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsRepository extends GithubCommitsPinnableItem
-    with EquatableMixin
-    implements
-        GithubCommitsNode,
-        GithubCommitsProjectOwner,
-        GithubCommitsRegistryPackageOwner,
-        GithubCommitsRegistryPackageSearch,
-        GithubCommitsSubscribable,
-        GithubCommitsStarrable,
-        GithubCommitsUniformResourceLocatable,
-        GithubCommitsRepositoryInfo {
-  GithubCommitsRepository();
-
-  factory GithubCommitsRepository.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsRepositoryFromJson(json);
-
-  GithubCommitsRef defaultBranchRef;
-
-  GithubCommitsRef ref;
-
-  @override
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [defaultBranchRef, ref, resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsRepositoryToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsRef
-    with EquatableMixin, TMixin
-    implements GithubCommitsNode {
-  GithubCommitsRef();
-
-  factory GithubCommitsRef.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsRefFromJson(json);
-
-  @override
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [target, resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsRefToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsGitObject with EquatableMixin {
-  GithubCommitsGitObject();
-
-  factory GithubCommitsGitObject.fromJson(Map<String, dynamic> json) {
-    switch (json['__typename'].toString()) {
-      case 'Commit':
-        return GithubCommitsCommit.fromJson(json);
-      default:
-    }
-    return _$GithubCommitsGitObjectFromJson(json);
-  }
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() {
-    switch (resolveType) {
-      case 'Commit':
-        return (this as GithubCommitsCommit).toJson();
-      default:
-    }
-    return _$GithubCommitsGitObjectToJson(this);
-  }
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsCommit extends GithubCommitsPullRequestTimelineItem
-    with EquatableMixin
-    implements
-        GithubCommitsNode,
-        GithubCommitsGitObject,
-        GithubCommitsSubscribable,
-        GithubCommitsUniformResourceLocatable {
-  GithubCommitsCommit();
-
-  factory GithubCommitsCommit.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsCommitFromJson(json);
-
-  String oid;
-
-  String url;
-
-  String messageHeadline;
-
-  DateTime committedDate;
-
-  GithubCommitsGitActor author;
-
-  GithubCommitsStatus status;
-
-  GithubCommitsCommitHistoryConnection history;
-
-  @override
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [
-        oid,
-        url,
-        messageHeadline,
-        committedDate,
-        author,
-        status,
-        history,
-        resolveType
-      ];
-  Map<String, dynamic> toJson() => _$GithubCommitsCommitToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsGitActor with EquatableMixin {
-  GithubCommitsGitActor();
-
-  factory GithubCommitsGitActor.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsGitActorFromJson(json);
-
-  String name;
-
-  String avatarUrl;
-
-  GithubCommitsUser user;
-
-  @override
-  List<Object> get props => [name, avatarUrl, user];
-  Map<String, dynamic> toJson() => _$GithubCommitsGitActorToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsUser extends GithubCommitsAuditEntryActor
-    with EquatableMixin
-    implements
-        GithubCommitsNode,
-        GithubCommitsActor,
-        GithubCommitsRegistryPackageOwner,
-        GithubCommitsRegistryPackageSearch,
-        GithubCommitsProjectOwner,
-        GithubCommitsRepositoryOwner,
-        GithubCommitsUniformResourceLocatable,
-        GithubCommitsProfileOwner,
-        GithubCommitsSponsorable {
-  GithubCommitsUser();
-
-  factory GithubCommitsUser.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsUserFromJson(json);
-
-  @override
-  String login;
-
-  @override
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [login, resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsUserToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsAuditEntryActor with EquatableMixin {
-  GithubCommitsAuditEntryActor();
-
-  factory GithubCommitsAuditEntryActor.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsAuditEntryActorFromJson(json);
-
-  @override
-  List<Object> get props => [];
-  Map<String, dynamic> toJson() => _$GithubCommitsAuditEntryActorToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsNode with EquatableMixin {
-  GithubCommitsNode();
-
-  factory GithubCommitsNode.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsNodeFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsNodeToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsActor with EquatableMixin {
-  GithubCommitsActor();
-
-  factory GithubCommitsActor.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsActorFromJson(json);
-
-  String login;
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [login, resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsActorToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsRegistryPackageOwner with EquatableMixin {
-  GithubCommitsRegistryPackageOwner();
-
-  factory GithubCommitsRegistryPackageOwner.fromJson(
-          Map<String, dynamic> json) =>
-      _$GithubCommitsRegistryPackageOwnerFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() =>
-      _$GithubCommitsRegistryPackageOwnerToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsRegistryPackageSearch with EquatableMixin {
-  GithubCommitsRegistryPackageSearch();
-
-  factory GithubCommitsRegistryPackageSearch.fromJson(
-          Map<String, dynamic> json) =>
-      _$GithubCommitsRegistryPackageSearchFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() =>
-      _$GithubCommitsRegistryPackageSearchToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsProjectOwner with EquatableMixin {
-  GithubCommitsProjectOwner();
-
-  factory GithubCommitsProjectOwner.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsProjectOwnerFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsProjectOwnerToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsRepositoryOwner with EquatableMixin {
-  GithubCommitsRepositoryOwner();
-
-  factory GithubCommitsRepositoryOwner.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsRepositoryOwnerFromJson(json);
-
-  String login;
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [login, resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsRepositoryOwnerToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsUniformResourceLocatable with EquatableMixin {
-  GithubCommitsUniformResourceLocatable();
-
-  factory GithubCommitsUniformResourceLocatable.fromJson(
-          Map<String, dynamic> json) =>
-      _$GithubCommitsUniformResourceLocatableFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() =>
-      _$GithubCommitsUniformResourceLocatableToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsProfileOwner with EquatableMixin {
-  GithubCommitsProfileOwner();
-
-  factory GithubCommitsProfileOwner.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsProfileOwnerFromJson(json);
-
-  String login;
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [login, resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsProfileOwnerToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsSponsorable with EquatableMixin {
-  GithubCommitsSponsorable();
-
-  factory GithubCommitsSponsorable.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsSponsorableFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsSponsorableToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsStatus with EquatableMixin implements GithubCommitsNode {
-  GithubCommitsStatus();
-
-  factory GithubCommitsStatus.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsStatusFromJson(json);
-
-  GithubCommitsStatusState state;
-
-  @override
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [state, resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsStatusToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsCommitHistoryConnection with EquatableMixin {
-  GithubCommitsCommitHistoryConnection();
-
-  factory GithubCommitsCommitHistoryConnection.fromJson(
-          Map<String, dynamic> json) =>
-      _$GithubCommitsCommitHistoryConnectionFromJson(json);
-
-  GithubCommitsPageInfo pageInfo;
-
-  List<GithubCommitsCommit> nodes;
-
-  @override
-  List<Object> get props => [pageInfo, nodes];
-  Map<String, dynamic> toJson() =>
-      _$GithubCommitsCommitHistoryConnectionToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsPageInfo with EquatableMixin {
-  GithubCommitsPageInfo();
-
-  factory GithubCommitsPageInfo.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsPageInfoFromJson(json);
-
-  bool hasNextPage;
-
-  String endCursor;
-
-  @override
-  List<Object> get props => [hasNextPage, endCursor];
-  Map<String, dynamic> toJson() => _$GithubCommitsPageInfoToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsPullRequestTimelineItem with EquatableMixin {
-  GithubCommitsPullRequestTimelineItem();
-
-  factory GithubCommitsPullRequestTimelineItem.fromJson(
-          Map<String, dynamic> json) =>
-      _$GithubCommitsPullRequestTimelineItemFromJson(json);
-
-  @override
-  List<Object> get props => [];
-  Map<String, dynamic> toJson() =>
-      _$GithubCommitsPullRequestTimelineItemToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsSubscribable with EquatableMixin {
-  GithubCommitsSubscribable();
-
-  factory GithubCommitsSubscribable.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsSubscribableFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsSubscribableToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsPinnableItem with EquatableMixin {
-  GithubCommitsPinnableItem();
-
-  factory GithubCommitsPinnableItem.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsPinnableItemFromJson(json);
-
-  @override
-  List<Object> get props => [];
-  Map<String, dynamic> toJson() => _$GithubCommitsPinnableItemToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsStarrable with EquatableMixin {
-  GithubCommitsStarrable();
-
-  factory GithubCommitsStarrable.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsStarrableFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsStarrableToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsRepositoryInfo with EquatableMixin {
-  GithubCommitsRepositoryInfo();
-
-  factory GithubCommitsRepositoryInfo.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsRepositoryInfoFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubCommitsRepositoryInfoToJson(this);
-}
-
-enum GithubCommitsStatusState {
-  EXPECTED,
-  ERROR,
-  FAILURE,
-  PENDING,
-  SUCCESS,
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubCommitsArguments extends JsonSerializable with EquatableMixin {
-  GithubCommitsArguments(
-      {this.owner, this.name, this.ref, this.hasRef, this.after});
-
-  factory GithubCommitsArguments.fromJson(Map<String, dynamic> json) =>
-      _$GithubCommitsArgumentsFromJson(json);
-
-  final String owner;
-
-  final String name;
-
-  final String ref;
-
-  final bool hasRef;
-
-  final String after;
-
-  @override
-  List<Object> get props => [owner, name, ref, hasRef, after];
-  Map<String, dynamic> toJson() => _$GithubCommitsArgumentsToJson(this);
-}
-
-class GithubCommitsQuery
-    extends GraphQLQuery<GithubCommits, GithubCommitsArguments> {
-  GithubCommitsQuery({this.variables});
-
-  @override
-  final DocumentNode document = DocumentNode(definitions: [
-    FragmentDefinitionNode(
-        name: NameNode(value: 'T'),
-        typeCondition: TypeConditionNode(
-            on: NamedTypeNode(name: NameNode(value: 'Ref'), isNonNull: false)),
-        directives: [],
-        selectionSet: SelectionSetNode(selections: [
-          FieldNode(
-              name: NameNode(value: 'target'),
-              alias: null,
-              arguments: [],
-              directives: [],
-              selectionSet: SelectionSetNode(selections: [
-                FieldNode(
-                    name: NameNode(value: '__typename'),
-                    alias: null,
-                    arguments: [],
-                    directives: [],
-                    selectionSet: null),
-                InlineFragmentNode(
-                    typeCondition: TypeConditionNode(
-                        on: NamedTypeNode(
-                            name: NameNode(value: 'Commit'), isNonNull: false)),
-                    directives: [],
-                    selectionSet: SelectionSetNode(selections: [
-                      FieldNode(
-                          name: NameNode(value: 'oid'),
-                          alias: null,
-                          arguments: [],
-                          directives: [],
-                          selectionSet: null),
-                      FieldNode(
-                          name: NameNode(value: 'url'),
-                          alias: null,
-                          arguments: [],
-                          directives: [],
-                          selectionSet: null),
-                      FieldNode(
-                          name: NameNode(value: 'messageHeadline'),
-                          alias: null,
-                          arguments: [],
-                          directives: [],
-                          selectionSet: null),
-                      FieldNode(
-                          name: NameNode(value: 'committedDate'),
-                          alias: null,
-                          arguments: [],
-                          directives: [],
-                          selectionSet: null),
-                      FieldNode(
-                          name: NameNode(value: 'author'),
-                          alias: null,
-                          arguments: [],
-                          directives: [],
-                          selectionSet: SelectionSetNode(selections: [
-                            FieldNode(
-                                name: NameNode(value: 'name'),
-                                alias: null,
-                                arguments: [],
-                                directives: [],
-                                selectionSet: null),
-                            FieldNode(
-                                name: NameNode(value: 'avatarUrl'),
-                                alias: null,
-                                arguments: [],
-                                directives: [],
-                                selectionSet: null),
-                            FieldNode(
-                                name: NameNode(value: 'user'),
-                                alias: null,
-                                arguments: [],
-                                directives: [],
-                                selectionSet: SelectionSetNode(selections: [
-                                  FieldNode(
-                                      name: NameNode(value: 'login'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet: null)
-                                ]))
-                          ])),
-                      FieldNode(
-                          name: NameNode(value: 'status'),
-                          alias: null,
-                          arguments: [],
-                          directives: [],
-                          selectionSet: SelectionSetNode(selections: [
-                            FieldNode(
-                                name: NameNode(value: 'state'),
-                                alias: null,
-                                arguments: [],
-                                directives: [],
-                                selectionSet: null)
-                          ])),
-                      FieldNode(
-                          name: NameNode(value: 'history'),
-                          alias: null,
-                          arguments: [
-                            ArgumentNode(
-                                name: NameNode(value: 'first'),
-                                value: IntValueNode(value: '30')),
-                            ArgumentNode(
-                                name: NameNode(value: 'after'),
-                                value: VariableNode(
-                                    name: NameNode(value: 'after')))
-                          ],
-                          directives: [],
-                          selectionSet: SelectionSetNode(selections: [
-                            FieldNode(
-                                name: NameNode(value: 'pageInfo'),
-                                alias: null,
-                                arguments: [],
-                                directives: [],
-                                selectionSet: SelectionSetNode(selections: [
-                                  FieldNode(
-                                      name: NameNode(value: 'hasNextPage'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet: null),
-                                  FieldNode(
-                                      name: NameNode(value: 'endCursor'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet: null)
-                                ])),
-                            FieldNode(
-                                name: NameNode(value: 'nodes'),
-                                alias: null,
-                                arguments: [],
-                                directives: [],
-                                selectionSet: SelectionSetNode(selections: [
-                                  FieldNode(
-                                      name: NameNode(value: 'oid'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet: null),
-                                  FieldNode(
-                                      name: NameNode(value: 'url'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet: null),
-                                  FieldNode(
-                                      name: NameNode(value: 'messageHeadline'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet: null),
-                                  FieldNode(
-                                      name: NameNode(value: 'committedDate'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet: null),
-                                  FieldNode(
-                                      name: NameNode(value: 'author'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet:
-                                          SelectionSetNode(selections: [
-                                        FieldNode(
-                                            name: NameNode(value: 'name'),
-                                            alias: null,
-                                            arguments: [],
-                                            directives: [],
-                                            selectionSet: null),
-                                        FieldNode(
-                                            name: NameNode(value: 'avatarUrl'),
-                                            alias: null,
-                                            arguments: [],
-                                            directives: [],
-                                            selectionSet: null),
-                                        FieldNode(
-                                            name: NameNode(value: 'user'),
-                                            alias: null,
-                                            arguments: [],
-                                            directives: [],
-                                            selectionSet:
-                                                SelectionSetNode(selections: [
-                                              FieldNode(
-                                                  name:
-                                                      NameNode(value: 'login'),
-                                                  alias: null,
-                                                  arguments: [],
-                                                  directives: [],
-                                                  selectionSet: null)
-                                            ]))
-                                      ])),
-                                  FieldNode(
-                                      name: NameNode(value: 'status'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet:
-                                          SelectionSetNode(selections: [
-                                        FieldNode(
-                                            name: NameNode(value: 'state'),
-                                            alias: null,
-                                            arguments: [],
-                                            directives: [],
-                                            selectionSet: null)
-                                      ]))
-                                ]))
-                          ]))
-                    ]))
-              ]))
-        ])),
-    OperationDefinitionNode(
-        type: OperationType.query,
-        name: null,
-        variableDefinitions: [
-          VariableDefinitionNode(
-              variable: VariableNode(name: NameNode(value: 'owner')),
-              type: NamedTypeNode(
-                  name: NameNode(value: 'String'), isNonNull: true),
-              defaultValue: DefaultValueNode(value: null),
-              directives: []),
-          VariableDefinitionNode(
-              variable: VariableNode(name: NameNode(value: 'name')),
-              type: NamedTypeNode(
-                  name: NameNode(value: 'String'), isNonNull: true),
-              defaultValue: DefaultValueNode(value: null),
-              directives: []),
-          VariableDefinitionNode(
-              variable: VariableNode(name: NameNode(value: 'ref')),
-              type: NamedTypeNode(
-                  name: NameNode(value: 'String'), isNonNull: true),
-              defaultValue: DefaultValueNode(value: null),
-              directives: []),
-          VariableDefinitionNode(
-              variable: VariableNode(name: NameNode(value: 'hasRef')),
-              type: NamedTypeNode(
-                  name: NameNode(value: 'Boolean'), isNonNull: true),
-              defaultValue: DefaultValueNode(value: null),
-              directives: []),
-          VariableDefinitionNode(
-              variable: VariableNode(name: NameNode(value: 'after')),
-              type: NamedTypeNode(
-                  name: NameNode(value: 'String'), isNonNull: false),
-              defaultValue: DefaultValueNode(value: null),
-              directives: [])
-        ],
-        directives: [],
-        selectionSet: SelectionSetNode(selections: [
-          FieldNode(
-              name: NameNode(value: 'repository'),
-              alias: null,
-              arguments: [
-                ArgumentNode(
-                    name: NameNode(value: 'owner'),
-                    value: VariableNode(name: NameNode(value: 'owner'))),
-                ArgumentNode(
-                    name: NameNode(value: 'name'),
-                    value: VariableNode(name: NameNode(value: 'name')))
-              ],
-              directives: [],
-              selectionSet: SelectionSetNode(selections: [
-                FieldNode(
-                    name: NameNode(value: 'defaultBranchRef'),
-                    alias: null,
-                    arguments: [],
-                    directives: [
-                      DirectiveNode(name: NameNode(value: 'skip'), arguments: [
-                        ArgumentNode(
-                            name: NameNode(value: 'if'),
-                            value:
-                                VariableNode(name: NameNode(value: 'hasRef')))
-                      ])
-                    ],
-                    selectionSet: SelectionSetNode(selections: [
-                      FragmentSpreadNode(
-                          name: NameNode(value: 'T'), directives: [])
-                    ])),
-                FieldNode(
-                    name: NameNode(value: 'ref'),
-                    alias: null,
-                    arguments: [
-                      ArgumentNode(
-                          name: NameNode(value: 'qualifiedName'),
-                          value: VariableNode(name: NameNode(value: 'ref')))
-                    ],
-                    directives: [
-                      DirectiveNode(
-                          name: NameNode(value: 'include'),
-                          arguments: [
-                            ArgumentNode(
-                                name: NameNode(value: 'if'),
-                                value: VariableNode(
-                                    name: NameNode(value: 'hasRef')))
-                          ])
-                    ],
-                    selectionSet: SelectionSetNode(selections: [
-                      FragmentSpreadNode(
-                          name: NameNode(value: 'T'), directives: [])
-                    ]))
-              ]))
-        ]))
-  ]);
-
-  @override
-  final String operationName = 'github_commits';
-
-  @override
-  final GithubCommitsArguments variables;
-
-  @override
-  List<Object> get props => [document, operationName, variables];
-  @override
-  GithubCommits parse(Map<String, dynamic> json) =>
-      GithubCommits.fromJson(json);
-}

lib/graphql/github_commits.g.dart

@@ -1,411 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'github_commits.dart';
-
-// **************************************************************************
-// JsonSerializableGenerator
-// **************************************************************************
-
-GithubCommits _$GithubCommitsFromJson(Map<String, dynamic> json) {
-  return GithubCommits()
-    ..repository = json['repository'] == null
-        ? null
-        : GithubCommitsRepository.fromJson(
-            json['repository'] as Map<String, dynamic>);
-}
-
-Map<String, dynamic> _$GithubCommitsToJson(GithubCommits instance) =>
-    <String, dynamic>{
-      'repository': instance.repository?.toJson(),
-    };
-
-GithubCommitsRepository _$GithubCommitsRepositoryFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsRepository()
-    ..defaultBranchRef = json['defaultBranchRef'] == null
-        ? null
-        : GithubCommitsRef.fromJson(
-            json['defaultBranchRef'] as Map<String, dynamic>)
-    ..ref = json['ref'] == null
-        ? null
-        : GithubCommitsRef.fromJson(json['ref'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsRepositoryToJson(
-        GithubCommitsRepository instance) =>
-    <String, dynamic>{
-      'defaultBranchRef': instance.defaultBranchRef?.toJson(),
-      'ref': instance.ref?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsRef _$GithubCommitsRefFromJson(Map<String, dynamic> json) {
-  return GithubCommitsRef()
-    ..target = json['target'] == null
-        ? null
-        : GithubCommitsGitObject.fromJson(
-            json['target'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsRefToJson(GithubCommitsRef instance) =>
-    <String, dynamic>{
-      'target': instance.target?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsGitObject _$GithubCommitsGitObjectFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsGitObject()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsGitObjectToJson(
-        GithubCommitsGitObject instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsCommit _$GithubCommitsCommitFromJson(Map<String, dynamic> json) {
-  return GithubCommitsCommit()
-    ..oid = json['oid'] as String
-    ..url = json['url'] as String
-    ..messageHeadline = json['messageHeadline'] as String
-    ..committedDate = json['committedDate'] == null
-        ? null
-        : DateTime.parse(json['committedDate'] as String)
-    ..author = json['author'] == null
-        ? null
-        : GithubCommitsGitActor.fromJson(json['author'] as Map<String, dynamic>)
-    ..status = json['status'] == null
-        ? null
-        : GithubCommitsStatus.fromJson(json['status'] as Map<String, dynamic>)
-    ..history = json['history'] == null
-        ? null
-        : GithubCommitsCommitHistoryConnection.fromJson(
-            json['history'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsCommitToJson(
-        GithubCommitsCommit instance) =>
-    <String, dynamic>{
-      'oid': instance.oid,
-      'url': instance.url,
-      'messageHeadline': instance.messageHeadline,
-      'committedDate': instance.committedDate?.toIso8601String(),
-      'author': instance.author?.toJson(),
-      'status': instance.status?.toJson(),
-      'history': instance.history?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsGitActor _$GithubCommitsGitActorFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsGitActor()
-    ..name = json['name'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..user = json['user'] == null
-        ? null
-        : GithubCommitsUser.fromJson(json['user'] as Map<String, dynamic>);
-}
-
-Map<String, dynamic> _$GithubCommitsGitActorToJson(
-        GithubCommitsGitActor instance) =>
-    <String, dynamic>{
-      'name': instance.name,
-      'avatarUrl': instance.avatarUrl,
-      'user': instance.user?.toJson(),
-    };
-
-GithubCommitsUser _$GithubCommitsUserFromJson(Map<String, dynamic> json) {
-  return GithubCommitsUser()
-    ..login = json['login'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsUserToJson(GithubCommitsUser instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsAuditEntryActor _$GithubCommitsAuditEntryActorFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsAuditEntryActor();
-}
-
-Map<String, dynamic> _$GithubCommitsAuditEntryActorToJson(
-        GithubCommitsAuditEntryActor instance) =>
-    <String, dynamic>{};
-
-GithubCommitsNode _$GithubCommitsNodeFromJson(Map<String, dynamic> json) {
-  return GithubCommitsNode()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsNodeToJson(GithubCommitsNode instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsActor _$GithubCommitsActorFromJson(Map<String, dynamic> json) {
-  return GithubCommitsActor()
-    ..login = json['login'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsActorToJson(GithubCommitsActor instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsRegistryPackageOwner _$GithubCommitsRegistryPackageOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsRegistryPackageOwner()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsRegistryPackageOwnerToJson(
-        GithubCommitsRegistryPackageOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsRegistryPackageSearch _$GithubCommitsRegistryPackageSearchFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsRegistryPackageSearch()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsRegistryPackageSearchToJson(
-        GithubCommitsRegistryPackageSearch instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsProjectOwner _$GithubCommitsProjectOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsProjectOwner()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsProjectOwnerToJson(
-        GithubCommitsProjectOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsRepositoryOwner _$GithubCommitsRepositoryOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsRepositoryOwner()
-    ..login = json['login'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsRepositoryOwnerToJson(
-        GithubCommitsRepositoryOwner instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsUniformResourceLocatable
-    _$GithubCommitsUniformResourceLocatableFromJson(Map<String, dynamic> json) {
-  return GithubCommitsUniformResourceLocatable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsUniformResourceLocatableToJson(
-        GithubCommitsUniformResourceLocatable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsProfileOwner _$GithubCommitsProfileOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsProfileOwner()
-    ..login = json['login'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsProfileOwnerToJson(
-        GithubCommitsProfileOwner instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsSponsorable _$GithubCommitsSponsorableFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsSponsorable()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsSponsorableToJson(
-        GithubCommitsSponsorable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsStatus _$GithubCommitsStatusFromJson(Map<String, dynamic> json) {
-  return GithubCommitsStatus()
-    ..state =
-        _$enumDecodeNullable(_$GithubCommitsStatusStateEnumMap, json['state'])
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsStatusToJson(
-        GithubCommitsStatus instance) =>
-    <String, dynamic>{
-      'state': _$GithubCommitsStatusStateEnumMap[instance.state],
-      '__typename': instance.resolveType,
-    };
-
-T _$enumDecode<T>(
-  Map<T, dynamic> enumValues,
-  dynamic source, {
-  T unknownValue,
-}) {
-  if (source == null) {
-    throw ArgumentError('A value must be provided. Supported values: '
-        '${enumValues.values.join(', ')}');
-  }
-
-  final value = enumValues.entries
-      .singleWhere((e) => e.value == source, orElse: () => null)
-      ?.key;
-
-  if (value == null && unknownValue == null) {
-    throw ArgumentError('`$source` is not one of the supported values: '
-        '${enumValues.values.join(', ')}');
-  }
-  return value ?? unknownValue;
-}
-
-T _$enumDecodeNullable<T>(
-  Map<T, dynamic> enumValues,
-  dynamic source, {
-  T unknownValue,
-}) {
-  if (source == null) {
-    return null;
-  }
-  return _$enumDecode<T>(enumValues, source, unknownValue: unknownValue);
-}
-
-const _$GithubCommitsStatusStateEnumMap = {
-  GithubCommitsStatusState.EXPECTED: 'EXPECTED',
-  GithubCommitsStatusState.ERROR: 'ERROR',
-  GithubCommitsStatusState.FAILURE: 'FAILURE',
-  GithubCommitsStatusState.PENDING: 'PENDING',
-  GithubCommitsStatusState.SUCCESS: 'SUCCESS',
-};
-
-GithubCommitsCommitHistoryConnection
-    _$GithubCommitsCommitHistoryConnectionFromJson(Map<String, dynamic> json) {
-  return GithubCommitsCommitHistoryConnection()
-    ..pageInfo = json['pageInfo'] == null
-        ? null
-        : GithubCommitsPageInfo.fromJson(
-            json['pageInfo'] as Map<String, dynamic>)
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubCommitsCommit.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubCommitsCommitHistoryConnectionToJson(
-        GithubCommitsCommitHistoryConnection instance) =>
-    <String, dynamic>{
-      'pageInfo': instance.pageInfo?.toJson(),
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubCommitsPageInfo _$GithubCommitsPageInfoFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsPageInfo()
-    ..hasNextPage = json['hasNextPage'] as bool
-    ..endCursor = json['endCursor'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsPageInfoToJson(
-        GithubCommitsPageInfo instance) =>
-    <String, dynamic>{
-      'hasNextPage': instance.hasNextPage,
-      'endCursor': instance.endCursor,
-    };
-
-GithubCommitsPullRequestTimelineItem
-    _$GithubCommitsPullRequestTimelineItemFromJson(Map<String, dynamic> json) {
-  return GithubCommitsPullRequestTimelineItem();
-}
-
-Map<String, dynamic> _$GithubCommitsPullRequestTimelineItemToJson(
-        GithubCommitsPullRequestTimelineItem instance) =>
-    <String, dynamic>{};
-
-GithubCommitsSubscribable _$GithubCommitsSubscribableFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsSubscribable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsSubscribableToJson(
-        GithubCommitsSubscribable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsPinnableItem _$GithubCommitsPinnableItemFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsPinnableItem();
-}
-
-Map<String, dynamic> _$GithubCommitsPinnableItemToJson(
-        GithubCommitsPinnableItem instance) =>
-    <String, dynamic>{};
-
-GithubCommitsStarrable _$GithubCommitsStarrableFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsStarrable()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsStarrableToJson(
-        GithubCommitsStarrable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsRepositoryInfo _$GithubCommitsRepositoryInfoFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsRepositoryInfo()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubCommitsRepositoryInfoToJson(
-        GithubCommitsRepositoryInfo instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubCommitsArguments _$GithubCommitsArgumentsFromJson(
-    Map<String, dynamic> json) {
-  return GithubCommitsArguments(
-    owner: json['owner'] as String,
-    name: json['name'] as String,
-    ref: json['ref'] as String,
-    hasRef: json['hasRef'] as bool,
-    after: json['after'] as String,
-  );
-}
-
-Map<String, dynamic> _$GithubCommitsArgumentsToJson(
-        GithubCommitsArguments instance) =>
-    <String, dynamic>{
-      'owner': instance.owner,
-      'name': instance.name,
-      'ref': instance.ref,
-      'hasRef': instance.hasRef,
-      'after': instance.after,
-    };

lib/graphql/github_object.dart

@@ -1,412 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-import 'package:artemis/artemis.dart';
-import 'package:json_annotation/json_annotation.dart';
-import 'package:equatable/equatable.dart';
-import 'package:gql/ast.dart';
-part 'github_object.g.dart';
-
-@JsonSerializable(explicitToJson: true)
-class GithubObject with EquatableMixin {
-  GithubObject();
-
-  factory GithubObject.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectFromJson(json);
-
-  GithubObjectRepository repository;
-
-  @override
-  List<Object> get props => [repository];
-  Map<String, dynamic> toJson() => _$GithubObjectToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectRepository extends GithubObjectPinnableItem
-    with EquatableMixin
-    implements
-        GithubObjectNode,
-        GithubObjectProjectOwner,
-        GithubObjectRegistryPackageOwner,
-        GithubObjectRegistryPackageSearch,
-        GithubObjectSubscribable,
-        GithubObjectStarrable,
-        GithubObjectUniformResourceLocatable,
-        GithubObjectRepositoryInfo {
-  GithubObjectRepository();
-
-  factory GithubObjectRepository.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectRepositoryFromJson(json);
-
-  GithubObjectGitObject object;
-
-  @override
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [object, resolveType];
-  Map<String, dynamic> toJson() => _$GithubObjectRepositoryToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectGitObject with EquatableMixin {
-  GithubObjectGitObject();
-
-  factory GithubObjectGitObject.fromJson(Map<String, dynamic> json) {
-    switch (json['__typename'].toString()) {
-      case 'Tree':
-        return GithubObjectTree.fromJson(json);
-      case 'Blob':
-        return GithubObjectBlob.fromJson(json);
-      default:
-    }
-    return _$GithubObjectGitObjectFromJson(json);
-  }
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() {
-    switch (resolveType) {
-      case 'Tree':
-        return (this as GithubObjectTree).toJson();
-      case 'Blob':
-        return (this as GithubObjectBlob).toJson();
-      default:
-    }
-    return _$GithubObjectGitObjectToJson(this);
-  }
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectTree
-    with EquatableMixin
-    implements GithubObjectNode, GithubObjectGitObject {
-  GithubObjectTree();
-
-  factory GithubObjectTree.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectTreeFromJson(json);
-
-  List<GithubObjectTreeEntry> entries;
-
-  @override
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [entries, resolveType];
-  Map<String, dynamic> toJson() => _$GithubObjectTreeToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectTreeEntry with EquatableMixin {
-  GithubObjectTreeEntry();
-
-  factory GithubObjectTreeEntry.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectTreeEntryFromJson(json);
-
-  String type;
-
-  String name;
-
-  @override
-  List<Object> get props => [type, name];
-  Map<String, dynamic> toJson() => _$GithubObjectTreeEntryToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectNode with EquatableMixin {
-  GithubObjectNode();
-
-  factory GithubObjectNode.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectNodeFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubObjectNodeToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectBlob
-    with EquatableMixin
-    implements GithubObjectNode, GithubObjectGitObject {
-  GithubObjectBlob();
-
-  factory GithubObjectBlob.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectBlobFromJson(json);
-
-  String text;
-
-  @override
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [text, resolveType];
-  Map<String, dynamic> toJson() => _$GithubObjectBlobToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectPinnableItem with EquatableMixin {
-  GithubObjectPinnableItem();
-
-  factory GithubObjectPinnableItem.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectPinnableItemFromJson(json);
-
-  @override
-  List<Object> get props => [];
-  Map<String, dynamic> toJson() => _$GithubObjectPinnableItemToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectProjectOwner with EquatableMixin {
-  GithubObjectProjectOwner();
-
-  factory GithubObjectProjectOwner.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectProjectOwnerFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubObjectProjectOwnerToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectRegistryPackageOwner with EquatableMixin {
-  GithubObjectRegistryPackageOwner();
-
-  factory GithubObjectRegistryPackageOwner.fromJson(
-          Map<String, dynamic> json) =>
-      _$GithubObjectRegistryPackageOwnerFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() =>
-      _$GithubObjectRegistryPackageOwnerToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectRegistryPackageSearch with EquatableMixin {
-  GithubObjectRegistryPackageSearch();
-
-  factory GithubObjectRegistryPackageSearch.fromJson(
-          Map<String, dynamic> json) =>
-      _$GithubObjectRegistryPackageSearchFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() =>
-      _$GithubObjectRegistryPackageSearchToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectSubscribable with EquatableMixin {
-  GithubObjectSubscribable();
-
-  factory GithubObjectSubscribable.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectSubscribableFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubObjectSubscribableToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectStarrable with EquatableMixin {
-  GithubObjectStarrable();
-
-  factory GithubObjectStarrable.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectStarrableFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubObjectStarrableToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectUniformResourceLocatable with EquatableMixin {
-  GithubObjectUniformResourceLocatable();
-
-  factory GithubObjectUniformResourceLocatable.fromJson(
-          Map<String, dynamic> json) =>
-      _$GithubObjectUniformResourceLocatableFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() =>
-      _$GithubObjectUniformResourceLocatableToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectRepositoryInfo with EquatableMixin {
-  GithubObjectRepositoryInfo();
-
-  factory GithubObjectRepositoryInfo.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectRepositoryInfoFromJson(json);
-
-  @JsonKey(name: '__typename')
-  String resolveType;
-
-  @override
-  List<Object> get props => [resolveType];
-  Map<String, dynamic> toJson() => _$GithubObjectRepositoryInfoToJson(this);
-}
-
-@JsonSerializable(explicitToJson: true)
-class GithubObjectArguments extends JsonSerializable with EquatableMixin {
-  GithubObjectArguments({this.owner, this.name, this.expression});
-
-  factory GithubObjectArguments.fromJson(Map<String, dynamic> json) =>
-      _$GithubObjectArgumentsFromJson(json);
-
-  final String owner;
-
-  final String name;
-
-  final String expression;
-
-  @override
-  List<Object> get props => [owner, name, expression];
-  Map<String, dynamic> toJson() => _$GithubObjectArgumentsToJson(this);
-}
-
-class GithubObjectQuery
-    extends GraphQLQuery<GithubObject, GithubObjectArguments> {
-  GithubObjectQuery({this.variables});
-
-  @override
-  final DocumentNode document = DocumentNode(definitions: [
-    OperationDefinitionNode(
-        type: OperationType.query,
-        name: null,
-        variableDefinitions: [
-          VariableDefinitionNode(
-              variable: VariableNode(name: NameNode(value: 'owner')),
-              type: NamedTypeNode(
-                  name: NameNode(value: 'String'), isNonNull: true),
-              defaultValue: DefaultValueNode(value: null),
-              directives: []),
-          VariableDefinitionNode(
-              variable: VariableNode(name: NameNode(value: 'name')),
-              type: NamedTypeNode(
-                  name: NameNode(value: 'String'), isNonNull: true),
-              defaultValue: DefaultValueNode(value: null),
-              directives: []),
-          VariableDefinitionNode(
-              variable: VariableNode(name: NameNode(value: 'expression')),
-              type: NamedTypeNode(
-                  name: NameNode(value: 'String'), isNonNull: true),
-              defaultValue: DefaultValueNode(value: null),
-              directives: [])
-        ],
-        directives: [],
-        selectionSet: SelectionSetNode(selections: [
-          FieldNode(
-              name: NameNode(value: 'repository'),
-              alias: null,
-              arguments: [
-                ArgumentNode(
-                    name: NameNode(value: 'owner'),
-                    value: VariableNode(name: NameNode(value: 'owner'))),
-                ArgumentNode(
-                    name: NameNode(value: 'name'),
-                    value: VariableNode(name: NameNode(value: 'name')))
-              ],
-              directives: [],
-              selectionSet: SelectionSetNode(selections: [
-                FieldNode(
-                    name: NameNode(value: 'object'),
-                    alias: null,
-                    arguments: [
-                      ArgumentNode(
-                          name: NameNode(value: 'expression'),
-                          value:
-                              VariableNode(name: NameNode(value: 'expression')))
-                    ],
-                    directives: [],
-                    selectionSet: SelectionSetNode(selections: [
-                      FieldNode(
-                          name: NameNode(value: '__typename'),
-                          alias: null,
-                          arguments: [],
-                          directives: [],
-                          selectionSet: null),
-                      InlineFragmentNode(
-                          typeCondition: TypeConditionNode(
-                              on: NamedTypeNode(
-                                  name: NameNode(value: 'Tree'),
-                                  isNonNull: false)),
-                          directives: [],
-                          selectionSet: SelectionSetNode(selections: [
-                            FieldNode(
-                                name: NameNode(value: 'entries'),
-                                alias: null,
-                                arguments: [],
-                                directives: [],
-                                selectionSet: SelectionSetNode(selections: [
-                                  FieldNode(
-                                      name: NameNode(value: 'type'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet: null),
-                                  FieldNode(
-                                      name: NameNode(value: 'name'),
-                                      alias: null,
-                                      arguments: [],
-                                      directives: [],
-                                      selectionSet: null)
-                                ]))
-                          ])),
-                      InlineFragmentNode(
-                          typeCondition: TypeConditionNode(
-                              on: NamedTypeNode(
-                                  name: NameNode(value: 'Blob'),
-                                  isNonNull: false)),
-                          directives: [],
-                          selectionSet: SelectionSetNode(selections: [
-                            FieldNode(
-                                name: NameNode(value: 'text'),
-                                alias: null,
-                                arguments: [],
-                                directives: [],
-                                selectionSet: null)
-                          ]))
-                    ]))
-              ]))
-        ]))
-  ]);
-
-  @override
-  final String operationName = 'github_object';
-
-  @override
-  final GithubObjectArguments variables;
-
-  @override
-  List<Object> get props => [document, operationName, variables];
-  @override
-  GithubObject parse(Map<String, dynamic> json) => GithubObject.fromJson(json);
-}

lib/graphql/github_object.g.dart

@@ -1,205 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'github_object.dart';
-
-// **************************************************************************
-// JsonSerializableGenerator
-// **************************************************************************
-
-GithubObject _$GithubObjectFromJson(Map<String, dynamic> json) {
-  return GithubObject()
-    ..repository = json['repository'] == null
-        ? null
-        : GithubObjectRepository.fromJson(
-            json['repository'] as Map<String, dynamic>);
-}
-
-Map<String, dynamic> _$GithubObjectToJson(GithubObject instance) =>
-    <String, dynamic>{
-      'repository': instance.repository?.toJson(),
-    };
-
-GithubObjectRepository _$GithubObjectRepositoryFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectRepository()
-    ..object = json['object'] == null
-        ? null
-        : GithubObjectGitObject.fromJson(json['object'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectRepositoryToJson(
-        GithubObjectRepository instance) =>
-    <String, dynamic>{
-      'object': instance.object?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectGitObject _$GithubObjectGitObjectFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectGitObject()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectGitObjectToJson(
-        GithubObjectGitObject instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectTree _$GithubObjectTreeFromJson(Map<String, dynamic> json) {
-  return GithubObjectTree()
-    ..entries = (json['entries'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubObjectTreeEntry.fromJson(e as Map<String, dynamic>))
-        ?.toList()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectTreeToJson(GithubObjectTree instance) =>
-    <String, dynamic>{
-      'entries': instance.entries?.map((e) => e?.toJson())?.toList(),
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectTreeEntry _$GithubObjectTreeEntryFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectTreeEntry()
-    ..type = json['type'] as String
-    ..name = json['name'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectTreeEntryToJson(
-        GithubObjectTreeEntry instance) =>
-    <String, dynamic>{
-      'type': instance.type,
-      'name': instance.name,
-    };
-
-GithubObjectNode _$GithubObjectNodeFromJson(Map<String, dynamic> json) {
-  return GithubObjectNode()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectNodeToJson(GithubObjectNode instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectBlob _$GithubObjectBlobFromJson(Map<String, dynamic> json) {
-  return GithubObjectBlob()
-    ..text = json['text'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectBlobToJson(GithubObjectBlob instance) =>
-    <String, dynamic>{
-      'text': instance.text,
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectPinnableItem _$GithubObjectPinnableItemFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectPinnableItem();
-}
-
-Map<String, dynamic> _$GithubObjectPinnableItemToJson(
-        GithubObjectPinnableItem instance) =>
-    <String, dynamic>{};
-
-GithubObjectProjectOwner _$GithubObjectProjectOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectProjectOwner()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectProjectOwnerToJson(
-        GithubObjectProjectOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectRegistryPackageOwner _$GithubObjectRegistryPackageOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectRegistryPackageOwner()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectRegistryPackageOwnerToJson(
-        GithubObjectRegistryPackageOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectRegistryPackageSearch _$GithubObjectRegistryPackageSearchFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectRegistryPackageSearch()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectRegistryPackageSearchToJson(
-        GithubObjectRegistryPackageSearch instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectSubscribable _$GithubObjectSubscribableFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectSubscribable()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectSubscribableToJson(
-        GithubObjectSubscribable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectStarrable _$GithubObjectStarrableFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectStarrable()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectStarrableToJson(
-        GithubObjectStarrable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectUniformResourceLocatable
-    _$GithubObjectUniformResourceLocatableFromJson(Map<String, dynamic> json) {
-  return GithubObjectUniformResourceLocatable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectUniformResourceLocatableToJson(
-        GithubObjectUniformResourceLocatable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectRepositoryInfo _$GithubObjectRepositoryInfoFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectRepositoryInfo()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubObjectRepositoryInfoToJson(
-        GithubObjectRepositoryInfo instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubObjectArguments _$GithubObjectArgumentsFromJson(
-    Map<String, dynamic> json) {
-  return GithubObjectArguments(
-    owner: json['owner'] as String,
-    name: json['name'] as String,
-    expression: json['expression'] as String,
-  );
-}
-
-Map<String, dynamic> _$GithubObjectArgumentsToJson(
-        GithubObjectArguments instance) =>
-    <String, dynamic>{
-      'owner': instance.owner,
-      'name': instance.name,
-      'expression': instance.expression,
-    };

lib/graphql/github_repositories.g.dart

@@ -1,432 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'github_repositories.dart';
-
-// **************************************************************************
-// JsonSerializableGenerator
-// **************************************************************************
-
-GithubRepositories _$GithubRepositoriesFromJson(Map<String, dynamic> json) {
-  return GithubRepositories()
-    ..repositoryOwner = json['repositoryOwner'] == null
-        ? null
-        : GithubRepositoriesRepositoryOwner.fromJson(
-            json['repositoryOwner'] as Map<String, dynamic>);
-}
-
-Map<String, dynamic> _$GithubRepositoriesToJson(GithubRepositories instance) =>
-    <String, dynamic>{
-      'repositoryOwner': instance.repositoryOwner?.toJson(),
-    };
-
-GithubRepositoriesRepositoryOwner _$GithubRepositoriesRepositoryOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesRepositoryOwner()
-    ..login = json['login'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesRepositoryOwnerToJson(
-        GithubRepositoriesRepositoryOwner instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'avatarUrl': instance.avatarUrl,
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesUser _$GithubRepositoriesUserFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesUser()
-    ..repositories = json['repositories'] == null
-        ? null
-        : GithubRepositoriesRepositoryConnection.fromJson(
-            json['repositories'] as Map<String, dynamic>)
-    ..starredRepositories = json['starredRepositories'] == null
-        ? null
-        : GithubRepositoriesStarredRepositoryConnection.fromJson(
-            json['starredRepositories'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String
-    ..login = json['login'] as String
-    ..avatarUrl = json['avatarUrl'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesUserToJson(
-        GithubRepositoriesUser instance) =>
-    <String, dynamic>{
-      'repositories': instance.repositories?.toJson(),
-      'starredRepositories': instance.starredRepositories?.toJson(),
-      '__typename': instance.resolveType,
-      'login': instance.login,
-      'avatarUrl': instance.avatarUrl,
-    };
-
-GithubRepositoriesRepositoryConnection
-    _$GithubRepositoriesRepositoryConnectionFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoriesRepositoryConnection()
-    ..totalCount = json['totalCount'] as int
-    ..pageInfo = json['pageInfo'] == null
-        ? null
-        : GithubRepositoriesPageInfo.fromJson(
-            json['pageInfo'] as Map<String, dynamic>)
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubRepositoriesRepository.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubRepositoriesRepositoryConnectionToJson(
-        GithubRepositoriesRepositoryConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-      'pageInfo': instance.pageInfo?.toJson(),
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubRepositoriesPageInfo _$GithubRepositoriesPageInfoFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesPageInfo()
-    ..hasNextPage = json['hasNextPage'] as bool
-    ..endCursor = json['endCursor'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesPageInfoToJson(
-        GithubRepositoriesPageInfo instance) =>
-    <String, dynamic>{
-      'hasNextPage': instance.hasNextPage,
-      'endCursor': instance.endCursor,
-    };
-
-GithubRepositoriesRepository _$GithubRepositoriesRepositoryFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesRepository()
-    ..owner = json['owner'] == null
-        ? null
-        : GithubRepositoriesRepositoryOwner.fromJson(
-            json['owner'] as Map<String, dynamic>)
-    ..name = json['name'] as String
-    ..description = json['description'] as String
-    ..isPrivate = json['isPrivate'] as bool
-    ..isFork = json['isFork'] as bool
-    ..stargazers = json['stargazers'] == null
-        ? null
-        : GithubRepositoriesStargazerConnection.fromJson(
-            json['stargazers'] as Map<String, dynamic>)
-    ..forks = json['forks'] == null
-        ? null
-        : GithubRepositoriesRepositoryConnection.fromJson(
-            json['forks'] as Map<String, dynamic>)
-    ..primaryLanguage = json['primaryLanguage'] == null
-        ? null
-        : GithubRepositoriesLanguage.fromJson(
-            json['primaryLanguage'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesRepositoryToJson(
-        GithubRepositoriesRepository instance) =>
-    <String, dynamic>{
-      'owner': instance.owner?.toJson(),
-      'name': instance.name,
-      'description': instance.description,
-      'isPrivate': instance.isPrivate,
-      'isFork': instance.isFork,
-      'stargazers': instance.stargazers?.toJson(),
-      'forks': instance.forks?.toJson(),
-      'primaryLanguage': instance.primaryLanguage?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesStargazerConnection
-    _$GithubRepositoriesStargazerConnectionFromJson(Map<String, dynamic> json) {
-  return GithubRepositoriesStargazerConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubRepositoriesStargazerConnectionToJson(
-        GithubRepositoriesStargazerConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubRepositoriesLanguage _$GithubRepositoriesLanguageFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesLanguage()
-    ..color = json['color'] as String
-    ..name = json['name'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesLanguageToJson(
-        GithubRepositoriesLanguage instance) =>
-    <String, dynamic>{
-      'color': instance.color,
-      'name': instance.name,
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesNode _$GithubRepositoriesNodeFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesNode()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesNodeToJson(
-        GithubRepositoriesNode instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesPinnableItem _$GithubRepositoriesPinnableItemFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesPinnableItem();
-}
-
-Map<String, dynamic> _$GithubRepositoriesPinnableItemToJson(
-        GithubRepositoriesPinnableItem instance) =>
-    <String, dynamic>{};
-
-GithubRepositoriesProjectOwner _$GithubRepositoriesProjectOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesProjectOwner()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesProjectOwnerToJson(
-        GithubRepositoriesProjectOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesRegistryPackageOwner
-    _$GithubRepositoriesRegistryPackageOwnerFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoriesRegistryPackageOwner()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesRegistryPackageOwnerToJson(
-        GithubRepositoriesRegistryPackageOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesRegistryPackageSearch
-    _$GithubRepositoriesRegistryPackageSearchFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoriesRegistryPackageSearch()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesRegistryPackageSearchToJson(
-        GithubRepositoriesRegistryPackageSearch instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesSubscribable _$GithubRepositoriesSubscribableFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesSubscribable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesSubscribableToJson(
-        GithubRepositoriesSubscribable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesStarrable _$GithubRepositoriesStarrableFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesStarrable()
-    ..stargazers = json['stargazers'] == null
-        ? null
-        : GithubRepositoriesStargazerConnection.fromJson(
-            json['stargazers'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesStarrableToJson(
-        GithubRepositoriesStarrable instance) =>
-    <String, dynamic>{
-      'stargazers': instance.stargazers?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesUniformResourceLocatable
-    _$GithubRepositoriesUniformResourceLocatableFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoriesUniformResourceLocatable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesUniformResourceLocatableToJson(
-        GithubRepositoriesUniformResourceLocatable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesRepositoryInfo _$GithubRepositoriesRepositoryInfoFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesRepositoryInfo()
-    ..owner = json['owner'] == null
-        ? null
-        : GithubRepositoriesRepositoryOwner.fromJson(
-            json['owner'] as Map<String, dynamic>)
-    ..name = json['name'] as String
-    ..description = json['description'] as String
-    ..isPrivate = json['isPrivate'] as bool
-    ..isFork = json['isFork'] as bool
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesRepositoryInfoToJson(
-        GithubRepositoriesRepositoryInfo instance) =>
-    <String, dynamic>{
-      'owner': instance.owner?.toJson(),
-      'name': instance.name,
-      'description': instance.description,
-      'isPrivate': instance.isPrivate,
-      'isFork': instance.isFork,
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesStarredRepositoryConnection
-    _$GithubRepositoriesStarredRepositoryConnectionFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoriesStarredRepositoryConnection()
-    ..pageInfo = json['pageInfo'] == null
-        ? null
-        : GithubRepositoriesPageInfo.fromJson(
-            json['pageInfo'] as Map<String, dynamic>)
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubRepositoriesRepository.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubRepositoriesStarredRepositoryConnectionToJson(
-        GithubRepositoriesStarredRepositoryConnection instance) =>
-    <String, dynamic>{
-      'pageInfo': instance.pageInfo?.toJson(),
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubRepositoriesAuditEntryActor _$GithubRepositoriesAuditEntryActorFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesAuditEntryActor();
-}
-
-Map<String, dynamic> _$GithubRepositoriesAuditEntryActorToJson(
-        GithubRepositoriesAuditEntryActor instance) =>
-    <String, dynamic>{};
-
-GithubRepositoriesActor _$GithubRepositoriesActorFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesActor()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesActorToJson(
-        GithubRepositoriesActor instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesProfileOwner _$GithubRepositoriesProfileOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesProfileOwner()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesProfileOwnerToJson(
-        GithubRepositoriesProfileOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesSponsorable _$GithubRepositoriesSponsorableFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesSponsorable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesSponsorableToJson(
-        GithubRepositoriesSponsorable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesOrganization _$GithubRepositoriesOrganizationFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesOrganization()
-    ..pinnableItems = json['pinnableItems'] == null
-        ? null
-        : GithubRepositoriesPinnableItemConnection.fromJson(
-            json['pinnableItems'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String
-    ..login = json['login'] as String
-    ..avatarUrl = json['avatarUrl'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesOrganizationToJson(
-        GithubRepositoriesOrganization instance) =>
-    <String, dynamic>{
-      'pinnableItems': instance.pinnableItems?.toJson(),
-      '__typename': instance.resolveType,
-      'login': instance.login,
-      'avatarUrl': instance.avatarUrl,
-    };
-
-GithubRepositoriesPinnableItemConnection
-    _$GithubRepositoriesPinnableItemConnectionFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoriesPinnableItemConnection()
-    ..pageInfo = json['pageInfo'] == null
-        ? null
-        : GithubRepositoriesPageInfo.fromJson(
-            json['pageInfo'] as Map<String, dynamic>)
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubRepositoriesPinnableItem.fromJson(
-                e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubRepositoriesPinnableItemConnectionToJson(
-        GithubRepositoriesPinnableItemConnection instance) =>
-    <String, dynamic>{
-      'pageInfo': instance.pageInfo?.toJson(),
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubRepositoriesMemberStatusable _$GithubRepositoriesMemberStatusableFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesMemberStatusable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoriesMemberStatusableToJson(
-        GithubRepositoriesMemberStatusable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoriesArguments _$GithubRepositoriesArgumentsFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoriesArguments(
-    owner: json['owner'] as String,
-    after: json['after'] as String,
-    isStar: json['isStar'] as bool,
-  );
-}
-
-Map<String, dynamic> _$GithubRepositoriesArgumentsToJson(
-        GithubRepositoriesArguments instance) =>
-    <String, dynamic>{
-      'owner': instance.owner,
-      'after': instance.after,
-      'isStar': instance.isStar,
-    };

lib/graphql/github_repository.g.dart

@@ -1,572 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'github_repository.dart';
-
-// **************************************************************************
-// JsonSerializableGenerator
-// **************************************************************************
-
-GithubRepository _$GithubRepositoryFromJson(Map<String, dynamic> json) {
-  return GithubRepository()
-    ..repository = json['repository'] == null
-        ? null
-        : GithubRepositoryRepository.fromJson(
-            json['repository'] as Map<String, dynamic>);
-}
-
-Map<String, dynamic> _$GithubRepositoryToJson(GithubRepository instance) =>
-    <String, dynamic>{
-      'repository': instance.repository?.toJson(),
-    };
-
-GithubRepositoryRepository _$GithubRepositoryRepositoryFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryRepository()
-    ..owner = json['owner'] == null
-        ? null
-        : GithubRepositoryRepositoryOwner.fromJson(
-            json['owner'] as Map<String, dynamic>)
-    ..name = json['name'] as String
-    ..description = json['description'] as String
-    ..homepageUrl = json['homepageUrl'] as String
-    ..isPrivate = json['isPrivate'] as bool
-    ..isFork = json['isFork'] as bool
-    ..stargazers = json['stargazers'] == null
-        ? null
-        : GithubRepositoryStargazerConnection.fromJson(
-            json['stargazers'] as Map<String, dynamic>)
-    ..forks = json['forks'] == null
-        ? null
-        : GithubRepositoryRepositoryConnection.fromJson(
-            json['forks'] as Map<String, dynamic>)
-    ..primaryLanguage = json['primaryLanguage'] == null
-        ? null
-        : GithubRepositoryLanguage.fromJson(
-            json['primaryLanguage'] as Map<String, dynamic>)
-    ..id = json['id'] as String
-    ..diskUsage = json['diskUsage'] as int
-    ..hasIssuesEnabled = json['hasIssuesEnabled'] as bool
-    ..url = json['url'] as String
-    ..viewerHasStarred = json['viewerHasStarred'] as bool
-    ..projectsUrl = json['projectsUrl'] as String
-    ..watchers = json['watchers'] == null
-        ? null
-        : GithubRepositoryUserConnection.fromJson(
-            json['watchers'] as Map<String, dynamic>)
-    ..issues = json['issues'] == null
-        ? null
-        : GithubRepositoryIssueConnection.fromJson(
-            json['issues'] as Map<String, dynamic>)
-    ..pullRequests = json['pullRequests'] == null
-        ? null
-        : GithubRepositoryPullRequestConnection.fromJson(
-            json['pullRequests'] as Map<String, dynamic>)
-    ..projects = json['projects'] == null
-        ? null
-        : GithubRepositoryProjectConnection.fromJson(json['projects'] as Map<String, dynamic>)
-    ..releases = json['releases'] == null ? null : GithubRepositoryReleaseConnection.fromJson(json['releases'] as Map<String, dynamic>)
-    ..languages = json['languages'] == null ? null : GithubRepositoryLanguageConnection.fromJson(json['languages'] as Map<String, dynamic>)
-    ..defaultBranchRef = json['defaultBranchRef'] == null ? null : GithubRepositoryRef.fromJson(json['defaultBranchRef'] as Map<String, dynamic>)
-    ..ref = json['ref'] == null ? null : GithubRepositoryRef.fromJson(json['ref'] as Map<String, dynamic>)
-    ..refs = json['refs'] == null ? null : GithubRepositoryRefConnection.fromJson(json['refs'] as Map<String, dynamic>)
-    ..licenseInfo = json['licenseInfo'] == null ? null : GithubRepositoryLicense.fromJson(json['licenseInfo'] as Map<String, dynamic>)
-    ..repositoryTopics = json['repositoryTopics'] == null ? null : GithubRepositoryRepositoryTopicConnection.fromJson(json['repositoryTopics'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryRepositoryToJson(
-        GithubRepositoryRepository instance) =>
-    <String, dynamic>{
-      'owner': instance.owner?.toJson(),
-      'name': instance.name,
-      'description': instance.description,
-      'homepageUrl': instance.homepageUrl,
-      'isPrivate': instance.isPrivate,
-      'isFork': instance.isFork,
-      'stargazers': instance.stargazers?.toJson(),
-      'forks': instance.forks?.toJson(),
-      'primaryLanguage': instance.primaryLanguage?.toJson(),
-      'id': instance.id,
-      'diskUsage': instance.diskUsage,
-      'hasIssuesEnabled': instance.hasIssuesEnabled,
-      'url': instance.url,
-      'viewerHasStarred': instance.viewerHasStarred,
-      'projectsUrl': instance.projectsUrl,
-      'watchers': instance.watchers?.toJson(),
-      'issues': instance.issues?.toJson(),
-      'pullRequests': instance.pullRequests?.toJson(),
-      'projects': instance.projects?.toJson(),
-      'releases': instance.releases?.toJson(),
-      'languages': instance.languages?.toJson(),
-      'defaultBranchRef': instance.defaultBranchRef?.toJson(),
-      'ref': instance.ref?.toJson(),
-      'refs': instance.refs?.toJson(),
-      'licenseInfo': instance.licenseInfo?.toJson(),
-      'repositoryTopics': instance.repositoryTopics?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryRepositoryOwner _$GithubRepositoryRepositoryOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryRepositoryOwner()
-    ..login = json['login'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryRepositoryOwnerToJson(
-        GithubRepositoryRepositoryOwner instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'avatarUrl': instance.avatarUrl,
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryStargazerConnection
-    _$GithubRepositoryStargazerConnectionFromJson(Map<String, dynamic> json) {
-  return GithubRepositoryStargazerConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubRepositoryStargazerConnectionToJson(
-        GithubRepositoryStargazerConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubRepositoryRepositoryConnection
-    _$GithubRepositoryRepositoryConnectionFromJson(Map<String, dynamic> json) {
-  return GithubRepositoryRepositoryConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubRepositoryRepositoryConnectionToJson(
-        GithubRepositoryRepositoryConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubRepositoryLanguage _$GithubRepositoryLanguageFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryLanguage()
-    ..color = json['color'] as String
-    ..name = json['name'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryLanguageToJson(
-        GithubRepositoryLanguage instance) =>
-    <String, dynamic>{
-      'color': instance.color,
-      'name': instance.name,
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryNode _$GithubRepositoryNodeFromJson(Map<String, dynamic> json) {
-  return GithubRepositoryNode()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryNodeToJson(
-        GithubRepositoryNode instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryUserConnection _$GithubRepositoryUserConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryUserConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubRepositoryUserConnectionToJson(
-        GithubRepositoryUserConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubRepositoryIssueConnection _$GithubRepositoryIssueConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryIssueConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubRepositoryIssueConnectionToJson(
-        GithubRepositoryIssueConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubRepositoryPullRequestConnection
-    _$GithubRepositoryPullRequestConnectionFromJson(Map<String, dynamic> json) {
-  return GithubRepositoryPullRequestConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubRepositoryPullRequestConnectionToJson(
-        GithubRepositoryPullRequestConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubRepositoryProjectConnection _$GithubRepositoryProjectConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryProjectConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubRepositoryProjectConnectionToJson(
-        GithubRepositoryProjectConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubRepositoryReleaseConnection _$GithubRepositoryReleaseConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryReleaseConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubRepositoryReleaseConnectionToJson(
-        GithubRepositoryReleaseConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubRepositoryLanguageConnection _$GithubRepositoryLanguageConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryLanguageConnection()
-    ..totalSize = json['totalSize'] as int
-    ..edges = (json['edges'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubRepositoryLanguageEdge.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubRepositoryLanguageConnectionToJson(
-        GithubRepositoryLanguageConnection instance) =>
-    <String, dynamic>{
-      'totalSize': instance.totalSize,
-      'edges': instance.edges?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubRepositoryLanguageEdge _$GithubRepositoryLanguageEdgeFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryLanguageEdge()
-    ..size = json['size'] as int
-    ..node = json['node'] == null
-        ? null
-        : GithubRepositoryLanguage.fromJson(
-            json['node'] as Map<String, dynamic>);
-}
-
-Map<String, dynamic> _$GithubRepositoryLanguageEdgeToJson(
-        GithubRepositoryLanguageEdge instance) =>
-    <String, dynamic>{
-      'size': instance.size,
-      'node': instance.node?.toJson(),
-    };
-
-GithubRepositoryRef _$GithubRepositoryRefFromJson(Map<String, dynamic> json) {
-  return GithubRepositoryRef()
-    ..name = json['name'] as String
-    ..target = json['target'] == null
-        ? null
-        : GithubRepositoryGitObject.fromJson(
-            json['target'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryRefToJson(
-        GithubRepositoryRef instance) =>
-    <String, dynamic>{
-      'name': instance.name,
-      'target': instance.target?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryGitObject _$GithubRepositoryGitObjectFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryGitObject()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryGitObjectToJson(
-        GithubRepositoryGitObject instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryCommit _$GithubRepositoryCommitFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryCommit()
-    ..history = json['history'] == null
-        ? null
-        : GithubRepositoryCommitHistoryConnection.fromJson(
-            json['history'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryCommitToJson(
-        GithubRepositoryCommit instance) =>
-    <String, dynamic>{
-      'history': instance.history?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryCommitHistoryConnection
-    _$GithubRepositoryCommitHistoryConnectionFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoryCommitHistoryConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubRepositoryCommitHistoryConnectionToJson(
-        GithubRepositoryCommitHistoryConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubRepositoryPullRequestTimelineItem
-    _$GithubRepositoryPullRequestTimelineItemFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoryPullRequestTimelineItem();
-}
-
-Map<String, dynamic> _$GithubRepositoryPullRequestTimelineItemToJson(
-        GithubRepositoryPullRequestTimelineItem instance) =>
-    <String, dynamic>{};
-
-GithubRepositorySubscribable _$GithubRepositorySubscribableFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositorySubscribable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositorySubscribableToJson(
-        GithubRepositorySubscribable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryUniformResourceLocatable
-    _$GithubRepositoryUniformResourceLocatableFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoryUniformResourceLocatable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryUniformResourceLocatableToJson(
-        GithubRepositoryUniformResourceLocatable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryRefConnection _$GithubRepositoryRefConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryRefConnection()
-    ..totalCount = json['totalCount'] as int
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubRepositoryRef.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubRepositoryRefConnectionToJson(
-        GithubRepositoryRefConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubRepositoryLicense _$GithubRepositoryLicenseFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryLicense()
-    ..name = json['name'] as String
-    ..spdxId = json['spdxId'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryLicenseToJson(
-        GithubRepositoryLicense instance) =>
-    <String, dynamic>{
-      'name': instance.name,
-      'spdxId': instance.spdxId,
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryRepositoryTopicConnection
-    _$GithubRepositoryRepositoryTopicConnectionFromJson(
-        Map<String, dynamic> json) {
-  return GithubRepositoryRepositoryTopicConnection()
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubRepositoryRepositoryTopic.fromJson(
-                e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubRepositoryRepositoryTopicConnectionToJson(
-        GithubRepositoryRepositoryTopicConnection instance) =>
-    <String, dynamic>{
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubRepositoryRepositoryTopic _$GithubRepositoryRepositoryTopicFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryRepositoryTopic()
-    ..url = json['url'] as String
-    ..topic = json['topic'] == null
-        ? null
-        : GithubRepositoryTopic.fromJson(json['topic'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryRepositoryTopicToJson(
-        GithubRepositoryRepositoryTopic instance) =>
-    <String, dynamic>{
-      'url': instance.url,
-      'topic': instance.topic?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryTopic _$GithubRepositoryTopicFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryTopic()
-    ..name = json['name'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryTopicToJson(
-        GithubRepositoryTopic instance) =>
-    <String, dynamic>{
-      'name': instance.name,
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryStarrable _$GithubRepositoryStarrableFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryStarrable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryStarrableToJson(
-        GithubRepositoryStarrable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryPinnableItem _$GithubRepositoryPinnableItemFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryPinnableItem();
-}
-
-Map<String, dynamic> _$GithubRepositoryPinnableItemToJson(
-        GithubRepositoryPinnableItem instance) =>
-    <String, dynamic>{};
-
-GithubRepositoryProjectOwner _$GithubRepositoryProjectOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryProjectOwner()
-    ..id = json['id'] as String
-    ..projectsUrl = json['projectsUrl'] as String
-    ..projects = json['projects'] == null
-        ? null
-        : GithubRepositoryProjectConnection.fromJson(
-            json['projects'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryProjectOwnerToJson(
-        GithubRepositoryProjectOwner instance) =>
-    <String, dynamic>{
-      'id': instance.id,
-      'projectsUrl': instance.projectsUrl,
-      'projects': instance.projects?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryRegistryPackageOwner
-    _$GithubRepositoryRegistryPackageOwnerFromJson(Map<String, dynamic> json) {
-  return GithubRepositoryRegistryPackageOwner()
-    ..id = json['id'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryRegistryPackageOwnerToJson(
-        GithubRepositoryRegistryPackageOwner instance) =>
-    <String, dynamic>{
-      'id': instance.id,
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryRegistryPackageSearch
-    _$GithubRepositoryRegistryPackageSearchFromJson(Map<String, dynamic> json) {
-  return GithubRepositoryRegistryPackageSearch()
-    ..id = json['id'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryRegistryPackageSearchToJson(
-        GithubRepositoryRegistryPackageSearch instance) =>
-    <String, dynamic>{
-      'id': instance.id,
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryRepositoryInfo _$GithubRepositoryRepositoryInfoFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryRepositoryInfo()
-    ..owner = json['owner'] == null
-        ? null
-        : GithubRepositoryRepositoryOwner.fromJson(
-            json['owner'] as Map<String, dynamic>)
-    ..name = json['name'] as String
-    ..description = json['description'] as String
-    ..homepageUrl = json['homepageUrl'] as String
-    ..isPrivate = json['isPrivate'] as bool
-    ..isFork = json['isFork'] as bool
-    ..hasIssuesEnabled = json['hasIssuesEnabled'] as bool
-    ..url = json['url'] as String
-    ..licenseInfo = json['licenseInfo'] == null
-        ? null
-        : GithubRepositoryLicense.fromJson(
-            json['licenseInfo'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubRepositoryRepositoryInfoToJson(
-        GithubRepositoryRepositoryInfo instance) =>
-    <String, dynamic>{
-      'owner': instance.owner?.toJson(),
-      'name': instance.name,
-      'description': instance.description,
-      'homepageUrl': instance.homepageUrl,
-      'isPrivate': instance.isPrivate,
-      'isFork': instance.isFork,
-      'hasIssuesEnabled': instance.hasIssuesEnabled,
-      'url': instance.url,
-      'licenseInfo': instance.licenseInfo?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubRepositoryArguments _$GithubRepositoryArgumentsFromJson(
-    Map<String, dynamic> json) {
-  return GithubRepositoryArguments(
-    owner: json['owner'] as String,
-    name: json['name'] as String,
-    branchSpecified: json['branchSpecified'] as bool,
-    branch: json['branch'] as String,
-  );
-}
-
-Map<String, dynamic> _$GithubRepositoryArgumentsToJson(
-        GithubRepositoryArguments instance) =>
-    <String, dynamic>{
-      'owner': instance.owner,
-      'name': instance.name,
-      'branchSpecified': instance.branchSpecified,
-      'branch': instance.branch,
-    };

lib/graphql/github_user.g.dart

@@ -1,562 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'github_user.dart';
-
-// **************************************************************************
-// JsonSerializableGenerator
-// **************************************************************************
-
-GithubUser _$GithubUserFromJson(Map<String, dynamic> json) {
-  return GithubUser()
-    ..repositoryOwner = json['repositoryOwner'] == null
-        ? null
-        : GithubUserRepositoryOwner.fromJson(
-            json['repositoryOwner'] as Map<String, dynamic>)
-    ..viewer = json['viewer'] == null
-        ? null
-        : GithubUserUser.fromJson(json['viewer'] as Map<String, dynamic>);
-}
-
-Map<String, dynamic> _$GithubUserToJson(GithubUser instance) =>
-    <String, dynamic>{
-      'repositoryOwner': instance.repositoryOwner?.toJson(),
-      'viewer': instance.viewer?.toJson(),
-    };
-
-GithubUserRepositoryOwner _$GithubUserRepositoryOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserRepositoryOwner()
-    ..login = json['login'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..url = json['url'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserRepositoryOwnerToJson(
-        GithubUserRepositoryOwner instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'avatarUrl': instance.avatarUrl,
-      'url': instance.url,
-      '__typename': instance.resolveType,
-    };
-
-GithubUserUser _$GithubUserUserFromJson(Map<String, dynamic> json) {
-  return GithubUserUser()
-    ..name = json['name'] as String
-    ..bio = json['bio'] as String
-    ..company = json['company'] as String
-    ..location = json['location'] as String
-    ..email = json['email'] as String
-    ..createdAt = json['createdAt'] == null
-        ? null
-        : DateTime.parse(json['createdAt'] as String)
-    ..websiteUrl = json['websiteUrl'] as String
-    ..starredRepositories = json['starredRepositories'] == null
-        ? null
-        : GithubUserStarredRepositoryConnection.fromJson(
-            json['starredRepositories'] as Map<String, dynamic>)
-    ..followers = json['followers'] == null
-        ? null
-        : GithubUserFollowerConnection.fromJson(
-            json['followers'] as Map<String, dynamic>)
-    ..following = json['following'] == null
-        ? null
-        : GithubUserFollowingConnection.fromJson(
-            json['following'] as Map<String, dynamic>)
-    ..contributionsCollection = json['contributionsCollection'] == null
-        ? null
-        : GithubUserContributionsCollection.fromJson(
-            json['contributionsCollection'] as Map<String, dynamic>)
-    ..repositories = json['repositories'] == null
-        ? null
-        : GithubUserRepositoryConnection.fromJson(
-            json['repositories'] as Map<String, dynamic>)
-    ..pinnedItems = json['pinnedItems'] == null
-        ? null
-        : GithubUserPinnableItemConnection.fromJson(
-            json['pinnedItems'] as Map<String, dynamic>)
-    ..viewerCanFollow = json['viewerCanFollow'] as bool
-    ..viewerIsFollowing = json['viewerIsFollowing'] as bool
-    ..resolveType = json['__typename'] as String
-    ..login = json['login'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..url = json['url'] as String;
-}
-
-Map<String, dynamic> _$GithubUserUserToJson(GithubUserUser instance) =>
-    <String, dynamic>{
-      'name': instance.name,
-      'bio': instance.bio,
-      'company': instance.company,
-      'location': instance.location,
-      'email': instance.email,
-      'createdAt': instance.createdAt?.toIso8601String(),
-      'websiteUrl': instance.websiteUrl,
-      'starredRepositories': instance.starredRepositories?.toJson(),
-      'followers': instance.followers?.toJson(),
-      'following': instance.following?.toJson(),
-      'contributionsCollection': instance.contributionsCollection?.toJson(),
-      'repositories': instance.repositories?.toJson(),
-      'pinnedItems': instance.pinnedItems?.toJson(),
-      'viewerCanFollow': instance.viewerCanFollow,
-      'viewerIsFollowing': instance.viewerIsFollowing,
-      '__typename': instance.resolveType,
-      'login': instance.login,
-      'avatarUrl': instance.avatarUrl,
-      'url': instance.url,
-    };
-
-GithubUserStarredRepositoryConnection
-    _$GithubUserStarredRepositoryConnectionFromJson(Map<String, dynamic> json) {
-  return GithubUserStarredRepositoryConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubUserStarredRepositoryConnectionToJson(
-        GithubUserStarredRepositoryConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubUserFollowerConnection _$GithubUserFollowerConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserFollowerConnection()..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubUserFollowerConnectionToJson(
-        GithubUserFollowerConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubUserFollowingConnection _$GithubUserFollowingConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserFollowingConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubUserFollowingConnectionToJson(
-        GithubUserFollowingConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubUserContributionsCollection _$GithubUserContributionsCollectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserContributionsCollection()
-    ..contributionCalendar = json['contributionCalendar'] == null
-        ? null
-        : GithubUserContributionCalendar.fromJson(
-            json['contributionCalendar'] as Map<String, dynamic>);
-}
-
-Map<String, dynamic> _$GithubUserContributionsCollectionToJson(
-        GithubUserContributionsCollection instance) =>
-    <String, dynamic>{
-      'contributionCalendar': instance.contributionCalendar?.toJson(),
-    };
-
-GithubUserContributionCalendar _$GithubUserContributionCalendarFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserContributionCalendar()
-    ..weeks = (json['weeks'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubUserContributionCalendarWeek.fromJson(
-                e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubUserContributionCalendarToJson(
-        GithubUserContributionCalendar instance) =>
-    <String, dynamic>{
-      'weeks': instance.weeks?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubUserContributionCalendarWeek _$GithubUserContributionCalendarWeekFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserContributionCalendarWeek()
-    ..contributionDays = (json['contributionDays'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubUserContributionCalendarDay.fromJson(
-                e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubUserContributionCalendarWeekToJson(
-        GithubUserContributionCalendarWeek instance) =>
-    <String, dynamic>{
-      'contributionDays':
-          instance.contributionDays?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubUserContributionCalendarDay _$GithubUserContributionCalendarDayFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserContributionCalendarDay()..color = json['color'] as String;
-}
-
-Map<String, dynamic> _$GithubUserContributionCalendarDayToJson(
-        GithubUserContributionCalendarDay instance) =>
-    <String, dynamic>{
-      'color': instance.color,
-    };
-
-GithubUserRepositoryConnection _$GithubUserRepositoryConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserRepositoryConnection()
-    ..totalCount = json['totalCount'] as int
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubUserRepository.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubUserRepositoryConnectionToJson(
-        GithubUserRepositoryConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubUserRepository _$GithubUserRepositoryFromJson(Map<String, dynamic> json) {
-  return GithubUserRepository()
-    ..owner = json['owner'] == null
-        ? null
-        : GithubUserRepositoryOwner.fromJson(
-            json['owner'] as Map<String, dynamic>)
-    ..name = json['name'] as String
-    ..description = json['description'] as String
-    ..isPrivate = json['isPrivate'] as bool
-    ..isFork = json['isFork'] as bool
-    ..stargazers = json['stargazers'] == null
-        ? null
-        : GithubUserStargazerConnection.fromJson(
-            json['stargazers'] as Map<String, dynamic>)
-    ..forks = json['forks'] == null
-        ? null
-        : GithubUserRepositoryConnection.fromJson(
-            json['forks'] as Map<String, dynamic>)
-    ..primaryLanguage = json['primaryLanguage'] == null
-        ? null
-        : GithubUserLanguage.fromJson(
-            json['primaryLanguage'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserRepositoryToJson(
-        GithubUserRepository instance) =>
-    <String, dynamic>{
-      'owner': instance.owner?.toJson(),
-      'name': instance.name,
-      'description': instance.description,
-      'isPrivate': instance.isPrivate,
-      'isFork': instance.isFork,
-      'stargazers': instance.stargazers?.toJson(),
-      'forks': instance.forks?.toJson(),
-      'primaryLanguage': instance.primaryLanguage?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubUserStargazerConnection _$GithubUserStargazerConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserStargazerConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubUserStargazerConnectionToJson(
-        GithubUserStargazerConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubUserLanguage _$GithubUserLanguageFromJson(Map<String, dynamic> json) {
-  return GithubUserLanguage()
-    ..color = json['color'] as String
-    ..name = json['name'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserLanguageToJson(GithubUserLanguage instance) =>
-    <String, dynamic>{
-      'color': instance.color,
-      'name': instance.name,
-      '__typename': instance.resolveType,
-    };
-
-GithubUserNode _$GithubUserNodeFromJson(Map<String, dynamic> json) {
-  return GithubUserNode()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserNodeToJson(GithubUserNode instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUserPinnableItem _$GithubUserPinnableItemFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserPinnableItem();
-}
-
-Map<String, dynamic> _$GithubUserPinnableItemToJson(
-        GithubUserPinnableItem instance) =>
-    <String, dynamic>{};
-
-GithubUserProjectOwner _$GithubUserProjectOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserProjectOwner()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserProjectOwnerToJson(
-        GithubUserProjectOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUserRegistryPackageOwner _$GithubUserRegistryPackageOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserRegistryPackageOwner()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserRegistryPackageOwnerToJson(
-        GithubUserRegistryPackageOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUserRegistryPackageSearch _$GithubUserRegistryPackageSearchFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserRegistryPackageSearch()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserRegistryPackageSearchToJson(
-        GithubUserRegistryPackageSearch instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUserSubscribable _$GithubUserSubscribableFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserSubscribable()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserSubscribableToJson(
-        GithubUserSubscribable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUserStarrable _$GithubUserStarrableFromJson(Map<String, dynamic> json) {
-  return GithubUserStarrable()
-    ..stargazers = json['stargazers'] == null
-        ? null
-        : GithubUserStargazerConnection.fromJson(
-            json['stargazers'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserStarrableToJson(
-        GithubUserStarrable instance) =>
-    <String, dynamic>{
-      'stargazers': instance.stargazers?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubUserUniformResourceLocatable _$GithubUserUniformResourceLocatableFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserUniformResourceLocatable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserUniformResourceLocatableToJson(
-        GithubUserUniformResourceLocatable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUserRepositoryInfo _$GithubUserRepositoryInfoFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserRepositoryInfo()
-    ..owner = json['owner'] == null
-        ? null
-        : GithubUserRepositoryOwner.fromJson(
-            json['owner'] as Map<String, dynamic>)
-    ..name = json['name'] as String
-    ..description = json['description'] as String
-    ..isPrivate = json['isPrivate'] as bool
-    ..isFork = json['isFork'] as bool
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserRepositoryInfoToJson(
-        GithubUserRepositoryInfo instance) =>
-    <String, dynamic>{
-      'owner': instance.owner?.toJson(),
-      'name': instance.name,
-      'description': instance.description,
-      'isPrivate': instance.isPrivate,
-      'isFork': instance.isFork,
-      '__typename': instance.resolveType,
-    };
-
-GithubUserPinnableItemConnection _$GithubUserPinnableItemConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserPinnableItemConnection()
-    ..totalCount = json['totalCount'] as int
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubUserPinnableItem.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubUserPinnableItemConnectionToJson(
-        GithubUserPinnableItemConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubUserAuditEntryActor _$GithubUserAuditEntryActorFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserAuditEntryActor();
-}
-
-Map<String, dynamic> _$GithubUserAuditEntryActorToJson(
-        GithubUserAuditEntryActor instance) =>
-    <String, dynamic>{};
-
-GithubUserActor _$GithubUserActorFromJson(Map<String, dynamic> json) {
-  return GithubUserActor()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserActorToJson(GithubUserActor instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUserProfileOwner _$GithubUserProfileOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserProfileOwner()
-    ..name = json['name'] as String
-    ..location = json['location'] as String
-    ..email = json['email'] as String
-    ..websiteUrl = json['websiteUrl'] as String
-    ..pinnedItems = json['pinnedItems'] == null
-        ? null
-        : GithubUserPinnableItemConnection.fromJson(
-            json['pinnedItems'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserProfileOwnerToJson(
-        GithubUserProfileOwner instance) =>
-    <String, dynamic>{
-      'name': instance.name,
-      'location': instance.location,
-      'email': instance.email,
-      'websiteUrl': instance.websiteUrl,
-      'pinnedItems': instance.pinnedItems?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubUserSponsorable _$GithubUserSponsorableFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserSponsorable()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserSponsorableToJson(
-        GithubUserSponsorable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUserOrganization _$GithubUserOrganizationFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserOrganization()
-    ..name = json['name'] as String
-    ..description = json['description'] as String
-    ..location = json['location'] as String
-    ..email = json['email'] as String
-    ..websiteUrl = json['websiteUrl'] as String
-    ..createdAt = json['createdAt'] == null
-        ? null
-        : DateTime.parse(json['createdAt'] as String)
-    ..pinnedItems = json['pinnedItems'] == null
-        ? null
-        : GithubUserPinnableItemConnection.fromJson(
-            json['pinnedItems'] as Map<String, dynamic>)
-    ..pinnableItems = json['pinnableItems'] == null
-        ? null
-        : GithubUserPinnableItemConnection.fromJson(
-            json['pinnableItems'] as Map<String, dynamic>)
-    ..membersWithRole = json['membersWithRole'] == null
-        ? null
-        : GithubUserOrganizationMemberConnection.fromJson(
-            json['membersWithRole'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String
-    ..login = json['login'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..url = json['url'] as String;
-}
-
-Map<String, dynamic> _$GithubUserOrganizationToJson(
-        GithubUserOrganization instance) =>
-    <String, dynamic>{
-      'name': instance.name,
-      'description': instance.description,
-      'location': instance.location,
-      'email': instance.email,
-      'websiteUrl': instance.websiteUrl,
-      'createdAt': instance.createdAt?.toIso8601String(),
-      'pinnedItems': instance.pinnedItems?.toJson(),
-      'pinnableItems': instance.pinnableItems?.toJson(),
-      'membersWithRole': instance.membersWithRole?.toJson(),
-      '__typename': instance.resolveType,
-      'login': instance.login,
-      'avatarUrl': instance.avatarUrl,
-      'url': instance.url,
-    };
-
-GithubUserOrganizationMemberConnection
-    _$GithubUserOrganizationMemberConnectionFromJson(
-        Map<String, dynamic> json) {
-  return GithubUserOrganizationMemberConnection()
-    ..totalCount = json['totalCount'] as int;
-}
-
-Map<String, dynamic> _$GithubUserOrganizationMemberConnectionToJson(
-        GithubUserOrganizationMemberConnection instance) =>
-    <String, dynamic>{
-      'totalCount': instance.totalCount,
-    };
-
-GithubUserMemberStatusable _$GithubUserMemberStatusableFromJson(
-    Map<String, dynamic> json) {
-  return GithubUserMemberStatusable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUserMemberStatusableToJson(
-        GithubUserMemberStatusable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUserArguments _$GithubUserArgumentsFromJson(Map<String, dynamic> json) {
-  return GithubUserArguments(
-    login: json['login'] as String,
-    isViewer: json['isViewer'] as bool,
-  );
-}
-
-Map<String, dynamic> _$GithubUserArgumentsToJson(
-        GithubUserArguments instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'isViewer': instance.isViewer,
-    };

lib/graphql/github_users.g.dart

@@ -1,434 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'github_users.dart';
-
-// **************************************************************************
-// JsonSerializableGenerator
-// **************************************************************************
-
-GithubUsers _$GithubUsersFromJson(Map<String, dynamic> json) {
-  return GithubUsers()
-    ..user = json['user'] == null
-        ? null
-        : GithubUsersUser.fromJson(json['user'] as Map<String, dynamic>)
-    ..organization = json['organization'] == null
-        ? null
-        : GithubUsersOrganization.fromJson(
-            json['organization'] as Map<String, dynamic>)
-    ..repository = json['repository'] == null
-        ? null
-        : GithubUsersRepository.fromJson(
-            json['repository'] as Map<String, dynamic>);
-}
-
-Map<String, dynamic> _$GithubUsersToJson(GithubUsers instance) =>
-    <String, dynamic>{
-      'user': instance.user?.toJson(),
-      'organization': instance.organization?.toJson(),
-      'repository': instance.repository?.toJson(),
-    };
-
-GithubUsersUser _$GithubUsersUserFromJson(Map<String, dynamic> json) {
-  return GithubUsersUser()
-    ..login = json['login'] as String
-    ..name = json['name'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..company = json['company'] as String
-    ..location = json['location'] as String
-    ..createdAt = json['createdAt'] == null
-        ? null
-        : DateTime.parse(json['createdAt'] as String)
-    ..followers = json['followers'] == null
-        ? null
-        : GithubUsersFollowerConnection.fromJson(
-            json['followers'] as Map<String, dynamic>)
-    ..following = json['following'] == null
-        ? null
-        : GithubUsersFollowingConnection.fromJson(
-            json['following'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersUserToJson(GithubUsersUser instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'name': instance.name,
-      'avatarUrl': instance.avatarUrl,
-      'company': instance.company,
-      'location': instance.location,
-      'createdAt': instance.createdAt?.toIso8601String(),
-      'followers': instance.followers?.toJson(),
-      'following': instance.following?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersFollowerConnection _$GithubUsersFollowerConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersFollowerConnection()
-    ..pageInfo = json['pageInfo'] == null
-        ? null
-        : GithubUsersPageInfo.fromJson(json['pageInfo'] as Map<String, dynamic>)
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubUsersUser.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubUsersFollowerConnectionToJson(
-        GithubUsersFollowerConnection instance) =>
-    <String, dynamic>{
-      'pageInfo': instance.pageInfo?.toJson(),
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubUsersPageInfo _$GithubUsersPageInfoFromJson(Map<String, dynamic> json) {
-  return GithubUsersPageInfo()
-    ..hasNextPage = json['hasNextPage'] as bool
-    ..endCursor = json['endCursor'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersPageInfoToJson(
-        GithubUsersPageInfo instance) =>
-    <String, dynamic>{
-      'hasNextPage': instance.hasNextPage,
-      'endCursor': instance.endCursor,
-    };
-
-GithubUsersAuditEntryActor _$GithubUsersAuditEntryActorFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersAuditEntryActor();
-}
-
-Map<String, dynamic> _$GithubUsersAuditEntryActorToJson(
-        GithubUsersAuditEntryActor instance) =>
-    <String, dynamic>{};
-
-GithubUsersNode _$GithubUsersNodeFromJson(Map<String, dynamic> json) {
-  return GithubUsersNode()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersNodeToJson(GithubUsersNode instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersActor _$GithubUsersActorFromJson(Map<String, dynamic> json) {
-  return GithubUsersActor()
-    ..login = json['login'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersActorToJson(GithubUsersActor instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'avatarUrl': instance.avatarUrl,
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersRegistryPackageOwner _$GithubUsersRegistryPackageOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersRegistryPackageOwner()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersRegistryPackageOwnerToJson(
-        GithubUsersRegistryPackageOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersRegistryPackageSearch _$GithubUsersRegistryPackageSearchFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersRegistryPackageSearch()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersRegistryPackageSearchToJson(
-        GithubUsersRegistryPackageSearch instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersProjectOwner _$GithubUsersProjectOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersProjectOwner()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersProjectOwnerToJson(
-        GithubUsersProjectOwner instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersRepositoryOwner _$GithubUsersRepositoryOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersRepositoryOwner()
-    ..login = json['login'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersRepositoryOwnerToJson(
-        GithubUsersRepositoryOwner instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'avatarUrl': instance.avatarUrl,
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersUniformResourceLocatable
-    _$GithubUsersUniformResourceLocatableFromJson(Map<String, dynamic> json) {
-  return GithubUsersUniformResourceLocatable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersUniformResourceLocatableToJson(
-        GithubUsersUniformResourceLocatable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersProfileOwner _$GithubUsersProfileOwnerFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersProfileOwner()
-    ..login = json['login'] as String
-    ..name = json['name'] as String
-    ..location = json['location'] as String
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersProfileOwnerToJson(
-        GithubUsersProfileOwner instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'name': instance.name,
-      'location': instance.location,
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersSponsorable _$GithubUsersSponsorableFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersSponsorable()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersSponsorableToJson(
-        GithubUsersSponsorable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersFollowingConnection _$GithubUsersFollowingConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersFollowingConnection()
-    ..pageInfo = json['pageInfo'] == null
-        ? null
-        : GithubUsersPageInfo.fromJson(json['pageInfo'] as Map<String, dynamic>)
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubUsersUser.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubUsersFollowingConnectionToJson(
-        GithubUsersFollowingConnection instance) =>
-    <String, dynamic>{
-      'pageInfo': instance.pageInfo?.toJson(),
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubUsersOrganization _$GithubUsersOrganizationFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersOrganization()
-    ..login = json['login'] as String
-    ..name = json['name'] as String
-    ..avatarUrl = json['avatarUrl'] as String
-    ..location = json['location'] as String
-    ..membersWithRole = json['membersWithRole'] == null
-        ? null
-        : GithubUsersOrganizationMemberConnection.fromJson(
-            json['membersWithRole'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersOrganizationToJson(
-        GithubUsersOrganization instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'name': instance.name,
-      'avatarUrl': instance.avatarUrl,
-      'location': instance.location,
-      'membersWithRole': instance.membersWithRole?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersOrganizationMemberConnection
-    _$GithubUsersOrganizationMemberConnectionFromJson(
-        Map<String, dynamic> json) {
-  return GithubUsersOrganizationMemberConnection()
-    ..pageInfo = json['pageInfo'] == null
-        ? null
-        : GithubUsersPageInfo.fromJson(json['pageInfo'] as Map<String, dynamic>)
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubUsersUser.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubUsersOrganizationMemberConnectionToJson(
-        GithubUsersOrganizationMemberConnection instance) =>
-    <String, dynamic>{
-      'pageInfo': instance.pageInfo?.toJson(),
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubUsersMemberStatusable _$GithubUsersMemberStatusableFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersMemberStatusable()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersMemberStatusableToJson(
-        GithubUsersMemberStatusable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersRepository _$GithubUsersRepositoryFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersRepository()
-    ..watchers = json['watchers'] == null
-        ? null
-        : GithubUsersUserConnection.fromJson(
-            json['watchers'] as Map<String, dynamic>)
-    ..stargazers = json['stargazers'] == null
-        ? null
-        : GithubUsersStargazerConnection.fromJson(
-            json['stargazers'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersRepositoryToJson(
-        GithubUsersRepository instance) =>
-    <String, dynamic>{
-      'watchers': instance.watchers?.toJson(),
-      'stargazers': instance.stargazers?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersUserConnection _$GithubUsersUserConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersUserConnection()
-    ..pageInfo = json['pageInfo'] == null
-        ? null
-        : GithubUsersPageInfo.fromJson(json['pageInfo'] as Map<String, dynamic>)
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubUsersUser.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubUsersUserConnectionToJson(
-        GithubUsersUserConnection instance) =>
-    <String, dynamic>{
-      'pageInfo': instance.pageInfo?.toJson(),
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubUsersStargazerConnection _$GithubUsersStargazerConnectionFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersStargazerConnection()
-    ..pageInfo = json['pageInfo'] == null
-        ? null
-        : GithubUsersPageInfo.fromJson(json['pageInfo'] as Map<String, dynamic>)
-    ..nodes = (json['nodes'] as List)
-        ?.map((e) => e == null
-            ? null
-            : GithubUsersUser.fromJson(e as Map<String, dynamic>))
-        ?.toList();
-}
-
-Map<String, dynamic> _$GithubUsersStargazerConnectionToJson(
-        GithubUsersStargazerConnection instance) =>
-    <String, dynamic>{
-      'pageInfo': instance.pageInfo?.toJson(),
-      'nodes': instance.nodes?.map((e) => e?.toJson())?.toList(),
-    };
-
-GithubUsersPinnableItem _$GithubUsersPinnableItemFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersPinnableItem();
-}
-
-Map<String, dynamic> _$GithubUsersPinnableItemToJson(
-        GithubUsersPinnableItem instance) =>
-    <String, dynamic>{};
-
-GithubUsersSubscribable _$GithubUsersSubscribableFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersSubscribable()..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersSubscribableToJson(
-        GithubUsersSubscribable instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersStarrable _$GithubUsersStarrableFromJson(Map<String, dynamic> json) {
-  return GithubUsersStarrable()
-    ..stargazers = json['stargazers'] == null
-        ? null
-        : GithubUsersStargazerConnection.fromJson(
-            json['stargazers'] as Map<String, dynamic>)
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersStarrableToJson(
-        GithubUsersStarrable instance) =>
-    <String, dynamic>{
-      'stargazers': instance.stargazers?.toJson(),
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersRepositoryInfo _$GithubUsersRepositoryInfoFromJson(
-    Map<String, dynamic> json) {
-  return GithubUsersRepositoryInfo()
-    ..resolveType = json['__typename'] as String;
-}
-
-Map<String, dynamic> _$GithubUsersRepositoryInfoToJson(
-        GithubUsersRepositoryInfo instance) =>
-    <String, dynamic>{
-      '__typename': instance.resolveType,
-    };
-
-GithubUsersArguments _$GithubUsersArgumentsFromJson(Map<String, dynamic> json) {
-  return GithubUsersArguments(
-    login: json['login'] as String,
-    repoName: json['repoName'] as String,
-    after: json['after'] as String,
-    isFollowers: json['isFollowers'] as bool,
-    isFollowing: json['isFollowing'] as bool,
-    isMember: json['isMember'] as bool,
-    isStar: json['isStar'] as bool,
-    isWatch: json['isWatch'] as bool,
-  );
-}
-
-Map<String, dynamic> _$GithubUsersArgumentsToJson(
-        GithubUsersArguments instance) =>
-    <String, dynamic>{
-      'login': instance.login,
-      'repoName': instance.repoName,
-      'after': instance.after,
-      'isFollowers': instance.isFollowers,
-      'isFollowing': instance.isFollowing,
-      'isMember': instance.isMember,
-      'isStar': instance.isStar,
-      'isWatch': instance.isWatch,
-    };

lib/screens/commits.dart

@@ -1,5 +1,5 @@
 import 'package:flutter/material.dart';
-import 'package:git_touch/graphql/github_commits.dart';
+import 'package:git_touch/graphql/gh.dart';
 import 'package:git_touch/models/auth.dart';
 import 'package:git_touch/models/theme.dart';
 import 'package:git_touch/scaffolds/list_stateful.dart';
@@ -22,18 +22,18 @@ class CommitsScreen extends StatelessWidget {
 
   CommitsScreen(this.owner, this.name, {this.branch});
 
-  Future<ListPayload<GithubCommitsCommit, String>> _query(BuildContext context,
+  Future<ListPayload<GhCommitsCommit, String>> _query(BuildContext context,
       [String cursor]) async {
     final res = await Provider.of<AuthModel>(context).gqlClient.execute(
-        GithubCommitsQuery(
+        GhCommitsQuery(
-            variables: GithubCommitsArguments(
+            variables: GhCommitsArguments(
                 owner: owner,
                 name: name,
                 hasRef: branch != null,
                 ref: branch ?? '',
                 after: cursor)));
     final ref = res.data.repository.defaultBranchRef ?? res.data.repository.ref;
-    final history = (ref.target as GithubCommitsCommit).history;
+    final history = (ref.target as GhCommitsCommit).history;
     return ListPayload(
       cursor: history.pageInfo.endCursor,
       hasMore: history.pageInfo.hasNextPage,
@@ -41,12 +41,12 @@ class CommitsScreen extends StatelessWidget {
     );
   }
 
-  Widget _buildStatus(GithubCommitsStatusState state) {
+  Widget _buildStatus(GhCommitsStatusState state) {
     const size = 18.0;
     switch (state) {
-      case GithubCommitsStatusState.SUCCESS:
+      case GhCommitsStatusState.SUCCESS:
         return Icon(Octicons.check, color: GithubPalette.open, size: size);
-      case GithubCommitsStatusState.FAILURE:
+      case GhCommitsStatusState.FAILURE:
         return Icon(Octicons.x, color: GithubPalette.closed, size: size);
       default:
         return Container();
@@ -57,7 +57,7 @@ class CommitsScreen extends StatelessWidget {
   Widget build(BuildContext context) {
     final theme = Provider.of<ThemeModel>(context);
 
-    return ListStatefulScaffold<GithubCommitsCommit, String>(
+    return ListStatefulScaffold<GhCommitsCommit, String>(
       title: AppBarTitle('Commits'),
       onRefresh: () => _query(context),
       onLoadMore: (cursor) => _query(context, cursor),

lib/screens/object.dart

@@ -1,7 +1,7 @@
 import 'package:flutter/cupertino.dart';
 import 'package:flutter_highlight/theme_map.dart';
 import 'package:flutter_svg/flutter_svg.dart';
-import 'package:git_touch/graphql/github_object.dart';
+import 'package:git_touch/graphql/gh.dart';
 import 'package:git_touch/models/code.dart';
 import 'package:git_touch/models/theme.dart';
 import 'package:git_touch/scaffolds/refresh_stateful.dart';
@@ -54,7 +54,7 @@ class ObjectScreen extends StatelessWidget {
 
   static const _iconDefaultColor = PrimerColors.blue300;
 
-  Widget _buildIcon(GithubObjectTreeEntry item) {
+  Widget _buildIcon(GhObjectTreeEntry item) {
     switch (item.type) {
       case 'blob':
         return SetiIcon(item.name, size: 36);
@@ -74,14 +74,14 @@ class ObjectScreen extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return RefreshStatefulScaffold<GithubObjectGitObject>(
+    return RefreshStatefulScaffold<GhObjectGitObject>(
       canRefresh: !_isImage,
       title: AppBarTitle(_path.isEmpty ? 'Files' : _path),
       fetchData: () async {
         final res = await Provider.of<AuthModel>(context)
             .gqlClient
-            .execute(GithubObjectQuery(
+            .execute(GhObjectQuery(
-              variables: GithubObjectArguments(
+              variables: GhObjectArguments(
                 owner: owner,
                 name: name,
                 expression: _expression,
@@ -90,7 +90,7 @@ class ObjectScreen extends StatelessWidget {
         final data = res.data.repository.object;
 
         if (data.resolveType == 'Tree') {
-          (data as GithubObjectTree).entries.sort((a, b) {
+          (data as GhObjectTree).entries.sort((a, b) {
             if (a.type == 'tree' && b.type == 'blob') {
               return -1;
             }
@@ -106,7 +106,7 @@ class ObjectScreen extends StatelessWidget {
       actionBuilder: (data, _) {
         switch (data.resolveType) {
           case 'Blob':
-            final blob = data as GithubObjectBlob;
+            final blob = data as GhObjectBlob;
             return ActionEntry(
               iconData: Octicons.settings,
               onTap: () {
@@ -124,7 +124,7 @@ class ObjectScreen extends StatelessWidget {
       bodyBuilder: (data, _) {
         switch (data.resolveType) {
           case 'Tree':
-            final tree = data as GithubObjectTree;
+            final tree = data as GhObjectTree;
 
             return TableView(
               hasIcon: true,
@@ -143,7 +143,7 @@ class ObjectScreen extends StatelessWidget {
           case 'Blob':
             final codeProvider = Provider.of<CodeModel>(context);
             final theme = Provider.of<ThemeModel>(context);
-            final text = (data as GithubObjectBlob).text;
+            final text = (data as GhObjectBlob).text;
 
             switch (_extname) {
               // TODO: All image types

lib/screens/repositories.dart

@@ -1,5 +1,5 @@
 import 'package:flutter/material.dart';
-import 'package:git_touch/graphql/github_repositories.dart';
+import 'package:git_touch/graphql/gh.dart';
 import 'package:git_touch/scaffolds/list_stateful.dart';
 import 'package:git_touch/utils/utils.dart';
 import 'package:git_touch/widgets/app_bar_title.dart';
@@ -19,17 +19,16 @@ class RepositoriesScreen extends StatelessWidget {
       : title = 'Stars',
         isStar = true;
 
-  Future<ListPayload<GithubRepositoriesRepository, String>> _query(
+  Future<ListPayload<GhReposRepository, String>> _query(BuildContext context,
-      BuildContext context,
       [String cursor]) async {
     final res = await Provider.of<AuthModel>(context).gqlClient.execute(
-        GithubRepositoriesQuery(
+        GhReposQuery(
-            variables: GithubRepositoriesArguments(
+            variables:
-                owner: owner, isStar: isStar, after: cursor)));
+                GhReposArguments(owner: owner, isStar: isStar, after: cursor)));
     final data = res.data.repositoryOwner;
     switch (data.resolveType) {
       case 'User':
-        final user = data as GithubRepositoriesUser;
+        final user = data as GhReposUser;
         if (isStar) {
           return ListPayload(
             cursor: user.starredRepositories.pageInfo.endCursor,
@@ -45,7 +44,7 @@ class RepositoriesScreen extends StatelessWidget {
         }
         break;
       case 'Organization':
-        final org = data as GithubRepositoriesOrganization;
+        final org = data as GhReposOrganization;
         return ListPayload(
           cursor: org.pinnableItems.pageInfo.endCursor,
           items: org.pinnableItems.nodes,
@@ -58,7 +57,7 @@ class RepositoriesScreen extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return ListStatefulScaffold<GithubRepositoriesRepository, String>(
+    return ListStatefulScaffold<GhReposRepository, String>(
         title: AppBarTitle(title),
         onRefresh: () => _query(context),
         onLoadMore: (cursor) => _query(context, cursor),

lib/screens/repository.dart

@@ -2,7 +2,7 @@ import 'dart:convert';
 import 'package:filesize/filesize.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/cupertino.dart';
-import 'package:git_touch/graphql/github_repository.dart';
+import 'package:git_touch/graphql/gh.dart';
 import 'package:git_touch/models/auth.dart';
 import 'package:git_touch/scaffolds/refresh_stateful.dart';
 import 'package:git_touch/utils/utils.dart';
@@ -35,10 +35,10 @@ class RepositoryScreen extends StatelessWidget {
 
   RepositoryScreen(this.owner, this.name, {this.branch});
 
-  Future<GithubRepositoryRepository> _query(BuildContext context) async {
+  Future<GhRepoRepository> _query(BuildContext context) async {
     var res = await Provider.of<AuthModel>(context).gqlClient.execute(
-        GithubRepositoryQuery(
+        GhRepoQuery(
-            variables: GithubRepositoryArguments(
+            variables: GhRepoArguments(
                 owner: owner,
                 name: name,
                 branchSpecified: branch != null,
@@ -61,14 +61,14 @@ class RepositoryScreen extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return RefreshStatefulScaffold<Tuple2<GithubRepositoryRepository, String>>(
+    return RefreshStatefulScaffold<Tuple2<GhRepoRepository, String>>(
       title: AppBarTitle('Repository'),
       fetchData: () async {
         final rs = await Future.wait([
           _query(context),
           _fetchReadme(context),
         ]);
-        return Tuple2(rs[0] as GithubRepositoryRepository, rs[1] as String);
+        return Tuple2(rs[0] as GhRepoRepository, rs[1] as String);
       },
       actionBuilder: (data, setState) {
         final repo = data.item1;
@@ -251,7 +251,7 @@ class RepositoryScreen extends StatelessWidget {
                         height: 400,
                         child: charts.PieChart(
                           [
-                            charts.Series<GithubRepositoryLanguageEdge, String>(
+                            charts.Series<GhRepoLanguageEdge, String>(
                               id: 'languages',
                               domainFn: (v, _) => v.node.name,
                               measureFn: (v, _) => v.size,
@@ -332,7 +332,7 @@ class RepositoryScreen extends StatelessWidget {
                 TableViewItem(
                   leftIconData: Octicons.history,
                   text: Text('Commits'),
-                  rightWidget: Text((ref.target as GithubRepositoryCommit)
+                  rightWidget: Text((ref.target as GhRepoCommit)
                       .history
                       ?.totalCount
                       .toString()),

lib/screens/user.dart

@@ -1,6 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/cupertino.dart';
-import 'package:git_touch/graphql/github_user.dart';
+import 'package:git_touch/graphql/gh.dart';
 import 'package:git_touch/models/theme.dart';
 import 'package:git_touch/scaffolds/refresh_stateful.dart';
 import 'package:git_touch/screens/users.dart';
@@ -45,10 +45,10 @@ class UserScreen extends StatelessWidget {
 
   bool get isViewer => login.isEmpty;
 
-  Iterable<Widget> _buildPinnedItems(Iterable<GithubUserRepository> pinnedItems,
+  Iterable<Widget> _buildPinnedItems(Iterable<GhUserRepository> pinnedItems,
-      Iterable<GithubUserRepository> repositories) {
+      Iterable<GhUserRepository> repositories) {
     String title;
-    Iterable<GithubUserRepository> items = [];
+    Iterable<GhUserRepository> items = [];
 
     if (pinnedItems.isNotEmpty) {
       title = 'pinned repositories';
@@ -148,7 +148,7 @@ class UserScreen extends StatelessWidget {
     );
   }
 
-  Widget _buildUser(BuildContext context, GithubUserUser user) {
+  Widget _buildUser(BuildContext context, GhUserUser user) {
     final theme = Provider.of<ThemeModel>(context);
     final login = user.login;
     return Column(
@@ -280,16 +280,15 @@ class UserScreen extends StatelessWidget {
         else
           ..._buildPinnedItems(
               user.pinnedItems.nodes
-                  .where((n) => n is GithubUserRepository)
+                  .where((n) => n is GhUserRepository)
-                  .cast<GithubUserRepository>(),
+                  .cast<GhUserRepository>(),
               user.repositories.nodes),
         CommonStyle.verticalGap,
       ],
     );
   }
 
-  Widget _buildOrganization(
+  Widget _buildOrganization(BuildContext context, GhUserOrganization payload) {
-      BuildContext context, GithubUserOrganization payload) {
     return Column(
       crossAxisAlignment: CrossAxisAlignment.stretch,
       children: <Widget>[
@@ -346,11 +345,11 @@ class UserScreen extends StatelessWidget {
         CommonStyle.verticalGap,
         ..._buildPinnedItems(
           payload.pinnedItems.nodes
-              .where((n) => n is GithubUserRepository)
+              .where((n) => n is GhUserRepository)
-              .cast<GithubUserRepository>(),
+              .cast<GhUserRepository>(),
           payload.pinnableItems.nodes
-              .where((n) => n is GithubUserRepository)
+              .where((n) => n is GhUserRepository)
-              .cast<GithubUserRepository>(),
+              .cast<GhUserRepository>(),
         ),
         CommonStyle.verticalGap,
       ],
@@ -359,19 +358,18 @@ class UserScreen extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return RefreshStatefulScaffold<GithubUserRepositoryOwner>(
+    return RefreshStatefulScaffold<GhUserRepositoryOwner>(
       fetchData: () async {
         final data = await Provider.of<AuthModel>(context).gqlClient.execute(
-            GithubUserQuery(
+            GhUserQuery(
-                variables:
+                variables: GhUserArguments(login: login, isViewer: isViewer)));
-                    GithubUserArguments(login: login, isViewer: isViewer)));
         return isViewer ? data.data.viewer : data.data.repositoryOwner;
       },
       title: AppBarTitle(isViewer ? 'Me' : login),
       actionBuilder: (payload, _) {
         switch (payload.resolveType) {
           case 'User':
-            final user = payload as GithubUserUser;
+            final user = payload as GhUserUser;
             return ActionButton(
               title: 'User Actions',
               items: [
@@ -398,7 +396,7 @@ class UserScreen extends StatelessWidget {
               ],
             );
           case 'Organization':
-            final organization = payload as GithubUserOrganization;
+            final organization = payload as GhUserOrganization;
             return ActionButton(
               title: 'Organization Actions',
               items: [
@@ -414,14 +412,13 @@ class UserScreen extends StatelessWidget {
       },
       bodyBuilder: (payload, _) {
         if (isViewer) {
-          return _buildUser(context, payload as GithubUserUser);
+          return _buildUser(context, payload as GhUserUser);
         }
         switch (payload.resolveType) {
           case 'User':
-            return _buildUser(context, payload as GithubUserUser);
+            return _buildUser(context, payload as GhUserUser);
           case 'Organization':
-            return _buildOrganization(
+            return _buildOrganization(context, payload as GhUserOrganization);
-                context, payload as GithubUserOrganization);
           default:
             return null;
         }

lib/screens/users.dart

@@ -1,5 +1,5 @@
 import 'package:flutter/material.dart';
-import 'package:git_touch/graphql/github_users.dart';
+import 'package:git_touch/graphql/gh.dart';
 import 'package:git_touch/models/theme.dart';
 import 'package:git_touch/scaffolds/list_stateful.dart';
 import 'package:git_touch/utils/utils.dart';
@@ -40,11 +40,11 @@ class UsersScreen extends StatelessWidget {
     }
   }
 
-  Future<ListPayload<GithubUsersUser, String>> _queryUsers(BuildContext context,
+  Future<ListPayload<GhUsersUser, String>> _queryUsers(BuildContext context,
       [String cursor]) async {
     final res = await Provider.of<AuthModel>(context).gqlClient.execute(
-        GithubUsersQuery(
+        GhUsersQuery(
-            variables: GithubUsersArguments(
+            variables: GhUsersArguments(
                 login: login,
                 repoName: repoName,
                 isFollowers: type == UsersScreenType.follower,
@@ -139,7 +139,7 @@ class UsersScreen extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return ListStatefulScaffold<GithubUsersUser, String>(
+    return ListStatefulScaffold<GhUsersUser, String>(
       title: AppBarTitle(_title),
       onRefresh: () => _queryUsers(context),
       onLoadMore: (cursor) => _queryUsers(context, cursor),

lib/widgets/repository_item.dart

@@ -1,7 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/cupertino.dart';
-import 'package:git_touch/graphql/github_repository.dart';
+import 'package:git_touch/graphql/gh.dart'; // FIXME:
-import 'package:git_touch/graphql/github_user.dart';
 import 'package:git_touch/models/gitea.dart';
 import 'package:git_touch/models/gitlab.dart';
 import 'package:git_touch/models/theme.dart';
@@ -44,7 +43,7 @@ class RepositoryItem extends StatelessWidget {
   final String primaryLanguageName;
   final String primaryLanguageColor;
   final bool inRepoScreen;
-  final Iterable<GithubRepositoryRepositoryTopic> topics;
+  final Iterable<GhRepoRepositoryTopic> topics;
 
   RepositoryItem.raw(
       this.owner,
@@ -75,8 +74,7 @@ class RepositoryItem extends StatelessWidget {
             : payload['primaryLanguage']['color'],
         this.topics = [];
 
-  RepositoryItem.github(GithubUserRepository payload,
+  RepositoryItem.github(GhUserRepository payload, {this.inRepoScreen = false})
-      {this.inRepoScreen = false})
       : this.owner = payload.owner.login,
         this.avatarUrl = payload.owner.avatarUrl,
         this.name = payload.name,