git-touch-android-ios-app/lib/graphql/gh.dart

10068 lines
346 KiB
Dart
Raw Normal View History

2020-01-07 08:07:57 +01:00
// GENERATED CODE - DO NOT MODIFY BY HAND
2020-01-26 12:39:15 +01:00
import 'package:meta/meta.dart';
2020-01-07 08:07:57 +01:00
import 'package:artemis/artemis.dart';
import 'package:json_annotation/json_annotation.dart';
import 'package:equatable/equatable.dart';
import 'package:gql/ast.dart';
part 'gh.g.dart';
@JsonSerializable(explicitToJson: true)
class GhRepo with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepo({this.repository});
2020-01-07 08:07:57 +01:00
factory GhRepo.fromJson(Map<String, dynamic> json) => _$GhRepoFromJson(json);
GhRepoRepository repository;
@override
List<Object> get props => [repository];
Map<String, dynamic> toJson() => _$GhRepoToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRepository extends GhRepoPinnableItem
with EquatableMixin
implements
GhRepoNode,
GhRepoProjectOwner,
GhRepoRegistryPackageOwner,
GhRepoRegistryPackageSearch,
GhRepoSubscribable,
GhRepoStarrable,
GhRepoUniformResourceLocatable,
GhRepoRepositoryInfo {
2020-01-26 12:39:15 +01:00
GhRepoRepository(
{this.forks,
this.primaryLanguage,
this.diskUsage,
this.watchers,
this.issues,
this.pullRequests,
this.releases,
this.languages,
this.defaultBranchRef,
this.ref,
this.refs,
this.repositoryTopics});
2020-01-07 08:07:57 +01:00
factory GhRepoRepository.fromJson(Map<String, dynamic> json) =>
_$GhRepoRepositoryFromJson(json);
@override
GhRepoRepositoryOwner owner;
@override
String name;
@override
String description;
@override
String homepageUrl;
@override
bool isPrivate;
@override
bool isFork;
@override
GhRepoStargazerConnection stargazers;
GhRepoRepositoryConnection forks;
GhRepoLanguage primaryLanguage;
@override
String id;
int diskUsage;
@override
bool hasIssuesEnabled;
@override
String url;
@override
bool viewerHasStarred;
2020-01-20 07:18:45 +01:00
@override
2020-02-06 06:53:43 +01:00
@JsonKey(unknownEnumValue: GhRepoSubscriptionState.ARTEMIS_UNKNOWN)
2020-01-20 07:18:45 +01:00
GhRepoSubscriptionState viewerSubscription;
2020-01-07 08:07:57 +01:00
@override
String projectsUrl;
GhRepoUserConnection watchers;
GhRepoIssueConnection issues;
GhRepoPullRequestConnection pullRequests;
@override
GhRepoProjectConnection projects;
GhRepoReleaseConnection releases;
GhRepoLanguageConnection languages;
GhRepoRef defaultBranchRef;
GhRepoRef ref;
GhRepoRefConnection refs;
@override
GhRepoLicense licenseInfo;
GhRepoRepositoryTopicConnection repositoryTopics;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [
owner,
name,
description,
homepageUrl,
isPrivate,
isFork,
stargazers,
forks,
primaryLanguage,
id,
diskUsage,
hasIssuesEnabled,
url,
viewerHasStarred,
2020-01-20 07:18:45 +01:00
viewerSubscription,
2020-01-07 08:07:57 +01:00
projectsUrl,
watchers,
issues,
pullRequests,
projects,
releases,
languages,
defaultBranchRef,
ref,
refs,
licenseInfo,
repositoryTopics,
resolveType
];
Map<String, dynamic> toJson() => _$GhRepoRepositoryToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRepositoryOwner with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoRepositoryOwner({this.login, this.avatarUrl});
2020-01-07 08:07:57 +01:00
factory GhRepoRepositoryOwner.fromJson(Map<String, dynamic> json) =>
_$GhRepoRepositoryOwnerFromJson(json);
String login;
String avatarUrl;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [login, avatarUrl, resolveType];
Map<String, dynamic> toJson() => _$GhRepoRepositoryOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoStargazerConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoStargazerConnection({this.totalCount});
2020-01-07 08:07:57 +01:00
factory GhRepoStargazerConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoStargazerConnectionFromJson(json);
int totalCount;
@override
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhRepoStargazerConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRepositoryConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoRepositoryConnection({this.totalCount});
2020-01-07 08:07:57 +01:00
factory GhRepoRepositoryConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoRepositoryConnectionFromJson(json);
int totalCount;
@override
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhRepoRepositoryConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoLanguage with EquatableMixin implements GhRepoNode {
2020-01-26 12:39:15 +01:00
GhRepoLanguage({this.color, this.name});
2020-01-07 08:07:57 +01:00
factory GhRepoLanguage.fromJson(Map<String, dynamic> json) =>
_$GhRepoLanguageFromJson(json);
String color;
String name;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [color, name, resolveType];
Map<String, dynamic> toJson() => _$GhRepoLanguageToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoNode with EquatableMixin {
GhRepoNode();
factory GhRepoNode.fromJson(Map<String, dynamic> json) =>
_$GhRepoNodeFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhRepoNodeToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoUserConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoUserConnection({this.totalCount});
2020-01-07 08:07:57 +01:00
factory GhRepoUserConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoUserConnectionFromJson(json);
int totalCount;
@override
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhRepoUserConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoIssueConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoIssueConnection({this.totalCount});
2020-01-07 08:07:57 +01:00
factory GhRepoIssueConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoIssueConnectionFromJson(json);
int totalCount;
@override
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhRepoIssueConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoPullRequestConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoPullRequestConnection({this.totalCount});
2020-01-07 08:07:57 +01:00
factory GhRepoPullRequestConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoPullRequestConnectionFromJson(json);
int totalCount;
@override
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhRepoPullRequestConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoProjectConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoProjectConnection({this.totalCount});
2020-01-07 08:07:57 +01:00
factory GhRepoProjectConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoProjectConnectionFromJson(json);
int totalCount;
@override
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhRepoProjectConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoReleaseConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoReleaseConnection({this.totalCount});
2020-01-07 08:07:57 +01:00
factory GhRepoReleaseConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoReleaseConnectionFromJson(json);
int totalCount;
@override
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhRepoReleaseConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoLanguageConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoLanguageConnection({this.totalSize, this.edges});
2020-01-07 08:07:57 +01:00
factory GhRepoLanguageConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoLanguageConnectionFromJson(json);
int totalSize;
List<GhRepoLanguageEdge> edges;
@override
List<Object> get props => [totalSize, edges];
Map<String, dynamic> toJson() => _$GhRepoLanguageConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoLanguageEdge with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoLanguageEdge({this.size, this.node});
2020-01-07 08:07:57 +01:00
factory GhRepoLanguageEdge.fromJson(Map<String, dynamic> json) =>
_$GhRepoLanguageEdgeFromJson(json);
int size;
GhRepoLanguage node;
@override
List<Object> get props => [size, node];
Map<String, dynamic> toJson() => _$GhRepoLanguageEdgeToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRef with EquatableMixin implements GhRepoNode {
2020-01-26 12:39:15 +01:00
GhRepoRef({this.name, this.target});
2020-01-07 08:07:57 +01:00
factory GhRepoRef.fromJson(Map<String, dynamic> json) =>
_$GhRepoRefFromJson(json);
String name;
GhRepoGitObject target;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [name, target, resolveType];
Map<String, dynamic> toJson() => _$GhRepoRefToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoGitObject with EquatableMixin {
GhRepoGitObject();
factory GhRepoGitObject.fromJson(Map<String, dynamic> json) {
switch (json['__typename'].toString()) {
case 'Commit':
return GhRepoCommit.fromJson(json);
default:
}
return _$GhRepoGitObjectFromJson(json);
}
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() {
switch (resolveType) {
case 'Commit':
return (this as GhRepoCommit).toJson();
default:
}
return _$GhRepoGitObjectToJson(this);
}
}
@JsonSerializable(explicitToJson: true)
class GhRepoCommit extends GhRepoPullRequestTimelineItem
with EquatableMixin
implements
GhRepoNode,
GhRepoGitObject,
GhRepoSubscribable,
GhRepoUniformResourceLocatable {
2020-01-26 12:39:15 +01:00
GhRepoCommit({this.history});
2020-01-07 08:07:57 +01:00
factory GhRepoCommit.fromJson(Map<String, dynamic> json) =>
_$GhRepoCommitFromJson(json);
GhRepoCommitHistoryConnection history;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [history, resolveType];
Map<String, dynamic> toJson() => _$GhRepoCommitToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoCommitHistoryConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoCommitHistoryConnection({this.totalCount});
2020-01-07 08:07:57 +01:00
factory GhRepoCommitHistoryConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoCommitHistoryConnectionFromJson(json);
int totalCount;
@override
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhRepoCommitHistoryConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoPullRequestTimelineItem with EquatableMixin {
GhRepoPullRequestTimelineItem();
factory GhRepoPullRequestTimelineItem.fromJson(Map<String, dynamic> json) =>
_$GhRepoPullRequestTimelineItemFromJson(json);
@override
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhRepoPullRequestTimelineItemToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoSubscribable with EquatableMixin {
GhRepoSubscribable();
factory GhRepoSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhRepoSubscribableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhRepoSubscribableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoUniformResourceLocatable with EquatableMixin {
GhRepoUniformResourceLocatable();
factory GhRepoUniformResourceLocatable.fromJson(Map<String, dynamic> json) =>
_$GhRepoUniformResourceLocatableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhRepoUniformResourceLocatableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRefConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoRefConnection({this.totalCount, this.nodes});
2020-01-07 08:07:57 +01:00
factory GhRepoRefConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoRefConnectionFromJson(json);
int totalCount;
List<GhRepoRef> nodes;
@override
List<Object> get props => [totalCount, nodes];
Map<String, dynamic> toJson() => _$GhRepoRefConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoLicense with EquatableMixin implements GhRepoNode {
2020-01-26 12:39:15 +01:00
GhRepoLicense({this.name, this.spdxId});
2020-01-07 08:07:57 +01:00
factory GhRepoLicense.fromJson(Map<String, dynamic> json) =>
_$GhRepoLicenseFromJson(json);
String name;
String spdxId;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [name, spdxId, resolveType];
Map<String, dynamic> toJson() => _$GhRepoLicenseToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRepositoryTopicConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoRepositoryTopicConnection({this.nodes});
2020-01-07 08:07:57 +01:00
factory GhRepoRepositoryTopicConnection.fromJson(Map<String, dynamic> json) =>
_$GhRepoRepositoryTopicConnectionFromJson(json);
List<GhRepoRepositoryTopic> nodes;
@override
List<Object> get props => [nodes];
Map<String, dynamic> toJson() =>
_$GhRepoRepositoryTopicConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRepositoryTopic
with EquatableMixin
implements GhRepoNode, GhRepoUniformResourceLocatable {
2020-01-26 12:39:15 +01:00
GhRepoRepositoryTopic({this.topic});
2020-01-07 08:07:57 +01:00
factory GhRepoRepositoryTopic.fromJson(Map<String, dynamic> json) =>
_$GhRepoRepositoryTopicFromJson(json);
@override
String url;
GhRepoTopic topic;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [url, topic, resolveType];
Map<String, dynamic> toJson() => _$GhRepoRepositoryTopicToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoTopic with EquatableMixin implements GhRepoNode, GhRepoStarrable {
2020-01-26 12:39:15 +01:00
GhRepoTopic({this.name});
2020-01-07 08:07:57 +01:00
factory GhRepoTopic.fromJson(Map<String, dynamic> json) =>
_$GhRepoTopicFromJson(json);
String name;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [name, resolveType];
Map<String, dynamic> toJson() => _$GhRepoTopicToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoStarrable with EquatableMixin {
GhRepoStarrable();
factory GhRepoStarrable.fromJson(Map<String, dynamic> json) =>
_$GhRepoStarrableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhRepoStarrableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoPinnableItem with EquatableMixin {
GhRepoPinnableItem();
factory GhRepoPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhRepoPinnableItemFromJson(json);
@override
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhRepoPinnableItemToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoProjectOwner with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoProjectOwner({this.id, this.projectsUrl, this.projects});
2020-01-07 08:07:57 +01:00
factory GhRepoProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhRepoProjectOwnerFromJson(json);
String id;
String projectsUrl;
GhRepoProjectConnection projects;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [id, projectsUrl, projects, resolveType];
Map<String, dynamic> toJson() => _$GhRepoProjectOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRegistryPackageOwner with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoRegistryPackageOwner({this.id});
2020-01-07 08:07:57 +01:00
factory GhRepoRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhRepoRegistryPackageOwnerFromJson(json);
String id;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [id, resolveType];
Map<String, dynamic> toJson() => _$GhRepoRegistryPackageOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRegistryPackageSearch with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoRegistryPackageSearch({this.id});
2020-01-07 08:07:57 +01:00
factory GhRepoRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhRepoRegistryPackageSearchFromJson(json);
String id;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [id, resolveType];
Map<String, dynamic> toJson() => _$GhRepoRegistryPackageSearchToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhRepoRepositoryInfo with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoRepositoryInfo(
{this.owner,
this.name,
this.description,
this.homepageUrl,
this.isPrivate,
this.isFork,
this.hasIssuesEnabled,
this.url,
this.licenseInfo});
2020-01-07 08:07:57 +01:00
factory GhRepoRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhRepoRepositoryInfoFromJson(json);
GhRepoRepositoryOwner owner;
String name;
String description;
String homepageUrl;
bool isPrivate;
bool isFork;
bool hasIssuesEnabled;
String url;
GhRepoLicense licenseInfo;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [
owner,
name,
description,
homepageUrl,
isPrivate,
isFork,
hasIssuesEnabled,
url,
licenseInfo,
resolveType
];
Map<String, dynamic> toJson() => _$GhRepoRepositoryInfoToJson(this);
}
2020-01-20 07:18:45 +01:00
enum GhRepoSubscriptionState {
UNSUBSCRIBED,
SUBSCRIBED,
IGNORED,
2020-02-06 06:53:43 +01:00
ARTEMIS_UNKNOWN,
2020-01-20 07:18:45 +01:00
}
2020-01-07 08:07:57 +01:00
@JsonSerializable(explicitToJson: true)
class GhRepoArguments extends JsonSerializable with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhRepoArguments(
{@required this.owner,
@required this.name,
@required this.branchSpecified,
@required this.branch});
2020-01-07 08:07:57 +01:00
factory GhRepoArguments.fromJson(Map<String, dynamic> json) =>
_$GhRepoArgumentsFromJson(json);
final String owner;
final String name;
final bool branchSpecified;
final String branch;
@override
List<Object> get props => [owner, name, branchSpecified, branch];
Map<String, dynamic> toJson() => _$GhRepoArgumentsToJson(this);
}
class GhRepoQuery extends GraphQLQuery<GhRepo, GhRepoArguments> {
GhRepoQuery({this.variables});
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
type: OperationType.query,
name: NameNode(value: 'GhRepo'),
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: 'branchSpecified')),
type: NamedTypeNode(
name: NameNode(value: 'Boolean'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'branch')),
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: 'owner'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: '__typename'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'avatarUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'description'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'homepageUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isPrivate'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isFork'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'stargazers'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'forks'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'primaryLanguage'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'color'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'id'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'diskUsage'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'hasIssuesEnabled'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'url'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'viewerHasStarred'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
2020-01-20 07:18:45 +01:00
FieldNode(
name: NameNode(value: 'viewerSubscription'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
2020-01-07 08:07:57 +01:00
FieldNode(
name: NameNode(value: 'projectsUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'watchers'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'issues'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'states'),
value: EnumValueNode(name: NameNode(value: 'OPEN')))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'pullRequests'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'states'),
value: EnumValueNode(name: NameNode(value: 'OPEN')))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'projects'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'releases'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'languages'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '10')),
ArgumentNode(
name: NameNode(value: 'orderBy'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'field'),
value: EnumValueNode(
name: NameNode(value: 'SIZE'))),
ObjectFieldNode(
name: NameNode(value: 'direction'),
value: EnumValueNode(
name: NameNode(value: 'DESC')))
]))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalSize'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'edges'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'size'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'node'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'color'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
])),
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: 'branchSpecified')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
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: 'history'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
])),
FieldNode(
name: NameNode(value: 'ref'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'qualifiedName'),
value: VariableNode(name: NameNode(value: 'branch')))
],
directives: [
DirectiveNode(
name: NameNode(value: 'include'),
arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(
name: NameNode(value: 'branchSpecified')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
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: 'history'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
])),
FieldNode(
name: NameNode(value: 'refs'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '100')),
ArgumentNode(
name: NameNode(value: 'refPrefix'),
value: StringValueNode(
value: 'refs/heads/', isBlock: false))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'nodes'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
])),
FieldNode(
name: NameNode(value: 'licenseInfo'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'spdxId'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'repositoryTopics'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '10'))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'nodes'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'url'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'topic'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
]))
]))
]);
@override
final String operationName = 'GhRepo';
@override
final GhRepoArguments variables;
@override
List<Object> get props => [document, operationName, variables];
@override
GhRepo parse(Map<String, dynamic> json) => GhRepo.fromJson(json);
}
@JsonSerializable(explicitToJson: true)
class GhUsers with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsers({this.user, this.organization, this.repository});
2020-01-07 08:07:57 +01:00
factory GhUsers.fromJson(Map<String, dynamic> json) =>
_$GhUsersFromJson(json);
GhUsersUser user;
GhUsersOrganization organization;
GhUsersRepository repository;
@override
List<Object> get props => [user, organization, repository];
Map<String, dynamic> toJson() => _$GhUsersToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersUser extends GhUsersAuditEntryActor
with EquatableMixin
implements
GhUsersNode,
GhUsersActor,
GhUsersRegistryPackageOwner,
GhUsersRegistryPackageSearch,
GhUsersProjectOwner,
GhUsersRepositoryOwner,
GhUsersUniformResourceLocatable,
GhUsersProfileOwner,
GhUsersSponsorable {
2020-01-26 12:39:15 +01:00
GhUsersUser({this.company, this.createdAt, this.followers, this.following});
2020-01-07 08:07:57 +01:00
factory GhUsersUser.fromJson(Map<String, dynamic> json) =>
_$GhUsersUserFromJson(json);
@override
String login;
@override
String name;
@override
String avatarUrl;
String company;
@override
String location;
DateTime createdAt;
GhUsersFollowerConnection followers;
GhUsersFollowingConnection following;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [
login,
name,
avatarUrl,
company,
location,
createdAt,
followers,
following,
resolveType
];
Map<String, dynamic> toJson() => _$GhUsersUserToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersFollowerConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersFollowerConnection({this.pageInfo, this.nodes});
2020-01-07 08:07:57 +01:00
factory GhUsersFollowerConnection.fromJson(Map<String, dynamic> json) =>
_$GhUsersFollowerConnectionFromJson(json);
GhUsersPageInfo pageInfo;
List<GhUsersUser> nodes;
@override
List<Object> get props => [pageInfo, nodes];
Map<String, dynamic> toJson() => _$GhUsersFollowerConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersPageInfo with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersPageInfo({this.hasNextPage, this.endCursor});
2020-01-07 08:07:57 +01:00
factory GhUsersPageInfo.fromJson(Map<String, dynamic> json) =>
_$GhUsersPageInfoFromJson(json);
bool hasNextPage;
String endCursor;
@override
List<Object> get props => [hasNextPage, endCursor];
Map<String, dynamic> toJson() => _$GhUsersPageInfoToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersAuditEntryActor with EquatableMixin {
GhUsersAuditEntryActor();
factory GhUsersAuditEntryActor.fromJson(Map<String, dynamic> json) =>
_$GhUsersAuditEntryActorFromJson(json);
@override
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhUsersAuditEntryActorToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersNode with EquatableMixin {
GhUsersNode();
factory GhUsersNode.fromJson(Map<String, dynamic> json) =>
_$GhUsersNodeFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUsersNodeToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersActor with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersActor({this.login, this.avatarUrl});
2020-01-07 08:07:57 +01:00
factory GhUsersActor.fromJson(Map<String, dynamic> json) =>
_$GhUsersActorFromJson(json);
String login;
String avatarUrl;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [login, avatarUrl, resolveType];
Map<String, dynamic> toJson() => _$GhUsersActorToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersRegistryPackageOwner with EquatableMixin {
GhUsersRegistryPackageOwner();
factory GhUsersRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhUsersRegistryPackageOwnerFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUsersRegistryPackageOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersRegistryPackageSearch with EquatableMixin {
GhUsersRegistryPackageSearch();
factory GhUsersRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhUsersRegistryPackageSearchFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUsersRegistryPackageSearchToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersProjectOwner with EquatableMixin {
GhUsersProjectOwner();
factory GhUsersProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhUsersProjectOwnerFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUsersProjectOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersRepositoryOwner with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersRepositoryOwner({this.login, this.avatarUrl});
2020-01-07 08:07:57 +01:00
factory GhUsersRepositoryOwner.fromJson(Map<String, dynamic> json) =>
_$GhUsersRepositoryOwnerFromJson(json);
String login;
String avatarUrl;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [login, avatarUrl, resolveType];
Map<String, dynamic> toJson() => _$GhUsersRepositoryOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersUniformResourceLocatable with EquatableMixin {
GhUsersUniformResourceLocatable();
factory GhUsersUniformResourceLocatable.fromJson(Map<String, dynamic> json) =>
_$GhUsersUniformResourceLocatableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() =>
_$GhUsersUniformResourceLocatableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersProfileOwner with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersProfileOwner({this.login, this.name, this.location});
2020-01-07 08:07:57 +01:00
factory GhUsersProfileOwner.fromJson(Map<String, dynamic> json) =>
_$GhUsersProfileOwnerFromJson(json);
String login;
String name;
String location;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [login, name, location, resolveType];
Map<String, dynamic> toJson() => _$GhUsersProfileOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersSponsorable with EquatableMixin {
GhUsersSponsorable();
factory GhUsersSponsorable.fromJson(Map<String, dynamic> json) =>
_$GhUsersSponsorableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUsersSponsorableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersFollowingConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersFollowingConnection({this.pageInfo, this.nodes});
2020-01-07 08:07:57 +01:00
factory GhUsersFollowingConnection.fromJson(Map<String, dynamic> json) =>
_$GhUsersFollowingConnectionFromJson(json);
GhUsersPageInfo pageInfo;
List<GhUsersUser> nodes;
@override
List<Object> get props => [pageInfo, nodes];
Map<String, dynamic> toJson() => _$GhUsersFollowingConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersOrganization extends GhUsersAuditEntryActor
with EquatableMixin
implements
GhUsersNode,
GhUsersActor,
GhUsersRegistryPackageOwner,
GhUsersRegistryPackageSearch,
GhUsersProjectOwner,
GhUsersRepositoryOwner,
GhUsersUniformResourceLocatable,
GhUsersMemberStatusable,
GhUsersProfileOwner,
GhUsersSponsorable {
2020-01-26 12:39:15 +01:00
GhUsersOrganization({this.membersWithRole});
2020-01-07 08:07:57 +01:00
factory GhUsersOrganization.fromJson(Map<String, dynamic> json) =>
_$GhUsersOrganizationFromJson(json);
@override
String login;
@override
String name;
@override
String avatarUrl;
@override
String location;
GhUsersOrganizationMemberConnection membersWithRole;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props =>
[login, name, avatarUrl, location, membersWithRole, resolveType];
Map<String, dynamic> toJson() => _$GhUsersOrganizationToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersOrganizationMemberConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersOrganizationMemberConnection({this.pageInfo, this.nodes});
2020-01-07 08:07:57 +01:00
factory GhUsersOrganizationMemberConnection.fromJson(
Map<String, dynamic> json) =>
_$GhUsersOrganizationMemberConnectionFromJson(json);
GhUsersPageInfo pageInfo;
List<GhUsersUser> nodes;
@override
List<Object> get props => [pageInfo, nodes];
Map<String, dynamic> toJson() =>
_$GhUsersOrganizationMemberConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersMemberStatusable with EquatableMixin {
GhUsersMemberStatusable();
factory GhUsersMemberStatusable.fromJson(Map<String, dynamic> json) =>
_$GhUsersMemberStatusableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUsersMemberStatusableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersRepository extends GhUsersPinnableItem
with EquatableMixin
implements
GhUsersNode,
GhUsersProjectOwner,
GhUsersRegistryPackageOwner,
GhUsersRegistryPackageSearch,
GhUsersSubscribable,
GhUsersStarrable,
GhUsersUniformResourceLocatable,
GhUsersRepositoryInfo {
2020-01-26 12:39:15 +01:00
GhUsersRepository({this.watchers});
2020-01-07 08:07:57 +01:00
factory GhUsersRepository.fromJson(Map<String, dynamic> json) =>
_$GhUsersRepositoryFromJson(json);
GhUsersUserConnection watchers;
@override
GhUsersStargazerConnection stargazers;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [watchers, stargazers, resolveType];
Map<String, dynamic> toJson() => _$GhUsersRepositoryToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersUserConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersUserConnection({this.pageInfo, this.nodes});
2020-01-07 08:07:57 +01:00
factory GhUsersUserConnection.fromJson(Map<String, dynamic> json) =>
_$GhUsersUserConnectionFromJson(json);
GhUsersPageInfo pageInfo;
List<GhUsersUser> nodes;
@override
List<Object> get props => [pageInfo, nodes];
Map<String, dynamic> toJson() => _$GhUsersUserConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersStargazerConnection with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersStargazerConnection({this.pageInfo, this.nodes});
2020-01-07 08:07:57 +01:00
factory GhUsersStargazerConnection.fromJson(Map<String, dynamic> json) =>
_$GhUsersStargazerConnectionFromJson(json);
GhUsersPageInfo pageInfo;
List<GhUsersUser> nodes;
@override
List<Object> get props => [pageInfo, nodes];
Map<String, dynamic> toJson() => _$GhUsersStargazerConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersPinnableItem with EquatableMixin {
GhUsersPinnableItem();
factory GhUsersPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhUsersPinnableItemFromJson(json);
@override
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhUsersPinnableItemToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersSubscribable with EquatableMixin {
GhUsersSubscribable();
factory GhUsersSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhUsersSubscribableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUsersSubscribableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersStarrable with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhUsersStarrable({this.stargazers});
2020-01-07 08:07:57 +01:00
factory GhUsersStarrable.fromJson(Map<String, dynamic> json) =>
_$GhUsersStarrableFromJson(json);
GhUsersStargazerConnection stargazers;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [stargazers, resolveType];
Map<String, dynamic> toJson() => _$GhUsersStarrableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersRepositoryInfo with EquatableMixin {
GhUsersRepositoryInfo();
factory GhUsersRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhUsersRepositoryInfoFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUsersRepositoryInfoToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUsersArguments extends JsonSerializable with EquatableMixin {
GhUsersArguments(
2020-01-26 12:39:15 +01:00
{@required this.login,
@required this.repoName,
2020-01-07 08:07:57 +01:00
this.after,
2020-01-26 12:39:15 +01:00
@required this.isFollowers,
@required this.isFollowing,
@required this.isMember,
@required this.isStar,
@required this.isWatch});
2020-01-07 08:07:57 +01:00
factory GhUsersArguments.fromJson(Map<String, dynamic> json) =>
_$GhUsersArgumentsFromJson(json);
final String login;
final String repoName;
final String after;
final bool isFollowers;
final bool isFollowing;
final bool isMember;
final bool isStar;
final bool isWatch;
@override
List<Object> get props => [
login,
repoName,
after,
isFollowers,
isFollowing,
isMember,
isStar,
isWatch
];
Map<String, dynamic> toJson() => _$GhUsersArgumentsToJson(this);
}
class GhUsersQuery extends GraphQLQuery<GhUsers, GhUsersArguments> {
GhUsersQuery({this.variables});
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
type: OperationType.query,
name: NameNode(value: 'GhUsers'),
variableDefinitions: [
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'login')),
type: NamedTypeNode(
name: NameNode(value: 'String'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'repoName')),
type: NamedTypeNode(
name: NameNode(value: 'String'), 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: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'isFollowers')),
type: NamedTypeNode(
name: NameNode(value: 'Boolean'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'isFollowing')),
type: NamedTypeNode(
name: NameNode(value: 'Boolean'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'isMember')),
type: NamedTypeNode(
name: NameNode(value: 'Boolean'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'isStar')),
type: NamedTypeNode(
name: NameNode(value: 'Boolean'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'isWatch')),
type: NamedTypeNode(
name: NameNode(value: 'Boolean'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: [])
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'user'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'login'),
value: VariableNode(name: NameNode(value: 'login')))
],
directives: [
DirectiveNode(name: NameNode(value: 'skip'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'isMember')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
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: 'company'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'createdAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'followers'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '30')),
ArgumentNode(
name: NameNode(value: 'after'),
value: VariableNode(name: NameNode(value: 'after')))
],
directives: [
DirectiveNode(
name: NameNode(value: 'include'),
arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(
name: NameNode(value: 'isFollowers')))
])
],
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: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
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: 'company'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'createdAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
])),
FieldNode(
name: NameNode(value: 'following'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '30')),
ArgumentNode(
name: NameNode(value: 'after'),
value: VariableNode(name: NameNode(value: 'after')))
],
directives: [
DirectiveNode(
name: NameNode(value: 'include'),
arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(
name: NameNode(value: 'isFollowing')))
])
],
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: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
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: 'company'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'createdAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
])),
FieldNode(
name: NameNode(value: 'organization'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'login'),
value: VariableNode(name: NameNode(value: 'login')))
],
directives: [
DirectiveNode(name: NameNode(value: 'include'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'isMember')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
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: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'membersWithRole'),
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: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
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: 'company'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'createdAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
])),
FieldNode(
name: NameNode(value: 'repository'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'owner'),
value: VariableNode(name: NameNode(value: 'login'))),
ArgumentNode(
name: NameNode(value: 'name'),
value: VariableNode(name: NameNode(value: 'repoName')))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'watchers'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '30')),
ArgumentNode(
name: NameNode(value: 'after'),
value: VariableNode(name: NameNode(value: 'after')))
],
directives: [
DirectiveNode(
name: NameNode(value: 'include'),
arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(
name: NameNode(value: 'isWatch')))
])
],
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: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
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: 'company'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'createdAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
])),
FieldNode(
name: NameNode(value: 'stargazers'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '30')),
ArgumentNode(
name: NameNode(value: 'after'),
value: VariableNode(name: NameNode(value: 'after')))
],
directives: [
DirectiveNode(
name: NameNode(value: 'include'),
arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(
name: NameNode(value: 'isStar')))
])
],
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: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
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: 'company'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'createdAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
]))
]);
@override
final String operationName = 'GhUsers';
@override
final GhUsersArguments variables;
@override
List<Object> get props => [document, operationName, variables];
@override
GhUsers parse(Map<String, dynamic> json) => GhUsers.fromJson(json);
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssue with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhCreateIssue({this.createIssue});
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssue.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
GhCreateIssueCreateIssuePayload createIssue;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [createIssue];
Map<String, dynamic> toJson() => _$GhCreateIssueToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueCreateIssuePayload with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhCreateIssueCreateIssuePayload({this.issue});
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueCreateIssuePayload.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueCreateIssuePayloadFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
GhCreateIssueIssue issue;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [issue];
Map<String, dynamic> toJson() =>
_$GhCreateIssueCreateIssuePayloadToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueIssue extends GhCreateIssueProjectCardItem
2020-01-07 08:07:57 +01:00
with EquatableMixin
implements
2020-01-15 10:58:24 +01:00
GhCreateIssueNode,
GhCreateIssueAssignable,
GhCreateIssueClosable,
GhCreateIssueComment,
GhCreateIssueUpdatable,
GhCreateIssueUpdatableComment,
GhCreateIssueLabelable,
GhCreateIssueLockable,
GhCreateIssueReactable,
GhCreateIssueRepositoryNode,
GhCreateIssueSubscribable,
GhCreateIssueUniformResourceLocatable {
2020-01-26 12:39:15 +01:00
GhCreateIssueIssue({this.number});
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueIssue.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueIssueFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
int number;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
GhCreateIssueRepository repository;
2020-01-07 08:07:57 +01:00
@override
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [number, repository, resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueIssueToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueRepository extends GhCreateIssuePinnableItem
with EquatableMixin
implements
GhCreateIssueNode,
GhCreateIssueProjectOwner,
GhCreateIssueRegistryPackageOwner,
GhCreateIssueRegistryPackageSearch,
GhCreateIssueSubscribable,
GhCreateIssueStarrable,
GhCreateIssueUniformResourceLocatable,
GhCreateIssueRepositoryInfo {
GhCreateIssueRepository();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueRepository.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueRepositoryFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
GhCreateIssueRepositoryOwner owner;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
String name;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [owner, name, resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueRepositoryToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueRepositoryOwner with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhCreateIssueRepositoryOwner({this.login});
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueRepositoryOwner.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueRepositoryOwnerFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
String login;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [login, resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueRepositoryOwnerToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssuePinnableItem with EquatableMixin {
GhCreateIssuePinnableItem();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssuePinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssuePinnableItemFromJson(json);
2020-01-11 12:25:33 +01:00
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhCreateIssuePinnableItemToJson(this);
}
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonSerializable(explicitToJson: true)
class GhCreateIssueNode with EquatableMixin {
GhCreateIssueNode();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueNode.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueNodeFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueNodeToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueProjectOwner with EquatableMixin {
GhCreateIssueProjectOwner();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueProjectOwnerFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueProjectOwnerToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueRegistryPackageOwner with EquatableMixin {
GhCreateIssueRegistryPackageOwner();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueRegistryPackageOwner.fromJson(
Map<String, dynamic> json) =>
_$GhCreateIssueRegistryPackageOwnerFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() =>
_$GhCreateIssueRegistryPackageOwnerToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueRegistryPackageSearch with EquatableMixin {
GhCreateIssueRegistryPackageSearch();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueRegistryPackageSearch.fromJson(
Map<String, dynamic> json) =>
_$GhCreateIssueRegistryPackageSearchFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-01-15 10:58:24 +01:00
Map<String, dynamic> toJson() =>
_$GhCreateIssueRegistryPackageSearchToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueSubscribable with EquatableMixin {
GhCreateIssueSubscribable();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueSubscribableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-01-15 10:58:24 +01:00
Map<String, dynamic> toJson() => _$GhCreateIssueSubscribableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueStarrable with EquatableMixin {
GhCreateIssueStarrable();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueStarrable.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueStarrableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-01-15 10:58:24 +01:00
Map<String, dynamic> toJson() => _$GhCreateIssueStarrableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueUniformResourceLocatable with EquatableMixin {
GhCreateIssueUniformResourceLocatable();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueUniformResourceLocatable.fromJson(
Map<String, dynamic> json) =>
_$GhCreateIssueUniformResourceLocatableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-01-15 10:58:24 +01:00
Map<String, dynamic> toJson() =>
_$GhCreateIssueUniformResourceLocatableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueRepositoryInfo with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhCreateIssueRepositoryInfo({this.owner, this.name});
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueRepositoryInfoFromJson(json);
GhCreateIssueRepositoryOwner owner;
String name;
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [owner, name, resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueRepositoryInfoToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueProjectCardItem with EquatableMixin {
GhCreateIssueProjectCardItem();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueProjectCardItem.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueProjectCardItemFromJson(json);
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhCreateIssueProjectCardItemToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueAssignable with EquatableMixin {
GhCreateIssueAssignable();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueAssignable.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueAssignableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-01-15 10:58:24 +01:00
Map<String, dynamic> toJson() => _$GhCreateIssueAssignableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueClosable with EquatableMixin {
GhCreateIssueClosable();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueClosable.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueClosableFromJson(json);
2020-01-11 12:25:33 +01:00
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueClosableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueComment with EquatableMixin {
GhCreateIssueComment();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueComment.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueCommentFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueCommentToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueUpdatable with EquatableMixin {
GhCreateIssueUpdatable();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueUpdatable.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueUpdatableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-01-15 10:58:24 +01:00
Map<String, dynamic> toJson() => _$GhCreateIssueUpdatableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueUpdatableComment with EquatableMixin {
GhCreateIssueUpdatableComment();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueUpdatableComment.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueUpdatableCommentFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-01-15 10:58:24 +01:00
Map<String, dynamic> toJson() => _$GhCreateIssueUpdatableCommentToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueLabelable with EquatableMixin {
GhCreateIssueLabelable();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueLabelable.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueLabelableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-01-15 10:58:24 +01:00
Map<String, dynamic> toJson() => _$GhCreateIssueLabelableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueLockable with EquatableMixin {
GhCreateIssueLockable();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueLockable.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueLockableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueLockableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueReactable with EquatableMixin {
GhCreateIssueReactable();
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueReactable.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueReactableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueReactableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueRepositoryNode with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhCreateIssueRepositoryNode({this.repository});
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueRepositoryNode.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueRepositoryNodeFromJson(json);
GhCreateIssueRepository repository;
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [repository, resolveType];
Map<String, dynamic> toJson() => _$GhCreateIssueRepositoryNodeToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-01-15 10:58:24 +01:00
class GhCreateIssueArguments extends JsonSerializable with EquatableMixin {
2020-01-26 12:39:15 +01:00
GhCreateIssueArguments(
{@required this.repoId, @required this.title, @required this.body});
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
factory GhCreateIssueArguments.fromJson(Map<String, dynamic> json) =>
_$GhCreateIssueArgumentsFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
final String repoId;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
final String title;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
final String body;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [repoId, title, body];
Map<String, dynamic> toJson() => _$GhCreateIssueArgumentsToJson(this);
2020-01-07 08:07:57 +01:00
}
2020-01-15 10:58:24 +01:00
class GhCreateIssueQuery
extends GraphQLQuery<GhCreateIssue, GhCreateIssueArguments> {
GhCreateIssueQuery({this.variables});
2020-01-07 08:07:57 +01:00
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
2020-01-15 10:58:24 +01:00
type: OperationType.mutation,
name: NameNode(value: 'GhCreateIssue'),
2020-01-07 08:07:57 +01:00
variableDefinitions: [
VariableDefinitionNode(
2020-01-15 10:58:24 +01:00
variable: VariableNode(name: NameNode(value: 'repoId')),
type: NamedTypeNode(name: NameNode(value: 'ID'), isNonNull: true),
2020-01-07 08:07:57 +01:00
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
2020-01-15 10:58:24 +01:00
variable: VariableNode(name: NameNode(value: 'title')),
2020-01-07 08:07:57 +01:00
type: NamedTypeNode(
2020-01-15 10:58:24 +01:00
name: NameNode(value: 'String'), isNonNull: true),
2020-01-07 08:07:57 +01:00
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
2020-01-15 10:58:24 +01:00
variable: VariableNode(name: NameNode(value: 'body')),
2020-01-07 08:07:57 +01:00
type: NamedTypeNode(
2020-01-15 10:58:24 +01:00
name: NameNode(value: 'String'), isNonNull: true),
2020-01-07 08:07:57 +01:00
defaultValue: DefaultValueNode(value: null),
directives: [])
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-01-15 10:58:24 +01:00
name: NameNode(value: 'createIssue'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [
ArgumentNode(
2020-01-15 10:58:24 +01:00
name: NameNode(value: 'input'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'repositoryId'),
value: VariableNode(name: NameNode(value: 'repoId'))),
ObjectFieldNode(
name: NameNode(value: 'title'),
value: VariableNode(name: NameNode(value: 'title'))),
ObjectFieldNode(
name: NameNode(value: 'body'),
value: VariableNode(name: NameNode(value: 'body')))
]))
2020-01-07 08:07:57 +01:00
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-01-15 10:58:24 +01:00
name: NameNode(value: 'issue'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-01-15 10:58:24 +01:00
name: NameNode(value: 'number'),
2020-01-07 08:07:57 +01:00
alias: null,
2020-01-15 10:58:24 +01:00
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'repository'),
alias: null,
arguments: [],
directives: [],
2020-01-07 08:07:57 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-01-15 10:58:24 +01:00
name: NameNode(value: 'owner'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-01-15 10:58:24 +01:00
name: NameNode(value: 'login'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
2020-01-15 10:58:24 +01:00
name: NameNode(value: 'name'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
2020-01-15 10:58:24 +01:00
selectionSet: null)
2020-01-07 08:07:57 +01:00
]))
]))
]))
]))
]);
@override
2020-01-15 10:58:24 +01:00
final String operationName = 'GhCreateIssue';
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
final GhCreateIssueArguments variables;
2020-01-07 08:07:57 +01:00
@override
List<Object> get props => [document, operationName, variables];
@override
2020-01-15 10:58:24 +01:00
GhCreateIssue parse(Map<String, dynamic> json) =>
GhCreateIssue.fromJson(json);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPulls with EquatableMixin {
GhPulls({this.repository});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPulls.fromJson(Map<String, dynamic> json) =>
_$GhPullsFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
GhPullsRepository repository;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [repository];
Map<String, dynamic> toJson() => _$GhPullsToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsRepository extends GhPullsPinnableItem
with EquatableMixin
implements
GhPullsNode,
GhPullsProjectOwner,
GhPullsRegistryPackageOwner,
GhPullsRegistryPackageSearch,
GhPullsSubscribable,
GhPullsStarrable,
GhPullsUniformResourceLocatable,
GhPullsRepositoryInfo {
GhPullsRepository({this.pullRequests});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsRepository.fromJson(Map<String, dynamic> json) =>
_$GhPullsRepositoryFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
GhPullsRepositoryOwner owner;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
String name;
GhPullsPullRequestConnection pullRequests;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [owner, name, pullRequests, resolveType];
Map<String, dynamic> toJson() => _$GhPullsRepositoryToJson(this);
2020-01-15 10:58:24 +01:00
}
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsRepositoryOwner with EquatableMixin {
GhPullsRepositoryOwner({this.login});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsRepositoryOwner.fromJson(Map<String, dynamic> json) =>
_$GhPullsRepositoryOwnerFromJson(json);
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
String login;
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [login, resolveType];
Map<String, dynamic> toJson() => _$GhPullsRepositoryOwnerToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsPullRequestConnection with EquatableMixin {
GhPullsPullRequestConnection({this.pageInfo, this.nodes});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsPullRequestConnection.fromJson(Map<String, dynamic> json) =>
_$GhPullsPullRequestConnectionFromJson(json);
GhPullsPageInfo pageInfo;
List<GhPullsPullRequest> nodes;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [pageInfo, nodes];
Map<String, dynamic> toJson() => _$GhPullsPullRequestConnectionToJson(this);
2020-01-15 10:58:24 +01:00
}
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsPageInfo with EquatableMixin {
GhPullsPageInfo({this.hasNextPage, this.endCursor});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsPageInfo.fromJson(Map<String, dynamic> json) =>
_$GhPullsPageInfoFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
bool hasNextPage;
String endCursor;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [hasNextPage, endCursor];
Map<String, dynamic> toJson() => _$GhPullsPageInfoToJson(this);
2020-01-15 10:58:24 +01:00
}
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsPullRequest extends GhPullsProjectCardItem
with EquatableMixin
implements
GhPullsNode,
GhPullsAssignable,
GhPullsClosable,
GhPullsComment,
GhPullsUpdatable,
GhPullsUpdatableComment,
GhPullsLabelable,
GhPullsLockable,
GhPullsReactable,
GhPullsRepositoryNode,
GhPullsSubscribable,
GhPullsUniformResourceLocatable {
GhPullsPullRequest({this.number, this.title, this.comments});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsPullRequest.fromJson(Map<String, dynamic> json) =>
_$GhPullsPullRequestFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
GhPullsRepository repository;
int number;
String title;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
DateTime updatedAt;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
GhPullsActor author;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
GhPullsLabelConnection labels;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
GhPullsIssueCommentConnection comments;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [
repository,
number,
title,
updatedAt,
author,
labels,
comments,
resolveType
];
Map<String, dynamic> toJson() => _$GhPullsPullRequestToJson(this);
2020-01-15 10:58:24 +01:00
}
2020-01-15 10:58:24 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsPinnableItem with EquatableMixin {
GhPullsPinnableItem();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhPullsPinnableItemFromJson(json);
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhPullsPinnableItemToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsNode with EquatableMixin {
GhPullsNode();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsNode.fromJson(Map<String, dynamic> json) =>
_$GhPullsNodeFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhPullsNodeToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsProjectOwner with EquatableMixin {
GhPullsProjectOwner();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhPullsProjectOwnerFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhPullsProjectOwnerToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsRegistryPackageOwner with EquatableMixin {
GhPullsRegistryPackageOwner();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhPullsRegistryPackageOwnerFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhPullsRegistryPackageOwnerToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsRegistryPackageSearch with EquatableMixin {
GhPullsRegistryPackageSearch();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhPullsRegistryPackageSearchFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhPullsRegistryPackageSearchToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsSubscribable with EquatableMixin {
GhPullsSubscribable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhPullsSubscribableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhPullsSubscribableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsStarrable with EquatableMixin {
GhPullsStarrable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsStarrable.fromJson(Map<String, dynamic> json) =>
_$GhPullsStarrableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhPullsStarrableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsUniformResourceLocatable with EquatableMixin {
GhPullsUniformResourceLocatable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsUniformResourceLocatable.fromJson(Map<String, dynamic> json) =>
_$GhPullsUniformResourceLocatableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() =>
_$GhPullsUniformResourceLocatableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsRepositoryInfo with EquatableMixin {
GhPullsRepositoryInfo({this.owner, this.name});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhPullsRepositoryInfoFromJson(json);
GhPullsRepositoryOwner owner;
String name;
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [owner, name, resolveType];
Map<String, dynamic> toJson() => _$GhPullsRepositoryInfoToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsActor with EquatableMixin {
GhPullsActor({this.login, this.avatarUrl});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsActor.fromJson(Map<String, dynamic> json) =>
_$GhPullsActorFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
String login;
String avatarUrl;
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [login, avatarUrl, resolveType];
Map<String, dynamic> toJson() => _$GhPullsActorToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsLabelConnection with EquatableMixin {
GhPullsLabelConnection({this.nodes});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsLabelConnection.fromJson(Map<String, dynamic> json) =>
_$GhPullsLabelConnectionFromJson(json);
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
List<GhPullsLabel> nodes;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [nodes];
Map<String, dynamic> toJson() => _$GhPullsLabelConnectionToJson(this);
2020-01-07 08:07:57 +01:00
}
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhPullsLabel with EquatableMixin implements GhPullsNode {
GhPullsLabel({this.name, this.color});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsLabel.fromJson(Map<String, dynamic> json) =>
_$GhPullsLabelFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
String name;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
String color;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [name, color, resolveType];
Map<String, dynamic> toJson() => _$GhPullsLabelToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsIssueCommentConnection with EquatableMixin {
GhPullsIssueCommentConnection({this.totalCount});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsIssueCommentConnection.fromJson(Map<String, dynamic> json) =>
_$GhPullsIssueCommentConnectionFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhPullsIssueCommentConnectionToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsProjectCardItem with EquatableMixin {
GhPullsProjectCardItem();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsProjectCardItem.fromJson(Map<String, dynamic> json) =>
_$GhPullsProjectCardItemFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhPullsProjectCardItemToJson(this);
}
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhPullsAssignable with EquatableMixin {
GhPullsAssignable();
factory GhPullsAssignable.fromJson(Map<String, dynamic> json) =>
_$GhPullsAssignableFromJson(json);
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhPullsAssignableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsClosable with EquatableMixin {
GhPullsClosable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsClosable.fromJson(Map<String, dynamic> json) =>
_$GhPullsClosableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhPullsClosableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsComment with EquatableMixin {
GhPullsComment({this.updatedAt, this.author});
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsComment.fromJson(Map<String, dynamic> json) =>
_$GhPullsCommentFromJson(json);
2020-01-15 10:58:24 +01:00
DateTime updatedAt;
2020-02-06 06:53:43 +01:00
GhPullsActor author;
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [updatedAt, author, resolveType];
Map<String, dynamic> toJson() => _$GhPullsCommentToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsUpdatable with EquatableMixin {
GhPullsUpdatable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsUpdatable.fromJson(Map<String, dynamic> json) =>
_$GhPullsUpdatableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhPullsUpdatableToJson(this);
2020-01-15 10:58:24 +01:00
}
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsUpdatableComment with EquatableMixin {
GhPullsUpdatableComment();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsUpdatableComment.fromJson(Map<String, dynamic> json) =>
_$GhPullsUpdatableCommentFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhPullsUpdatableCommentToJson(this);
2020-01-15 10:58:24 +01:00
}
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsLabelable with EquatableMixin {
GhPullsLabelable({this.labels});
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsLabelable.fromJson(Map<String, dynamic> json) =>
_$GhPullsLabelableFromJson(json);
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
GhPullsLabelConnection labels;
2020-01-15 10:58:24 +01:00
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [labels, resolveType];
Map<String, dynamic> toJson() => _$GhPullsLabelableToJson(this);
2020-01-15 10:58:24 +01:00
}
2020-01-15 10:58:24 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsLockable with EquatableMixin {
GhPullsLockable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsLockable.fromJson(Map<String, dynamic> json) =>
_$GhPullsLockableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhPullsLockableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsReactable with EquatableMixin {
GhPullsReactable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsReactable.fromJson(Map<String, dynamic> json) =>
_$GhPullsReactableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhPullsReactableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsRepositoryNode with EquatableMixin {
GhPullsRepositoryNode({this.repository});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsRepositoryNode.fromJson(Map<String, dynamic> json) =>
_$GhPullsRepositoryNodeFromJson(json);
GhPullsRepository repository;
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [repository, resolveType];
Map<String, dynamic> toJson() => _$GhPullsRepositoryNodeToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhPullsArguments extends JsonSerializable with EquatableMixin {
GhPullsArguments({@required this.owner, @required this.name, this.cursor});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhPullsArguments.fromJson(Map<String, dynamic> json) =>
_$GhPullsArgumentsFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
final String owner;
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
final String name;
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
final String cursor;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [owner, name, cursor];
Map<String, dynamic> toJson() => _$GhPullsArgumentsToJson(this);
2020-01-15 10:58:24 +01:00
}
2020-02-06 06:53:43 +01:00
class GhPullsQuery extends GraphQLQuery<GhPulls, GhPullsArguments> {
GhPullsQuery({this.variables});
2020-01-15 10:58:24 +01:00
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
type: OperationType.query,
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'GhPulls'),
2020-01-15 10:58:24 +01:00
variableDefinitions: [
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'owner')),
type: NamedTypeNode(
name: NameNode(value: 'String'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
2020-02-06 06:53:43 +01:00
variable: VariableNode(name: NameNode(value: 'name')),
2020-01-15 10:58:24 +01:00
type: NamedTypeNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'String'), isNonNull: true),
2020-01-15 10:58:24 +01:00
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
2020-02-06 06:53:43 +01:00
variable: VariableNode(name: NameNode(value: 'cursor')),
2020-01-15 10:58:24 +01:00
type: NamedTypeNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'String'), isNonNull: false),
2020-01-15 10:58:24 +01:00
defaultValue: DefaultValueNode(value: null),
directives: [])
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'repository'),
2020-01-15 10:58:24 +01:00
alias: null,
arguments: [
ArgumentNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'owner'),
value: VariableNode(name: NameNode(value: 'owner'))),
ArgumentNode(
name: NameNode(value: 'name'),
value: VariableNode(name: NameNode(value: 'name')))
2020-01-07 08:07:57 +01:00
],
2020-01-15 10:58:24 +01:00
directives: [],
2020-01-07 08:07:57 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'owner'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
2020-01-07 08:07:57 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'name'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'pullRequests'),
2020-01-07 08:07:57 +01:00
alias: null,
2020-02-06 06:53:43 +01:00
arguments: [
ArgumentNode(
name: NameNode(value: 'states'),
value: EnumValueNode(name: NameNode(value: 'OPEN'))),
ArgumentNode(
name: NameNode(value: 'orderBy'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'field'),
value: EnumValueNode(
name: NameNode(value: 'CREATED_AT'))),
ObjectFieldNode(
name: NameNode(value: 'direction'),
value: EnumValueNode(
name: NameNode(value: 'DESC')))
])),
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '30')),
ArgumentNode(
name: NameNode(value: 'after'),
value: VariableNode(name: NameNode(value: 'cursor')))
],
2020-01-07 08:07:57 +01:00
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'pageInfo'),
2020-01-07 08:07:57 +01:00
alias: null,
2020-02-06 06:53:43 +01:00
arguments: [],
directives: [],
2020-01-07 08:07:57 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'hasNextPage'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
2020-01-15 10:58:24 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'endCursor'),
2020-01-15 10:58:24 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'nodes'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-01-07 08:07:57 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'repository'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'owner'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
])),
2020-01-07 08:07:57 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'number'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'title'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'updatedAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'author'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
2020-01-15 10:58:24 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'login'),
2020-01-15 10:58:24 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'avatarUrl'),
2020-01-15 10:58:24 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
2020-01-07 08:07:57 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'labels'),
2020-01-07 08:07:57 +01:00
alias: null,
2020-02-06 06:53:43 +01:00
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '10'))
],
2020-01-07 08:07:57 +01:00
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'nodes'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'name'),
2020-01-07 08:07:57 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'color'),
2020-01-15 10:58:24 +01:00
alias: null,
arguments: [],
2020-01-07 08:07:57 +01:00
directives: [],
2020-01-15 10:58:24 +01:00
selectionSet: null)
2020-02-06 06:53:43 +01:00
]))
])),
FieldNode(
name: NameNode(value: 'comments'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-01-15 10:58:24 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'totalCount'),
2020-01-15 10:58:24 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
2020-01-07 08:07:57 +01:00
]))
]))
]))
]))
]))
]);
@override
2020-02-06 06:53:43 +01:00
final String operationName = 'GhPulls';
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
final GhPullsArguments variables;
2020-01-07 08:07:57 +01:00
@override
List<Object> get props => [document, operationName, variables];
@override
2020-02-06 06:53:43 +01:00
GhPulls parse(Map<String, dynamic> json) => GhPulls.fromJson(json);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssue with EquatableMixin {
GhOpenIssue({this.reopenIssue, this.closeIssue});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssue.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
GhOpenIssueReopenIssuePayload reopenIssue;
GhOpenIssueCloseIssuePayload closeIssue;
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [reopenIssue, closeIssue];
Map<String, dynamic> toJson() => _$GhOpenIssueToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueReopenIssuePayload with EquatableMixin {
GhOpenIssueReopenIssuePayload({this.issue});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueReopenIssuePayload.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueReopenIssuePayloadFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhOpenIssueIssue issue;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [issue];
Map<String, dynamic> toJson() => _$GhOpenIssueReopenIssuePayloadToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueIssue extends GhOpenIssueProjectCardItem
with EquatableMixin
implements
GhOpenIssueNode,
GhOpenIssueAssignable,
GhOpenIssueClosable,
GhOpenIssueComment,
GhOpenIssueUpdatable,
GhOpenIssueUpdatableComment,
GhOpenIssueLabelable,
GhOpenIssueLockable,
GhOpenIssueReactable,
GhOpenIssueRepositoryNode,
GhOpenIssueSubscribable,
GhOpenIssueUniformResourceLocatable {
GhOpenIssueIssue();
factory GhOpenIssueIssue.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueIssueFromJson(json);
@override
bool closed;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [closed, resolveType];
Map<String, dynamic> toJson() => _$GhOpenIssueIssueToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhOpenIssueProjectCardItem with EquatableMixin {
GhOpenIssueProjectCardItem();
factory GhOpenIssueProjectCardItem.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueProjectCardItemFromJson(json);
@override
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhOpenIssueProjectCardItemToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhOpenIssueNode with EquatableMixin {
GhOpenIssueNode();
factory GhOpenIssueNode.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueNodeFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhOpenIssueNodeToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueAssignable with EquatableMixin {
GhOpenIssueAssignable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueAssignable.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueAssignableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhOpenIssueAssignableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhOpenIssueClosable with EquatableMixin {
GhOpenIssueClosable({this.closed});
factory GhOpenIssueClosable.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueClosableFromJson(json);
bool closed;
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [closed, resolveType];
Map<String, dynamic> toJson() => _$GhOpenIssueClosableToJson(this);
2020-01-22 10:33:13 +01:00
}
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueComment with EquatableMixin {
GhOpenIssueComment();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueComment.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueCommentFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhOpenIssueCommentToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueUpdatable with EquatableMixin {
GhOpenIssueUpdatable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueUpdatable.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueUpdatableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhOpenIssueUpdatableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueUpdatableComment with EquatableMixin {
GhOpenIssueUpdatableComment();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueUpdatableComment.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueUpdatableCommentFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhOpenIssueUpdatableCommentToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueLabelable with EquatableMixin {
GhOpenIssueLabelable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueLabelable.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueLabelableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhOpenIssueLabelableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueLockable with EquatableMixin {
GhOpenIssueLockable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueLockable.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueLockableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhOpenIssueLockableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueReactable with EquatableMixin {
GhOpenIssueReactable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueReactable.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueReactableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhOpenIssueReactableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueRepositoryNode with EquatableMixin {
GhOpenIssueRepositoryNode();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueRepositoryNode.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueRepositoryNodeFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhOpenIssueRepositoryNodeToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueSubscribable with EquatableMixin {
GhOpenIssueSubscribable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueSubscribableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhOpenIssueSubscribableToJson(this);
2020-01-22 10:33:13 +01:00
}
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhOpenIssueUniformResourceLocatable with EquatableMixin {
GhOpenIssueUniformResourceLocatable();
factory GhOpenIssueUniformResourceLocatable.fromJson(
Map<String, dynamic> json) =>
_$GhOpenIssueUniformResourceLocatableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() =>
_$GhOpenIssueUniformResourceLocatableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhOpenIssueCloseIssuePayload with EquatableMixin {
GhOpenIssueCloseIssuePayload({this.issue});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhOpenIssueCloseIssuePayload.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueCloseIssuePayloadFromJson(json);
GhOpenIssueIssue issue;
@override
List<Object> get props => [issue];
Map<String, dynamic> toJson() => _$GhOpenIssueCloseIssuePayloadToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhOpenIssueArguments extends JsonSerializable with EquatableMixin {
GhOpenIssueArguments({@required this.id, @required this.open});
factory GhOpenIssueArguments.fromJson(Map<String, dynamic> json) =>
_$GhOpenIssueArgumentsFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
final String id;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
final bool open;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, open];
Map<String, dynamic> toJson() => _$GhOpenIssueArgumentsToJson(this);
2020-01-07 08:07:57 +01:00
}
2020-02-06 06:53:43 +01:00
class GhOpenIssueQuery extends GraphQLQuery<GhOpenIssue, GhOpenIssueArguments> {
GhOpenIssueQuery({this.variables});
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
type: OperationType.mutation,
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'GhOpenIssue'),
2020-01-22 10:33:13 +01:00
variableDefinitions: [
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'id')),
type: NamedTypeNode(name: NameNode(value: 'ID'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
2020-02-06 06:53:43 +01:00
variable: VariableNode(name: NameNode(value: 'open')),
2020-01-22 10:33:13 +01:00
type: NamedTypeNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'Boolean'), isNonNull: true),
2020-01-22 10:33:13 +01:00
defaultValue: DefaultValueNode(value: null),
directives: [])
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'reopenIssue'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'input'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'issueId'),
value: VariableNode(name: NameNode(value: 'id')))
2020-01-22 10:33:13 +01:00
]))
],
2020-02-06 06:53:43 +01:00
directives: [
DirectiveNode(name: NameNode(value: 'include'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'open')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'issue'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-02-06 06:53:43 +01:00
FieldNode(
name: NameNode(value: 'closed'),
alias: null,
arguments: [],
2020-01-22 10:33:13 +01:00
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
]))
])),
FieldNode(
name: NameNode(value: 'closeIssue'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'input'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'issueId'),
value: VariableNode(name: NameNode(value: 'id')))
]))
],
directives: [
DirectiveNode(name: NameNode(value: 'skip'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'open')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'issue'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'closed'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
2020-01-22 10:33:13 +01:00
]))
]))
]))
]);
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
final String operationName = 'GhOpenIssue';
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
final GhOpenIssueArguments variables;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [document, operationName, variables];
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
GhOpenIssue parse(Map<String, dynamic> json) => GhOpenIssue.fromJson(json);
2020-01-22 10:33:13 +01:00
}
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssues with EquatableMixin {
GhIssues({this.repository});
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssues.fromJson(Map<String, dynamic> json) =>
_$GhIssuesFromJson(json);
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
GhIssuesRepository repository;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [repository];
Map<String, dynamic> toJson() => _$GhIssuesToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesRepository extends GhIssuesPinnableItem
with EquatableMixin
implements
GhIssuesNode,
GhIssuesProjectOwner,
GhIssuesRegistryPackageOwner,
GhIssuesRegistryPackageSearch,
GhIssuesSubscribable,
GhIssuesStarrable,
GhIssuesUniformResourceLocatable,
GhIssuesRepositoryInfo {
GhIssuesRepository({this.issues});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesRepository.fromJson(Map<String, dynamic> json) =>
_$GhIssuesRepositoryFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
GhIssuesRepositoryOwner owner;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
String name;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
GhIssuesIssueConnection issues;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [owner, name, issues, resolveType];
Map<String, dynamic> toJson() => _$GhIssuesRepositoryToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesRepositoryOwner with EquatableMixin {
GhIssuesRepositoryOwner({this.login});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesRepositoryOwner.fromJson(Map<String, dynamic> json) =>
_$GhIssuesRepositoryOwnerFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
String login;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
List<Object> get props => [login, resolveType];
Map<String, dynamic> toJson() => _$GhIssuesRepositoryOwnerToJson(this);
}
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhIssuesIssueConnection with EquatableMixin {
GhIssuesIssueConnection({this.pageInfo, this.nodes});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesIssueConnection.fromJson(Map<String, dynamic> json) =>
_$GhIssuesIssueConnectionFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
GhIssuesPageInfo pageInfo;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
List<GhIssuesIssue> nodes;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
List<Object> get props => [pageInfo, nodes];
Map<String, dynamic> toJson() => _$GhIssuesIssueConnectionToJson(this);
}
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhIssuesPageInfo with EquatableMixin {
GhIssuesPageInfo({this.hasNextPage, this.endCursor});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesPageInfo.fromJson(Map<String, dynamic> json) =>
_$GhIssuesPageInfoFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
bool hasNextPage;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
String endCursor;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@override
List<Object> get props => [hasNextPage, endCursor];
Map<String, dynamic> toJson() => _$GhIssuesPageInfoToJson(this);
}
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhIssuesIssue extends GhIssuesProjectCardItem
with EquatableMixin
implements
GhIssuesNode,
GhIssuesAssignable,
GhIssuesClosable,
GhIssuesComment,
GhIssuesUpdatable,
GhIssuesUpdatableComment,
GhIssuesLabelable,
GhIssuesLockable,
GhIssuesReactable,
GhIssuesRepositoryNode,
GhIssuesSubscribable,
GhIssuesUniformResourceLocatable {
GhIssuesIssue({this.number, this.title, this.comments});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesIssue.fromJson(Map<String, dynamic> json) =>
_$GhIssuesIssueFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
GhIssuesRepository repository;
int number;
String title;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
DateTime updatedAt;
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
GhIssuesActor author;
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
GhIssuesLabelConnection labels;
GhIssuesIssueCommentConnection comments;
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [
2020-02-06 06:53:43 +01:00
repository,
number,
title,
updatedAt,
author,
labels,
comments,
resolveType
2020-01-22 10:33:13 +01:00
];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhIssuesIssueToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesPinnableItem with EquatableMixin {
GhIssuesPinnableItem();
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhIssuesPinnableItemFromJson(json);
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhIssuesPinnableItemToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesNode with EquatableMixin {
GhIssuesNode();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesNode.fromJson(Map<String, dynamic> json) =>
_$GhIssuesNodeFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhIssuesNodeToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesProjectOwner with EquatableMixin {
GhIssuesProjectOwner();
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhIssuesProjectOwnerFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhIssuesProjectOwnerToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesRegistryPackageOwner with EquatableMixin {
GhIssuesRegistryPackageOwner();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhIssuesRegistryPackageOwnerFromJson(json);
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhIssuesRegistryPackageOwnerToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesRegistryPackageSearch with EquatableMixin {
GhIssuesRegistryPackageSearch();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhIssuesRegistryPackageSearchFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhIssuesRegistryPackageSearchToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesSubscribable with EquatableMixin {
GhIssuesSubscribable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhIssuesSubscribableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhIssuesSubscribableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesStarrable with EquatableMixin {
GhIssuesStarrable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesStarrable.fromJson(Map<String, dynamic> json) =>
_$GhIssuesStarrableFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhIssuesStarrableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesUniformResourceLocatable with EquatableMixin {
GhIssuesUniformResourceLocatable();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesUniformResourceLocatable.fromJson(
Map<String, dynamic> json) =>
_$GhIssuesUniformResourceLocatableFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() =>
_$GhIssuesUniformResourceLocatableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesRepositoryInfo with EquatableMixin {
GhIssuesRepositoryInfo({this.owner, this.name});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhIssuesRepositoryInfoFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
GhIssuesRepositoryOwner owner;
2020-01-22 10:33:13 +01:00
2020-01-15 10:58:24 +01:00
String name;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [owner, name, resolveType];
Map<String, dynamic> toJson() => _$GhIssuesRepositoryInfoToJson(this);
}
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhIssuesActor with EquatableMixin {
GhIssuesActor({this.login, this.avatarUrl});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesActor.fromJson(Map<String, dynamic> json) =>
_$GhIssuesActorFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
String login;
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
String avatarUrl;
2020-01-07 08:07:57 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [login, avatarUrl, resolveType];
Map<String, dynamic> toJson() => _$GhIssuesActorToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesLabelConnection with EquatableMixin {
GhIssuesLabelConnection({this.nodes});
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesLabelConnection.fromJson(Map<String, dynamic> json) =>
_$GhIssuesLabelConnectionFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
List<GhIssuesLabel> nodes;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [nodes];
Map<String, dynamic> toJson() => _$GhIssuesLabelConnectionToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesLabel with EquatableMixin implements GhIssuesNode {
GhIssuesLabel({this.name, this.color});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesLabel.fromJson(Map<String, dynamic> json) =>
_$GhIssuesLabelFromJson(json);
2020-01-22 10:33:13 +01:00
String name;
2020-02-06 06:53:43 +01:00
String color;
2020-01-22 10:33:13 +01:00
@override
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [name, color, resolveType];
Map<String, dynamic> toJson() => _$GhIssuesLabelToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesIssueCommentConnection with EquatableMixin {
GhIssuesIssueCommentConnection({this.totalCount});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesIssueCommentConnection.fromJson(Map<String, dynamic> json) =>
_$GhIssuesIssueCommentConnectionFromJson(json);
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
2020-01-07 08:07:57 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhIssuesIssueCommentConnectionToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesProjectCardItem with EquatableMixin {
GhIssuesProjectCardItem();
2020-01-07 08:07:57 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesProjectCardItem.fromJson(Map<String, dynamic> json) =>
_$GhIssuesProjectCardItemFromJson(json);
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@override
List<Object> get props => [];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhIssuesProjectCardItemToJson(this);
2020-01-22 10:33:13 +01:00
}
2020-01-07 08:07:57 +01:00
2020-01-22 10:33:13 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesAssignable with EquatableMixin {
GhIssuesAssignable();
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesAssignable.fromJson(Map<String, dynamic> json) =>
_$GhIssuesAssignableFromJson(json);
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhIssuesAssignableToJson(this);
2020-01-07 08:07:57 +01:00
}
2020-01-22 10:33:13 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesClosable with EquatableMixin {
GhIssuesClosable();
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesClosable.fromJson(Map<String, dynamic> json) =>
_$GhIssuesClosableFromJson(json);
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 08:07:57 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhIssuesClosableToJson(this);
2020-01-07 08:07:57 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesComment with EquatableMixin {
GhIssuesComment({this.updatedAt, this.author});
2020-02-06 06:53:43 +01:00
factory GhIssuesComment.fromJson(Map<String, dynamic> json) =>
_$GhIssuesCommentFromJson(json);
2020-02-06 06:53:43 +01:00
DateTime updatedAt;
2020-02-06 06:53:43 +01:00
GhIssuesActor author;
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [updatedAt, author, resolveType];
Map<String, dynamic> toJson() => _$GhIssuesCommentToJson(this);
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesUpdatable with EquatableMixin {
GhIssuesUpdatable();
2020-02-06 06:53:43 +01:00
factory GhIssuesUpdatable.fromJson(Map<String, dynamic> json) =>
_$GhIssuesUpdatableFromJson(json);
@JsonKey(name: '__typename')
2020-01-22 10:33:13 +01:00
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhIssuesUpdatableToJson(this);
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesUpdatableComment with EquatableMixin {
GhIssuesUpdatableComment();
2020-02-06 06:53:43 +01:00
factory GhIssuesUpdatableComment.fromJson(Map<String, dynamic> json) =>
_$GhIssuesUpdatableCommentFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhIssuesUpdatableCommentToJson(this);
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesLabelable with EquatableMixin {
GhIssuesLabelable({this.labels});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesLabelable.fromJson(Map<String, dynamic> json) =>
_$GhIssuesLabelableFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhIssuesLabelConnection labels;
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [labels, resolveType];
Map<String, dynamic> toJson() => _$GhIssuesLabelableToJson(this);
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesLockable with EquatableMixin {
GhIssuesLockable();
2020-02-06 06:53:43 +01:00
factory GhIssuesLockable.fromJson(Map<String, dynamic> json) =>
_$GhIssuesLockableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhIssuesLockableToJson(this);
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesReactable with EquatableMixin {
GhIssuesReactable();
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesReactable.fromJson(Map<String, dynamic> json) =>
_$GhIssuesReactableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhIssuesReactableToJson(this);
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesRepositoryNode with EquatableMixin {
GhIssuesRepositoryNode({this.repository});
2020-02-06 06:53:43 +01:00
factory GhIssuesRepositoryNode.fromJson(Map<String, dynamic> json) =>
_$GhIssuesRepositoryNodeFromJson(json);
GhIssuesRepository repository;
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [repository, resolveType];
Map<String, dynamic> toJson() => _$GhIssuesRepositoryNodeToJson(this);
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhIssuesArguments extends JsonSerializable with EquatableMixin {
GhIssuesArguments({@required this.owner, @required this.name, this.cursor});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhIssuesArguments.fromJson(Map<String, dynamic> json) =>
_$GhIssuesArgumentsFromJson(json);
2020-02-06 06:53:43 +01:00
final String owner;
2020-02-06 06:53:43 +01:00
final String name;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
final String cursor;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [owner, name, cursor];
Map<String, dynamic> toJson() => _$GhIssuesArgumentsToJson(this);
}
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
class GhIssuesQuery extends GraphQLQuery<GhIssues, GhIssuesArguments> {
GhIssuesQuery({this.variables});
2020-01-15 10:58:24 +01:00
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
2020-01-22 10:33:13 +01:00
type: OperationType.query,
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'GhIssues'),
2020-01-15 10:58:24 +01:00
variableDefinitions: [
VariableDefinitionNode(
2020-02-06 06:53:43 +01:00
variable: VariableNode(name: NameNode(value: 'owner')),
2020-01-22 10:33:13 +01:00
type: NamedTypeNode(
name: NameNode(value: 'String'), isNonNull: true),
2020-01-15 10:58:24 +01:00
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
2020-02-06 06:53:43 +01:00
variable: VariableNode(name: NameNode(value: 'name')),
2020-01-15 10:58:24 +01:00
type: NamedTypeNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'String'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'cursor')),
type: NamedTypeNode(
name: NameNode(value: 'String'), isNonNull: false),
2020-01-15 10:58:24 +01:00
defaultValue: DefaultValueNode(value: null),
directives: [])
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'repository'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [
ArgumentNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'owner'),
value: VariableNode(name: NameNode(value: 'owner'))),
ArgumentNode(
name: NameNode(value: 'name'),
value: VariableNode(name: NameNode(value: 'name')))
2020-01-22 10:33:13 +01:00
],
2020-02-06 06:53:43 +01:00
directives: [],
2020-01-22 10:33:13 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'owner'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'name'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'issues'),
2020-01-22 10:33:13 +01:00
alias: null,
2020-02-06 06:53:43 +01:00
arguments: [
ArgumentNode(
name: NameNode(value: 'states'),
value: EnumValueNode(name: NameNode(value: 'OPEN'))),
ArgumentNode(
name: NameNode(value: 'orderBy'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'field'),
value: EnumValueNode(
name: NameNode(value: 'CREATED_AT'))),
ObjectFieldNode(
name: NameNode(value: 'direction'),
value: EnumValueNode(
name: NameNode(value: 'DESC')))
])),
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '30')),
ArgumentNode(
name: NameNode(value: 'after'),
value: VariableNode(name: NameNode(value: 'cursor')))
],
2020-01-22 10:33:13 +01:00
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'pageInfo'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'hasNextPage'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null),
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'endCursor'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'nodes'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'repository'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'owner'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'login'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'number'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'title'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'updatedAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'author'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'login'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'avatarUrl'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'labels'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '10'))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'nodes'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'name'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'color'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
2020-02-06 06:53:43 +01:00
])),
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'comments'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'totalCount'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
2020-01-22 10:33:13 +01:00
]))
]))
2020-02-06 06:53:43 +01:00
]))
]))
]))
]);
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
final String operationName = 'GhIssues';
@override
final GhIssuesArguments variables;
@override
List<Object> get props => [document, operationName, variables];
@override
GhIssues parse(Map<String, dynamic> json) => GhIssues.fromJson(json);
}
@JsonSerializable(explicitToJson: true)
class GhRepos with EquatableMixin {
2020-02-07 08:43:35 +01:00
GhRepos({this.user});
2020-02-06 06:53:43 +01:00
factory GhRepos.fromJson(Map<String, dynamic> json) =>
_$GhReposFromJson(json);
2020-02-07 08:43:35 +01:00
GhReposUser user;
2020-02-06 06:53:43 +01:00
@override
2020-02-07 08:43:35 +01:00
List<Object> get props => [user];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposUser extends GhReposAuditEntryActor
with EquatableMixin
implements
GhReposNode,
GhReposActor,
GhReposRegistryPackageOwner,
GhReposRegistryPackageSearch,
GhReposProjectOwner,
GhReposRepositoryOwner,
GhReposUniformResourceLocatable,
GhReposProfileOwner,
GhReposSponsorable {
2020-02-07 08:43:35 +01:00
GhReposUser({this.starredRepositories});
2020-02-06 06:53:43 +01:00
factory GhReposUser.fromJson(Map<String, dynamic> json) =>
_$GhReposUserFromJson(json);
2020-02-07 08:43:35 +01:00
@override
String login;
@override
String avatarUrl;
@override
2020-02-06 06:53:43 +01:00
GhReposRepositoryConnection repositories;
GhReposStarredRepositoryConnection starredRepositories;
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props =>
2020-02-07 08:43:35 +01:00
[login, avatarUrl, repositories, starredRepositories, resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposUserToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposRepositoryConnection with EquatableMixin {
GhReposRepositoryConnection({this.totalCount, this.pageInfo, this.nodes});
factory GhReposRepositoryConnection.fromJson(Map<String, dynamic> json) =>
_$GhReposRepositoryConnectionFromJson(json);
int totalCount;
GhReposPageInfo pageInfo;
List<GhReposRepository> nodes;
@override
List<Object> get props => [totalCount, pageInfo, nodes];
Map<String, dynamic> toJson() => _$GhReposRepositoryConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposPageInfo with EquatableMixin {
GhReposPageInfo({this.hasNextPage, this.endCursor});
factory GhReposPageInfo.fromJson(Map<String, dynamic> json) =>
_$GhReposPageInfoFromJson(json);
bool hasNextPage;
String endCursor;
@override
List<Object> get props => [hasNextPage, endCursor];
Map<String, dynamic> toJson() => _$GhReposPageInfoToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposRepository extends GhReposPinnableItem
with EquatableMixin
implements
GhReposNode,
GhReposProjectOwner,
GhReposRegistryPackageOwner,
GhReposRegistryPackageSearch,
GhReposSubscribable,
GhReposStarrable,
GhReposUniformResourceLocatable,
GhReposRepositoryInfo {
GhReposRepository({this.forks, this.primaryLanguage});
factory GhReposRepository.fromJson(Map<String, dynamic> json) =>
_$GhReposRepositoryFromJson(json);
@override
GhReposRepositoryOwner owner;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
String name;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
String description;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
bool isPrivate;
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
@override
bool isFork;
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
@override
DateTime updatedAt;
2020-02-06 06:53:43 +01:00
@override
GhReposStargazerConnection stargazers;
2020-02-06 06:53:43 +01:00
GhReposRepositoryConnection forks;
GhReposLanguage primaryLanguage;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [
owner,
name,
description,
isPrivate,
isFork,
updatedAt,
stargazers,
forks,
primaryLanguage,
resolveType
];
Map<String, dynamic> toJson() => _$GhReposRepositoryToJson(this);
2020-01-07 11:33:41 +01:00
}
2020-02-07 08:43:35 +01:00
@JsonSerializable(explicitToJson: true)
class GhReposRepositoryOwner with EquatableMixin {
GhReposRepositoryOwner({this.login, this.avatarUrl});
factory GhReposRepositoryOwner.fromJson(Map<String, dynamic> json) =>
_$GhReposRepositoryOwnerFromJson(json);
String login;
String avatarUrl;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [login, avatarUrl, resolveType];
Map<String, dynamic> toJson() => _$GhReposRepositoryOwnerToJson(this);
}
2020-01-07 11:33:41 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposStargazerConnection with EquatableMixin {
GhReposStargazerConnection({this.totalCount});
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposStargazerConnection.fromJson(Map<String, dynamic> json) =>
_$GhReposStargazerConnectionFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhReposStargazerConnectionToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposLanguage with EquatableMixin implements GhReposNode {
GhReposLanguage({this.color, this.name});
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposLanguage.fromJson(Map<String, dynamic> json) =>
_$GhReposLanguageFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
String color;
String name;
2020-01-07 11:33:41 +01:00
@override
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [color, name, resolveType];
Map<String, dynamic> toJson() => _$GhReposLanguageToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposNode with EquatableMixin {
GhReposNode();
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposNode.fromJson(Map<String, dynamic> json) =>
_$GhReposNodeFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhReposNodeToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposPinnableItem with EquatableMixin {
GhReposPinnableItem();
factory GhReposPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhReposPinnableItemFromJson(json);
2020-01-07 11:33:41 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposPinnableItemToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposProjectOwner with EquatableMixin {
GhReposProjectOwner();
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhReposProjectOwnerFromJson(json);
2020-01-07 11:33:41 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposProjectOwnerToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposRegistryPackageOwner with EquatableMixin {
GhReposRegistryPackageOwner();
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhReposRegistryPackageOwnerFromJson(json);
2020-01-07 11:33:41 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposRegistryPackageOwnerToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposRegistryPackageSearch with EquatableMixin {
GhReposRegistryPackageSearch();
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhReposRegistryPackageSearchFromJson(json);
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 14:03:04 +01:00
2020-01-15 10:58:24 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposRegistryPackageSearchToJson(this);
2020-01-15 10:58:24 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposSubscribable with EquatableMixin {
GhReposSubscribable();
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhReposSubscribableFromJson(json);
2020-01-07 11:33:41 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposSubscribableToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposStarrable with EquatableMixin {
GhReposStarrable({this.stargazers});
2020-01-07 14:03:04 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposStarrable.fromJson(Map<String, dynamic> json) =>
_$GhReposStarrableFromJson(json);
GhReposStargazerConnection stargazers;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [stargazers, resolveType];
Map<String, dynamic> toJson() => _$GhReposStarrableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposUniformResourceLocatable with EquatableMixin {
GhReposUniformResourceLocatable();
factory GhReposUniformResourceLocatable.fromJson(Map<String, dynamic> json) =>
_$GhReposUniformResourceLocatableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() =>
_$GhReposUniformResourceLocatableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposRepositoryInfo with EquatableMixin {
GhReposRepositoryInfo(
{this.owner,
this.name,
this.description,
this.isPrivate,
this.isFork,
this.updatedAt});
factory GhReposRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhReposRepositoryInfoFromJson(json);
GhReposRepositoryOwner owner;
String name;
String description;
bool isPrivate;
bool isFork;
DateTime updatedAt;
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props =>
[owner, name, description, isPrivate, isFork, updatedAt, resolveType];
Map<String, dynamic> toJson() => _$GhReposRepositoryInfoToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposStarredRepositoryConnection with EquatableMixin {
GhReposStarredRepositoryConnection({this.pageInfo, this.nodes});
factory GhReposStarredRepositoryConnection.fromJson(
Map<String, dynamic> json) =>
_$GhReposStarredRepositoryConnectionFromJson(json);
GhReposPageInfo pageInfo;
List<GhReposRepository> nodes;
@override
List<Object> get props => [pageInfo, nodes];
Map<String, dynamic> toJson() =>
_$GhReposStarredRepositoryConnectionToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposAuditEntryActor with EquatableMixin {
GhReposAuditEntryActor();
factory GhReposAuditEntryActor.fromJson(Map<String, dynamic> json) =>
_$GhReposAuditEntryActorFromJson(json);
@override
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhReposAuditEntryActorToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhReposActor with EquatableMixin {
2020-02-07 08:43:35 +01:00
GhReposActor({this.login, this.avatarUrl});
2020-02-06 06:53:43 +01:00
factory GhReposActor.fromJson(Map<String, dynamic> json) =>
_$GhReposActorFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-07 08:43:35 +01:00
String login;
String avatarUrl;
2020-01-07 11:33:41 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-07 08:43:35 +01:00
List<Object> get props => [login, avatarUrl, resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposActorToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposProfileOwner with EquatableMixin {
2020-02-07 08:43:35 +01:00
GhReposProfileOwner({this.login});
2020-01-07 14:03:04 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposProfileOwner.fromJson(Map<String, dynamic> json) =>
_$GhReposProfileOwnerFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-07 08:43:35 +01:00
String login;
2020-01-07 11:33:41 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-07 08:43:35 +01:00
List<Object> get props => [login, resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposProfileOwnerToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposSponsorable with EquatableMixin {
GhReposSponsorable();
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposSponsorable.fromJson(Map<String, dynamic> json) =>
_$GhReposSponsorableFromJson(json);
2020-01-07 14:03:04 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhReposSponsorableToJson(this);
2020-01-15 10:58:24 +01:00
}
2020-01-07 11:33:41 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhReposArguments extends JsonSerializable with EquatableMixin {
GhReposArguments({@required this.owner, this.after, @required this.isStar});
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhReposArguments.fromJson(Map<String, dynamic> json) =>
_$GhReposArgumentsFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
final String owner;
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
final String after;
final bool isStar;
2020-01-15 10:58:24 +01:00
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [owner, after, isStar];
Map<String, dynamic> toJson() => _$GhReposArgumentsToJson(this);
2020-01-07 11:33:41 +01:00
}
2020-02-06 06:53:43 +01:00
class GhReposQuery extends GraphQLQuery<GhRepos, GhReposArguments> {
GhReposQuery({this.variables});
2020-01-07 11:33:41 +01:00
@override
2020-01-07 14:03:04 +01:00
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
2020-02-06 06:53:43 +01:00
type: OperationType.query,
name: NameNode(value: 'GhRepos'),
2020-01-07 14:03:04 +01:00
variableDefinitions: [
VariableDefinitionNode(
2020-02-06 06:53:43 +01:00
variable: VariableNode(name: NameNode(value: 'owner')),
type: NamedTypeNode(
name: NameNode(value: 'String'), isNonNull: true),
2020-01-07 14:03:04 +01:00
defaultValue: DefaultValueNode(value: null),
2020-01-15 10:58:24 +01:00
directives: []),
VariableDefinitionNode(
2020-02-06 06:53:43 +01:00
variable: VariableNode(name: NameNode(value: 'after')),
type: NamedTypeNode(
name: NameNode(value: 'String'), isNonNull: false),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'isStar')),
2020-01-15 10:58:24 +01:00
type: NamedTypeNode(
2020-01-22 10:33:13 +01:00
name: NameNode(value: 'Boolean'), isNonNull: true),
2020-01-15 10:58:24 +01:00
defaultValue: DefaultValueNode(value: null),
2020-01-07 14:03:04 +01:00
directives: [])
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'user'),
2020-01-07 14:03:04 +01:00
alias: null,
arguments: [
ArgumentNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'login'),
value: VariableNode(name: NameNode(value: 'owner')))
2020-01-07 14:03:04 +01:00
],
2020-02-06 06:53:43 +01:00
directives: [],
2020-01-07 14:03:04 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: '__typename'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'avatarUrl'),
2020-01-07 14:03:04 +01:00
alias: null,
2020-01-22 10:33:13 +01:00
arguments: [],
2020-01-07 14:03:04 +01:00
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null),
2020-02-07 08:43:35 +01:00
FieldNode(
name: NameNode(value: 'repositories'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '30')),
ArgumentNode(
name: NameNode(value: 'after'),
value: VariableNode(name: NameNode(value: 'after'))),
ArgumentNode(
name: NameNode(value: 'orderBy'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'field'),
value: EnumValueNode(
name: NameNode(value: 'UPDATED_AT'))),
ObjectFieldNode(
name: NameNode(value: 'direction'),
value: EnumValueNode(
name: NameNode(value: 'DESC')))
]))
],
directives: [
DirectiveNode(name: NameNode(value: 'skip'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value:
VariableNode(name: NameNode(value: 'isStar')))
])
],
2020-01-15 10:58:24 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'totalCount'),
2020-02-06 06:53:43 +01:00
alias: null,
2020-02-07 08:43:35 +01:00
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'pageInfo'),
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'hasNextPage'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-07 08:43:35 +01:00
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: 'owner'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'login'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'avatarUrl'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'description'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isPrivate'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isFork'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'updatedAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'stargazers'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'totalCount'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-07 08:43:35 +01:00
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'forks'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-02-06 06:53:43 +01:00
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'totalCount'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-07 08:43:35 +01:00
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'primaryLanguage'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-02-06 06:53:43 +01:00
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'color'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'name'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-07 08:43:35 +01:00
selectionSet: null)
2020-02-06 06:53:43 +01:00
]))
2020-02-07 08:43:35 +01:00
]))
])),
FieldNode(
name: NameNode(value: 'starredRepositories'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '30')),
ArgumentNode(
name: NameNode(value: 'after'),
value: VariableNode(name: NameNode(value: 'after'))),
ArgumentNode(
name: NameNode(value: 'orderBy'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'field'),
value: EnumValueNode(
name: NameNode(value: 'STARRED_AT'))),
ObjectFieldNode(
name: NameNode(value: 'direction'),
value: EnumValueNode(
name: NameNode(value: 'DESC')))
]))
],
directives: [
DirectiveNode(
name: NameNode(value: 'include'),
2020-02-06 06:53:43 +01:00
arguments: [
ArgumentNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'if'),
2020-02-06 06:53:43 +01:00
value: VariableNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'isStar')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'pageInfo'),
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-07 08:43:35 +01:00
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: 'owner'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'login'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'avatarUrl'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'name'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-07 08:43:35 +01:00
selectionSet: null),
2020-02-06 06:53:43 +01:00
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'description'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'isPrivate'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isFork'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'updatedAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'stargazers'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'totalCount'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-07 08:43:35 +01:00
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'forks'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-02-06 06:53:43 +01:00
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'totalCount'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
2020-02-07 08:43:35 +01:00
name: NameNode(value: 'primaryLanguage'),
2020-02-06 06:53:43 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-02-07 08:43:35 +01:00
FieldNode(
name: NameNode(value: 'color'),
alias: null,
arguments: [],
2020-02-06 06:53:43 +01:00
directives: [],
2020-02-07 08:43:35 +01:00
selectionSet: null),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
2020-02-06 06:53:43 +01:00
]))
]))
2020-01-22 10:33:13 +01:00
]))
]))
]))
]);
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
final String operationName = 'GhRepos';
2020-01-07 14:03:04 +01:00
@override
2020-02-06 06:53:43 +01:00
final GhReposArguments variables;
2020-01-07 11:33:41 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [document, operationName, variables];
2020-01-07 14:03:04 +01:00
@override
2020-02-06 06:53:43 +01:00
GhRepos parse(Map<String, dynamic> json) => GhRepos.fromJson(json);
2020-01-07 14:03:04 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatch with EquatableMixin {
GhWatch({this.updateSubscription});
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatch.fromJson(Map<String, dynamic> json) =>
_$GhWatchFromJson(json);
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
GhWatchUpdateSubscriptionPayload updateSubscription;
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
@override
List<Object> get props => [updateSubscription];
Map<String, dynamic> toJson() => _$GhWatchToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhWatchUpdateSubscriptionPayload with EquatableMixin {
GhWatchUpdateSubscriptionPayload({this.subscribable});
factory GhWatchUpdateSubscriptionPayload.fromJson(
Map<String, dynamic> json) =>
_$GhWatchUpdateSubscriptionPayloadFromJson(json);
GhWatchSubscribable subscribable;
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [subscribable];
Map<String, dynamic> toJson() =>
_$GhWatchUpdateSubscriptionPayloadToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchSubscribable with EquatableMixin {
GhWatchSubscribable();
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchSubscribable.fromJson(Map<String, dynamic> json) {
switch (json['__typename'].toString()) {
case 'Repository':
return GhWatchRepository.fromJson(json);
default:
}
return _$GhWatchSubscribableFromJson(json);
}
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-15 10:58:24 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() {
switch (resolveType) {
case 'Repository':
return (this as GhWatchRepository).toJson();
default:
}
return _$GhWatchSubscribableToJson(this);
}
2020-01-15 10:58:24 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchRepository extends GhWatchPinnableItem
with EquatableMixin
implements
GhWatchNode,
GhWatchProjectOwner,
GhWatchRegistryPackageOwner,
GhWatchRegistryPackageSearch,
GhWatchSubscribable,
GhWatchStarrable,
GhWatchUniformResourceLocatable,
GhWatchRepositoryInfo {
GhWatchRepository({this.viewerSubscription});
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchRepository.fromJson(Map<String, dynamic> json) =>
_$GhWatchRepositoryFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(unknownEnumValue: GhWatchSubscriptionState.ARTEMIS_UNKNOWN)
GhWatchSubscriptionState viewerSubscription;
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
@override
2020-01-07 11:33:41 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [viewerSubscription, resolveType];
Map<String, dynamic> toJson() => _$GhWatchRepositoryToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchPinnableItem with EquatableMixin {
GhWatchPinnableItem();
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhWatchPinnableItemFromJson(json);
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhWatchPinnableItemToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchNode with EquatableMixin {
GhWatchNode();
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchNode.fromJson(Map<String, dynamic> json) =>
_$GhWatchNodeFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhWatchNodeToJson(this);
2020-01-07 11:33:41 +01:00
}
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhWatchProjectOwner with EquatableMixin {
GhWatchProjectOwner();
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhWatchProjectOwnerFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhWatchProjectOwnerToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchRegistryPackageOwner with EquatableMixin {
GhWatchRegistryPackageOwner();
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhWatchRegistryPackageOwnerFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 11:33:41 +01:00
2020-01-07 14:03:04 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhWatchRegistryPackageOwnerToJson(this);
2020-01-07 14:03:04 +01:00
}
2020-01-07 11:33:41 +01:00
2020-01-07 14:03:04 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchRegistryPackageSearch with EquatableMixin {
GhWatchRegistryPackageSearch();
2020-01-07 14:03:04 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhWatchRegistryPackageSearchFromJson(json);
2020-01-07 11:33:41 +01:00
2020-01-07 14:03:04 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhWatchRegistryPackageSearchToJson(this);
2020-01-07 14:03:04 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchStarrable with EquatableMixin {
GhWatchStarrable();
2020-01-07 14:03:04 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchStarrable.fromJson(Map<String, dynamic> json) =>
_$GhWatchStarrableFromJson(json);
2020-01-07 14:03:04 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhWatchStarrableToJson(this);
2020-01-07 14:03:04 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchUniformResourceLocatable with EquatableMixin {
GhWatchUniformResourceLocatable();
2020-01-30 08:31:46 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchUniformResourceLocatable.fromJson(Map<String, dynamic> json) =>
_$GhWatchUniformResourceLocatableFromJson(json);
2020-01-07 14:03:04 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() =>
_$GhWatchUniformResourceLocatableToJson(this);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchRepositoryInfo with EquatableMixin {
GhWatchRepositoryInfo();
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhWatchRepositoryInfoFromJson(json);
2020-01-07 11:33:41 +01:00
2020-01-15 10:58:24 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 11:33:41 +01:00
@override
2020-01-15 10:58:24 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhWatchRepositoryInfoToJson(this);
}
enum GhWatchSubscriptionState {
UNSUBSCRIBED,
SUBSCRIBED,
IGNORED,
ARTEMIS_UNKNOWN,
2020-01-15 10:58:24 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhWatchArguments extends JsonSerializable with EquatableMixin {
GhWatchArguments({@required this.id, @required this.state});
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhWatchArguments.fromJson(Map<String, dynamic> json) =>
_$GhWatchArgumentsFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
final String id;
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
final GhWatchSubscriptionState state;
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, state];
Map<String, dynamic> toJson() => _$GhWatchArgumentsToJson(this);
2020-01-30 08:31:46 +01:00
}
2020-02-06 06:53:43 +01:00
class GhWatchQuery extends GraphQLQuery<GhWatch, GhWatchArguments> {
GhWatchQuery({this.variables});
2020-01-30 08:31:46 +01:00
2020-02-06 06:53:43 +01:00
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
type: OperationType.mutation,
name: NameNode(value: 'GhWatch'),
variableDefinitions: [
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'id')),
type: NamedTypeNode(name: NameNode(value: 'ID'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'state')),
type: NamedTypeNode(
name: NameNode(value: 'SubscriptionState'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: [])
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'updateSubscription'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'input'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'subscribableId'),
value: VariableNode(name: NameNode(value: 'id'))),
ObjectFieldNode(
name: NameNode(value: 'state'),
value: VariableNode(name: NameNode(value: 'state')))
]))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'subscribable'),
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: 'Repository'),
isNonNull: false)),
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'viewerSubscription'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
]))
]);
2020-01-30 08:31:46 +01:00
2020-02-06 06:53:43 +01:00
@override
final String operationName = 'GhWatch';
2020-01-30 08:31:46 +01:00
2020-02-06 06:53:43 +01:00
@override
final GhWatchArguments variables;
2020-01-30 08:31:46 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [document, operationName, variables];
@override
GhWatch parse(Map<String, dynamic> json) => GhWatch.fromJson(json);
2020-01-07 11:33:41 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUser with EquatableMixin {
GhUser({this.repositoryOwner, this.viewer});
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhUser.fromJson(Map<String, dynamic> json) => _$GhUserFromJson(json);
GhUserRepositoryOwner repositoryOwner;
GhUserUser viewer;
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [repositoryOwner, viewer];
Map<String, dynamic> toJson() => _$GhUserToJson(this);
2020-01-07 11:33:41 +01:00
}
2020-01-22 10:33:13 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserRepositoryOwner with EquatableMixin {
GhUserRepositoryOwner({this.id, this.login, this.avatarUrl, this.url});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserRepositoryOwner.fromJson(Map<String, dynamic> json) {
switch (json['__typename'].toString()) {
case 'User':
return GhUserUser.fromJson(json);
case 'Organization':
return GhUserOrganization.fromJson(json);
default:
}
return _$GhUserRepositoryOwnerFromJson(json);
}
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String id;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String login;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String avatarUrl;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String url;
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, login, avatarUrl, url, resolveType];
Map<String, dynamic> toJson() {
switch (resolveType) {
case 'User':
return (this as GhUserUser).toJson();
case 'Organization':
return (this as GhUserOrganization).toJson();
default:
}
return _$GhUserRepositoryOwnerToJson(this);
}
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserUser extends GhUserAuditEntryActor
with EquatableMixin
implements
GhUserNode,
GhUserActor,
GhUserRegistryPackageOwner,
GhUserRegistryPackageSearch,
GhUserProjectOwner,
GhUserRepositoryOwner,
GhUserUniformResourceLocatable,
GhUserProfileOwner,
GhUserSponsorable {
GhUserUser(
{this.name,
this.bio,
this.company,
this.location,
this.email,
this.createdAt,
this.websiteUrl,
this.starredRepositories,
this.followers,
this.following,
this.contributionsCollection,
this.repositories,
this.pinnedItems,
this.viewerCanFollow,
this.viewerIsFollowing});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserUser.fromJson(Map<String, dynamic> json) =>
_$GhUserUserFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String name;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String bio;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String company;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String location;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String email;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
DateTime createdAt;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
String websiteUrl;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhUserStarredRepositoryConnection starredRepositories;
GhUserFollowerConnection followers;
GhUserFollowingConnection following;
GhUserContributionsCollection contributionsCollection;
GhUserRepositoryConnection repositories;
GhUserPinnableItemConnection pinnedItems;
bool viewerCanFollow;
bool viewerIsFollowing;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@override
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
String id;
@override
String login;
@override
String avatarUrl;
@override
String url;
@override
List<Object> get props => [
name,
bio,
company,
location,
email,
createdAt,
websiteUrl,
starredRepositories,
followers,
following,
contributionsCollection,
repositories,
pinnedItems,
viewerCanFollow,
viewerIsFollowing,
resolveType,
id,
login,
avatarUrl,
url
];
Map<String, dynamic> toJson() => _$GhUserUserToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserStarredRepositoryConnection with EquatableMixin {
GhUserStarredRepositoryConnection({this.totalCount});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserStarredRepositoryConnection.fromJson(
2020-01-22 10:33:13 +01:00
Map<String, dynamic> json) =>
2020-02-06 06:53:43 +01:00
_$GhUserStarredRepositoryConnectionFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount];
2020-01-22 10:33:13 +01:00
Map<String, dynamic> toJson() =>
2020-02-06 06:53:43 +01:00
_$GhUserStarredRepositoryConnectionToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserFollowerConnection with EquatableMixin {
GhUserFollowerConnection({this.totalCount});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserFollowerConnection.fromJson(Map<String, dynamic> json) =>
_$GhUserFollowerConnectionFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhUserFollowerConnectionToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserFollowingConnection with EquatableMixin {
GhUserFollowingConnection({this.totalCount});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserFollowingConnection.fromJson(Map<String, dynamic> json) =>
_$GhUserFollowingConnectionFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhUserFollowingConnectionToJson(this);
2020-01-22 10:33:13 +01:00
}
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhUserContributionsCollection with EquatableMixin {
GhUserContributionsCollection({this.contributionCalendar});
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserContributionsCollection.fromJson(Map<String, dynamic> json) =>
_$GhUserContributionsCollectionFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhUserContributionCalendar contributionCalendar;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [contributionCalendar];
Map<String, dynamic> toJson() => _$GhUserContributionsCollectionToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserContributionCalendar with EquatableMixin {
GhUserContributionCalendar({this.weeks});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserContributionCalendar.fromJson(Map<String, dynamic> json) =>
_$GhUserContributionCalendarFromJson(json);
List<GhUserContributionCalendarWeek> weeks;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [weeks];
Map<String, dynamic> toJson() => _$GhUserContributionCalendarToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserContributionCalendarWeek with EquatableMixin {
GhUserContributionCalendarWeek({this.contributionDays});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserContributionCalendarWeek.fromJson(Map<String, dynamic> json) =>
_$GhUserContributionCalendarWeekFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
List<GhUserContributionCalendarDay> contributionDays;
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [contributionDays];
Map<String, dynamic> toJson() => _$GhUserContributionCalendarWeekToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserContributionCalendarDay with EquatableMixin {
GhUserContributionCalendarDay({this.color});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserContributionCalendarDay.fromJson(Map<String, dynamic> json) =>
_$GhUserContributionCalendarDayFromJson(json);
2020-01-07 11:33:41 +01:00
2020-02-06 06:53:43 +01:00
String color;
2020-01-22 10:33:13 +01:00
2020-01-07 11:33:41 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [color];
Map<String, dynamic> toJson() => _$GhUserContributionCalendarDayToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserRepositoryConnection with EquatableMixin {
GhUserRepositoryConnection({this.totalCount, this.nodes});
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserRepositoryConnection.fromJson(Map<String, dynamic> json) =>
_$GhUserRepositoryConnectionFromJson(json);
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
List<GhUserRepository> nodes;
2020-01-07 13:48:50 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount, nodes];
Map<String, dynamic> toJson() => _$GhUserRepositoryConnectionToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserRepository extends GhUserPinnableItem
2020-01-07 13:48:50 +01:00
with EquatableMixin
implements
2020-02-06 06:53:43 +01:00
GhUserNode,
GhUserProjectOwner,
GhUserRegistryPackageOwner,
GhUserRegistryPackageSearch,
GhUserSubscribable,
GhUserStarrable,
GhUserUniformResourceLocatable,
GhUserRepositoryInfo {
GhUserRepository({this.forks, this.primaryLanguage});
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserRepository.fromJson(Map<String, dynamic> json) =>
_$GhUserRepositoryFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@override
GhUserRepositoryOwner owner;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@override
String name;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@override
String description;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@override
bool isPrivate;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@override
bool isFork;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@override
GhUserStargazerConnection stargazers;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhUserRepositoryConnection forks;
GhUserLanguage primaryLanguage;
2020-01-22 10:33:13 +01:00
@override
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [
2020-02-06 06:53:43 +01:00
owner,
name,
description,
isPrivate,
isFork,
stargazers,
forks,
primaryLanguage,
2020-01-22 10:33:13 +01:00
resolveType
];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhUserRepositoryToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserStargazerConnection with EquatableMixin {
GhUserStargazerConnection({this.totalCount});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserStargazerConnection.fromJson(Map<String, dynamic> json) =>
_$GhUserStargazerConnectionFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() => _$GhUserStargazerConnectionToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserLanguage with EquatableMixin implements GhUserNode {
GhUserLanguage({this.color, this.name});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserLanguage.fromJson(Map<String, dynamic> json) =>
_$GhUserLanguageFromJson(json);
String color;
String name;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [color, name, resolveType];
Map<String, dynamic> toJson() => _$GhUserLanguageToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUserNode with EquatableMixin {
GhUserNode();
factory GhUserNode.fromJson(Map<String, dynamic> json) =>
_$GhUserNodeFromJson(json);
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUserNodeToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserPinnableItem with EquatableMixin {
GhUserPinnableItem();
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhUserPinnableItemFromJson(json);
2020-01-22 10:33:13 +01:00
@override
List<Object> get props => [];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhUserPinnableItemToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserProjectOwner with EquatableMixin {
GhUserProjectOwner();
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhUserProjectOwnerFromJson(json);
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhUserProjectOwnerToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserRegistryPackageOwner with EquatableMixin {
GhUserRegistryPackageOwner();
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhUserRegistryPackageOwnerFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUserRegistryPackageOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhUserRegistryPackageSearch with EquatableMixin {
GhUserRegistryPackageSearch();
factory GhUserRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhUserRegistryPackageSearchFromJson(json);
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUserRegistryPackageSearchToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserSubscribable with EquatableMixin {
GhUserSubscribable();
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhUserSubscribableFromJson(json);
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhUserSubscribableToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserStarrable with EquatableMixin {
GhUserStarrable({this.stargazers});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserStarrable.fromJson(Map<String, dynamic> json) =>
_$GhUserStarrableFromJson(json);
GhUserStargazerConnection stargazers;
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [stargazers, resolveType];
Map<String, dynamic> toJson() => _$GhUserStarrableToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserUniformResourceLocatable with EquatableMixin {
GhUserUniformResourceLocatable();
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserUniformResourceLocatable.fromJson(Map<String, dynamic> json) =>
_$GhUserUniformResourceLocatableFromJson(json);
2020-01-22 10:33:13 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-15 10:58:24 +01:00
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhUserUniformResourceLocatableToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserRepositoryInfo with EquatableMixin {
GhUserRepositoryInfo(
{this.owner, this.name, this.description, this.isPrivate, this.isFork});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhUserRepositoryInfoFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhUserRepositoryOwner owner;
String name;
String description;
bool isPrivate;
bool isFork;
2020-01-07 13:48:50 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props =>
[owner, name, description, isPrivate, isFork, resolveType];
Map<String, dynamic> toJson() => _$GhUserRepositoryInfoToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserPinnableItemConnection with EquatableMixin {
GhUserPinnableItemConnection({this.totalCount, this.nodes});
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserPinnableItemConnection.fromJson(Map<String, dynamic> json) =>
_$GhUserPinnableItemConnectionFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
List<GhUserPinnableItem> nodes;
2020-01-07 13:48:50 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount, nodes];
Map<String, dynamic> toJson() => _$GhUserPinnableItemConnectionToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserAuditEntryActor with EquatableMixin {
GhUserAuditEntryActor();
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserAuditEntryActor.fromJson(Map<String, dynamic> json) =>
_$GhUserAuditEntryActorFromJson(json);
2020-01-07 13:48:50 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhUserAuditEntryActorToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserActor with EquatableMixin {
GhUserActor();
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserActor.fromJson(Map<String, dynamic> json) =>
_$GhUserActorFromJson(json);
2020-01-07 13:48:50 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-01-22 10:33:13 +01:00
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhUserActorToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserProfileOwner with EquatableMixin {
GhUserProfileOwner(
{this.name,
this.location,
this.email,
this.websiteUrl,
this.pinnedItems});
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserProfileOwner.fromJson(Map<String, dynamic> json) =>
_$GhUserProfileOwnerFromJson(json);
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
String name;
String location;
String email;
String websiteUrl;
GhUserPinnableItemConnection pinnedItems;
2020-01-07 13:48:50 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props =>
[name, location, email, websiteUrl, pinnedItems, resolveType];
Map<String, dynamic> toJson() => _$GhUserProfileOwnerToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserSponsorable with EquatableMixin {
GhUserSponsorable();
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserSponsorable.fromJson(Map<String, dynamic> json) =>
_$GhUserSponsorableFromJson(json);
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-07 13:48:50 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhUserSponsorableToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserOrganization extends GhUserAuditEntryActor
with EquatableMixin
implements
GhUserNode,
GhUserActor,
GhUserRegistryPackageOwner,
GhUserRegistryPackageSearch,
GhUserProjectOwner,
GhUserRepositoryOwner,
GhUserUniformResourceLocatable,
GhUserMemberStatusable,
GhUserProfileOwner,
GhUserSponsorable {
GhUserOrganization(
{this.name,
this.description,
this.location,
this.email,
this.websiteUrl,
this.createdAt,
this.pinnedItems,
this.pinnableItems,
this.membersWithRole});
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserOrganization.fromJson(Map<String, dynamic> json) =>
_$GhUserOrganizationFromJson(json);
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
String name;
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
String description;
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
String location;
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
String email;
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
String websiteUrl;
2020-01-15 10:58:24 +01:00
2020-02-06 06:53:43 +01:00
DateTime createdAt;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhUserPinnableItemConnection pinnedItems;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhUserPinnableItemConnection pinnableItems;
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
GhUserOrganizationMemberConnection membersWithRole;
@override
2020-01-07 13:48:50 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
String id;
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
@override
String login;
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
@override
String avatarUrl;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
String url;
@override
List<Object> get props => [
name,
description,
location,
email,
websiteUrl,
createdAt,
pinnedItems,
pinnableItems,
membersWithRole,
resolveType,
id,
login,
avatarUrl,
url
];
Map<String, dynamic> toJson() => _$GhUserOrganizationToJson(this);
2020-01-22 10:33:13 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserOrganizationMemberConnection with EquatableMixin {
GhUserOrganizationMemberConnection({this.totalCount});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserOrganizationMemberConnection.fromJson(
Map<String, dynamic> json) =>
_$GhUserOrganizationMemberConnectionFromJson(json);
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
int totalCount;
2020-01-07 13:48:50 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [totalCount];
Map<String, dynamic> toJson() =>
_$GhUserOrganizationMemberConnectionToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserMemberStatusable with EquatableMixin {
GhUserMemberStatusable();
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserMemberStatusable.fromJson(Map<String, dynamic> json) =>
_$GhUserMemberStatusableFromJson(json);
2020-01-07 13:48:50 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhUserMemberStatusableToJson(this);
2020-01-07 13:48:50 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhUserArguments extends JsonSerializable with EquatableMixin {
GhUserArguments({@required this.login, @required this.isViewer});
2020-01-07 13:48:50 +01:00
2020-02-06 06:53:43 +01:00
factory GhUserArguments.fromJson(Map<String, dynamic> json) =>
_$GhUserArgumentsFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
final String login;
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
final bool isViewer;
2020-01-22 10:33:13 +01:00
2020-01-07 13:48:50 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [login, isViewer];
Map<String, dynamic> toJson() => _$GhUserArgumentsToJson(this);
2020-01-07 13:48:50 +01:00
}
2020-02-06 06:53:43 +01:00
class GhUserQuery extends GraphQLQuery<GhUser, GhUserArguments> {
GhUserQuery({this.variables});
2020-01-07 13:48:50 +01:00
@override
final DocumentNode document = DocumentNode(definitions: [
2020-02-06 06:53:43 +01:00
OperationDefinitionNode(
type: OperationType.query,
name: NameNode(value: 'GhUser'),
variableDefinitions: [
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'login')),
type: NamedTypeNode(
name: NameNode(value: 'String'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'isViewer')),
type: NamedTypeNode(
name: NameNode(value: 'Boolean'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: [])
],
2020-01-22 10:33:13 +01:00
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'repositoryOwner'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'login'),
value: VariableNode(name: NameNode(value: 'login')))
],
directives: [
DirectiveNode(name: NameNode(value: 'skip'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'isViewer')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: '__typename'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'id'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'avatarUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'url'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
InlineFragmentNode(
typeCondition: TypeConditionNode(
on: NamedTypeNode(
name: NameNode(value: 'User'), isNonNull: false)),
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'bio'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'company'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'email'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'createdAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'websiteUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'starredRepositories'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'followers'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'following'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'contributionsCollection'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'contributionCalendar'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'weeks'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(
value: 'contributionDays'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name:
NameNode(value: 'color'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
])),
FieldNode(
name: NameNode(value: 'repositories'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '6')),
ArgumentNode(
name: NameNode(value: 'ownerAffiliations'),
value: EnumValueNode(
name: NameNode(value: 'OWNER'))),
ArgumentNode(
name: NameNode(value: 'orderBy'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'field'),
value: EnumValueNode(
name: NameNode(value: 'STARGAZERS'))),
ObjectFieldNode(
name: NameNode(value: 'direction'),
value: EnumValueNode(
name: NameNode(value: 'DESC')))
]))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'nodes'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'owner'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'avatarUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'description'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isPrivate'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isFork'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'stargazers'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'forks'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'primaryLanguage'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'color'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
])),
FieldNode(
name: NameNode(value: 'pinnedItems'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '6'))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'nodes'),
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: 'Repository'),
isNonNull: false)),
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'owner'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name:
NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(
value: 'avatarUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name:
NameNode(value: 'description'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isPrivate'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isFork'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'stargazers'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(
value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'forks'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(
value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(
value: 'primaryLanguage'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name:
NameNode(value: 'color'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
])),
FieldNode(
name: NameNode(value: 'viewerCanFollow'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'viewerIsFollowing'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
InlineFragmentNode(
typeCondition: TypeConditionNode(
on: NamedTypeNode(
name: NameNode(value: 'Organization'),
isNonNull: false)),
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'description'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'email'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'websiteUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'createdAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'pinnedItems'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '6'))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'nodes'),
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: 'Repository'),
isNonNull: false)),
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'owner'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name:
NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(
value: 'avatarUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name:
NameNode(value: 'description'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isPrivate'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isFork'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'stargazers'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(
value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'forks'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(
value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(
value: 'primaryLanguage'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name:
NameNode(value: 'color'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
])),
FieldNode(
name: NameNode(value: 'pinnableItems'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '6')),
ArgumentNode(
name: NameNode(value: 'types'),
value: ListValueNode(values: [
EnumValueNode(
name: NameNode(value: 'REPOSITORY'))
]))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'nodes'),
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: 'Repository'),
isNonNull: false)),
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'owner'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name:
NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(
value: 'avatarUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name:
NameNode(value: 'description'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isPrivate'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isFork'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'stargazers'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(
value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'forks'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(
value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(
value: 'primaryLanguage'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name:
NameNode(value: 'color'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
])),
FieldNode(
name: NameNode(value: 'membersWithRole'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
])),
FieldNode(
name: NameNode(value: 'viewer'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
2020-02-06 06:53:43 +01:00
directives: [
DirectiveNode(name: NameNode(value: 'include'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'isViewer')))
])
],
2020-01-22 10:33:13 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'id'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
2020-02-06 06:53:43 +01:00
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'avatarUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'url'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'bio'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'company'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'location'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'email'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'createdAt'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'websiteUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'starredRepositories'),
alias: null,
arguments: [],
2020-01-22 10:33:13 +01:00
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'totalCount'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'followers'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'totalCount'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'following'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'totalCount'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'contributionsCollection'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'contributionCalendar'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'weeks'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'contributionDays'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'color'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
])),
FieldNode(
name: NameNode(value: 'repositories'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '6')),
ArgumentNode(
name: NameNode(value: 'ownerAffiliations'),
value: EnumValueNode(name: NameNode(value: 'OWNER'))),
ArgumentNode(
name: NameNode(value: 'orderBy'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'field'),
value: EnumValueNode(
name: NameNode(value: 'STARGAZERS'))),
ObjectFieldNode(
name: NameNode(value: 'direction'),
value: EnumValueNode(
name: NameNode(value: 'DESC')))
]))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'totalCount'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'nodes'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-02-06 06:53:43 +01:00
FieldNode(
name: NameNode(value: 'owner'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'avatarUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
2020-01-22 10:33:13 +01:00
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'description'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'isPrivate'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'isFork'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'stargazers'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'totalCount'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
2020-02-06 06:53:43 +01:00
])),
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'forks'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'primaryLanguage'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'color'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'name'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
2020-02-06 06:53:43 +01:00
]))
]))
])),
FieldNode(
name: NameNode(value: 'pinnedItems'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'first'),
value: IntValueNode(value: '6'))
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'totalCount'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'nodes'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: '__typename'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null),
InlineFragmentNode(
typeCondition: TypeConditionNode(
on: NamedTypeNode(
name: NameNode(value: 'Repository'),
isNonNull: false)),
directives: [],
2020-01-22 10:33:13 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'owner'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'login'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'avatarUrl'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
])),
FieldNode(
name: NameNode(value: 'name'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'description'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'isPrivate'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'isFork'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'stargazers'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'totalCount'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
2020-01-22 10:33:13 +01:00
])),
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'forks'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'totalCount'),
2020-01-22 10:33:13 +01:00
alias: null,
arguments: [],
directives: [],
selectionSet: null)
2020-02-06 06:53:43 +01:00
])),
FieldNode(
name: NameNode(value: 'primaryLanguage'),
alias: null,
arguments: [],
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'color'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'name'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
])),
2020-01-07 13:48:50 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'viewerCanFollow'),
2020-01-07 13:48:50 +01:00
alias: null,
arguments: [],
2020-02-06 06:53:43 +01:00
directives: [],
selectionSet: null),
2020-01-22 10:33:13 +01:00
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'viewerIsFollowing'),
2020-01-22 10:33:13 +01:00
alias: null,
2020-02-06 06:53:43 +01:00
arguments: [],
directives: [],
selectionSet: null)
2020-01-07 13:48:50 +01:00
]))
]))
]);
@override
2020-02-06 06:53:43 +01:00
final String operationName = 'GhUser';
2020-01-07 13:48:50 +01:00
@override
2020-02-06 06:53:43 +01:00
final GhUserArguments variables;
2020-01-07 13:48:50 +01:00
@override
List<Object> get props => [document, operationName, variables];
@override
2020-02-06 06:53:43 +01:00
GhUser parse(Map<String, dynamic> json) => GhUser.fromJson(json);
2020-01-20 07:18:45 +01:00
}
2020-01-22 10:33:13 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhFollow with EquatableMixin {
GhFollow({this.followUser, this.unfollowUser});
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
factory GhFollow.fromJson(Map<String, dynamic> json) =>
_$GhFollowFromJson(json);
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
GhFollowFollowUserPayload followUser;
GhFollowUnfollowUserPayload unfollowUser;
2020-01-20 07:18:45 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [followUser, unfollowUser];
Map<String, dynamic> toJson() => _$GhFollowToJson(this);
2020-01-20 07:18:45 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhFollowFollowUserPayload with EquatableMixin {
GhFollowFollowUserPayload({this.user});
factory GhFollowFollowUserPayload.fromJson(Map<String, dynamic> json) =>
_$GhFollowFollowUserPayloadFromJson(json);
GhFollowUser user;
@override
List<Object> get props => [user];
Map<String, dynamic> toJson() => _$GhFollowFollowUserPayloadToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhFollowUser extends GhFollowAuditEntryActor
2020-01-20 07:18:45 +01:00
with EquatableMixin
implements
2020-02-06 06:53:43 +01:00
GhFollowNode,
GhFollowActor,
GhFollowRegistryPackageOwner,
GhFollowRegistryPackageSearch,
GhFollowProjectOwner,
GhFollowRepositoryOwner,
GhFollowUniformResourceLocatable,
GhFollowProfileOwner,
GhFollowSponsorable {
GhFollowUser({this.viewerIsFollowing});
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
factory GhFollowUser.fromJson(Map<String, dynamic> json) =>
_$GhFollowUserFromJson(json);
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
bool viewerIsFollowing;
2020-01-20 07:18:45 +01:00
@override
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [viewerIsFollowing, resolveType];
Map<String, dynamic> toJson() => _$GhFollowUserToJson(this);
2020-01-20 07:18:45 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhFollowAuditEntryActor with EquatableMixin {
GhFollowAuditEntryActor();
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
factory GhFollowAuditEntryActor.fromJson(Map<String, dynamic> json) =>
_$GhFollowAuditEntryActorFromJson(json);
2020-01-20 07:18:45 +01:00
@override
List<Object> get props => [];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhFollowAuditEntryActorToJson(this);
2020-01-20 07:18:45 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhFollowNode with EquatableMixin {
GhFollowNode();
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
factory GhFollowNode.fromJson(Map<String, dynamic> json) =>
_$GhFollowNodeFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhFollowNodeToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhFollowActor with EquatableMixin {
GhFollowActor();
factory GhFollowActor.fromJson(Map<String, dynamic> json) =>
_$GhFollowActorFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhFollowActorToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhFollowRegistryPackageOwner with EquatableMixin {
GhFollowRegistryPackageOwner();
factory GhFollowRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhFollowRegistryPackageOwnerFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhFollowRegistryPackageOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhFollowRegistryPackageSearch with EquatableMixin {
GhFollowRegistryPackageSearch();
factory GhFollowRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhFollowRegistryPackageSearchFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhFollowRegistryPackageSearchToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhFollowProjectOwner with EquatableMixin {
GhFollowProjectOwner();
factory GhFollowProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhFollowProjectOwnerFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhFollowProjectOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhFollowRepositoryOwner with EquatableMixin {
GhFollowRepositoryOwner();
factory GhFollowRepositoryOwner.fromJson(Map<String, dynamic> json) =>
_$GhFollowRepositoryOwnerFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhFollowRepositoryOwnerToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhFollowUniformResourceLocatable with EquatableMixin {
GhFollowUniformResourceLocatable();
factory GhFollowUniformResourceLocatable.fromJson(
Map<String, dynamic> json) =>
_$GhFollowUniformResourceLocatableFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() =>
_$GhFollowUniformResourceLocatableToJson(this);
}
@JsonSerializable(explicitToJson: true)
class GhFollowProfileOwner with EquatableMixin {
GhFollowProfileOwner();
factory GhFollowProfileOwner.fromJson(Map<String, dynamic> json) =>
_$GhFollowProfileOwnerFromJson(json);
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhFollowProfileOwnerToJson(this);
}
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhFollowSponsorable with EquatableMixin {
GhFollowSponsorable();
factory GhFollowSponsorable.fromJson(Map<String, dynamic> json) =>
_$GhFollowSponsorableFromJson(json);
2020-01-20 07:18:45 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhFollowSponsorableToJson(this);
2020-01-20 07:18:45 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhFollowUnfollowUserPayload with EquatableMixin {
GhFollowUnfollowUserPayload({this.user});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhFollowUnfollowUserPayload.fromJson(Map<String, dynamic> json) =>
_$GhFollowUnfollowUserPayloadFromJson(json);
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
GhFollowUser user;
2020-01-20 07:18:45 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [user];
Map<String, dynamic> toJson() => _$GhFollowUnfollowUserPayloadToJson(this);
2020-01-20 07:18:45 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhFollowArguments extends JsonSerializable with EquatableMixin {
GhFollowArguments({@required this.id, @required this.flag});
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
factory GhFollowArguments.fromJson(Map<String, dynamic> json) =>
_$GhFollowArgumentsFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
final String id;
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
final bool flag;
2020-01-20 07:18:45 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, flag];
Map<String, dynamic> toJson() => _$GhFollowArgumentsToJson(this);
2020-01-20 07:18:45 +01:00
}
2020-02-06 06:53:43 +01:00
class GhFollowQuery extends GraphQLQuery<GhFollow, GhFollowArguments> {
GhFollowQuery({this.variables});
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
type: OperationType.mutation,
name: NameNode(value: 'GhFollow'),
variableDefinitions: [
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'id')),
type: NamedTypeNode(name: NameNode(value: 'ID'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
variable: VariableNode(name: NameNode(value: 'flag')),
type: NamedTypeNode(
name: NameNode(value: 'Boolean'), isNonNull: true),
defaultValue: DefaultValueNode(value: null),
directives: [])
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'followUser'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'input'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'userId'),
value: VariableNode(name: NameNode(value: 'id')))
]))
],
directives: [
DirectiveNode(name: NameNode(value: 'include'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'flag')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'user'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'viewerIsFollowing'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
])),
FieldNode(
name: NameNode(value: 'unfollowUser'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'input'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'userId'),
value: VariableNode(name: NameNode(value: 'id')))
]))
],
directives: [
DirectiveNode(name: NameNode(value: 'skip'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'flag')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'user'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'viewerIsFollowing'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
]);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
@override
final String operationName = 'GhFollow';
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
@override
final GhFollowArguments variables;
2020-01-20 07:18:45 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [document, operationName, variables];
@override
GhFollow parse(Map<String, dynamic> json) => GhFollow.fromJson(json);
2020-01-20 07:18:45 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhStar with EquatableMixin {
GhStar({this.addStar, this.removeStar});
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
factory GhStar.fromJson(Map<String, dynamic> json) => _$GhStarFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhStarAddStarPayload addStar;
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
GhStarRemoveStarPayload removeStar;
2020-01-20 07:18:45 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [addStar, removeStar];
Map<String, dynamic> toJson() => _$GhStarToJson(this);
2020-01-20 07:18:45 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhStarAddStarPayload with EquatableMixin {
GhStarAddStarPayload({this.starrable});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhStarAddStarPayload.fromJson(Map<String, dynamic> json) =>
_$GhStarAddStarPayloadFromJson(json);
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
GhStarStarrable starrable;
2020-01-20 07:18:45 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [starrable];
Map<String, dynamic> toJson() => _$GhStarAddStarPayloadToJson(this);
2020-01-20 07:18:45 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhStarStarrable with EquatableMixin {
GhStarStarrable({this.viewerHasStarred});
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
factory GhStarStarrable.fromJson(Map<String, dynamic> json) =>
_$GhStarStarrableFromJson(json);
bool viewerHasStarred;
2020-01-20 07:18:45 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [viewerHasStarred, resolveType];
Map<String, dynamic> toJson() => _$GhStarStarrableToJson(this);
2020-01-20 07:18:45 +01:00
}
2020-01-22 10:33:13 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhStarRemoveStarPayload with EquatableMixin {
GhStarRemoveStarPayload({this.starrable});
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
factory GhStarRemoveStarPayload.fromJson(Map<String, dynamic> json) =>
_$GhStarRemoveStarPayloadFromJson(json);
2020-01-22 10:33:13 +01:00
2020-02-06 06:53:43 +01:00
GhStarStarrable starrable;
2020-01-22 10:33:13 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [starrable];
Map<String, dynamic> toJson() => _$GhStarRemoveStarPayloadToJson(this);
2020-01-20 07:18:45 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhStarArguments extends JsonSerializable with EquatableMixin {
GhStarArguments({@required this.id, @required this.flag});
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
factory GhStarArguments.fromJson(Map<String, dynamic> json) =>
_$GhStarArgumentsFromJson(json);
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
final String id;
2020-01-20 07:18:45 +01:00
2020-02-06 06:53:43 +01:00
final bool flag;
2020-01-20 07:18:45 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, flag];
Map<String, dynamic> toJson() => _$GhStarArgumentsToJson(this);
2020-01-20 07:18:45 +01:00
}
2020-02-06 06:53:43 +01:00
class GhStarQuery extends GraphQLQuery<GhStar, GhStarArguments> {
GhStarQuery({this.variables});
2020-01-20 07:18:45 +01:00
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
2020-02-06 06:53:43 +01:00
type: OperationType.mutation,
name: NameNode(value: 'GhStar'),
2020-01-20 07:18:45 +01:00
variableDefinitions: [
VariableDefinitionNode(
2020-02-06 06:53:43 +01:00
variable: VariableNode(name: NameNode(value: 'id')),
type: NamedTypeNode(name: NameNode(value: 'ID'), isNonNull: true),
2020-01-20 07:18:45 +01:00
defaultValue: DefaultValueNode(value: null),
directives: []),
VariableDefinitionNode(
2020-02-06 06:53:43 +01:00
variable: VariableNode(name: NameNode(value: 'flag')),
2020-01-20 07:18:45 +01:00
type: NamedTypeNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'Boolean'), isNonNull: true),
2020-01-20 07:18:45 +01:00
defaultValue: DefaultValueNode(value: null),
directives: [])
],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'addStar'),
alias: null,
arguments: [
ArgumentNode(
name: NameNode(value: 'input'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'starrableId'),
value: VariableNode(name: NameNode(value: 'id')))
]))
],
directives: [
DirectiveNode(name: NameNode(value: 'include'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'flag')))
])
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'starrable'),
alias: null,
arguments: [],
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'viewerHasStarred'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
])),
FieldNode(
name: NameNode(value: 'removeStar'),
2020-01-20 07:18:45 +01:00
alias: null,
arguments: [
ArgumentNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'input'),
value: ObjectValueNode(fields: [
ObjectFieldNode(
name: NameNode(value: 'starrableId'),
value: VariableNode(name: NameNode(value: 'id')))
]))
],
directives: [
DirectiveNode(name: NameNode(value: 'skip'), arguments: [
ArgumentNode(
name: NameNode(value: 'if'),
value: VariableNode(name: NameNode(value: 'flag')))
])
2020-01-20 07:18:45 +01:00
],
selectionSet: SelectionSetNode(selections: [
FieldNode(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'starrable'),
2020-01-20 07:18:45 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'viewerHasStarred'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
2020-01-20 07:18:45 +01:00
]))
]))
]);
@override
2020-02-06 06:53:43 +01:00
final String operationName = 'GhStar';
2020-01-20 07:18:45 +01:00
@override
2020-02-06 06:53:43 +01:00
final GhStarArguments variables;
2020-01-20 07:18:45 +01:00
@override
List<Object> get props => [document, operationName, variables];
@override
2020-02-06 06:53:43 +01:00
GhStar parse(Map<String, dynamic> json) => GhStar.fromJson(json);
2020-01-20 07:18:45 +01:00
}
2020-01-28 16:19:05 +01:00
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObject with EquatableMixin {
GhObject({this.repository});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObject.fromJson(Map<String, dynamic> json) =>
_$GhObjectFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
GhObjectRepository repository;
2020-01-28 16:19:05 +01:00
@override
List<Object> get props => [repository];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhObjectToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectRepository extends GhObjectPinnableItem
2020-01-28 16:19:05 +01:00
with EquatableMixin
implements
2020-02-06 06:53:43 +01:00
GhObjectNode,
GhObjectProjectOwner,
GhObjectRegistryPackageOwner,
GhObjectRegistryPackageSearch,
GhObjectSubscribable,
GhObjectStarrable,
GhObjectUniformResourceLocatable,
GhObjectRepositoryInfo {
GhObjectRepository({this.object});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectRepository.fromJson(Map<String, dynamic> json) =>
_$GhObjectRepositoryFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
GhObjectGitObject object;
2020-01-28 16:19:05 +01:00
@override
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [object, resolveType];
Map<String, dynamic> toJson() => _$GhObjectRepositoryToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectGitObject with EquatableMixin {
GhObjectGitObject();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectGitObject.fromJson(Map<String, dynamic> json) {
switch (json['__typename'].toString()) {
case 'Blob':
return GhObjectBlob.fromJson(json);
case 'Tree':
return GhObjectTree.fromJson(json);
default:
}
return _$GhObjectGitObjectFromJson(json);
}
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() {
switch (resolveType) {
case 'Blob':
return (this as GhObjectBlob).toJson();
case 'Tree':
return (this as GhObjectTree).toJson();
default:
}
return _$GhObjectGitObjectToJson(this);
}
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectBlob
with EquatableMixin
implements GhObjectNode, GhObjectGitObject {
GhObjectBlob({this.text, this.byteSize});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectBlob.fromJson(Map<String, dynamic> json) =>
_$GhObjectBlobFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
String text;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
int byteSize;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [text, byteSize, resolveType];
Map<String, dynamic> toJson() => _$GhObjectBlobToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectNode with EquatableMixin {
GhObjectNode();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectNode.fromJson(Map<String, dynamic> json) =>
_$GhObjectNodeFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhObjectNodeToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectTree
2020-01-28 16:19:05 +01:00
with EquatableMixin
2020-02-06 06:53:43 +01:00
implements GhObjectNode, GhObjectGitObject {
GhObjectTree({this.entries});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectTree.fromJson(Map<String, dynamic> json) =>
_$GhObjectTreeFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
List<GhObjectTreeEntry> entries;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [entries, resolveType];
Map<String, dynamic> toJson() => _$GhObjectTreeToJson(this);
}
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhObjectTreeEntry with EquatableMixin {
GhObjectTreeEntry({this.type, this.name, this.object});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectTreeEntry.fromJson(Map<String, dynamic> json) =>
_$GhObjectTreeEntryFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
String type;
String name;
GhObjectGitObject object;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [type, name, object];
Map<String, dynamic> toJson() => _$GhObjectTreeEntryToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectPinnableItem with EquatableMixin {
GhObjectPinnableItem();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhObjectPinnableItemFromJson(json);
2020-01-28 16:19:05 +01:00
@override
List<Object> get props => [];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhObjectPinnableItemToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectProjectOwner with EquatableMixin {
GhObjectProjectOwner();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhObjectProjectOwnerFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhObjectProjectOwnerToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectRegistryPackageOwner with EquatableMixin {
GhObjectRegistryPackageOwner();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhObjectRegistryPackageOwnerFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhObjectRegistryPackageOwnerToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectRegistryPackageSearch with EquatableMixin {
GhObjectRegistryPackageSearch();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhObjectRegistryPackageSearchFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhObjectRegistryPackageSearchToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectSubscribable with EquatableMixin {
GhObjectSubscribable();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhObjectSubscribableFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhObjectSubscribableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectStarrable with EquatableMixin {
GhObjectStarrable();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectStarrable.fromJson(Map<String, dynamic> json) =>
_$GhObjectStarrableFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhObjectStarrableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectUniformResourceLocatable with EquatableMixin {
GhObjectUniformResourceLocatable();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectUniformResourceLocatable.fromJson(
Map<String, dynamic> json) =>
_$GhObjectUniformResourceLocatableFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() =>
_$GhObjectUniformResourceLocatableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectRepositoryInfo with EquatableMixin {
GhObjectRepositoryInfo();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhObjectRepositoryInfoFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhObjectRepositoryInfoToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhObjectArguments extends JsonSerializable with EquatableMixin {
GhObjectArguments(
{@required this.owner, @required this.name, @required this.expression});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhObjectArguments.fromJson(Map<String, dynamic> json) =>
_$GhObjectArgumentsFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
final String owner;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
final String name;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
final String expression;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [owner, name, expression];
Map<String, dynamic> toJson() => _$GhObjectArgumentsToJson(this);
2020-01-28 16:19:05 +01:00
}
2020-02-06 06:53:43 +01:00
class GhObjectQuery extends GraphQLQuery<GhObject, GhObjectArguments> {
GhObjectQuery({this.variables});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
type: OperationType.query,
name: NameNode(value: 'GhObject'),
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: 'Blob'),
isNonNull: false)),
directives: [],
selectionSet: SelectionSetNode(selections: [
FieldNode(
name: NameNode(value: 'text'),
alias: null,
arguments: [],
directives: [],
selectionSet: null),
FieldNode(
name: NameNode(value: 'byteSize'),
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),
FieldNode(
name: NameNode(value: 'object'),
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: 'Blob'),
isNonNull: false)),
directives: [],
selectionSet:
SelectionSetNode(selections: [
FieldNode(
name: NameNode(
value: 'byteSize'),
alias: null,
arguments: [],
directives: [],
selectionSet: null)
]))
]))
]))
]))
]))
]))
]))
]);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@override
final String operationName = 'GhObject';
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@override
final GhObjectArguments variables;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@override
List<Object> get props => [document, operationName, variables];
@override
GhObject parse(Map<String, dynamic> json) => GhObject.fromJson(json);
}
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
mixin TMixin {
GhCommitsGitObject target;
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommits with EquatableMixin {
GhCommits({this.repository});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommits.fromJson(Map<String, dynamic> json) =>
_$GhCommitsFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
GhCommitsRepository repository;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [repository];
Map<String, dynamic> toJson() => _$GhCommitsToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsRepository extends GhCommitsPinnableItem
with EquatableMixin
implements
GhCommitsNode,
GhCommitsProjectOwner,
GhCommitsRegistryPackageOwner,
GhCommitsRegistryPackageSearch,
GhCommitsSubscribable,
GhCommitsStarrable,
GhCommitsUniformResourceLocatable,
GhCommitsRepositoryInfo {
GhCommitsRepository({this.defaultBranchRef, this.ref});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsRepository.fromJson(Map<String, dynamic> json) =>
_$GhCommitsRepositoryFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
GhCommitsRef defaultBranchRef;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
GhCommitsRef ref;
2020-01-28 16:19:05 +01:00
@override
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [defaultBranchRef, ref, resolveType];
Map<String, dynamic> toJson() => _$GhCommitsRepositoryToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsRef with EquatableMixin, TMixin implements GhCommitsNode {
GhCommitsRef();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsRef.fromJson(Map<String, dynamic> json) =>
_$GhCommitsRefFromJson(json);
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [target, resolveType];
Map<String, dynamic> toJson() => _$GhCommitsRefToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsGitObject with EquatableMixin {
GhCommitsGitObject();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsGitObject.fromJson(Map<String, dynamic> json) {
switch (json['__typename'].toString()) {
case 'Commit':
return GhCommitsCommit.fromJson(json);
default:
}
return _$GhCommitsGitObjectFromJson(json);
}
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() {
switch (resolveType) {
case 'Commit':
return (this as GhCommitsCommit).toJson();
default:
}
return _$GhCommitsGitObjectToJson(this);
}
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsCommit extends GhCommitsPullRequestTimelineItem
with EquatableMixin
implements
GhCommitsNode,
GhCommitsGitObject,
GhCommitsSubscribable,
GhCommitsUniformResourceLocatable {
GhCommitsCommit(
{this.oid,
this.url,
this.messageHeadline,
this.committedDate,
this.author,
this.status,
this.history});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsCommit.fromJson(Map<String, dynamic> json) =>
_$GhCommitsCommitFromJson(json);
String oid;
String url;
String messageHeadline;
DateTime committedDate;
GhCommitsGitActor author;
GhCommitsStatus status;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
GhCommitsCommitHistoryConnection history;
@override
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [
oid,
url,
messageHeadline,
committedDate,
author,
status,
history,
resolveType
];
Map<String, dynamic> toJson() => _$GhCommitsCommitToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsGitActor with EquatableMixin {
GhCommitsGitActor({this.name, this.avatarUrl, this.user});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsGitActor.fromJson(Map<String, dynamic> json) =>
_$GhCommitsGitActorFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
String name;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
String avatarUrl;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
GhCommitsUser user;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [name, avatarUrl, user];
Map<String, dynamic> toJson() => _$GhCommitsGitActorToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsUser extends GhCommitsAuditEntryActor
with EquatableMixin
implements
GhCommitsNode,
GhCommitsActor,
GhCommitsRegistryPackageOwner,
GhCommitsRegistryPackageSearch,
GhCommitsProjectOwner,
GhCommitsRepositoryOwner,
GhCommitsUniformResourceLocatable,
GhCommitsProfileOwner,
GhCommitsSponsorable {
GhCommitsUser();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsUser.fromJson(Map<String, dynamic> json) =>
_$GhCommitsUserFromJson(json);
@override
String login;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@override
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [login, resolveType];
Map<String, dynamic> toJson() => _$GhCommitsUserToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsAuditEntryActor with EquatableMixin {
GhCommitsAuditEntryActor();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsAuditEntryActor.fromJson(Map<String, dynamic> json) =>
_$GhCommitsAuditEntryActorFromJson(json);
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [];
Map<String, dynamic> toJson() => _$GhCommitsAuditEntryActorToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsNode with EquatableMixin {
GhCommitsNode();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsNode.fromJson(Map<String, dynamic> json) =>
_$GhCommitsNodeFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCommitsNodeToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsActor with EquatableMixin {
GhCommitsActor({this.login});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsActor.fromJson(Map<String, dynamic> json) =>
_$GhCommitsActorFromJson(json);
String login;
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [login, resolveType];
Map<String, dynamic> toJson() => _$GhCommitsActorToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsRegistryPackageOwner with EquatableMixin {
GhCommitsRegistryPackageOwner();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhCommitsRegistryPackageOwnerFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhCommitsRegistryPackageOwnerToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsRegistryPackageSearch with EquatableMixin {
GhCommitsRegistryPackageSearch();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhCommitsRegistryPackageSearchFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-02-06 06:53:43 +01:00
@override
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCommitsRegistryPackageSearchToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsProjectOwner with EquatableMixin {
GhCommitsProjectOwner();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhCommitsProjectOwnerFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCommitsProjectOwnerToJson(this);
2020-01-28 16:19:05 +01:00
}
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhCommitsRepositoryOwner with EquatableMixin {
GhCommitsRepositoryOwner({this.login});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsRepositoryOwner.fromJson(Map<String, dynamic> json) =>
_$GhCommitsRepositoryOwnerFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
String login;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [login, resolveType];
Map<String, dynamic> toJson() => _$GhCommitsRepositoryOwnerToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsUniformResourceLocatable with EquatableMixin {
GhCommitsUniformResourceLocatable();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsUniformResourceLocatable.fromJson(
Map<String, dynamic> json) =>
_$GhCommitsUniformResourceLocatableFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(name: '__typename')
String resolveType;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() =>
_$GhCommitsUniformResourceLocatableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsProfileOwner with EquatableMixin {
GhCommitsProfileOwner({this.login});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsProfileOwner.fromJson(Map<String, dynamic> json) =>
_$GhCommitsProfileOwnerFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
String login;
@JsonKey(name: '__typename')
String resolveType;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [login, resolveType];
Map<String, dynamic> toJson() => _$GhCommitsProfileOwnerToJson(this);
}
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhCommitsSponsorable with EquatableMixin {
GhCommitsSponsorable();
factory GhCommitsSponsorable.fromJson(Map<String, dynamic> json) =>
_$GhCommitsSponsorableFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCommitsSponsorableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsStatus with EquatableMixin implements GhCommitsNode {
GhCommitsStatus({this.state});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsStatus.fromJson(Map<String, dynamic> json) =>
_$GhCommitsStatusFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@JsonKey(unknownEnumValue: GhCommitsStatusState.ARTEMIS_UNKNOWN)
GhCommitsStatusState state;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@override
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [state, resolveType];
Map<String, dynamic> toJson() => _$GhCommitsStatusToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsCommitHistoryConnection with EquatableMixin {
GhCommitsCommitHistoryConnection({this.pageInfo, this.nodes});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsCommitHistoryConnection.fromJson(
Map<String, dynamic> json) =>
_$GhCommitsCommitHistoryConnectionFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
GhCommitsPageInfo pageInfo;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
List<GhCommitsCommit> nodes;
2020-01-28 16:19:05 +01:00
@override
List<Object> get props => [pageInfo, nodes];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() =>
_$GhCommitsCommitHistoryConnectionToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsPageInfo with EquatableMixin {
GhCommitsPageInfo({this.hasNextPage, this.endCursor});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsPageInfo.fromJson(Map<String, dynamic> json) =>
_$GhCommitsPageInfoFromJson(json);
2020-01-28 16:19:05 +01:00
bool hasNextPage;
String endCursor;
@override
List<Object> get props => [hasNextPage, endCursor];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhCommitsPageInfoToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsPullRequestTimelineItem with EquatableMixin {
GhCommitsPullRequestTimelineItem();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsPullRequestTimelineItem.fromJson(
Map<String, dynamic> json) =>
_$GhCommitsPullRequestTimelineItemFromJson(json);
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [];
Map<String, dynamic> toJson() =>
_$GhCommitsPullRequestTimelineItemToJson(this);
}
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@JsonSerializable(explicitToJson: true)
class GhCommitsSubscribable with EquatableMixin {
GhCommitsSubscribable();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhCommitsSubscribableFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhCommitsSubscribableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsPinnableItem with EquatableMixin {
GhCommitsPinnableItem();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhCommitsPinnableItemFromJson(json);
2020-01-28 16:19:05 +01:00
@override
List<Object> get props => [];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhCommitsPinnableItemToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsStarrable with EquatableMixin {
GhCommitsStarrable();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsStarrable.fromJson(Map<String, dynamic> json) =>
_$GhCommitsStarrableFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhCommitsStarrableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsRepositoryInfo with EquatableMixin {
GhCommitsRepositoryInfo();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhCommitsRepositoryInfoFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhCommitsRepositoryInfoToJson(this);
}
enum GhCommitsStatusState {
EXPECTED,
ERROR,
FAILURE,
PENDING,
SUCCESS,
ARTEMIS_UNKNOWN,
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhCommitsArguments extends JsonSerializable with EquatableMixin {
GhCommitsArguments(
{@required this.owner,
@required this.name,
@required this.ref,
@required this.hasRef,
this.after});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhCommitsArguments.fromJson(Map<String, dynamic> json) =>
_$GhCommitsArgumentsFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
final String owner;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
final String name;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
final String ref;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
final bool hasRef;
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
final String after;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [owner, name, ref, hasRef, after];
Map<String, dynamic> toJson() => _$GhCommitsArgumentsToJson(this);
2020-01-28 16:19:05 +01:00
}
2020-02-06 06:53:43 +01:00
class GhCommitsQuery extends GraphQLQuery<GhCommits, GhCommitsArguments> {
GhCommitsQuery({this.variables});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
@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: NameNode(value: 'GhCommits'),
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: [])
]))
]))
]))
]);
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
final String operationName = 'GhCommits';
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
final GhCommitsArguments variables;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [document, operationName, variables];
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
GhCommits parse(Map<String, dynamic> json) => GhCommits.fromJson(json);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoId with EquatableMixin {
GhRepoId({this.repository});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoId.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
GhRepoIdRepository repository;
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [repository];
Map<String, dynamic> toJson() => _$GhRepoIdToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdRepository extends GhRepoIdPinnableItem
with EquatableMixin
implements
GhRepoIdNode,
GhRepoIdProjectOwner,
GhRepoIdRegistryPackageOwner,
GhRepoIdRegistryPackageSearch,
GhRepoIdSubscribable,
GhRepoIdStarrable,
GhRepoIdUniformResourceLocatable,
GhRepoIdRepositoryInfo {
GhRepoIdRepository();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdRepository.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdRepositoryFromJson(json);
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
String id;
2020-01-28 16:19:05 +01:00
@override
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, resolveType];
Map<String, dynamic> toJson() => _$GhRepoIdRepositoryToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdPinnableItem with EquatableMixin {
GhRepoIdPinnableItem();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdPinnableItem.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdPinnableItemFromJson(json);
2020-01-28 16:19:05 +01:00
@override
List<Object> get props => [];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() => _$GhRepoIdPinnableItemToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdNode with EquatableMixin {
GhRepoIdNode({this.id});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdNode.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdNodeFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
String id;
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, resolveType];
Map<String, dynamic> toJson() => _$GhRepoIdNodeToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdProjectOwner with EquatableMixin {
GhRepoIdProjectOwner({this.id});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdProjectOwner.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdProjectOwnerFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
String id;
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, resolveType];
Map<String, dynamic> toJson() => _$GhRepoIdProjectOwnerToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdRegistryPackageOwner with EquatableMixin {
GhRepoIdRegistryPackageOwner({this.id});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdRegistryPackageOwner.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdRegistryPackageOwnerFromJson(json);
String id;
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, resolveType];
Map<String, dynamic> toJson() => _$GhRepoIdRegistryPackageOwnerToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdRegistryPackageSearch with EquatableMixin {
GhRepoIdRegistryPackageSearch({this.id});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdRegistryPackageSearch.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdRegistryPackageSearchFromJson(json);
String id;
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, resolveType];
Map<String, dynamic> toJson() => _$GhRepoIdRegistryPackageSearchToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdSubscribable with EquatableMixin {
GhRepoIdSubscribable({this.id});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdSubscribable.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdSubscribableFromJson(json);
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
String id;
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, resolveType];
Map<String, dynamic> toJson() => _$GhRepoIdSubscribableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdStarrable with EquatableMixin {
GhRepoIdStarrable({this.id});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdStarrable.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdStarrableFromJson(json);
String id;
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [id, resolveType];
Map<String, dynamic> toJson() => _$GhRepoIdStarrableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdUniformResourceLocatable with EquatableMixin {
GhRepoIdUniformResourceLocatable();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdUniformResourceLocatable.fromJson(
Map<String, dynamic> json) =>
_$GhRepoIdUniformResourceLocatableFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
List<Object> get props => [resolveType];
2020-02-06 06:53:43 +01:00
Map<String, dynamic> toJson() =>
_$GhRepoIdUniformResourceLocatableToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdRepositoryInfo with EquatableMixin {
GhRepoIdRepositoryInfo();
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdRepositoryInfo.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdRepositoryInfoFromJson(json);
2020-01-28 16:19:05 +01:00
@JsonKey(name: '__typename')
String resolveType;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [resolveType];
Map<String, dynamic> toJson() => _$GhRepoIdRepositoryInfoToJson(this);
2020-01-28 16:19:05 +01:00
}
@JsonSerializable(explicitToJson: true)
2020-02-06 06:53:43 +01:00
class GhRepoIdArguments extends JsonSerializable with EquatableMixin {
GhRepoIdArguments({@required this.owner, @required this.name});
2020-01-28 16:19:05 +01:00
2020-02-06 06:53:43 +01:00
factory GhRepoIdArguments.fromJson(Map<String, dynamic> json) =>
_$GhRepoIdArgumentsFromJson(json);
2020-01-28 16:19:05 +01:00
final String owner;
final String name;
@override
2020-02-06 06:53:43 +01:00
List<Object> get props => [owner, name];
Map<String, dynamic> toJson() => _$GhRepoIdArgumentsToJson(this);
2020-01-28 16:19:05 +01:00
}
2020-02-06 06:53:43 +01:00
class GhRepoIdQuery extends GraphQLQuery<GhRepoId, GhRepoIdArguments> {
GhRepoIdQuery({this.variables});
2020-01-28 16:19:05 +01:00
@override
final DocumentNode document = DocumentNode(definitions: [
OperationDefinitionNode(
type: OperationType.query,
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'GhRepoId'),
2020-01-28 16:19:05 +01:00
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: [])
],
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(
2020-02-06 06:53:43 +01:00
name: NameNode(value: 'id'),
2020-01-28 16:19:05 +01:00
alias: null,
arguments: [],
directives: [],
2020-02-06 06:53:43 +01:00
selectionSet: null)
2020-01-28 16:19:05 +01:00
]))
]))
]);
@override
2020-02-06 06:53:43 +01:00
final String operationName = 'GhRepoId';
2020-01-28 16:19:05 +01:00
@override
2020-02-06 06:53:43 +01:00
final GhRepoIdArguments variables;
2020-01-28 16:19:05 +01:00
@override
List<Object> get props => [document, operationName, variables];
@override
2020-02-06 06:53:43 +01:00
GhRepoId parse(Map<String, dynamic> json) => GhRepoId.fromJson(json);
2020-01-28 16:19:05 +01:00
}