7603 lines
253 KiB
Dart
7603 lines
253 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'commits.data.gql.dart';
|
|
|
|
// **************************************************************************
|
|
// BuiltValueGenerator
|
|
// **************************************************************************
|
|
|
|
Serializer<GCommitsData> _$gCommitsDataSerializer =
|
|
new _$GCommitsDataSerializer();
|
|
Serializer<GCommitsData_repository> _$gCommitsDataRepositorySerializer =
|
|
new _$GCommitsData_repositorySerializer();
|
|
Serializer<GCommitsData_repository_defaultBranchRef>
|
|
_$gCommitsDataRepositoryDefaultBranchRefSerializer =
|
|
new _$GCommitsData_repository_defaultBranchRefSerializer();
|
|
Serializer<GCommitsData_repository_defaultBranchRef_target__base>
|
|
_$gCommitsDataRepositoryDefaultBranchRefTargetBaseSerializer =
|
|
new _$GCommitsData_repository_defaultBranchRef_target__baseSerializer();
|
|
Serializer<GCommitsData_repository_defaultBranchRef_target__asCommit>
|
|
_$gCommitsDataRepositoryDefaultBranchRefTargetAsCommitSerializer =
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommitSerializer();
|
|
Serializer<GCommitsData_repository_defaultBranchRef_target__asCommit_history>
|
|
_$gCommitsDataRepositoryDefaultBranchRefTargetAsCommitHistorySerializer =
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_historySerializer();
|
|
Serializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo>
|
|
_$gCommitsDataRepositoryDefaultBranchRefTargetAsCommitHistoryPageInfoSerializer =
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoSerializer();
|
|
Serializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes>
|
|
_$gCommitsDataRepositoryDefaultBranchRefTargetAsCommitHistoryNodesSerializer =
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesSerializer();
|
|
Serializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author>
|
|
_$gCommitsDataRepositoryDefaultBranchRefTargetAsCommitHistoryNodesAuthorSerializer =
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorSerializer();
|
|
Serializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user>
|
|
_$gCommitsDataRepositoryDefaultBranchRefTargetAsCommitHistoryNodesAuthorUserSerializer =
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userSerializer();
|
|
Serializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status>
|
|
_$gCommitsDataRepositoryDefaultBranchRefTargetAsCommitHistoryNodesStatusSerializer =
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusSerializer();
|
|
Serializer<GCommitsData_repository_ref> _$gCommitsDataRepositoryRefSerializer =
|
|
new _$GCommitsData_repository_refSerializer();
|
|
Serializer<GCommitsData_repository_ref_target__base>
|
|
_$gCommitsDataRepositoryRefTargetBaseSerializer =
|
|
new _$GCommitsData_repository_ref_target__baseSerializer();
|
|
Serializer<GCommitsData_repository_ref_target__asCommit>
|
|
_$gCommitsDataRepositoryRefTargetAsCommitSerializer =
|
|
new _$GCommitsData_repository_ref_target__asCommitSerializer();
|
|
Serializer<GCommitsData_repository_ref_target__asCommit_history>
|
|
_$gCommitsDataRepositoryRefTargetAsCommitHistorySerializer =
|
|
new _$GCommitsData_repository_ref_target__asCommit_historySerializer();
|
|
Serializer<GCommitsData_repository_ref_target__asCommit_history_pageInfo>
|
|
_$gCommitsDataRepositoryRefTargetAsCommitHistoryPageInfoSerializer =
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_pageInfoSerializer();
|
|
Serializer<GCommitsData_repository_ref_target__asCommit_history_nodes>
|
|
_$gCommitsDataRepositoryRefTargetAsCommitHistoryNodesSerializer =
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_nodesSerializer();
|
|
Serializer<GCommitsData_repository_ref_target__asCommit_history_nodes_author>
|
|
_$gCommitsDataRepositoryRefTargetAsCommitHistoryNodesAuthorSerializer =
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_nodes_authorSerializer();
|
|
Serializer<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user>
|
|
_$gCommitsDataRepositoryRefTargetAsCommitHistoryNodesAuthorUserSerializer =
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_nodes_author_userSerializer();
|
|
Serializer<GCommitsData_repository_ref_target__asCommit_history_nodes_status>
|
|
_$gCommitsDataRepositoryRefTargetAsCommitHistoryNodesStatusSerializer =
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_nodes_statusSerializer();
|
|
Serializer<GCommitsRefCommitData> _$gCommitsRefCommitDataSerializer =
|
|
new _$GCommitsRefCommitDataSerializer();
|
|
Serializer<GCommitsRefCommitData_history>
|
|
_$gCommitsRefCommitDataHistorySerializer =
|
|
new _$GCommitsRefCommitData_historySerializer();
|
|
Serializer<GCommitsRefCommitData_history_pageInfo>
|
|
_$gCommitsRefCommitDataHistoryPageInfoSerializer =
|
|
new _$GCommitsRefCommitData_history_pageInfoSerializer();
|
|
Serializer<GCommitsRefCommitData_history_nodes>
|
|
_$gCommitsRefCommitDataHistoryNodesSerializer =
|
|
new _$GCommitsRefCommitData_history_nodesSerializer();
|
|
Serializer<GCommitsRefCommitData_history_nodes_author>
|
|
_$gCommitsRefCommitDataHistoryNodesAuthorSerializer =
|
|
new _$GCommitsRefCommitData_history_nodes_authorSerializer();
|
|
Serializer<GCommitsRefCommitData_history_nodes_author_user>
|
|
_$gCommitsRefCommitDataHistoryNodesAuthorUserSerializer =
|
|
new _$GCommitsRefCommitData_history_nodes_author_userSerializer();
|
|
Serializer<GCommitsRefCommitData_history_nodes_status>
|
|
_$gCommitsRefCommitDataHistoryNodesStatusSerializer =
|
|
new _$GCommitsRefCommitData_history_nodes_statusSerializer();
|
|
Serializer<GCommitsRefData> _$gCommitsRefDataSerializer =
|
|
new _$GCommitsRefDataSerializer();
|
|
Serializer<GCommitsRefData_target__base> _$gCommitsRefDataTargetBaseSerializer =
|
|
new _$GCommitsRefData_target__baseSerializer();
|
|
Serializer<GCommitsRefData_target__asCommit>
|
|
_$gCommitsRefDataTargetAsCommitSerializer =
|
|
new _$GCommitsRefData_target__asCommitSerializer();
|
|
Serializer<GCommitsRefData_target__asCommit_history>
|
|
_$gCommitsRefDataTargetAsCommitHistorySerializer =
|
|
new _$GCommitsRefData_target__asCommit_historySerializer();
|
|
Serializer<GCommitsRefData_target__asCommit_history_pageInfo>
|
|
_$gCommitsRefDataTargetAsCommitHistoryPageInfoSerializer =
|
|
new _$GCommitsRefData_target__asCommit_history_pageInfoSerializer();
|
|
Serializer<GCommitsRefData_target__asCommit_history_nodes>
|
|
_$gCommitsRefDataTargetAsCommitHistoryNodesSerializer =
|
|
new _$GCommitsRefData_target__asCommit_history_nodesSerializer();
|
|
Serializer<GCommitsRefData_target__asCommit_history_nodes_author>
|
|
_$gCommitsRefDataTargetAsCommitHistoryNodesAuthorSerializer =
|
|
new _$GCommitsRefData_target__asCommit_history_nodes_authorSerializer();
|
|
Serializer<GCommitsRefData_target__asCommit_history_nodes_author_user>
|
|
_$gCommitsRefDataTargetAsCommitHistoryNodesAuthorUserSerializer =
|
|
new _$GCommitsRefData_target__asCommit_history_nodes_author_userSerializer();
|
|
Serializer<GCommitsRefData_target__asCommit_history_nodes_status>
|
|
_$gCommitsRefDataTargetAsCommitHistoryNodesStatusSerializer =
|
|
new _$GCommitsRefData_target__asCommit_history_nodes_statusSerializer();
|
|
|
|
class _$GCommitsDataSerializer implements StructuredSerializer<GCommitsData> {
|
|
@override
|
|
final Iterable<Type> types = const [GCommitsData, _$GCommitsData];
|
|
@override
|
|
final String wireName = 'GCommitsData';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers, GCommitsData object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
Object? value;
|
|
value = object.repository;
|
|
if (value != null) {
|
|
result
|
|
..add('repository')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(GCommitsData_repository)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsDataBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'repository':
|
|
result.repository.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(GCommitsData_repository))!
|
|
as GCommitsData_repository);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repositorySerializer
|
|
implements StructuredSerializer<GCommitsData_repository> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository,
|
|
_$GCommitsData_repository
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsData_repository';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsData_repository object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
Object? value;
|
|
value = object.defaultBranchRef;
|
|
if (value != null) {
|
|
result
|
|
..add('defaultBranchRef')
|
|
..add(serializers.serialize(value,
|
|
specifiedType:
|
|
const FullType(GCommitsData_repository_defaultBranchRef)));
|
|
}
|
|
value = object.ref;
|
|
if (value != null) {
|
|
result
|
|
..add('ref')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(GCommitsData_repository_ref)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsData_repositoryBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'defaultBranchRef':
|
|
result.defaultBranchRef.replace(serializers.deserialize(value,
|
|
specifiedType:
|
|
const FullType(GCommitsData_repository_defaultBranchRef))!
|
|
as GCommitsData_repository_defaultBranchRef);
|
|
break;
|
|
case 'ref':
|
|
result.ref.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(GCommitsData_repository_ref))!
|
|
as GCommitsData_repository_ref);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRefSerializer
|
|
implements StructuredSerializer<GCommitsData_repository_defaultBranchRef> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_defaultBranchRef,
|
|
_$GCommitsData_repository_defaultBranchRef
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsData_repository_defaultBranchRef';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsData_repository_defaultBranchRef object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
Object? value;
|
|
value = object.target;
|
|
if (value != null) {
|
|
result
|
|
..add('target')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsData_repository_defaultBranchRefBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'target':
|
|
result.target = serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target))
|
|
as GCommitsData_repository_defaultBranchRef_target?;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__baseSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_defaultBranchRef_target__base> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_defaultBranchRef_target__base,
|
|
_$GCommitsData_repository_defaultBranchRef_target__base
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_defaultBranchRef_target__base';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsData_repository_defaultBranchRef_target__base object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__base deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_defaultBranchRef_target__baseBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommitSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit,
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_defaultBranchRef_target__asCommit';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'history',
|
|
serializers.serialize(object.history,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommitBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'history':
|
|
result.history.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history))!
|
|
as GCommitsData_repository_defaultBranchRef_target__asCommit_history);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_historySerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history,
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_defaultBranchRef_target__asCommit_history';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'pageInfo',
|
|
serializers.serialize(object.pageInfo,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo)),
|
|
];
|
|
Object? value;
|
|
value = object.nodes;
|
|
if (value != null) {
|
|
result
|
|
..add('nodes')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(BuiltList, const [
|
|
const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes)
|
|
])));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'pageInfo':
|
|
result.pageInfo.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo))!
|
|
as GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo);
|
|
break;
|
|
case 'nodes':
|
|
result.nodes.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(BuiltList, const [
|
|
const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes)
|
|
]))! as BuiltList<Object?>);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo,
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'hasNextPage',
|
|
serializers.serialize(object.hasNextPage,
|
|
specifiedType: const FullType(bool)),
|
|
];
|
|
Object? value;
|
|
value = object.endCursor;
|
|
if (value != null) {
|
|
result
|
|
..add('endCursor')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(String)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
deserialize(Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'hasNextPage':
|
|
result.hasNextPage = serializers.deserialize(value,
|
|
specifiedType: const FullType(bool))! as bool;
|
|
break;
|
|
case 'endCursor':
|
|
result.endCursor = serializers.deserialize(value,
|
|
specifiedType: const FullType(String)) as String?;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes,
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes
|
|
object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'oid',
|
|
serializers.serialize(object.oid, specifiedType: const FullType(String)),
|
|
'messageHeadline',
|
|
serializers.serialize(object.messageHeadline,
|
|
specifiedType: const FullType(String)),
|
|
'committedDate',
|
|
serializers.serialize(object.committedDate,
|
|
specifiedType: const FullType(DateTime)),
|
|
];
|
|
Object? value;
|
|
value = object.author;
|
|
if (value != null) {
|
|
result
|
|
..add('author')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author)));
|
|
}
|
|
value = object.status;
|
|
if (value != null) {
|
|
result
|
|
..add('status')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes
|
|
deserialize(Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'oid':
|
|
result.oid = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'messageHeadline':
|
|
result.messageHeadline = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'committedDate':
|
|
result.committedDate = serializers.deserialize(value,
|
|
specifiedType: const FullType(DateTime))! as DateTime;
|
|
break;
|
|
case 'author':
|
|
result.author.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author))!
|
|
as GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author);
|
|
break;
|
|
case 'status':
|
|
result.status.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status))!
|
|
as GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author,
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'avatarUrl',
|
|
serializers.serialize(object.avatarUrl,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
Object? value;
|
|
value = object.name;
|
|
if (value != null) {
|
|
result
|
|
..add('name')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(String)));
|
|
}
|
|
value = object.user;
|
|
if (value != null) {
|
|
result
|
|
..add('user')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
deserialize(Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'name':
|
|
result.name = serializers.deserialize(value,
|
|
specifiedType: const FullType(String)) as String?;
|
|
break;
|
|
case 'avatarUrl':
|
|
result.avatarUrl = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'user':
|
|
result.user.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user))!
|
|
as GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user,
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'login',
|
|
serializers.serialize(object.login,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
deserialize(Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'login':
|
|
result.login = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status,
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'state',
|
|
serializers.serialize(object.state,
|
|
specifiedType: const FullType(_i3.GStatusState)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
deserialize(Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'state':
|
|
result.state = serializers.deserialize(value,
|
|
specifiedType: const FullType(_i3.GStatusState))!
|
|
as _i3.GStatusState;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_refSerializer
|
|
implements StructuredSerializer<GCommitsData_repository_ref> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_ref,
|
|
_$GCommitsData_repository_ref
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsData_repository_ref';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsData_repository_ref object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
Object? value;
|
|
value = object.target;
|
|
if (value != null) {
|
|
result
|
|
..add('target')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(GCommitsData_repository_ref_target)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsData_repository_refBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'target':
|
|
result.target = serializers.deserialize(value,
|
|
specifiedType:
|
|
const FullType(GCommitsData_repository_ref_target))
|
|
as GCommitsData_repository_ref_target?;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__baseSerializer
|
|
implements StructuredSerializer<GCommitsData_repository_ref_target__base> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_ref_target__base,
|
|
_$GCommitsData_repository_ref_target__base
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsData_repository_ref_target__base';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsData_repository_ref_target__base object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__base deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsData_repository_ref_target__baseBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommitSerializer
|
|
implements
|
|
StructuredSerializer<GCommitsData_repository_ref_target__asCommit> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_ref_target__asCommit,
|
|
_$GCommitsData_repository_ref_target__asCommit
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsData_repository_ref_target__asCommit';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsData_repository_ref_target__asCommit object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'history',
|
|
serializers.serialize(object.history,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsData_repository_ref_target__asCommitBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'history':
|
|
result.history.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history))!
|
|
as GCommitsData_repository_ref_target__asCommit_history);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_historySerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_ref_target__asCommit_history> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_ref_target__asCommit_history,
|
|
_$GCommitsData_repository_ref_target__asCommit_history
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_ref_target__asCommit_history';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsData_repository_ref_target__asCommit_history object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'pageInfo',
|
|
serializers.serialize(object.pageInfo,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo)),
|
|
];
|
|
Object? value;
|
|
value = object.nodes;
|
|
if (value != null) {
|
|
result
|
|
..add('nodes')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(BuiltList, const [
|
|
const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes)
|
|
])));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_ref_target__asCommit_historyBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'pageInfo':
|
|
result.pageInfo.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo))!
|
|
as GCommitsData_repository_ref_target__asCommit_history_pageInfo);
|
|
break;
|
|
case 'nodes':
|
|
result.nodes.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(BuiltList, const [
|
|
const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes)
|
|
]))! as BuiltList<Object?>);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_pageInfoSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo,
|
|
_$GCommitsData_repository_ref_target__asCommit_history_pageInfo
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_ref_target__asCommit_history_pageInfo';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'hasNextPage',
|
|
serializers.serialize(object.hasNextPage,
|
|
specifiedType: const FullType(bool)),
|
|
];
|
|
Object? value;
|
|
value = object.endCursor;
|
|
if (value != null) {
|
|
result
|
|
..add('endCursor')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(String)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'hasNextPage':
|
|
result.hasNextPage = serializers.deserialize(value,
|
|
specifiedType: const FullType(bool))! as bool;
|
|
break;
|
|
case 'endCursor':
|
|
result.endCursor = serializers.deserialize(value,
|
|
specifiedType: const FullType(String)) as String?;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_nodesSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes,
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_ref_target__asCommit_history_nodes';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'oid',
|
|
serializers.serialize(object.oid, specifiedType: const FullType(String)),
|
|
'messageHeadline',
|
|
serializers.serialize(object.messageHeadline,
|
|
specifiedType: const FullType(String)),
|
|
'committedDate',
|
|
serializers.serialize(object.committedDate,
|
|
specifiedType: const FullType(DateTime)),
|
|
];
|
|
Object? value;
|
|
value = object.author;
|
|
if (value != null) {
|
|
result
|
|
..add('author')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author)));
|
|
}
|
|
value = object.status;
|
|
if (value != null) {
|
|
result
|
|
..add('status')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodesBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'oid':
|
|
result.oid = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'messageHeadline':
|
|
result.messageHeadline = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'committedDate':
|
|
result.committedDate = serializers.deserialize(value,
|
|
specifiedType: const FullType(DateTime))! as DateTime;
|
|
break;
|
|
case 'author':
|
|
result.author.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author))!
|
|
as GCommitsData_repository_ref_target__asCommit_history_nodes_author);
|
|
break;
|
|
case 'status':
|
|
result.status.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status))!
|
|
as GCommitsData_repository_ref_target__asCommit_history_nodes_status);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_nodes_authorSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author,
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_author
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_ref_target__asCommit_history_nodes_author';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'avatarUrl',
|
|
serializers.serialize(object.avatarUrl,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
Object? value;
|
|
value = object.name;
|
|
if (value != null) {
|
|
result
|
|
..add('name')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(String)));
|
|
}
|
|
value = object.user;
|
|
if (value != null) {
|
|
result
|
|
..add('user')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'name':
|
|
result.name = serializers.deserialize(value,
|
|
specifiedType: const FullType(String)) as String?;
|
|
break;
|
|
case 'avatarUrl':
|
|
result.avatarUrl = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'user':
|
|
result.user.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user))!
|
|
as GCommitsData_repository_ref_target__asCommit_history_nodes_author_user);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_nodes_author_userSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user,
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_author_user
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_ref_target__asCommit_history_nodes_author_user';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers,
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user
|
|
object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'login',
|
|
serializers.serialize(object.login,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user
|
|
deserialize(Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'login':
|
|
result.login = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_nodes_statusSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status,
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_status
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsData_repository_ref_target__asCommit_history_nodes_status';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'state',
|
|
serializers.serialize(object.state,
|
|
specifiedType: const FullType(_i3.GStatusState)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'state':
|
|
result.state = serializers.deserialize(value,
|
|
specifiedType: const FullType(_i3.GStatusState))!
|
|
as _i3.GStatusState;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitDataSerializer
|
|
implements StructuredSerializer<GCommitsRefCommitData> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefCommitData,
|
|
_$GCommitsRefCommitData
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefCommitData';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsRefCommitData object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'history',
|
|
serializers.serialize(object.history,
|
|
specifiedType: const FullType(GCommitsRefCommitData_history)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefCommitDataBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'history':
|
|
result.history.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(GCommitsRefCommitData_history))!
|
|
as GCommitsRefCommitData_history);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_historySerializer
|
|
implements StructuredSerializer<GCommitsRefCommitData_history> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefCommitData_history,
|
|
_$GCommitsRefCommitData_history
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefCommitData_history';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsRefCommitData_history object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'pageInfo',
|
|
serializers.serialize(object.pageInfo,
|
|
specifiedType:
|
|
const FullType(GCommitsRefCommitData_history_pageInfo)),
|
|
];
|
|
Object? value;
|
|
value = object.nodes;
|
|
if (value != null) {
|
|
result
|
|
..add('nodes')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(BuiltList,
|
|
const [const FullType(GCommitsRefCommitData_history_nodes)])));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefCommitData_historyBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'pageInfo':
|
|
result.pageInfo.replace(serializers.deserialize(value,
|
|
specifiedType:
|
|
const FullType(GCommitsRefCommitData_history_pageInfo))!
|
|
as GCommitsRefCommitData_history_pageInfo);
|
|
break;
|
|
case 'nodes':
|
|
result.nodes.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(BuiltList, const [
|
|
const FullType(GCommitsRefCommitData_history_nodes)
|
|
]))! as BuiltList<Object?>);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_pageInfoSerializer
|
|
implements StructuredSerializer<GCommitsRefCommitData_history_pageInfo> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefCommitData_history_pageInfo,
|
|
_$GCommitsRefCommitData_history_pageInfo
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefCommitData_history_pageInfo';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsRefCommitData_history_pageInfo object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'hasNextPage',
|
|
serializers.serialize(object.hasNextPage,
|
|
specifiedType: const FullType(bool)),
|
|
];
|
|
Object? value;
|
|
value = object.endCursor;
|
|
if (value != null) {
|
|
result
|
|
..add('endCursor')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(String)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_pageInfo deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefCommitData_history_pageInfoBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'hasNextPage':
|
|
result.hasNextPage = serializers.deserialize(value,
|
|
specifiedType: const FullType(bool))! as bool;
|
|
break;
|
|
case 'endCursor':
|
|
result.endCursor = serializers.deserialize(value,
|
|
specifiedType: const FullType(String)) as String?;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_nodesSerializer
|
|
implements StructuredSerializer<GCommitsRefCommitData_history_nodes> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefCommitData_history_nodes,
|
|
_$GCommitsRefCommitData_history_nodes
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefCommitData_history_nodes';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsRefCommitData_history_nodes object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'oid',
|
|
serializers.serialize(object.oid, specifiedType: const FullType(String)),
|
|
'messageHeadline',
|
|
serializers.serialize(object.messageHeadline,
|
|
specifiedType: const FullType(String)),
|
|
'committedDate',
|
|
serializers.serialize(object.committedDate,
|
|
specifiedType: const FullType(DateTime)),
|
|
];
|
|
Object? value;
|
|
value = object.author;
|
|
if (value != null) {
|
|
result
|
|
..add('author')
|
|
..add(serializers.serialize(value,
|
|
specifiedType:
|
|
const FullType(GCommitsRefCommitData_history_nodes_author)));
|
|
}
|
|
value = object.status;
|
|
if (value != null) {
|
|
result
|
|
..add('status')
|
|
..add(serializers.serialize(value,
|
|
specifiedType:
|
|
const FullType(GCommitsRefCommitData_history_nodes_status)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefCommitData_history_nodesBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'oid':
|
|
result.oid = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'messageHeadline':
|
|
result.messageHeadline = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'committedDate':
|
|
result.committedDate = serializers.deserialize(value,
|
|
specifiedType: const FullType(DateTime))! as DateTime;
|
|
break;
|
|
case 'author':
|
|
result.author.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefCommitData_history_nodes_author))!
|
|
as GCommitsRefCommitData_history_nodes_author);
|
|
break;
|
|
case 'status':
|
|
result.status.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefCommitData_history_nodes_status))!
|
|
as GCommitsRefCommitData_history_nodes_status);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_nodes_authorSerializer
|
|
implements
|
|
StructuredSerializer<GCommitsRefCommitData_history_nodes_author> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefCommitData_history_nodes_author,
|
|
_$GCommitsRefCommitData_history_nodes_author
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefCommitData_history_nodes_author';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsRefCommitData_history_nodes_author object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'avatarUrl',
|
|
serializers.serialize(object.avatarUrl,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
Object? value;
|
|
value = object.name;
|
|
if (value != null) {
|
|
result
|
|
..add('name')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(String)));
|
|
}
|
|
value = object.user;
|
|
if (value != null) {
|
|
result
|
|
..add('user')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefCommitData_history_nodes_author_user)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_author deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefCommitData_history_nodes_authorBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'name':
|
|
result.name = serializers.deserialize(value,
|
|
specifiedType: const FullType(String)) as String?;
|
|
break;
|
|
case 'avatarUrl':
|
|
result.avatarUrl = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'user':
|
|
result.user.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefCommitData_history_nodes_author_user))!
|
|
as GCommitsRefCommitData_history_nodes_author_user);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_nodes_author_userSerializer
|
|
implements
|
|
StructuredSerializer<GCommitsRefCommitData_history_nodes_author_user> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefCommitData_history_nodes_author_user,
|
|
_$GCommitsRefCommitData_history_nodes_author_user
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefCommitData_history_nodes_author_user';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsRefCommitData_history_nodes_author_user object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'login',
|
|
serializers.serialize(object.login,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_author_user deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefCommitData_history_nodes_author_userBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'login':
|
|
result.login = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_nodes_statusSerializer
|
|
implements
|
|
StructuredSerializer<GCommitsRefCommitData_history_nodes_status> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefCommitData_history_nodes_status,
|
|
_$GCommitsRefCommitData_history_nodes_status
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefCommitData_history_nodes_status';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsRefCommitData_history_nodes_status object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'state',
|
|
serializers.serialize(object.state,
|
|
specifiedType: const FullType(_i3.GStatusState)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_status deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefCommitData_history_nodes_statusBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'state':
|
|
result.state = serializers.deserialize(value,
|
|
specifiedType: const FullType(_i3.GStatusState))!
|
|
as _i3.GStatusState;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefDataSerializer
|
|
implements StructuredSerializer<GCommitsRefData> {
|
|
@override
|
|
final Iterable<Type> types = const [GCommitsRefData, _$GCommitsRefData];
|
|
@override
|
|
final String wireName = 'GCommitsRefData';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers, GCommitsRefData object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
Object? value;
|
|
value = object.target;
|
|
if (value != null) {
|
|
result
|
|
..add('target')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(GCommitsRefData_target)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefDataBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'target':
|
|
result.target = serializers.deserialize(value,
|
|
specifiedType: const FullType(GCommitsRefData_target))
|
|
as GCommitsRefData_target?;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__baseSerializer
|
|
implements StructuredSerializer<GCommitsRefData_target__base> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefData_target__base,
|
|
_$GCommitsRefData_target__base
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefData_target__base';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsRefData_target__base object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__base deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefData_target__baseBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommitSerializer
|
|
implements StructuredSerializer<GCommitsRefData_target__asCommit> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefData_target__asCommit,
|
|
_$GCommitsRefData_target__asCommit
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefData_target__asCommit';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsRefData_target__asCommit object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'history',
|
|
serializers.serialize(object.history,
|
|
specifiedType:
|
|
const FullType(GCommitsRefData_target__asCommit_history)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefData_target__asCommitBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'history':
|
|
result.history.replace(serializers.deserialize(value,
|
|
specifiedType:
|
|
const FullType(GCommitsRefData_target__asCommit_history))!
|
|
as GCommitsRefData_target__asCommit_history);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_historySerializer
|
|
implements StructuredSerializer<GCommitsRefData_target__asCommit_history> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefData_target__asCommit_history,
|
|
_$GCommitsRefData_target__asCommit_history
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefData_target__asCommit_history';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(
|
|
Serializers serializers, GCommitsRefData_target__asCommit_history object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'pageInfo',
|
|
serializers.serialize(object.pageInfo,
|
|
specifiedType: const FullType(
|
|
GCommitsRefData_target__asCommit_history_pageInfo)),
|
|
];
|
|
Object? value;
|
|
value = object.nodes;
|
|
if (value != null) {
|
|
result
|
|
..add('nodes')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(BuiltList, const [
|
|
const FullType(GCommitsRefData_target__asCommit_history_nodes)
|
|
])));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefData_target__asCommit_historyBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'pageInfo':
|
|
result.pageInfo.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefData_target__asCommit_history_pageInfo))!
|
|
as GCommitsRefData_target__asCommit_history_pageInfo);
|
|
break;
|
|
case 'nodes':
|
|
result.nodes.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(BuiltList, const [
|
|
const FullType(GCommitsRefData_target__asCommit_history_nodes)
|
|
]))! as BuiltList<Object?>);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_pageInfoSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsRefData_target__asCommit_history_pageInfo> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefData_target__asCommit_history_pageInfo,
|
|
_$GCommitsRefData_target__asCommit_history_pageInfo
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefData_target__asCommit_history_pageInfo';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsRefData_target__asCommit_history_pageInfo object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'hasNextPage',
|
|
serializers.serialize(object.hasNextPage,
|
|
specifiedType: const FullType(bool)),
|
|
];
|
|
Object? value;
|
|
value = object.endCursor;
|
|
if (value != null) {
|
|
result
|
|
..add('endCursor')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(String)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_pageInfo deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsRefData_target__asCommit_history_pageInfoBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'hasNextPage':
|
|
result.hasNextPage = serializers.deserialize(value,
|
|
specifiedType: const FullType(bool))! as bool;
|
|
break;
|
|
case 'endCursor':
|
|
result.endCursor = serializers.deserialize(value,
|
|
specifiedType: const FullType(String)) as String?;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_nodesSerializer
|
|
implements
|
|
StructuredSerializer<GCommitsRefData_target__asCommit_history_nodes> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefData_target__asCommit_history_nodes,
|
|
_$GCommitsRefData_target__asCommit_history_nodes
|
|
];
|
|
@override
|
|
final String wireName = 'GCommitsRefData_target__asCommit_history_nodes';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsRefData_target__asCommit_history_nodes object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'oid',
|
|
serializers.serialize(object.oid, specifiedType: const FullType(String)),
|
|
'messageHeadline',
|
|
serializers.serialize(object.messageHeadline,
|
|
specifiedType: const FullType(String)),
|
|
'committedDate',
|
|
serializers.serialize(object.committedDate,
|
|
specifiedType: const FullType(DateTime)),
|
|
];
|
|
Object? value;
|
|
value = object.author;
|
|
if (value != null) {
|
|
result
|
|
..add('author')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefData_target__asCommit_history_nodes_author)));
|
|
}
|
|
value = object.status;
|
|
if (value != null) {
|
|
result
|
|
..add('status')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefData_target__asCommit_history_nodes_status)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = new GCommitsRefData_target__asCommit_history_nodesBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'oid':
|
|
result.oid = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'messageHeadline':
|
|
result.messageHeadline = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'committedDate':
|
|
result.committedDate = serializers.deserialize(value,
|
|
specifiedType: const FullType(DateTime))! as DateTime;
|
|
break;
|
|
case 'author':
|
|
result.author.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefData_target__asCommit_history_nodes_author))!
|
|
as GCommitsRefData_target__asCommit_history_nodes_author);
|
|
break;
|
|
case 'status':
|
|
result.status.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefData_target__asCommit_history_nodes_status))!
|
|
as GCommitsRefData_target__asCommit_history_nodes_status);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_nodes_authorSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsRefData_target__asCommit_history_nodes_author> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefData_target__asCommit_history_nodes_author,
|
|
_$GCommitsRefData_target__asCommit_history_nodes_author
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsRefData_target__asCommit_history_nodes_author';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsRefData_target__asCommit_history_nodes_author object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'avatarUrl',
|
|
serializers.serialize(object.avatarUrl,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
Object? value;
|
|
value = object.name;
|
|
if (value != null) {
|
|
result
|
|
..add('name')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(String)));
|
|
}
|
|
value = object.user;
|
|
if (value != null) {
|
|
result
|
|
..add('user')
|
|
..add(serializers.serialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_author deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsRefData_target__asCommit_history_nodes_authorBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'name':
|
|
result.name = serializers.deserialize(value,
|
|
specifiedType: const FullType(String)) as String?;
|
|
break;
|
|
case 'avatarUrl':
|
|
result.avatarUrl = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'user':
|
|
result.user.replace(serializers.deserialize(value,
|
|
specifiedType: const FullType(
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user))!
|
|
as GCommitsRefData_target__asCommit_history_nodes_author_user);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_nodes_author_userSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user,
|
|
_$GCommitsRefData_target__asCommit_history_nodes_author_user
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsRefData_target__asCommit_history_nodes_author_user';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'login',
|
|
serializers.serialize(object.login,
|
|
specifiedType: const FullType(String)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsRefData_target__asCommit_history_nodes_author_userBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'login':
|
|
result.login = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_nodes_statusSerializer
|
|
implements
|
|
StructuredSerializer<
|
|
GCommitsRefData_target__asCommit_history_nodes_status> {
|
|
@override
|
|
final Iterable<Type> types = const [
|
|
GCommitsRefData_target__asCommit_history_nodes_status,
|
|
_$GCommitsRefData_target__asCommit_history_nodes_status
|
|
];
|
|
@override
|
|
final String wireName =
|
|
'GCommitsRefData_target__asCommit_history_nodes_status';
|
|
|
|
@override
|
|
Iterable<Object?> serialize(Serializers serializers,
|
|
GCommitsRefData_target__asCommit_history_nodes_status object,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result = <Object?>[
|
|
'__typename',
|
|
serializers.serialize(object.G__typename,
|
|
specifiedType: const FullType(String)),
|
|
'state',
|
|
serializers.serialize(object.state,
|
|
specifiedType: const FullType(_i3.GStatusState)),
|
|
];
|
|
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_status deserialize(
|
|
Serializers serializers, Iterable<Object?> serialized,
|
|
{FullType specifiedType = FullType.unspecified}) {
|
|
final result =
|
|
new GCommitsRefData_target__asCommit_history_nodes_statusBuilder();
|
|
|
|
final iterator = serialized.iterator;
|
|
while (iterator.moveNext()) {
|
|
final key = iterator.current! as String;
|
|
iterator.moveNext();
|
|
final Object? value = iterator.current;
|
|
switch (key) {
|
|
case '__typename':
|
|
result.G__typename = serializers.deserialize(value,
|
|
specifiedType: const FullType(String))! as String;
|
|
break;
|
|
case 'state':
|
|
result.state = serializers.deserialize(value,
|
|
specifiedType: const FullType(_i3.GStatusState))!
|
|
as _i3.GStatusState;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result.build();
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData extends GCommitsData {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsData_repository? repository;
|
|
|
|
factory _$GCommitsData([void Function(GCommitsDataBuilder)? updates]) =>
|
|
(new GCommitsDataBuilder()..update(updates))._build();
|
|
|
|
_$GCommitsData._({required this.G__typename, this.repository}) : super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsData', 'G__typename');
|
|
}
|
|
|
|
@override
|
|
GCommitsData rebuild(void Function(GCommitsDataBuilder) updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsDataBuilder toBuilder() => new GCommitsDataBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsData &&
|
|
G__typename == other.G__typename &&
|
|
repository == other.repository;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), repository.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(r'GCommitsData')
|
|
..add('G__typename', G__typename)
|
|
..add('repository', repository))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsDataBuilder
|
|
implements Builder<GCommitsData, GCommitsDataBuilder> {
|
|
_$GCommitsData? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repositoryBuilder? _repository;
|
|
GCommitsData_repositoryBuilder get repository =>
|
|
_$this._repository ??= new GCommitsData_repositoryBuilder();
|
|
set repository(GCommitsData_repositoryBuilder? repository) =>
|
|
_$this._repository = repository;
|
|
|
|
GCommitsDataBuilder() {
|
|
GCommitsData._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsDataBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_repository = $v.repository?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsData other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData;
|
|
}
|
|
|
|
@override
|
|
void update(void Function(GCommitsDataBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData build() => _build();
|
|
|
|
_$GCommitsData _build() {
|
|
_$GCommitsData _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsData', 'G__typename'),
|
|
repository: _repository?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'repository';
|
|
_repository?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData', _$failedField, e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository extends GCommitsData_repository {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsData_repository_defaultBranchRef? defaultBranchRef;
|
|
@override
|
|
final GCommitsData_repository_ref? ref;
|
|
|
|
factory _$GCommitsData_repository(
|
|
[void Function(GCommitsData_repositoryBuilder)? updates]) =>
|
|
(new GCommitsData_repositoryBuilder()..update(updates))._build();
|
|
|
|
_$GCommitsData_repository._(
|
|
{required this.G__typename, this.defaultBranchRef, this.ref})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsData_repository', 'G__typename');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository rebuild(
|
|
void Function(GCommitsData_repositoryBuilder) updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repositoryBuilder toBuilder() =>
|
|
new GCommitsData_repositoryBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsData_repository &&
|
|
G__typename == other.G__typename &&
|
|
defaultBranchRef == other.defaultBranchRef &&
|
|
ref == other.ref;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc($jc(0, G__typename.hashCode), defaultBranchRef.hashCode),
|
|
ref.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(r'GCommitsData_repository')
|
|
..add('G__typename', G__typename)
|
|
..add('defaultBranchRef', defaultBranchRef)
|
|
..add('ref', ref))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repositoryBuilder
|
|
implements
|
|
Builder<GCommitsData_repository, GCommitsData_repositoryBuilder> {
|
|
_$GCommitsData_repository? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repository_defaultBranchRefBuilder? _defaultBranchRef;
|
|
GCommitsData_repository_defaultBranchRefBuilder get defaultBranchRef =>
|
|
_$this._defaultBranchRef ??=
|
|
new GCommitsData_repository_defaultBranchRefBuilder();
|
|
set defaultBranchRef(
|
|
GCommitsData_repository_defaultBranchRefBuilder? defaultBranchRef) =>
|
|
_$this._defaultBranchRef = defaultBranchRef;
|
|
|
|
GCommitsData_repository_refBuilder? _ref;
|
|
GCommitsData_repository_refBuilder get ref =>
|
|
_$this._ref ??= new GCommitsData_repository_refBuilder();
|
|
set ref(GCommitsData_repository_refBuilder? ref) => _$this._ref = ref;
|
|
|
|
GCommitsData_repositoryBuilder() {
|
|
GCommitsData_repository._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repositoryBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_defaultBranchRef = $v.defaultBranchRef?.toBuilder();
|
|
_ref = $v.ref?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsData_repository other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData_repository;
|
|
}
|
|
|
|
@override
|
|
void update(void Function(GCommitsData_repositoryBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository build() => _build();
|
|
|
|
_$GCommitsData_repository _build() {
|
|
_$GCommitsData_repository _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData_repository._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsData_repository', 'G__typename'),
|
|
defaultBranchRef: _defaultBranchRef?.build(),
|
|
ref: _ref?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'defaultBranchRef';
|
|
_defaultBranchRef?.build();
|
|
_$failedField = 'ref';
|
|
_ref?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData_repository', _$failedField, e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef
|
|
extends GCommitsData_repository_defaultBranchRef {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsData_repository_defaultBranchRef_target? target;
|
|
|
|
factory _$GCommitsData_repository_defaultBranchRef(
|
|
[void Function(GCommitsData_repository_defaultBranchRefBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_defaultBranchRefBuilder()..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef._(
|
|
{required this.G__typename, this.target})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef', 'G__typename');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef rebuild(
|
|
void Function(GCommitsData_repository_defaultBranchRefBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRefBuilder toBuilder() =>
|
|
new GCommitsData_repository_defaultBranchRefBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsData_repository_defaultBranchRef &&
|
|
G__typename == other.G__typename &&
|
|
target == other.target;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), target.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_defaultBranchRef')
|
|
..add('G__typename', G__typename)
|
|
..add('target', target))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_defaultBranchRefBuilder
|
|
implements
|
|
Builder<GCommitsData_repository_defaultBranchRef,
|
|
GCommitsData_repository_defaultBranchRefBuilder> {
|
|
_$GCommitsData_repository_defaultBranchRef? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target? _target;
|
|
GCommitsData_repository_defaultBranchRef_target? get target => _$this._target;
|
|
set target(GCommitsData_repository_defaultBranchRef_target? target) =>
|
|
_$this._target = target;
|
|
|
|
GCommitsData_repository_defaultBranchRefBuilder() {
|
|
GCommitsData_repository_defaultBranchRef._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_defaultBranchRefBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_target = $v.target;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsData_repository_defaultBranchRef other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData_repository_defaultBranchRef;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsData_repository_defaultBranchRefBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef build() => _build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_defaultBranchRef._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef', 'G__typename'),
|
|
target: target);
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__base
|
|
extends GCommitsData_repository_defaultBranchRef_target__base {
|
|
@override
|
|
final String G__typename;
|
|
|
|
factory _$GCommitsData_repository_defaultBranchRef_target__base(
|
|
[void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__baseBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_defaultBranchRef_target__baseBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__base._(
|
|
{required this.G__typename})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__base',
|
|
'G__typename');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__base rebuild(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__baseBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__baseBuilder toBuilder() =>
|
|
new GCommitsData_repository_defaultBranchRef_target__baseBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsData_repository_defaultBranchRef_target__base &&
|
|
G__typename == other.G__typename;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(0, G__typename.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_defaultBranchRef_target__base')
|
|
..add('G__typename', G__typename))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_defaultBranchRef_target__baseBuilder
|
|
implements
|
|
Builder<GCommitsData_repository_defaultBranchRef_target__base,
|
|
GCommitsData_repository_defaultBranchRef_target__baseBuilder> {
|
|
_$GCommitsData_repository_defaultBranchRef_target__base? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__baseBuilder() {
|
|
GCommitsData_repository_defaultBranchRef_target__base._initializeBuilder(
|
|
this);
|
|
}
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__baseBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsData_repository_defaultBranchRef_target__base other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData_repository_defaultBranchRef_target__base;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__baseBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__base build() => _build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__base _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_defaultBranchRef_target__base._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__base',
|
|
'G__typename'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit
|
|
extends GCommitsData_repository_defaultBranchRef_target__asCommit {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsData_repository_defaultBranchRef_target__asCommit_history
|
|
history;
|
|
|
|
factory _$GCommitsData_repository_defaultBranchRef_target__asCommit(
|
|
[void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommitBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_defaultBranchRef_target__asCommitBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit._(
|
|
{required this.G__typename, required this.history})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
history,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit',
|
|
'history');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit rebuild(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommitBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommitBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommitBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsData_repository_defaultBranchRef_target__asCommit &&
|
|
G__typename == other.G__typename &&
|
|
history == other.history;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), history.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit')
|
|
..add('G__typename', G__typename)
|
|
..add('history', history))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_defaultBranchRef_target__asCommitBuilder
|
|
implements
|
|
Builder<GCommitsData_repository_defaultBranchRef_target__asCommit,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommitBuilder> {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder?
|
|
_history;
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder
|
|
get history => _$this._history ??=
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder();
|
|
set history(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder?
|
|
history) =>
|
|
_$this._history = history;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommitBuilder() {
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommitBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_history = $v.history.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData_repository_defaultBranchRef_target__asCommit;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommitBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit build() => _build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit _build() {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit',
|
|
'G__typename'),
|
|
history: history.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'history';
|
|
history.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history
|
|
extends GCommitsData_repository_defaultBranchRef_target__asCommit_history {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
pageInfo;
|
|
@override
|
|
final BuiltList<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes>?
|
|
nodes;
|
|
|
|
factory _$GCommitsData_repository_defaultBranchRef_target__asCommit_history(
|
|
[void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history._(
|
|
{required this.G__typename, required this.pageInfo, this.nodes})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
pageInfo,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history',
|
|
'pageInfo');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history rebuild(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_defaultBranchRef_target__asCommit_history &&
|
|
G__typename == other.G__typename &&
|
|
pageInfo == other.pageInfo &&
|
|
nodes == other.nodes;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc($jc(0, G__typename.hashCode), pageInfo.hashCode), nodes.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history')
|
|
..add('G__typename', G__typename)
|
|
..add('pageInfo', pageInfo)
|
|
..add('nodes', nodes))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder
|
|
implements
|
|
Builder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder> {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder?
|
|
_pageInfo;
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder
|
|
get pageInfo => _$this._pageInfo ??=
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder();
|
|
set pageInfo(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder?
|
|
pageInfo) =>
|
|
_$this._pageInfo = pageInfo;
|
|
|
|
ListBuilder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes>?
|
|
_nodes;
|
|
ListBuilder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes>
|
|
get nodes => _$this._nodes ??= new ListBuilder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes>();
|
|
set nodes(
|
|
ListBuilder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes>?
|
|
nodes) =>
|
|
_$this._nodes = nodes;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder() {
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_pageInfo = $v.pageInfo.toBuilder();
|
|
_nodes = $v.nodes?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_defaultBranchRef_target__asCommit_history;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_historyBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history build() =>
|
|
_build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history _build() {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history
|
|
_$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history
|
|
._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history',
|
|
'G__typename'),
|
|
pageInfo: pageInfo.build(),
|
|
nodes: _nodes?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'pageInfo';
|
|
pageInfo.build();
|
|
_$failedField = 'nodes';
|
|
_nodes?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
extends GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final bool hasNextPage;
|
|
@override
|
|
final String? endCursor;
|
|
|
|
factory _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo(
|
|
[void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo._(
|
|
{required this.G__typename, required this.hasNextPage, this.endCursor})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
hasNextPage,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo',
|
|
'hasNextPage');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
rebuild(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo &&
|
|
G__typename == other.G__typename &&
|
|
hasNextPage == other.hasNextPage &&
|
|
endCursor == other.endCursor;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc($jc(0, G__typename.hashCode), hasNextPage.hashCode),
|
|
endCursor.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo')
|
|
..add('G__typename', G__typename)
|
|
..add('hasNextPage', hasNextPage)
|
|
..add('endCursor', endCursor))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder
|
|
implements
|
|
Builder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder> {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo?
|
|
_$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
bool? _hasNextPage;
|
|
bool? get hasNextPage => _$this._hasNextPage;
|
|
set hasNextPage(bool? hasNextPage) => _$this._hasNextPage = hasNextPage;
|
|
|
|
String? _endCursor;
|
|
String? get endCursor => _$this._endCursor;
|
|
set endCursor(String? endCursor) => _$this._endCursor = endCursor;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder() {
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_hasNextPage = $v.hasNextPage;
|
|
_endCursor = $v.endCursor;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfoBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
build() => _build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
_build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo
|
|
._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo',
|
|
'G__typename'),
|
|
hasNextPage: BuiltValueNullFieldError.checkNotNull(
|
|
hasNextPage,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_pageInfo',
|
|
'hasNextPage'),
|
|
endCursor: endCursor);
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes
|
|
extends GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String oid;
|
|
@override
|
|
final String messageHeadline;
|
|
@override
|
|
final DateTime committedDate;
|
|
@override
|
|
final GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author?
|
|
author;
|
|
@override
|
|
final GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status?
|
|
status;
|
|
|
|
factory _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes(
|
|
[void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes._(
|
|
{required this.G__typename,
|
|
required this.oid,
|
|
required this.messageHeadline,
|
|
required this.committedDate,
|
|
this.author,
|
|
this.status})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
oid,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes',
|
|
'oid');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
messageHeadline,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes',
|
|
'messageHeadline');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
committedDate,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes',
|
|
'committedDate');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes rebuild(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes &&
|
|
G__typename == other.G__typename &&
|
|
oid == other.oid &&
|
|
messageHeadline == other.messageHeadline &&
|
|
committedDate == other.committedDate &&
|
|
author == other.author &&
|
|
status == other.status;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc(
|
|
$jc(
|
|
$jc($jc($jc(0, G__typename.hashCode), oid.hashCode),
|
|
messageHeadline.hashCode),
|
|
committedDate.hashCode),
|
|
author.hashCode),
|
|
status.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes')
|
|
..add('G__typename', G__typename)
|
|
..add('oid', oid)
|
|
..add('messageHeadline', messageHeadline)
|
|
..add('committedDate', committedDate)
|
|
..add('author', author)
|
|
..add('status', status))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder
|
|
implements
|
|
Builder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder> {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes?
|
|
_$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _oid;
|
|
String? get oid => _$this._oid;
|
|
set oid(String? oid) => _$this._oid = oid;
|
|
|
|
String? _messageHeadline;
|
|
String? get messageHeadline => _$this._messageHeadline;
|
|
set messageHeadline(String? messageHeadline) =>
|
|
_$this._messageHeadline = messageHeadline;
|
|
|
|
DateTime? _committedDate;
|
|
DateTime? get committedDate => _$this._committedDate;
|
|
set committedDate(DateTime? committedDate) =>
|
|
_$this._committedDate = committedDate;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder?
|
|
_author;
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder
|
|
get author => _$this._author ??=
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder();
|
|
set author(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder?
|
|
author) =>
|
|
_$this._author = author;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder?
|
|
_status;
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder
|
|
get status => _$this._status ??=
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder();
|
|
set status(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder?
|
|
status) =>
|
|
_$this._status = status;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder() {
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_oid = $v.oid;
|
|
_messageHeadline = $v.messageHeadline;
|
|
_committedDate = $v.committedDate;
|
|
_author = $v.author?.toBuilder();
|
|
_status = $v.status?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes
|
|
other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodesBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes
|
|
build() => _build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes
|
|
_build() {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes
|
|
_$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes',
|
|
'G__typename'),
|
|
oid: BuiltValueNullFieldError.checkNotNull(
|
|
oid,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes',
|
|
'oid'),
|
|
messageHeadline: BuiltValueNullFieldError.checkNotNull(
|
|
messageHeadline,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes',
|
|
'messageHeadline'),
|
|
committedDate: BuiltValueNullFieldError.checkNotNull(
|
|
committedDate,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes',
|
|
'committedDate'),
|
|
author: _author?.build(),
|
|
status: _status?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'author';
|
|
_author?.build();
|
|
_$failedField = 'status';
|
|
_status?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
extends GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String? name;
|
|
@override
|
|
final String avatarUrl;
|
|
@override
|
|
final GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user?
|
|
user;
|
|
|
|
factory _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author(
|
|
[void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author._(
|
|
{required this.G__typename,
|
|
this.name,
|
|
required this.avatarUrl,
|
|
this.user})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
avatarUrl,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author',
|
|
'avatarUrl');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
rebuild(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author &&
|
|
G__typename == other.G__typename &&
|
|
name == other.name &&
|
|
avatarUrl == other.avatarUrl &&
|
|
user == other.user;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc($jc($jc(0, G__typename.hashCode), name.hashCode),
|
|
avatarUrl.hashCode),
|
|
user.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author')
|
|
..add('G__typename', G__typename)
|
|
..add('name', name)
|
|
..add('avatarUrl', avatarUrl)
|
|
..add('user', user))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder
|
|
implements
|
|
Builder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder> {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author?
|
|
_$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _name;
|
|
String? get name => _$this._name;
|
|
set name(String? name) => _$this._name = name;
|
|
|
|
String? _avatarUrl;
|
|
String? get avatarUrl => _$this._avatarUrl;
|
|
set avatarUrl(String? avatarUrl) => _$this._avatarUrl = avatarUrl;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder?
|
|
_user;
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder
|
|
get user => _$this._user ??=
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder();
|
|
set user(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder?
|
|
user) =>
|
|
_$this._user = user;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder() {
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_name = $v.name;
|
|
_avatarUrl = $v.avatarUrl;
|
|
_user = $v.user?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_authorBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
build() => _build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
_build() {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
_$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author
|
|
._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author',
|
|
'G__typename'),
|
|
name: name,
|
|
avatarUrl: BuiltValueNullFieldError.checkNotNull(
|
|
avatarUrl,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author',
|
|
'avatarUrl'),
|
|
user: _user?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'user';
|
|
_user?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
extends GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String login;
|
|
|
|
factory _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user(
|
|
[void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user._(
|
|
{required this.G__typename, required this.login})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
login,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user',
|
|
'login');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
rebuild(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user &&
|
|
G__typename == other.G__typename &&
|
|
login == other.login;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), login.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user')
|
|
..add('G__typename', G__typename)
|
|
..add('login', login))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder
|
|
implements
|
|
Builder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder> {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user?
|
|
_$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _login;
|
|
String? get login => _$this._login;
|
|
set login(String? login) => _$this._login = login;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder() {
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_login = $v.login;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_userBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
build() => _build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
_build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user
|
|
._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user',
|
|
'G__typename'),
|
|
login: BuiltValueNullFieldError.checkNotNull(
|
|
login,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_author_user',
|
|
'login'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
extends GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final _i3.GStatusState state;
|
|
|
|
factory _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status(
|
|
[void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status._(
|
|
{required this.G__typename, required this.state})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
state,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status',
|
|
'state');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
rebuild(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status &&
|
|
G__typename == other.G__typename &&
|
|
state == other.state;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), state.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status')
|
|
..add('G__typename', G__typename)
|
|
..add('state', state))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder
|
|
implements
|
|
Builder<
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status,
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder> {
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status?
|
|
_$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
_i3.GStatusState? _state;
|
|
_i3.GStatusState? get state => _$this._state;
|
|
set state(_i3.GStatusState? state) => _$this._state = state;
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder() {
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_state = $v.state;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_statusBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
build() => _build();
|
|
|
|
_$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
_build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status
|
|
._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status',
|
|
'G__typename'),
|
|
state: BuiltValueNullFieldError.checkNotNull(
|
|
state,
|
|
r'GCommitsData_repository_defaultBranchRef_target__asCommit_history_nodes_status',
|
|
'state'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref extends GCommitsData_repository_ref {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsData_repository_ref_target? target;
|
|
|
|
factory _$GCommitsData_repository_ref(
|
|
[void Function(GCommitsData_repository_refBuilder)? updates]) =>
|
|
(new GCommitsData_repository_refBuilder()..update(updates))._build();
|
|
|
|
_$GCommitsData_repository_ref._({required this.G__typename, this.target})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsData_repository_ref', 'G__typename');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref rebuild(
|
|
void Function(GCommitsData_repository_refBuilder) updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_refBuilder toBuilder() =>
|
|
new GCommitsData_repository_refBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsData_repository_ref &&
|
|
G__typename == other.G__typename &&
|
|
target == other.target;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), target.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(r'GCommitsData_repository_ref')
|
|
..add('G__typename', G__typename)
|
|
..add('target', target))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_refBuilder
|
|
implements
|
|
Builder<GCommitsData_repository_ref,
|
|
GCommitsData_repository_refBuilder> {
|
|
_$GCommitsData_repository_ref? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repository_ref_target? _target;
|
|
GCommitsData_repository_ref_target? get target => _$this._target;
|
|
set target(GCommitsData_repository_ref_target? target) =>
|
|
_$this._target = target;
|
|
|
|
GCommitsData_repository_refBuilder() {
|
|
GCommitsData_repository_ref._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_refBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_target = $v.target;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsData_repository_ref other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData_repository_ref;
|
|
}
|
|
|
|
@override
|
|
void update(void Function(GCommitsData_repository_refBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref build() => _build();
|
|
|
|
_$GCommitsData_repository_ref _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_ref._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsData_repository_ref', 'G__typename'),
|
|
target: target);
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__base
|
|
extends GCommitsData_repository_ref_target__base {
|
|
@override
|
|
final String G__typename;
|
|
|
|
factory _$GCommitsData_repository_ref_target__base(
|
|
[void Function(GCommitsData_repository_ref_target__baseBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_ref_target__baseBuilder()..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_ref_target__base._({required this.G__typename})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsData_repository_ref_target__base', 'G__typename');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__base rebuild(
|
|
void Function(GCommitsData_repository_ref_target__baseBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__baseBuilder toBuilder() =>
|
|
new GCommitsData_repository_ref_target__baseBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsData_repository_ref_target__base &&
|
|
G__typename == other.G__typename;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(0, G__typename.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_ref_target__base')
|
|
..add('G__typename', G__typename))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_ref_target__baseBuilder
|
|
implements
|
|
Builder<GCommitsData_repository_ref_target__base,
|
|
GCommitsData_repository_ref_target__baseBuilder> {
|
|
_$GCommitsData_repository_ref_target__base? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repository_ref_target__baseBuilder() {
|
|
GCommitsData_repository_ref_target__base._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_ref_target__baseBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsData_repository_ref_target__base other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData_repository_ref_target__base;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsData_repository_ref_target__baseBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__base build() => _build();
|
|
|
|
_$GCommitsData_repository_ref_target__base _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_ref_target__base._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsData_repository_ref_target__base', 'G__typename'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit
|
|
extends GCommitsData_repository_ref_target__asCommit {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsData_repository_ref_target__asCommit_history history;
|
|
|
|
factory _$GCommitsData_repository_ref_target__asCommit(
|
|
[void Function(GCommitsData_repository_ref_target__asCommitBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_ref_target__asCommitBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit._(
|
|
{required this.G__typename, required this.history})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
history, r'GCommitsData_repository_ref_target__asCommit', 'history');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit rebuild(
|
|
void Function(GCommitsData_repository_ref_target__asCommitBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommitBuilder toBuilder() =>
|
|
new GCommitsData_repository_ref_target__asCommitBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsData_repository_ref_target__asCommit &&
|
|
G__typename == other.G__typename &&
|
|
history == other.history;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), history.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_ref_target__asCommit')
|
|
..add('G__typename', G__typename)
|
|
..add('history', history))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_ref_target__asCommitBuilder
|
|
implements
|
|
Builder<GCommitsData_repository_ref_target__asCommit,
|
|
GCommitsData_repository_ref_target__asCommitBuilder> {
|
|
_$GCommitsData_repository_ref_target__asCommit? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder? _history;
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder get history =>
|
|
_$this._history ??=
|
|
new GCommitsData_repository_ref_target__asCommit_historyBuilder();
|
|
set history(
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder?
|
|
history) =>
|
|
_$this._history = history;
|
|
|
|
GCommitsData_repository_ref_target__asCommitBuilder() {
|
|
GCommitsData_repository_ref_target__asCommit._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_ref_target__asCommitBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_history = $v.history.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsData_repository_ref_target__asCommit other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData_repository_ref_target__asCommit;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsData_repository_ref_target__asCommitBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit build() => _build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit _build() {
|
|
_$GCommitsData_repository_ref_target__asCommit _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData_repository_ref_target__asCommit._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit',
|
|
'G__typename'),
|
|
history: history.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'history';
|
|
history.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData_repository_ref_target__asCommit',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history
|
|
extends GCommitsData_repository_ref_target__asCommit_history {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsData_repository_ref_target__asCommit_history_pageInfo pageInfo;
|
|
@override
|
|
final BuiltList<GCommitsData_repository_ref_target__asCommit_history_nodes>?
|
|
nodes;
|
|
|
|
factory _$GCommitsData_repository_ref_target__asCommit_history(
|
|
[void Function(
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_ref_target__asCommit_historyBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history._(
|
|
{required this.G__typename, required this.pageInfo, this.nodes})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(pageInfo,
|
|
r'GCommitsData_repository_ref_target__asCommit_history', 'pageInfo');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history rebuild(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder toBuilder() =>
|
|
new GCommitsData_repository_ref_target__asCommit_historyBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsData_repository_ref_target__asCommit_history &&
|
|
G__typename == other.G__typename &&
|
|
pageInfo == other.pageInfo &&
|
|
nodes == other.nodes;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc($jc(0, G__typename.hashCode), pageInfo.hashCode), nodes.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_ref_target__asCommit_history')
|
|
..add('G__typename', G__typename)
|
|
..add('pageInfo', pageInfo)
|
|
..add('nodes', nodes))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_ref_target__asCommit_historyBuilder
|
|
implements
|
|
Builder<GCommitsData_repository_ref_target__asCommit_history,
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder> {
|
|
_$GCommitsData_repository_ref_target__asCommit_history? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder?
|
|
_pageInfo;
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder
|
|
get pageInfo => _$this._pageInfo ??=
|
|
new GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder();
|
|
set pageInfo(
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder?
|
|
pageInfo) =>
|
|
_$this._pageInfo = pageInfo;
|
|
|
|
ListBuilder<GCommitsData_repository_ref_target__asCommit_history_nodes>?
|
|
_nodes;
|
|
ListBuilder<GCommitsData_repository_ref_target__asCommit_history_nodes>
|
|
get nodes => _$this._nodes ??= new ListBuilder<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes>();
|
|
set nodes(
|
|
ListBuilder<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes>?
|
|
nodes) =>
|
|
_$this._nodes = nodes;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder() {
|
|
GCommitsData_repository_ref_target__asCommit_history._initializeBuilder(
|
|
this);
|
|
}
|
|
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_pageInfo = $v.pageInfo.toBuilder();
|
|
_nodes = $v.nodes?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsData_repository_ref_target__asCommit_history other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData_repository_ref_target__asCommit_history;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_historyBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history build() => _build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history _build() {
|
|
_$GCommitsData_repository_ref_target__asCommit_history _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData_repository_ref_target__asCommit_history._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history',
|
|
'G__typename'),
|
|
pageInfo: pageInfo.build(),
|
|
nodes: _nodes?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'pageInfo';
|
|
pageInfo.build();
|
|
_$failedField = 'nodes';
|
|
_nodes?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData_repository_ref_target__asCommit_history',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_pageInfo
|
|
extends GCommitsData_repository_ref_target__asCommit_history_pageInfo {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final bool hasNextPage;
|
|
@override
|
|
final String? endCursor;
|
|
|
|
factory _$GCommitsData_repository_ref_target__asCommit_history_pageInfo(
|
|
[void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_pageInfo._(
|
|
{required this.G__typename, required this.hasNextPage, this.endCursor})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_pageInfo',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
hasNextPage,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_pageInfo',
|
|
'hasNextPage');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo rebuild(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_ref_target__asCommit_history_pageInfo &&
|
|
G__typename == other.G__typename &&
|
|
hasNextPage == other.hasNextPage &&
|
|
endCursor == other.endCursor;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc($jc(0, G__typename.hashCode), hasNextPage.hashCode),
|
|
endCursor.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_ref_target__asCommit_history_pageInfo')
|
|
..add('G__typename', G__typename)
|
|
..add('hasNextPage', hasNextPage)
|
|
..add('endCursor', endCursor))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder
|
|
implements
|
|
Builder<GCommitsData_repository_ref_target__asCommit_history_pageInfo,
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder> {
|
|
_$GCommitsData_repository_ref_target__asCommit_history_pageInfo? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
bool? _hasNextPage;
|
|
bool? get hasNextPage => _$this._hasNextPage;
|
|
set hasNextPage(bool? hasNextPage) => _$this._hasNextPage = hasNextPage;
|
|
|
|
String? _endCursor;
|
|
String? get endCursor => _$this._endCursor;
|
|
set endCursor(String? endCursor) => _$this._endCursor = endCursor;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder() {
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_hasNextPage = $v.hasNextPage;
|
|
_endCursor = $v.endCursor;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_ref_target__asCommit_history_pageInfo;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfoBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_pageInfo build() =>
|
|
_build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_pageInfo _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_pageInfo._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_pageInfo',
|
|
'G__typename'),
|
|
hasNextPage: BuiltValueNullFieldError.checkNotNull(
|
|
hasNextPage,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_pageInfo',
|
|
'hasNextPage'),
|
|
endCursor: endCursor);
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_nodes
|
|
extends GCommitsData_repository_ref_target__asCommit_history_nodes {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String oid;
|
|
@override
|
|
final String messageHeadline;
|
|
@override
|
|
final DateTime committedDate;
|
|
@override
|
|
final GCommitsData_repository_ref_target__asCommit_history_nodes_author?
|
|
author;
|
|
@override
|
|
final GCommitsData_repository_ref_target__asCommit_history_nodes_status?
|
|
status;
|
|
|
|
factory _$GCommitsData_repository_ref_target__asCommit_history_nodes(
|
|
[void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodesBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_ref_target__asCommit_history_nodesBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes._(
|
|
{required this.G__typename,
|
|
required this.oid,
|
|
required this.messageHeadline,
|
|
required this.committedDate,
|
|
this.author,
|
|
this.status})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(oid,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes', 'oid');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
messageHeadline,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes',
|
|
'messageHeadline');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
committedDate,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes',
|
|
'committedDate');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes rebuild(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodesBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodesBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodesBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_ref_target__asCommit_history_nodes &&
|
|
G__typename == other.G__typename &&
|
|
oid == other.oid &&
|
|
messageHeadline == other.messageHeadline &&
|
|
committedDate == other.committedDate &&
|
|
author == other.author &&
|
|
status == other.status;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc(
|
|
$jc(
|
|
$jc($jc($jc(0, G__typename.hashCode), oid.hashCode),
|
|
messageHeadline.hashCode),
|
|
committedDate.hashCode),
|
|
author.hashCode),
|
|
status.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes')
|
|
..add('G__typename', G__typename)
|
|
..add('oid', oid)
|
|
..add('messageHeadline', messageHeadline)
|
|
..add('committedDate', committedDate)
|
|
..add('author', author)
|
|
..add('status', status))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_ref_target__asCommit_history_nodesBuilder
|
|
implements
|
|
Builder<GCommitsData_repository_ref_target__asCommit_history_nodes,
|
|
GCommitsData_repository_ref_target__asCommit_history_nodesBuilder> {
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _oid;
|
|
String? get oid => _$this._oid;
|
|
set oid(String? oid) => _$this._oid = oid;
|
|
|
|
String? _messageHeadline;
|
|
String? get messageHeadline => _$this._messageHeadline;
|
|
set messageHeadline(String? messageHeadline) =>
|
|
_$this._messageHeadline = messageHeadline;
|
|
|
|
DateTime? _committedDate;
|
|
DateTime? get committedDate => _$this._committedDate;
|
|
set committedDate(DateTime? committedDate) =>
|
|
_$this._committedDate = committedDate;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder?
|
|
_author;
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder
|
|
get author => _$this._author ??=
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder();
|
|
set author(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder?
|
|
author) =>
|
|
_$this._author = author;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder?
|
|
_status;
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder
|
|
get status => _$this._status ??=
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder();
|
|
set status(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder?
|
|
status) =>
|
|
_$this._status = status;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodesBuilder() {
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodesBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_oid = $v.oid;
|
|
_messageHeadline = $v.messageHeadline;
|
|
_committedDate = $v.committedDate;
|
|
_author = $v.author?.toBuilder();
|
|
_status = $v.status?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsData_repository_ref_target__asCommit_history_nodes;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodesBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes build() =>
|
|
_build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes _build() {
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_nodes._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes',
|
|
'G__typename'),
|
|
oid: BuiltValueNullFieldError.checkNotNull(
|
|
oid,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes',
|
|
'oid'),
|
|
messageHeadline: BuiltValueNullFieldError.checkNotNull(
|
|
messageHeadline,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes',
|
|
'messageHeadline'),
|
|
committedDate: BuiltValueNullFieldError.checkNotNull(
|
|
committedDate,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes',
|
|
'committedDate'),
|
|
author: _author?.build(),
|
|
status: _status?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'author';
|
|
_author?.build();
|
|
_$failedField = 'status';
|
|
_status?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_nodes_author
|
|
extends GCommitsData_repository_ref_target__asCommit_history_nodes_author {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String? name;
|
|
@override
|
|
final String avatarUrl;
|
|
@override
|
|
final GCommitsData_repository_ref_target__asCommit_history_nodes_author_user?
|
|
user;
|
|
|
|
factory _$GCommitsData_repository_ref_target__asCommit_history_nodes_author(
|
|
[void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_author._(
|
|
{required this.G__typename,
|
|
this.name,
|
|
required this.avatarUrl,
|
|
this.user})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
avatarUrl,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author',
|
|
'avatarUrl');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author rebuild(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_ref_target__asCommit_history_nodes_author &&
|
|
G__typename == other.G__typename &&
|
|
name == other.name &&
|
|
avatarUrl == other.avatarUrl &&
|
|
user == other.user;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc($jc($jc(0, G__typename.hashCode), name.hashCode),
|
|
avatarUrl.hashCode),
|
|
user.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author')
|
|
..add('G__typename', G__typename)
|
|
..add('name', name)
|
|
..add('avatarUrl', avatarUrl)
|
|
..add('user', user))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder
|
|
implements
|
|
Builder<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author,
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder> {
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_author? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _name;
|
|
String? get name => _$this._name;
|
|
set name(String? name) => _$this._name = name;
|
|
|
|
String? _avatarUrl;
|
|
String? get avatarUrl => _$this._avatarUrl;
|
|
set avatarUrl(String? avatarUrl) => _$this._avatarUrl = avatarUrl;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder?
|
|
_user;
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder
|
|
get user => _$this._user ??=
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder();
|
|
set user(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder?
|
|
user) =>
|
|
_$this._user = user;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder() {
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_name = $v.name;
|
|
_avatarUrl = $v.avatarUrl;
|
|
_user = $v.user?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_ref_target__asCommit_history_nodes_author;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_authorBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author build() =>
|
|
_build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_author _build() {
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_author
|
|
_$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_nodes_author
|
|
._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author',
|
|
'G__typename'),
|
|
name: name,
|
|
avatarUrl: BuiltValueNullFieldError.checkNotNull(
|
|
avatarUrl,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author',
|
|
'avatarUrl'),
|
|
user: _user?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'user';
|
|
_user?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_nodes_author_user
|
|
extends GCommitsData_repository_ref_target__asCommit_history_nodes_author_user {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String login;
|
|
|
|
factory _$GCommitsData_repository_ref_target__asCommit_history_nodes_author_user(
|
|
[void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_author_user._(
|
|
{required this.G__typename, required this.login})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author_user',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
login,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author_user',
|
|
'login');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user rebuild(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_ref_target__asCommit_history_nodes_author_user &&
|
|
G__typename == other.G__typename &&
|
|
login == other.login;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), login.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author_user')
|
|
..add('G__typename', G__typename)
|
|
..add('login', login))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder
|
|
implements
|
|
Builder<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user,
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder> {
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_author_user? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _login;
|
|
String? get login => _$this._login;
|
|
set login(String? login) => _$this._login = login;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder() {
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_login = $v.login;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user
|
|
other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_ref_target__asCommit_history_nodes_author_user;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_userBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_author_user
|
|
build() => _build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_author_user
|
|
_build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_nodes_author_user
|
|
._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author_user',
|
|
'G__typename'),
|
|
login: BuiltValueNullFieldError.checkNotNull(
|
|
login,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_author_user',
|
|
'login'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsData_repository_ref_target__asCommit_history_nodes_status
|
|
extends GCommitsData_repository_ref_target__asCommit_history_nodes_status {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final _i3.GStatusState state;
|
|
|
|
factory _$GCommitsData_repository_ref_target__asCommit_history_nodes_status(
|
|
[void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder)?
|
|
updates]) =>
|
|
(new GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_status._(
|
|
{required this.G__typename, required this.state})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_status',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
state,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_status',
|
|
'state');
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status rebuild(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder
|
|
toBuilder() =>
|
|
new GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsData_repository_ref_target__asCommit_history_nodes_status &&
|
|
G__typename == other.G__typename &&
|
|
state == other.state;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), state.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_status')
|
|
..add('G__typename', G__typename)
|
|
..add('state', state))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder
|
|
implements
|
|
Builder<
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status,
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder> {
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_status? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
_i3.GStatusState? _state;
|
|
_i3.GStatusState? get state => _$this._state;
|
|
set state(_i3.GStatusState? state) => _$this._state = state;
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder() {
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder
|
|
get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_state = $v.state;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other
|
|
as _$GCommitsData_repository_ref_target__asCommit_history_nodes_status;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_statusBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsData_repository_ref_target__asCommit_history_nodes_status build() =>
|
|
_build();
|
|
|
|
_$GCommitsData_repository_ref_target__asCommit_history_nodes_status _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsData_repository_ref_target__asCommit_history_nodes_status
|
|
._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_status',
|
|
'G__typename'),
|
|
state: BuiltValueNullFieldError.checkNotNull(
|
|
state,
|
|
r'GCommitsData_repository_ref_target__asCommit_history_nodes_status',
|
|
'state'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData extends GCommitsRefCommitData {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsRefCommitData_history history;
|
|
|
|
factory _$GCommitsRefCommitData(
|
|
[void Function(GCommitsRefCommitDataBuilder)? updates]) =>
|
|
(new GCommitsRefCommitDataBuilder()..update(updates))._build();
|
|
|
|
_$GCommitsRefCommitData._({required this.G__typename, required this.history})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefCommitData', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
history, r'GCommitsRefCommitData', 'history');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData rebuild(
|
|
void Function(GCommitsRefCommitDataBuilder) updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefCommitDataBuilder toBuilder() =>
|
|
new GCommitsRefCommitDataBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefCommitData &&
|
|
G__typename == other.G__typename &&
|
|
history == other.history;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), history.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(r'GCommitsRefCommitData')
|
|
..add('G__typename', G__typename)
|
|
..add('history', history))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefCommitDataBuilder
|
|
implements Builder<GCommitsRefCommitData, GCommitsRefCommitDataBuilder> {
|
|
_$GCommitsRefCommitData? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsRefCommitData_historyBuilder? _history;
|
|
GCommitsRefCommitData_historyBuilder get history =>
|
|
_$this._history ??= new GCommitsRefCommitData_historyBuilder();
|
|
set history(GCommitsRefCommitData_historyBuilder? history) =>
|
|
_$this._history = history;
|
|
|
|
GCommitsRefCommitDataBuilder() {
|
|
GCommitsRefCommitData._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefCommitDataBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_history = $v.history.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefCommitData other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefCommitData;
|
|
}
|
|
|
|
@override
|
|
void update(void Function(GCommitsRefCommitDataBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData build() => _build();
|
|
|
|
_$GCommitsRefCommitData _build() {
|
|
_$GCommitsRefCommitData _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsRefCommitData._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefCommitData', 'G__typename'),
|
|
history: history.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'history';
|
|
history.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsRefCommitData', _$failedField, e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history extends GCommitsRefCommitData_history {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsRefCommitData_history_pageInfo pageInfo;
|
|
@override
|
|
final BuiltList<GCommitsRefCommitData_history_nodes>? nodes;
|
|
|
|
factory _$GCommitsRefCommitData_history(
|
|
[void Function(GCommitsRefCommitData_historyBuilder)? updates]) =>
|
|
(new GCommitsRefCommitData_historyBuilder()..update(updates))._build();
|
|
|
|
_$GCommitsRefCommitData_history._(
|
|
{required this.G__typename, required this.pageInfo, this.nodes})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefCommitData_history', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
pageInfo, r'GCommitsRefCommitData_history', 'pageInfo');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history rebuild(
|
|
void Function(GCommitsRefCommitData_historyBuilder) updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefCommitData_historyBuilder toBuilder() =>
|
|
new GCommitsRefCommitData_historyBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefCommitData_history &&
|
|
G__typename == other.G__typename &&
|
|
pageInfo == other.pageInfo &&
|
|
nodes == other.nodes;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc($jc(0, G__typename.hashCode), pageInfo.hashCode), nodes.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(r'GCommitsRefCommitData_history')
|
|
..add('G__typename', G__typename)
|
|
..add('pageInfo', pageInfo)
|
|
..add('nodes', nodes))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefCommitData_historyBuilder
|
|
implements
|
|
Builder<GCommitsRefCommitData_history,
|
|
GCommitsRefCommitData_historyBuilder> {
|
|
_$GCommitsRefCommitData_history? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsRefCommitData_history_pageInfoBuilder? _pageInfo;
|
|
GCommitsRefCommitData_history_pageInfoBuilder get pageInfo =>
|
|
_$this._pageInfo ??= new GCommitsRefCommitData_history_pageInfoBuilder();
|
|
set pageInfo(GCommitsRefCommitData_history_pageInfoBuilder? pageInfo) =>
|
|
_$this._pageInfo = pageInfo;
|
|
|
|
ListBuilder<GCommitsRefCommitData_history_nodes>? _nodes;
|
|
ListBuilder<GCommitsRefCommitData_history_nodes> get nodes =>
|
|
_$this._nodes ??= new ListBuilder<GCommitsRefCommitData_history_nodes>();
|
|
set nodes(ListBuilder<GCommitsRefCommitData_history_nodes>? nodes) =>
|
|
_$this._nodes = nodes;
|
|
|
|
GCommitsRefCommitData_historyBuilder() {
|
|
GCommitsRefCommitData_history._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefCommitData_historyBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_pageInfo = $v.pageInfo.toBuilder();
|
|
_nodes = $v.nodes?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefCommitData_history other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefCommitData_history;
|
|
}
|
|
|
|
@override
|
|
void update(void Function(GCommitsRefCommitData_historyBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history build() => _build();
|
|
|
|
_$GCommitsRefCommitData_history _build() {
|
|
_$GCommitsRefCommitData_history _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsRefCommitData_history._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefCommitData_history', 'G__typename'),
|
|
pageInfo: pageInfo.build(),
|
|
nodes: _nodes?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'pageInfo';
|
|
pageInfo.build();
|
|
_$failedField = 'nodes';
|
|
_nodes?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsRefCommitData_history', _$failedField, e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_pageInfo
|
|
extends GCommitsRefCommitData_history_pageInfo {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final bool hasNextPage;
|
|
@override
|
|
final String? endCursor;
|
|
|
|
factory _$GCommitsRefCommitData_history_pageInfo(
|
|
[void Function(GCommitsRefCommitData_history_pageInfoBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefCommitData_history_pageInfoBuilder()..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefCommitData_history_pageInfo._(
|
|
{required this.G__typename, required this.hasNextPage, this.endCursor})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefCommitData_history_pageInfo', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
hasNextPage, r'GCommitsRefCommitData_history_pageInfo', 'hasNextPage');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_pageInfo rebuild(
|
|
void Function(GCommitsRefCommitData_history_pageInfoBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_pageInfoBuilder toBuilder() =>
|
|
new GCommitsRefCommitData_history_pageInfoBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefCommitData_history_pageInfo &&
|
|
G__typename == other.G__typename &&
|
|
hasNextPage == other.hasNextPage &&
|
|
endCursor == other.endCursor;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc($jc(0, G__typename.hashCode), hasNextPage.hashCode),
|
|
endCursor.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefCommitData_history_pageInfo')
|
|
..add('G__typename', G__typename)
|
|
..add('hasNextPage', hasNextPage)
|
|
..add('endCursor', endCursor))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefCommitData_history_pageInfoBuilder
|
|
implements
|
|
Builder<GCommitsRefCommitData_history_pageInfo,
|
|
GCommitsRefCommitData_history_pageInfoBuilder> {
|
|
_$GCommitsRefCommitData_history_pageInfo? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
bool? _hasNextPage;
|
|
bool? get hasNextPage => _$this._hasNextPage;
|
|
set hasNextPage(bool? hasNextPage) => _$this._hasNextPage = hasNextPage;
|
|
|
|
String? _endCursor;
|
|
String? get endCursor => _$this._endCursor;
|
|
set endCursor(String? endCursor) => _$this._endCursor = endCursor;
|
|
|
|
GCommitsRefCommitData_history_pageInfoBuilder() {
|
|
GCommitsRefCommitData_history_pageInfo._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefCommitData_history_pageInfoBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_hasNextPage = $v.hasNextPage;
|
|
_endCursor = $v.endCursor;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefCommitData_history_pageInfo other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefCommitData_history_pageInfo;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsRefCommitData_history_pageInfoBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_pageInfo build() => _build();
|
|
|
|
_$GCommitsRefCommitData_history_pageInfo _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsRefCommitData_history_pageInfo._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefCommitData_history_pageInfo', 'G__typename'),
|
|
hasNextPage: BuiltValueNullFieldError.checkNotNull(hasNextPage,
|
|
r'GCommitsRefCommitData_history_pageInfo', 'hasNextPage'),
|
|
endCursor: endCursor);
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_nodes
|
|
extends GCommitsRefCommitData_history_nodes {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String oid;
|
|
@override
|
|
final String messageHeadline;
|
|
@override
|
|
final DateTime committedDate;
|
|
@override
|
|
final GCommitsRefCommitData_history_nodes_author? author;
|
|
@override
|
|
final GCommitsRefCommitData_history_nodes_status? status;
|
|
|
|
factory _$GCommitsRefCommitData_history_nodes(
|
|
[void Function(GCommitsRefCommitData_history_nodesBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefCommitData_history_nodesBuilder()..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefCommitData_history_nodes._(
|
|
{required this.G__typename,
|
|
required this.oid,
|
|
required this.messageHeadline,
|
|
required this.committedDate,
|
|
this.author,
|
|
this.status})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefCommitData_history_nodes', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
oid, r'GCommitsRefCommitData_history_nodes', 'oid');
|
|
BuiltValueNullFieldError.checkNotNull(messageHeadline,
|
|
r'GCommitsRefCommitData_history_nodes', 'messageHeadline');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
committedDate, r'GCommitsRefCommitData_history_nodes', 'committedDate');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes rebuild(
|
|
void Function(GCommitsRefCommitData_history_nodesBuilder) updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodesBuilder toBuilder() =>
|
|
new GCommitsRefCommitData_history_nodesBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefCommitData_history_nodes &&
|
|
G__typename == other.G__typename &&
|
|
oid == other.oid &&
|
|
messageHeadline == other.messageHeadline &&
|
|
committedDate == other.committedDate &&
|
|
author == other.author &&
|
|
status == other.status;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc(
|
|
$jc(
|
|
$jc($jc($jc(0, G__typename.hashCode), oid.hashCode),
|
|
messageHeadline.hashCode),
|
|
committedDate.hashCode),
|
|
author.hashCode),
|
|
status.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(r'GCommitsRefCommitData_history_nodes')
|
|
..add('G__typename', G__typename)
|
|
..add('oid', oid)
|
|
..add('messageHeadline', messageHeadline)
|
|
..add('committedDate', committedDate)
|
|
..add('author', author)
|
|
..add('status', status))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefCommitData_history_nodesBuilder
|
|
implements
|
|
Builder<GCommitsRefCommitData_history_nodes,
|
|
GCommitsRefCommitData_history_nodesBuilder> {
|
|
_$GCommitsRefCommitData_history_nodes? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _oid;
|
|
String? get oid => _$this._oid;
|
|
set oid(String? oid) => _$this._oid = oid;
|
|
|
|
String? _messageHeadline;
|
|
String? get messageHeadline => _$this._messageHeadline;
|
|
set messageHeadline(String? messageHeadline) =>
|
|
_$this._messageHeadline = messageHeadline;
|
|
|
|
DateTime? _committedDate;
|
|
DateTime? get committedDate => _$this._committedDate;
|
|
set committedDate(DateTime? committedDate) =>
|
|
_$this._committedDate = committedDate;
|
|
|
|
GCommitsRefCommitData_history_nodes_authorBuilder? _author;
|
|
GCommitsRefCommitData_history_nodes_authorBuilder get author =>
|
|
_$this._author ??=
|
|
new GCommitsRefCommitData_history_nodes_authorBuilder();
|
|
set author(GCommitsRefCommitData_history_nodes_authorBuilder? author) =>
|
|
_$this._author = author;
|
|
|
|
GCommitsRefCommitData_history_nodes_statusBuilder? _status;
|
|
GCommitsRefCommitData_history_nodes_statusBuilder get status =>
|
|
_$this._status ??=
|
|
new GCommitsRefCommitData_history_nodes_statusBuilder();
|
|
set status(GCommitsRefCommitData_history_nodes_statusBuilder? status) =>
|
|
_$this._status = status;
|
|
|
|
GCommitsRefCommitData_history_nodesBuilder() {
|
|
GCommitsRefCommitData_history_nodes._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefCommitData_history_nodesBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_oid = $v.oid;
|
|
_messageHeadline = $v.messageHeadline;
|
|
_committedDate = $v.committedDate;
|
|
_author = $v.author?.toBuilder();
|
|
_status = $v.status?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefCommitData_history_nodes other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefCommitData_history_nodes;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsRefCommitData_history_nodesBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes build() => _build();
|
|
|
|
_$GCommitsRefCommitData_history_nodes _build() {
|
|
_$GCommitsRefCommitData_history_nodes _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsRefCommitData_history_nodes._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefCommitData_history_nodes', 'G__typename'),
|
|
oid: BuiltValueNullFieldError.checkNotNull(
|
|
oid, r'GCommitsRefCommitData_history_nodes', 'oid'),
|
|
messageHeadline: BuiltValueNullFieldError.checkNotNull(
|
|
messageHeadline,
|
|
r'GCommitsRefCommitData_history_nodes',
|
|
'messageHeadline'),
|
|
committedDate: BuiltValueNullFieldError.checkNotNull(
|
|
committedDate,
|
|
r'GCommitsRefCommitData_history_nodes',
|
|
'committedDate'),
|
|
author: _author?.build(),
|
|
status: _status?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'author';
|
|
_author?.build();
|
|
_$failedField = 'status';
|
|
_status?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsRefCommitData_history_nodes',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_nodes_author
|
|
extends GCommitsRefCommitData_history_nodes_author {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String? name;
|
|
@override
|
|
final String avatarUrl;
|
|
@override
|
|
final GCommitsRefCommitData_history_nodes_author_user? user;
|
|
|
|
factory _$GCommitsRefCommitData_history_nodes_author(
|
|
[void Function(GCommitsRefCommitData_history_nodes_authorBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefCommitData_history_nodes_authorBuilder()..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefCommitData_history_nodes_author._(
|
|
{required this.G__typename,
|
|
this.name,
|
|
required this.avatarUrl,
|
|
this.user})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefCommitData_history_nodes_author', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
avatarUrl, r'GCommitsRefCommitData_history_nodes_author', 'avatarUrl');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_author rebuild(
|
|
void Function(GCommitsRefCommitData_history_nodes_authorBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_authorBuilder toBuilder() =>
|
|
new GCommitsRefCommitData_history_nodes_authorBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefCommitData_history_nodes_author &&
|
|
G__typename == other.G__typename &&
|
|
name == other.name &&
|
|
avatarUrl == other.avatarUrl &&
|
|
user == other.user;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc($jc($jc(0, G__typename.hashCode), name.hashCode),
|
|
avatarUrl.hashCode),
|
|
user.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefCommitData_history_nodes_author')
|
|
..add('G__typename', G__typename)
|
|
..add('name', name)
|
|
..add('avatarUrl', avatarUrl)
|
|
..add('user', user))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefCommitData_history_nodes_authorBuilder
|
|
implements
|
|
Builder<GCommitsRefCommitData_history_nodes_author,
|
|
GCommitsRefCommitData_history_nodes_authorBuilder> {
|
|
_$GCommitsRefCommitData_history_nodes_author? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _name;
|
|
String? get name => _$this._name;
|
|
set name(String? name) => _$this._name = name;
|
|
|
|
String? _avatarUrl;
|
|
String? get avatarUrl => _$this._avatarUrl;
|
|
set avatarUrl(String? avatarUrl) => _$this._avatarUrl = avatarUrl;
|
|
|
|
GCommitsRefCommitData_history_nodes_author_userBuilder? _user;
|
|
GCommitsRefCommitData_history_nodes_author_userBuilder get user =>
|
|
_$this._user ??=
|
|
new GCommitsRefCommitData_history_nodes_author_userBuilder();
|
|
set user(GCommitsRefCommitData_history_nodes_author_userBuilder? user) =>
|
|
_$this._user = user;
|
|
|
|
GCommitsRefCommitData_history_nodes_authorBuilder() {
|
|
GCommitsRefCommitData_history_nodes_author._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefCommitData_history_nodes_authorBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_name = $v.name;
|
|
_avatarUrl = $v.avatarUrl;
|
|
_user = $v.user?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefCommitData_history_nodes_author other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefCommitData_history_nodes_author;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsRefCommitData_history_nodes_authorBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_author build() => _build();
|
|
|
|
_$GCommitsRefCommitData_history_nodes_author _build() {
|
|
_$GCommitsRefCommitData_history_nodes_author _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsRefCommitData_history_nodes_author._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefCommitData_history_nodes_author', 'G__typename'),
|
|
name: name,
|
|
avatarUrl: BuiltValueNullFieldError.checkNotNull(avatarUrl,
|
|
r'GCommitsRefCommitData_history_nodes_author', 'avatarUrl'),
|
|
user: _user?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'user';
|
|
_user?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsRefCommitData_history_nodes_author',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_nodes_author_user
|
|
extends GCommitsRefCommitData_history_nodes_author_user {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String login;
|
|
|
|
factory _$GCommitsRefCommitData_history_nodes_author_user(
|
|
[void Function(
|
|
GCommitsRefCommitData_history_nodes_author_userBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefCommitData_history_nodes_author_userBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefCommitData_history_nodes_author_user._(
|
|
{required this.G__typename, required this.login})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefCommitData_history_nodes_author_user', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
login, r'GCommitsRefCommitData_history_nodes_author_user', 'login');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_author_user rebuild(
|
|
void Function(GCommitsRefCommitData_history_nodes_author_userBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_author_userBuilder toBuilder() =>
|
|
new GCommitsRefCommitData_history_nodes_author_userBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefCommitData_history_nodes_author_user &&
|
|
G__typename == other.G__typename &&
|
|
login == other.login;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), login.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefCommitData_history_nodes_author_user')
|
|
..add('G__typename', G__typename)
|
|
..add('login', login))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefCommitData_history_nodes_author_userBuilder
|
|
implements
|
|
Builder<GCommitsRefCommitData_history_nodes_author_user,
|
|
GCommitsRefCommitData_history_nodes_author_userBuilder> {
|
|
_$GCommitsRefCommitData_history_nodes_author_user? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _login;
|
|
String? get login => _$this._login;
|
|
set login(String? login) => _$this._login = login;
|
|
|
|
GCommitsRefCommitData_history_nodes_author_userBuilder() {
|
|
GCommitsRefCommitData_history_nodes_author_user._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefCommitData_history_nodes_author_userBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_login = $v.login;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefCommitData_history_nodes_author_user other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefCommitData_history_nodes_author_user;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsRefCommitData_history_nodes_author_userBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_author_user build() => _build();
|
|
|
|
_$GCommitsRefCommitData_history_nodes_author_user _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsRefCommitData_history_nodes_author_user._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsRefCommitData_history_nodes_author_user',
|
|
'G__typename'),
|
|
login: BuiltValueNullFieldError.checkNotNull(login,
|
|
r'GCommitsRefCommitData_history_nodes_author_user', 'login'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefCommitData_history_nodes_status
|
|
extends GCommitsRefCommitData_history_nodes_status {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final _i3.GStatusState state;
|
|
|
|
factory _$GCommitsRefCommitData_history_nodes_status(
|
|
[void Function(GCommitsRefCommitData_history_nodes_statusBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefCommitData_history_nodes_statusBuilder()..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefCommitData_history_nodes_status._(
|
|
{required this.G__typename, required this.state})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefCommitData_history_nodes_status', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
state, r'GCommitsRefCommitData_history_nodes_status', 'state');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_status rebuild(
|
|
void Function(GCommitsRefCommitData_history_nodes_statusBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_statusBuilder toBuilder() =>
|
|
new GCommitsRefCommitData_history_nodes_statusBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefCommitData_history_nodes_status &&
|
|
G__typename == other.G__typename &&
|
|
state == other.state;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), state.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefCommitData_history_nodes_status')
|
|
..add('G__typename', G__typename)
|
|
..add('state', state))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefCommitData_history_nodes_statusBuilder
|
|
implements
|
|
Builder<GCommitsRefCommitData_history_nodes_status,
|
|
GCommitsRefCommitData_history_nodes_statusBuilder> {
|
|
_$GCommitsRefCommitData_history_nodes_status? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
_i3.GStatusState? _state;
|
|
_i3.GStatusState? get state => _$this._state;
|
|
set state(_i3.GStatusState? state) => _$this._state = state;
|
|
|
|
GCommitsRefCommitData_history_nodes_statusBuilder() {
|
|
GCommitsRefCommitData_history_nodes_status._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefCommitData_history_nodes_statusBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_state = $v.state;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefCommitData_history_nodes_status other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefCommitData_history_nodes_status;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsRefCommitData_history_nodes_statusBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefCommitData_history_nodes_status build() => _build();
|
|
|
|
_$GCommitsRefCommitData_history_nodes_status _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsRefCommitData_history_nodes_status._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefCommitData_history_nodes_status', 'G__typename'),
|
|
state: BuiltValueNullFieldError.checkNotNull(
|
|
state, r'GCommitsRefCommitData_history_nodes_status', 'state'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData extends GCommitsRefData {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsRefData_target? target;
|
|
|
|
factory _$GCommitsRefData([void Function(GCommitsRefDataBuilder)? updates]) =>
|
|
(new GCommitsRefDataBuilder()..update(updates))._build();
|
|
|
|
_$GCommitsRefData._({required this.G__typename, this.target}) : super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefData', 'G__typename');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData rebuild(void Function(GCommitsRefDataBuilder) updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefDataBuilder toBuilder() =>
|
|
new GCommitsRefDataBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefData &&
|
|
G__typename == other.G__typename &&
|
|
target == other.target;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), target.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(r'GCommitsRefData')
|
|
..add('G__typename', G__typename)
|
|
..add('target', target))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefDataBuilder
|
|
implements Builder<GCommitsRefData, GCommitsRefDataBuilder> {
|
|
_$GCommitsRefData? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsRefData_target? _target;
|
|
GCommitsRefData_target? get target => _$this._target;
|
|
set target(GCommitsRefData_target? target) => _$this._target = target;
|
|
|
|
GCommitsRefDataBuilder() {
|
|
GCommitsRefData._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefDataBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_target = $v.target;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefData other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefData;
|
|
}
|
|
|
|
@override
|
|
void update(void Function(GCommitsRefDataBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData build() => _build();
|
|
|
|
_$GCommitsRefData _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsRefData._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefData', 'G__typename'),
|
|
target: target);
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__base extends GCommitsRefData_target__base {
|
|
@override
|
|
final String G__typename;
|
|
|
|
factory _$GCommitsRefData_target__base(
|
|
[void Function(GCommitsRefData_target__baseBuilder)? updates]) =>
|
|
(new GCommitsRefData_target__baseBuilder()..update(updates))._build();
|
|
|
|
_$GCommitsRefData_target__base._({required this.G__typename}) : super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefData_target__base', 'G__typename');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__base rebuild(
|
|
void Function(GCommitsRefData_target__baseBuilder) updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefData_target__baseBuilder toBuilder() =>
|
|
new GCommitsRefData_target__baseBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefData_target__base &&
|
|
G__typename == other.G__typename;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(0, G__typename.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(r'GCommitsRefData_target__base')
|
|
..add('G__typename', G__typename))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefData_target__baseBuilder
|
|
implements
|
|
Builder<GCommitsRefData_target__base,
|
|
GCommitsRefData_target__baseBuilder> {
|
|
_$GCommitsRefData_target__base? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsRefData_target__baseBuilder() {
|
|
GCommitsRefData_target__base._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefData_target__baseBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefData_target__base other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefData_target__base;
|
|
}
|
|
|
|
@override
|
|
void update(void Function(GCommitsRefData_target__baseBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__base build() => _build();
|
|
|
|
_$GCommitsRefData_target__base _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsRefData_target__base._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefData_target__base', 'G__typename'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit
|
|
extends GCommitsRefData_target__asCommit {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsRefData_target__asCommit_history history;
|
|
|
|
factory _$GCommitsRefData_target__asCommit(
|
|
[void Function(GCommitsRefData_target__asCommitBuilder)? updates]) =>
|
|
(new GCommitsRefData_target__asCommitBuilder()..update(updates))._build();
|
|
|
|
_$GCommitsRefData_target__asCommit._(
|
|
{required this.G__typename, required this.history})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename, r'GCommitsRefData_target__asCommit', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
history, r'GCommitsRefData_target__asCommit', 'history');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit rebuild(
|
|
void Function(GCommitsRefData_target__asCommitBuilder) updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommitBuilder toBuilder() =>
|
|
new GCommitsRefData_target__asCommitBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefData_target__asCommit &&
|
|
G__typename == other.G__typename &&
|
|
history == other.history;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), history.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(r'GCommitsRefData_target__asCommit')
|
|
..add('G__typename', G__typename)
|
|
..add('history', history))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefData_target__asCommitBuilder
|
|
implements
|
|
Builder<GCommitsRefData_target__asCommit,
|
|
GCommitsRefData_target__asCommitBuilder> {
|
|
_$GCommitsRefData_target__asCommit? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsRefData_target__asCommit_historyBuilder? _history;
|
|
GCommitsRefData_target__asCommit_historyBuilder get history =>
|
|
_$this._history ??= new GCommitsRefData_target__asCommit_historyBuilder();
|
|
set history(GCommitsRefData_target__asCommit_historyBuilder? history) =>
|
|
_$this._history = history;
|
|
|
|
GCommitsRefData_target__asCommitBuilder() {
|
|
GCommitsRefData_target__asCommit._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefData_target__asCommitBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_history = $v.history.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefData_target__asCommit other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefData_target__asCommit;
|
|
}
|
|
|
|
@override
|
|
void update(void Function(GCommitsRefData_target__asCommitBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit build() => _build();
|
|
|
|
_$GCommitsRefData_target__asCommit _build() {
|
|
_$GCommitsRefData_target__asCommit _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsRefData_target__asCommit._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefData_target__asCommit', 'G__typename'),
|
|
history: history.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'history';
|
|
history.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsRefData_target__asCommit', _$failedField, e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history
|
|
extends GCommitsRefData_target__asCommit_history {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final GCommitsRefData_target__asCommit_history_pageInfo pageInfo;
|
|
@override
|
|
final BuiltList<GCommitsRefData_target__asCommit_history_nodes>? nodes;
|
|
|
|
factory _$GCommitsRefData_target__asCommit_history(
|
|
[void Function(GCommitsRefData_target__asCommit_historyBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefData_target__asCommit_historyBuilder()..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history._(
|
|
{required this.G__typename, required this.pageInfo, this.nodes})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefData_target__asCommit_history', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
pageInfo, r'GCommitsRefData_target__asCommit_history', 'pageInfo');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history rebuild(
|
|
void Function(GCommitsRefData_target__asCommit_historyBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_historyBuilder toBuilder() =>
|
|
new GCommitsRefData_target__asCommit_historyBuilder()..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefData_target__asCommit_history &&
|
|
G__typename == other.G__typename &&
|
|
pageInfo == other.pageInfo &&
|
|
nodes == other.nodes;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc($jc(0, G__typename.hashCode), pageInfo.hashCode), nodes.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefData_target__asCommit_history')
|
|
..add('G__typename', G__typename)
|
|
..add('pageInfo', pageInfo)
|
|
..add('nodes', nodes))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefData_target__asCommit_historyBuilder
|
|
implements
|
|
Builder<GCommitsRefData_target__asCommit_history,
|
|
GCommitsRefData_target__asCommit_historyBuilder> {
|
|
_$GCommitsRefData_target__asCommit_history? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
GCommitsRefData_target__asCommit_history_pageInfoBuilder? _pageInfo;
|
|
GCommitsRefData_target__asCommit_history_pageInfoBuilder get pageInfo =>
|
|
_$this._pageInfo ??=
|
|
new GCommitsRefData_target__asCommit_history_pageInfoBuilder();
|
|
set pageInfo(
|
|
GCommitsRefData_target__asCommit_history_pageInfoBuilder? pageInfo) =>
|
|
_$this._pageInfo = pageInfo;
|
|
|
|
ListBuilder<GCommitsRefData_target__asCommit_history_nodes>? _nodes;
|
|
ListBuilder<GCommitsRefData_target__asCommit_history_nodes> get nodes =>
|
|
_$this._nodes ??=
|
|
new ListBuilder<GCommitsRefData_target__asCommit_history_nodes>();
|
|
set nodes(
|
|
ListBuilder<GCommitsRefData_target__asCommit_history_nodes>? nodes) =>
|
|
_$this._nodes = nodes;
|
|
|
|
GCommitsRefData_target__asCommit_historyBuilder() {
|
|
GCommitsRefData_target__asCommit_history._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefData_target__asCommit_historyBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_pageInfo = $v.pageInfo.toBuilder();
|
|
_nodes = $v.nodes?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefData_target__asCommit_history other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefData_target__asCommit_history;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsRefData_target__asCommit_historyBuilder)? updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history build() => _build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history _build() {
|
|
_$GCommitsRefData_target__asCommit_history _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsRefData_target__asCommit_history._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefData_target__asCommit_history', 'G__typename'),
|
|
pageInfo: pageInfo.build(),
|
|
nodes: _nodes?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'pageInfo';
|
|
pageInfo.build();
|
|
_$failedField = 'nodes';
|
|
_nodes?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsRefData_target__asCommit_history',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_pageInfo
|
|
extends GCommitsRefData_target__asCommit_history_pageInfo {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final bool hasNextPage;
|
|
@override
|
|
final String? endCursor;
|
|
|
|
factory _$GCommitsRefData_target__asCommit_history_pageInfo(
|
|
[void Function(
|
|
GCommitsRefData_target__asCommit_history_pageInfoBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefData_target__asCommit_history_pageInfoBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_pageInfo._(
|
|
{required this.G__typename, required this.hasNextPage, this.endCursor})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_pageInfo', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(hasNextPage,
|
|
r'GCommitsRefData_target__asCommit_history_pageInfo', 'hasNextPage');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_pageInfo rebuild(
|
|
void Function(
|
|
GCommitsRefData_target__asCommit_history_pageInfoBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_pageInfoBuilder toBuilder() =>
|
|
new GCommitsRefData_target__asCommit_history_pageInfoBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefData_target__asCommit_history_pageInfo &&
|
|
G__typename == other.G__typename &&
|
|
hasNextPage == other.hasNextPage &&
|
|
endCursor == other.endCursor;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc($jc(0, G__typename.hashCode), hasNextPage.hashCode),
|
|
endCursor.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefData_target__asCommit_history_pageInfo')
|
|
..add('G__typename', G__typename)
|
|
..add('hasNextPage', hasNextPage)
|
|
..add('endCursor', endCursor))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefData_target__asCommit_history_pageInfoBuilder
|
|
implements
|
|
Builder<GCommitsRefData_target__asCommit_history_pageInfo,
|
|
GCommitsRefData_target__asCommit_history_pageInfoBuilder> {
|
|
_$GCommitsRefData_target__asCommit_history_pageInfo? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
bool? _hasNextPage;
|
|
bool? get hasNextPage => _$this._hasNextPage;
|
|
set hasNextPage(bool? hasNextPage) => _$this._hasNextPage = hasNextPage;
|
|
|
|
String? _endCursor;
|
|
String? get endCursor => _$this._endCursor;
|
|
set endCursor(String? endCursor) => _$this._endCursor = endCursor;
|
|
|
|
GCommitsRefData_target__asCommit_history_pageInfoBuilder() {
|
|
GCommitsRefData_target__asCommit_history_pageInfo._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefData_target__asCommit_history_pageInfoBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_hasNextPage = $v.hasNextPage;
|
|
_endCursor = $v.endCursor;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefData_target__asCommit_history_pageInfo other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefData_target__asCommit_history_pageInfo;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsRefData_target__asCommit_history_pageInfoBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_pageInfo build() => _build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_pageInfo _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsRefData_target__asCommit_history_pageInfo._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_pageInfo',
|
|
'G__typename'),
|
|
hasNextPage: BuiltValueNullFieldError.checkNotNull(
|
|
hasNextPage,
|
|
r'GCommitsRefData_target__asCommit_history_pageInfo',
|
|
'hasNextPage'),
|
|
endCursor: endCursor);
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_nodes
|
|
extends GCommitsRefData_target__asCommit_history_nodes {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String oid;
|
|
@override
|
|
final String messageHeadline;
|
|
@override
|
|
final DateTime committedDate;
|
|
@override
|
|
final GCommitsRefData_target__asCommit_history_nodes_author? author;
|
|
@override
|
|
final GCommitsRefData_target__asCommit_history_nodes_status? status;
|
|
|
|
factory _$GCommitsRefData_target__asCommit_history_nodes(
|
|
[void Function(GCommitsRefData_target__asCommit_history_nodesBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefData_target__asCommit_history_nodesBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_nodes._(
|
|
{required this.G__typename,
|
|
required this.oid,
|
|
required this.messageHeadline,
|
|
required this.committedDate,
|
|
this.author,
|
|
this.status})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_nodes', 'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
oid, r'GCommitsRefData_target__asCommit_history_nodes', 'oid');
|
|
BuiltValueNullFieldError.checkNotNull(messageHeadline,
|
|
r'GCommitsRefData_target__asCommit_history_nodes', 'messageHeadline');
|
|
BuiltValueNullFieldError.checkNotNull(committedDate,
|
|
r'GCommitsRefData_target__asCommit_history_nodes', 'committedDate');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes rebuild(
|
|
void Function(GCommitsRefData_target__asCommit_history_nodesBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodesBuilder toBuilder() =>
|
|
new GCommitsRefData_target__asCommit_history_nodesBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefData_target__asCommit_history_nodes &&
|
|
G__typename == other.G__typename &&
|
|
oid == other.oid &&
|
|
messageHeadline == other.messageHeadline &&
|
|
committedDate == other.committedDate &&
|
|
author == other.author &&
|
|
status == other.status;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc(
|
|
$jc(
|
|
$jc($jc($jc(0, G__typename.hashCode), oid.hashCode),
|
|
messageHeadline.hashCode),
|
|
committedDate.hashCode),
|
|
author.hashCode),
|
|
status.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefData_target__asCommit_history_nodes')
|
|
..add('G__typename', G__typename)
|
|
..add('oid', oid)
|
|
..add('messageHeadline', messageHeadline)
|
|
..add('committedDate', committedDate)
|
|
..add('author', author)
|
|
..add('status', status))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefData_target__asCommit_history_nodesBuilder
|
|
implements
|
|
Builder<GCommitsRefData_target__asCommit_history_nodes,
|
|
GCommitsRefData_target__asCommit_history_nodesBuilder> {
|
|
_$GCommitsRefData_target__asCommit_history_nodes? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _oid;
|
|
String? get oid => _$this._oid;
|
|
set oid(String? oid) => _$this._oid = oid;
|
|
|
|
String? _messageHeadline;
|
|
String? get messageHeadline => _$this._messageHeadline;
|
|
set messageHeadline(String? messageHeadline) =>
|
|
_$this._messageHeadline = messageHeadline;
|
|
|
|
DateTime? _committedDate;
|
|
DateTime? get committedDate => _$this._committedDate;
|
|
set committedDate(DateTime? committedDate) =>
|
|
_$this._committedDate = committedDate;
|
|
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder? _author;
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder get author =>
|
|
_$this._author ??=
|
|
new GCommitsRefData_target__asCommit_history_nodes_authorBuilder();
|
|
set author(
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder?
|
|
author) =>
|
|
_$this._author = author;
|
|
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder? _status;
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder get status =>
|
|
_$this._status ??=
|
|
new GCommitsRefData_target__asCommit_history_nodes_statusBuilder();
|
|
set status(
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder?
|
|
status) =>
|
|
_$this._status = status;
|
|
|
|
GCommitsRefData_target__asCommit_history_nodesBuilder() {
|
|
GCommitsRefData_target__asCommit_history_nodes._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefData_target__asCommit_history_nodesBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_oid = $v.oid;
|
|
_messageHeadline = $v.messageHeadline;
|
|
_committedDate = $v.committedDate;
|
|
_author = $v.author?.toBuilder();
|
|
_status = $v.status?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefData_target__asCommit_history_nodes other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefData_target__asCommit_history_nodes;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(GCommitsRefData_target__asCommit_history_nodesBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes build() => _build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_nodes _build() {
|
|
_$GCommitsRefData_target__asCommit_history_nodes _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsRefData_target__asCommit_history_nodes._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_nodes',
|
|
'G__typename'),
|
|
oid: BuiltValueNullFieldError.checkNotNull(oid,
|
|
r'GCommitsRefData_target__asCommit_history_nodes', 'oid'),
|
|
messageHeadline: BuiltValueNullFieldError.checkNotNull(
|
|
messageHeadline,
|
|
r'GCommitsRefData_target__asCommit_history_nodes',
|
|
'messageHeadline'),
|
|
committedDate: BuiltValueNullFieldError.checkNotNull(
|
|
committedDate,
|
|
r'GCommitsRefData_target__asCommit_history_nodes',
|
|
'committedDate'),
|
|
author: _author?.build(),
|
|
status: _status?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'author';
|
|
_author?.build();
|
|
_$failedField = 'status';
|
|
_status?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsRefData_target__asCommit_history_nodes',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_nodes_author
|
|
extends GCommitsRefData_target__asCommit_history_nodes_author {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String? name;
|
|
@override
|
|
final String avatarUrl;
|
|
@override
|
|
final GCommitsRefData_target__asCommit_history_nodes_author_user? user;
|
|
|
|
factory _$GCommitsRefData_target__asCommit_history_nodes_author(
|
|
[void Function(
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefData_target__asCommit_history_nodes_authorBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_nodes_author._(
|
|
{required this.G__typename,
|
|
this.name,
|
|
required this.avatarUrl,
|
|
this.user})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(avatarUrl,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author', 'avatarUrl');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_author rebuild(
|
|
void Function(
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder toBuilder() =>
|
|
new GCommitsRefData_target__asCommit_history_nodes_authorBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefData_target__asCommit_history_nodes_author &&
|
|
G__typename == other.G__typename &&
|
|
name == other.name &&
|
|
avatarUrl == other.avatarUrl &&
|
|
user == other.user;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc(
|
|
$jc($jc($jc(0, G__typename.hashCode), name.hashCode),
|
|
avatarUrl.hashCode),
|
|
user.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author')
|
|
..add('G__typename', G__typename)
|
|
..add('name', name)
|
|
..add('avatarUrl', avatarUrl)
|
|
..add('user', user))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefData_target__asCommit_history_nodes_authorBuilder
|
|
implements
|
|
Builder<GCommitsRefData_target__asCommit_history_nodes_author,
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder> {
|
|
_$GCommitsRefData_target__asCommit_history_nodes_author? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _name;
|
|
String? get name => _$this._name;
|
|
set name(String? name) => _$this._name = name;
|
|
|
|
String? _avatarUrl;
|
|
String? get avatarUrl => _$this._avatarUrl;
|
|
set avatarUrl(String? avatarUrl) => _$this._avatarUrl = avatarUrl;
|
|
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder? _user;
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder get user =>
|
|
_$this._user ??=
|
|
new GCommitsRefData_target__asCommit_history_nodes_author_userBuilder();
|
|
set user(
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder?
|
|
user) =>
|
|
_$this._user = user;
|
|
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder() {
|
|
GCommitsRefData_target__asCommit_history_nodes_author._initializeBuilder(
|
|
this);
|
|
}
|
|
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_name = $v.name;
|
|
_avatarUrl = $v.avatarUrl;
|
|
_user = $v.user?.toBuilder();
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefData_target__asCommit_history_nodes_author other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefData_target__asCommit_history_nodes_author;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsRefData_target__asCommit_history_nodes_authorBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_author build() => _build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_nodes_author _build() {
|
|
_$GCommitsRefData_target__asCommit_history_nodes_author _$result;
|
|
try {
|
|
_$result = _$v ??
|
|
new _$GCommitsRefData_target__asCommit_history_nodes_author._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author',
|
|
'G__typename'),
|
|
name: name,
|
|
avatarUrl: BuiltValueNullFieldError.checkNotNull(
|
|
avatarUrl,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author',
|
|
'avatarUrl'),
|
|
user: _user?.build());
|
|
} catch (_) {
|
|
late String _$failedField;
|
|
try {
|
|
_$failedField = 'user';
|
|
_user?.build();
|
|
} catch (e) {
|
|
throw new BuiltValueNestedFieldError(
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author',
|
|
_$failedField,
|
|
e.toString());
|
|
}
|
|
rethrow;
|
|
}
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_nodes_author_user
|
|
extends GCommitsRefData_target__asCommit_history_nodes_author_user {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final String login;
|
|
|
|
factory _$GCommitsRefData_target__asCommit_history_nodes_author_user(
|
|
[void Function(
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefData_target__asCommit_history_nodes_author_userBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_nodes_author_user._(
|
|
{required this.G__typename, required this.login})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author_user',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(login,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author_user', 'login');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user rebuild(
|
|
void Function(
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder
|
|
toBuilder() =>
|
|
new GCommitsRefData_target__asCommit_history_nodes_author_userBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other
|
|
is GCommitsRefData_target__asCommit_history_nodes_author_user &&
|
|
G__typename == other.G__typename &&
|
|
login == other.login;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), login.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author_user')
|
|
..add('G__typename', G__typename)
|
|
..add('login', login))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefData_target__asCommit_history_nodes_author_userBuilder
|
|
implements
|
|
Builder<GCommitsRefData_target__asCommit_history_nodes_author_user,
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder> {
|
|
_$GCommitsRefData_target__asCommit_history_nodes_author_user? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
String? _login;
|
|
String? get login => _$this._login;
|
|
set login(String? login) => _$this._login = login;
|
|
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder() {
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user
|
|
._initializeBuilder(this);
|
|
}
|
|
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_login = $v.login;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefData_target__asCommit_history_nodes_author_user;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsRefData_target__asCommit_history_nodes_author_userBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_author_user build() =>
|
|
_build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_nodes_author_user _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsRefData_target__asCommit_history_nodes_author_user._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author_user',
|
|
'G__typename'),
|
|
login: BuiltValueNullFieldError.checkNotNull(
|
|
login,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_author_user',
|
|
'login'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
class _$GCommitsRefData_target__asCommit_history_nodes_status
|
|
extends GCommitsRefData_target__asCommit_history_nodes_status {
|
|
@override
|
|
final String G__typename;
|
|
@override
|
|
final _i3.GStatusState state;
|
|
|
|
factory _$GCommitsRefData_target__asCommit_history_nodes_status(
|
|
[void Function(
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder)?
|
|
updates]) =>
|
|
(new GCommitsRefData_target__asCommit_history_nodes_statusBuilder()
|
|
..update(updates))
|
|
._build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_nodes_status._(
|
|
{required this.G__typename, required this.state})
|
|
: super._() {
|
|
BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_status',
|
|
'G__typename');
|
|
BuiltValueNullFieldError.checkNotNull(state,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_status', 'state');
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_status rebuild(
|
|
void Function(
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder)
|
|
updates) =>
|
|
(toBuilder()..update(updates)).build();
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder toBuilder() =>
|
|
new GCommitsRefData_target__asCommit_history_nodes_statusBuilder()
|
|
..replace(this);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(other, this)) return true;
|
|
return other is GCommitsRefData_target__asCommit_history_nodes_status &&
|
|
G__typename == other.G__typename &&
|
|
state == other.state;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return $jf($jc($jc(0, G__typename.hashCode), state.hashCode));
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (newBuiltValueToStringHelper(
|
|
r'GCommitsRefData_target__asCommit_history_nodes_status')
|
|
..add('G__typename', G__typename)
|
|
..add('state', state))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class GCommitsRefData_target__asCommit_history_nodes_statusBuilder
|
|
implements
|
|
Builder<GCommitsRefData_target__asCommit_history_nodes_status,
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder> {
|
|
_$GCommitsRefData_target__asCommit_history_nodes_status? _$v;
|
|
|
|
String? _G__typename;
|
|
String? get G__typename => _$this._G__typename;
|
|
set G__typename(String? G__typename) => _$this._G__typename = G__typename;
|
|
|
|
_i3.GStatusState? _state;
|
|
_i3.GStatusState? get state => _$this._state;
|
|
set state(_i3.GStatusState? state) => _$this._state = state;
|
|
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder() {
|
|
GCommitsRefData_target__asCommit_history_nodes_status._initializeBuilder(
|
|
this);
|
|
}
|
|
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder get _$this {
|
|
final $v = _$v;
|
|
if ($v != null) {
|
|
_G__typename = $v.G__typename;
|
|
_state = $v.state;
|
|
_$v = null;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
void replace(GCommitsRefData_target__asCommit_history_nodes_status other) {
|
|
ArgumentError.checkNotNull(other, 'other');
|
|
_$v = other as _$GCommitsRefData_target__asCommit_history_nodes_status;
|
|
}
|
|
|
|
@override
|
|
void update(
|
|
void Function(
|
|
GCommitsRefData_target__asCommit_history_nodes_statusBuilder)?
|
|
updates) {
|
|
if (updates != null) updates(this);
|
|
}
|
|
|
|
@override
|
|
GCommitsRefData_target__asCommit_history_nodes_status build() => _build();
|
|
|
|
_$GCommitsRefData_target__asCommit_history_nodes_status _build() {
|
|
final _$result = _$v ??
|
|
new _$GCommitsRefData_target__asCommit_history_nodes_status._(
|
|
G__typename: BuiltValueNullFieldError.checkNotNull(
|
|
G__typename,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_status',
|
|
'G__typename'),
|
|
state: BuiltValueNullFieldError.checkNotNull(
|
|
state,
|
|
r'GCommitsRefData_target__asCommit_history_nodes_status',
|
|
'state'));
|
|
replace(_$result);
|
|
return _$result;
|
|
}
|
|
}
|
|
|
|
// ignore_for_file: always_put_control_body_on_new_line,always_specify_types,annotate_overrides,avoid_annotating_with_dynamic,avoid_as,avoid_catches_without_on_clauses,avoid_returning_this,deprecated_member_use_from_same_package,lines_longer_than_80_chars,no_leading_underscores_for_local_identifiers,omit_local_variable_types,prefer_expression_function_bodies,sort_constructors_first,test_types_in_equals,unnecessary_const,unnecessary_new,unnecessary_lambdas
|