royalcat
0d7aac068c
All checks were successful
docker / build-docker (linux/amd64) (push) Successful in 1m39s
docker / build-docker (linux/386) (push) Successful in 1m46s
docker / build-docker (linux/arm64/v8) (push) Successful in 8m18s
docker / build-docker (linux/arm64) (push) Successful in 8m29s
docker / build-docker (linux/arm/v7) (push) Successful in 8m49s
1579 lines
42 KiB
Dart
1579 lines
42 KiB
Dart
// ignore_for_file: type=lint
|
|
class Input$BooleanFilter {
|
|
factory Input$BooleanFilter({bool? eq}) => Input$BooleanFilter._({
|
|
if (eq != null) r'eq': eq,
|
|
});
|
|
|
|
Input$BooleanFilter._(this._$data);
|
|
|
|
factory Input$BooleanFilter.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
if (data.containsKey('eq')) {
|
|
final l$eq = data['eq'];
|
|
result$data['eq'] = (l$eq as bool?);
|
|
}
|
|
return Input$BooleanFilter._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
bool? get eq => (_$data['eq'] as bool?);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
if (_$data.containsKey('eq')) {
|
|
final l$eq = eq;
|
|
result$data['eq'] = l$eq;
|
|
}
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Input$BooleanFilter<Input$BooleanFilter> get copyWith =>
|
|
CopyWith$Input$BooleanFilter(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) {
|
|
return true;
|
|
}
|
|
if (!(other is Input$BooleanFilter) || runtimeType != other.runtimeType) {
|
|
return false;
|
|
}
|
|
final l$eq = eq;
|
|
final lOther$eq = other.eq;
|
|
if (_$data.containsKey('eq') != other._$data.containsKey('eq')) {
|
|
return false;
|
|
}
|
|
if (l$eq != lOther$eq) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$eq = eq;
|
|
return Object.hashAll([_$data.containsKey('eq') ? l$eq : const {}]);
|
|
}
|
|
}
|
|
|
|
abstract class CopyWith$Input$BooleanFilter<TRes> {
|
|
factory CopyWith$Input$BooleanFilter(
|
|
Input$BooleanFilter instance,
|
|
TRes Function(Input$BooleanFilter) then,
|
|
) = _CopyWithImpl$Input$BooleanFilter;
|
|
|
|
factory CopyWith$Input$BooleanFilter.stub(TRes res) =
|
|
_CopyWithStubImpl$Input$BooleanFilter;
|
|
|
|
TRes call({bool? eq});
|
|
}
|
|
|
|
class _CopyWithImpl$Input$BooleanFilter<TRes>
|
|
implements CopyWith$Input$BooleanFilter<TRes> {
|
|
_CopyWithImpl$Input$BooleanFilter(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Input$BooleanFilter _instance;
|
|
|
|
final TRes Function(Input$BooleanFilter) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({Object? eq = _undefined}) => _then(Input$BooleanFilter._({
|
|
..._instance._$data,
|
|
if (eq != _undefined) 'eq': (eq as bool?),
|
|
}));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Input$BooleanFilter<TRes>
|
|
implements CopyWith$Input$BooleanFilter<TRes> {
|
|
_CopyWithStubImpl$Input$BooleanFilter(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({bool? eq}) => _res;
|
|
}
|
|
|
|
class Input$DateTimeFilter {
|
|
factory Input$DateTimeFilter({
|
|
DateTime? eq,
|
|
DateTime? gt,
|
|
DateTime? lt,
|
|
DateTime? gte,
|
|
DateTime? lte,
|
|
}) =>
|
|
Input$DateTimeFilter._({
|
|
if (eq != null) r'eq': eq,
|
|
if (gt != null) r'gt': gt,
|
|
if (lt != null) r'lt': lt,
|
|
if (gte != null) r'gte': gte,
|
|
if (lte != null) r'lte': lte,
|
|
});
|
|
|
|
Input$DateTimeFilter._(this._$data);
|
|
|
|
factory Input$DateTimeFilter.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
if (data.containsKey('eq')) {
|
|
final l$eq = data['eq'];
|
|
result$data['eq'] =
|
|
l$eq == null ? null : DateTime.parse((l$eq as String));
|
|
}
|
|
if (data.containsKey('gt')) {
|
|
final l$gt = data['gt'];
|
|
result$data['gt'] =
|
|
l$gt == null ? null : DateTime.parse((l$gt as String));
|
|
}
|
|
if (data.containsKey('lt')) {
|
|
final l$lt = data['lt'];
|
|
result$data['lt'] =
|
|
l$lt == null ? null : DateTime.parse((l$lt as String));
|
|
}
|
|
if (data.containsKey('gte')) {
|
|
final l$gte = data['gte'];
|
|
result$data['gte'] =
|
|
l$gte == null ? null : DateTime.parse((l$gte as String));
|
|
}
|
|
if (data.containsKey('lte')) {
|
|
final l$lte = data['lte'];
|
|
result$data['lte'] =
|
|
l$lte == null ? null : DateTime.parse((l$lte as String));
|
|
}
|
|
return Input$DateTimeFilter._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
DateTime? get eq => (_$data['eq'] as DateTime?);
|
|
|
|
DateTime? get gt => (_$data['gt'] as DateTime?);
|
|
|
|
DateTime? get lt => (_$data['lt'] as DateTime?);
|
|
|
|
DateTime? get gte => (_$data['gte'] as DateTime?);
|
|
|
|
DateTime? get lte => (_$data['lte'] as DateTime?);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
if (_$data.containsKey('eq')) {
|
|
final l$eq = eq;
|
|
result$data['eq'] = l$eq?.toIso8601String();
|
|
}
|
|
if (_$data.containsKey('gt')) {
|
|
final l$gt = gt;
|
|
result$data['gt'] = l$gt?.toIso8601String();
|
|
}
|
|
if (_$data.containsKey('lt')) {
|
|
final l$lt = lt;
|
|
result$data['lt'] = l$lt?.toIso8601String();
|
|
}
|
|
if (_$data.containsKey('gte')) {
|
|
final l$gte = gte;
|
|
result$data['gte'] = l$gte?.toIso8601String();
|
|
}
|
|
if (_$data.containsKey('lte')) {
|
|
final l$lte = lte;
|
|
result$data['lte'] = l$lte?.toIso8601String();
|
|
}
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Input$DateTimeFilter<Input$DateTimeFilter> get copyWith =>
|
|
CopyWith$Input$DateTimeFilter(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) {
|
|
return true;
|
|
}
|
|
if (!(other is Input$DateTimeFilter) || runtimeType != other.runtimeType) {
|
|
return false;
|
|
}
|
|
final l$eq = eq;
|
|
final lOther$eq = other.eq;
|
|
if (_$data.containsKey('eq') != other._$data.containsKey('eq')) {
|
|
return false;
|
|
}
|
|
if (l$eq != lOther$eq) {
|
|
return false;
|
|
}
|
|
final l$gt = gt;
|
|
final lOther$gt = other.gt;
|
|
if (_$data.containsKey('gt') != other._$data.containsKey('gt')) {
|
|
return false;
|
|
}
|
|
if (l$gt != lOther$gt) {
|
|
return false;
|
|
}
|
|
final l$lt = lt;
|
|
final lOther$lt = other.lt;
|
|
if (_$data.containsKey('lt') != other._$data.containsKey('lt')) {
|
|
return false;
|
|
}
|
|
if (l$lt != lOther$lt) {
|
|
return false;
|
|
}
|
|
final l$gte = gte;
|
|
final lOther$gte = other.gte;
|
|
if (_$data.containsKey('gte') != other._$data.containsKey('gte')) {
|
|
return false;
|
|
}
|
|
if (l$gte != lOther$gte) {
|
|
return false;
|
|
}
|
|
final l$lte = lte;
|
|
final lOther$lte = other.lte;
|
|
if (_$data.containsKey('lte') != other._$data.containsKey('lte')) {
|
|
return false;
|
|
}
|
|
if (l$lte != lOther$lte) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$eq = eq;
|
|
final l$gt = gt;
|
|
final l$lt = lt;
|
|
final l$gte = gte;
|
|
final l$lte = lte;
|
|
return Object.hashAll([
|
|
_$data.containsKey('eq') ? l$eq : const {},
|
|
_$data.containsKey('gt') ? l$gt : const {},
|
|
_$data.containsKey('lt') ? l$lt : const {},
|
|
_$data.containsKey('gte') ? l$gte : const {},
|
|
_$data.containsKey('lte') ? l$lte : const {},
|
|
]);
|
|
}
|
|
}
|
|
|
|
abstract class CopyWith$Input$DateTimeFilter<TRes> {
|
|
factory CopyWith$Input$DateTimeFilter(
|
|
Input$DateTimeFilter instance,
|
|
TRes Function(Input$DateTimeFilter) then,
|
|
) = _CopyWithImpl$Input$DateTimeFilter;
|
|
|
|
factory CopyWith$Input$DateTimeFilter.stub(TRes res) =
|
|
_CopyWithStubImpl$Input$DateTimeFilter;
|
|
|
|
TRes call({
|
|
DateTime? eq,
|
|
DateTime? gt,
|
|
DateTime? lt,
|
|
DateTime? gte,
|
|
DateTime? lte,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Input$DateTimeFilter<TRes>
|
|
implements CopyWith$Input$DateTimeFilter<TRes> {
|
|
_CopyWithImpl$Input$DateTimeFilter(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Input$DateTimeFilter _instance;
|
|
|
|
final TRes Function(Input$DateTimeFilter) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? eq = _undefined,
|
|
Object? gt = _undefined,
|
|
Object? lt = _undefined,
|
|
Object? gte = _undefined,
|
|
Object? lte = _undefined,
|
|
}) =>
|
|
_then(Input$DateTimeFilter._({
|
|
..._instance._$data,
|
|
if (eq != _undefined) 'eq': (eq as DateTime?),
|
|
if (gt != _undefined) 'gt': (gt as DateTime?),
|
|
if (lt != _undefined) 'lt': (lt as DateTime?),
|
|
if (gte != _undefined) 'gte': (gte as DateTime?),
|
|
if (lte != _undefined) 'lte': (lte as DateTime?),
|
|
}));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Input$DateTimeFilter<TRes>
|
|
implements CopyWith$Input$DateTimeFilter<TRes> {
|
|
_CopyWithStubImpl$Input$DateTimeFilter(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
DateTime? eq,
|
|
DateTime? gt,
|
|
DateTime? lt,
|
|
DateTime? gte,
|
|
DateTime? lte,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Input$IntFilter {
|
|
factory Input$IntFilter({
|
|
int? eq,
|
|
int? gt,
|
|
int? lt,
|
|
int? gte,
|
|
int? lte,
|
|
List<int>? $in,
|
|
}) =>
|
|
Input$IntFilter._({
|
|
if (eq != null) r'eq': eq,
|
|
if (gt != null) r'gt': gt,
|
|
if (lt != null) r'lt': lt,
|
|
if (gte != null) r'gte': gte,
|
|
if (lte != null) r'lte': lte,
|
|
if ($in != null) r'in': $in,
|
|
});
|
|
|
|
Input$IntFilter._(this._$data);
|
|
|
|
factory Input$IntFilter.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
if (data.containsKey('eq')) {
|
|
final l$eq = data['eq'];
|
|
result$data['eq'] = (l$eq as int?);
|
|
}
|
|
if (data.containsKey('gt')) {
|
|
final l$gt = data['gt'];
|
|
result$data['gt'] = (l$gt as int?);
|
|
}
|
|
if (data.containsKey('lt')) {
|
|
final l$lt = data['lt'];
|
|
result$data['lt'] = (l$lt as int?);
|
|
}
|
|
if (data.containsKey('gte')) {
|
|
final l$gte = data['gte'];
|
|
result$data['gte'] = (l$gte as int?);
|
|
}
|
|
if (data.containsKey('lte')) {
|
|
final l$lte = data['lte'];
|
|
result$data['lte'] = (l$lte as int?);
|
|
}
|
|
if (data.containsKey('in')) {
|
|
final l$$in = data['in'];
|
|
result$data['in'] =
|
|
(l$$in as List<dynamic>?)?.map((e) => (e as int)).toList();
|
|
}
|
|
return Input$IntFilter._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
int? get eq => (_$data['eq'] as int?);
|
|
|
|
int? get gt => (_$data['gt'] as int?);
|
|
|
|
int? get lt => (_$data['lt'] as int?);
|
|
|
|
int? get gte => (_$data['gte'] as int?);
|
|
|
|
int? get lte => (_$data['lte'] as int?);
|
|
|
|
List<int>? get $in => (_$data['in'] as List<int>?);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
if (_$data.containsKey('eq')) {
|
|
final l$eq = eq;
|
|
result$data['eq'] = l$eq;
|
|
}
|
|
if (_$data.containsKey('gt')) {
|
|
final l$gt = gt;
|
|
result$data['gt'] = l$gt;
|
|
}
|
|
if (_$data.containsKey('lt')) {
|
|
final l$lt = lt;
|
|
result$data['lt'] = l$lt;
|
|
}
|
|
if (_$data.containsKey('gte')) {
|
|
final l$gte = gte;
|
|
result$data['gte'] = l$gte;
|
|
}
|
|
if (_$data.containsKey('lte')) {
|
|
final l$lte = lte;
|
|
result$data['lte'] = l$lte;
|
|
}
|
|
if (_$data.containsKey('in')) {
|
|
final l$$in = $in;
|
|
result$data['in'] = l$$in?.map((e) => e).toList();
|
|
}
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Input$IntFilter<Input$IntFilter> get copyWith =>
|
|
CopyWith$Input$IntFilter(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) {
|
|
return true;
|
|
}
|
|
if (!(other is Input$IntFilter) || runtimeType != other.runtimeType) {
|
|
return false;
|
|
}
|
|
final l$eq = eq;
|
|
final lOther$eq = other.eq;
|
|
if (_$data.containsKey('eq') != other._$data.containsKey('eq')) {
|
|
return false;
|
|
}
|
|
if (l$eq != lOther$eq) {
|
|
return false;
|
|
}
|
|
final l$gt = gt;
|
|
final lOther$gt = other.gt;
|
|
if (_$data.containsKey('gt') != other._$data.containsKey('gt')) {
|
|
return false;
|
|
}
|
|
if (l$gt != lOther$gt) {
|
|
return false;
|
|
}
|
|
final l$lt = lt;
|
|
final lOther$lt = other.lt;
|
|
if (_$data.containsKey('lt') != other._$data.containsKey('lt')) {
|
|
return false;
|
|
}
|
|
if (l$lt != lOther$lt) {
|
|
return false;
|
|
}
|
|
final l$gte = gte;
|
|
final lOther$gte = other.gte;
|
|
if (_$data.containsKey('gte') != other._$data.containsKey('gte')) {
|
|
return false;
|
|
}
|
|
if (l$gte != lOther$gte) {
|
|
return false;
|
|
}
|
|
final l$lte = lte;
|
|
final lOther$lte = other.lte;
|
|
if (_$data.containsKey('lte') != other._$data.containsKey('lte')) {
|
|
return false;
|
|
}
|
|
if (l$lte != lOther$lte) {
|
|
return false;
|
|
}
|
|
final l$$in = $in;
|
|
final lOther$$in = other.$in;
|
|
if (_$data.containsKey('in') != other._$data.containsKey('in')) {
|
|
return false;
|
|
}
|
|
if (l$$in != null && lOther$$in != null) {
|
|
if (l$$in.length != lOther$$in.length) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < l$$in.length; i++) {
|
|
final l$$in$entry = l$$in[i];
|
|
final lOther$$in$entry = lOther$$in[i];
|
|
if (l$$in$entry != lOther$$in$entry) {
|
|
return false;
|
|
}
|
|
}
|
|
} else if (l$$in != lOther$$in) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$eq = eq;
|
|
final l$gt = gt;
|
|
final l$lt = lt;
|
|
final l$gte = gte;
|
|
final l$lte = lte;
|
|
final l$$in = $in;
|
|
return Object.hashAll([
|
|
_$data.containsKey('eq') ? l$eq : const {},
|
|
_$data.containsKey('gt') ? l$gt : const {},
|
|
_$data.containsKey('lt') ? l$lt : const {},
|
|
_$data.containsKey('gte') ? l$gte : const {},
|
|
_$data.containsKey('lte') ? l$lte : const {},
|
|
_$data.containsKey('in')
|
|
? l$$in == null
|
|
? null
|
|
: Object.hashAll(l$$in.map((v) => v))
|
|
: const {},
|
|
]);
|
|
}
|
|
}
|
|
|
|
abstract class CopyWith$Input$IntFilter<TRes> {
|
|
factory CopyWith$Input$IntFilter(
|
|
Input$IntFilter instance,
|
|
TRes Function(Input$IntFilter) then,
|
|
) = _CopyWithImpl$Input$IntFilter;
|
|
|
|
factory CopyWith$Input$IntFilter.stub(TRes res) =
|
|
_CopyWithStubImpl$Input$IntFilter;
|
|
|
|
TRes call({
|
|
int? eq,
|
|
int? gt,
|
|
int? lt,
|
|
int? gte,
|
|
int? lte,
|
|
List<int>? $in,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Input$IntFilter<TRes>
|
|
implements CopyWith$Input$IntFilter<TRes> {
|
|
_CopyWithImpl$Input$IntFilter(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Input$IntFilter _instance;
|
|
|
|
final TRes Function(Input$IntFilter) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? eq = _undefined,
|
|
Object? gt = _undefined,
|
|
Object? lt = _undefined,
|
|
Object? gte = _undefined,
|
|
Object? lte = _undefined,
|
|
Object? $in = _undefined,
|
|
}) =>
|
|
_then(Input$IntFilter._({
|
|
..._instance._$data,
|
|
if (eq != _undefined) 'eq': (eq as int?),
|
|
if (gt != _undefined) 'gt': (gt as int?),
|
|
if (lt != _undefined) 'lt': (lt as int?),
|
|
if (gte != _undefined) 'gte': (gte as int?),
|
|
if (lte != _undefined) 'lte': (lte as int?),
|
|
if ($in != _undefined) 'in': ($in as List<int>?),
|
|
}));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Input$IntFilter<TRes>
|
|
implements CopyWith$Input$IntFilter<TRes> {
|
|
_CopyWithStubImpl$Input$IntFilter(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
int? eq,
|
|
int? gt,
|
|
int? lt,
|
|
int? gte,
|
|
int? lte,
|
|
List<int>? $in,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Input$Pagination {
|
|
factory Input$Pagination({
|
|
required int offset,
|
|
required int limit,
|
|
}) =>
|
|
Input$Pagination._({
|
|
r'offset': offset,
|
|
r'limit': limit,
|
|
});
|
|
|
|
Input$Pagination._(this._$data);
|
|
|
|
factory Input$Pagination.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
final l$offset = data['offset'];
|
|
result$data['offset'] = (l$offset as int);
|
|
final l$limit = data['limit'];
|
|
result$data['limit'] = (l$limit as int);
|
|
return Input$Pagination._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
int get offset => (_$data['offset'] as int);
|
|
|
|
int get limit => (_$data['limit'] as int);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
final l$offset = offset;
|
|
result$data['offset'] = l$offset;
|
|
final l$limit = limit;
|
|
result$data['limit'] = l$limit;
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Input$Pagination<Input$Pagination> get copyWith =>
|
|
CopyWith$Input$Pagination(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) {
|
|
return true;
|
|
}
|
|
if (!(other is Input$Pagination) || runtimeType != other.runtimeType) {
|
|
return false;
|
|
}
|
|
final l$offset = offset;
|
|
final lOther$offset = other.offset;
|
|
if (l$offset != lOther$offset) {
|
|
return false;
|
|
}
|
|
final l$limit = limit;
|
|
final lOther$limit = other.limit;
|
|
if (l$limit != lOther$limit) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$offset = offset;
|
|
final l$limit = limit;
|
|
return Object.hashAll([
|
|
l$offset,
|
|
l$limit,
|
|
]);
|
|
}
|
|
}
|
|
|
|
abstract class CopyWith$Input$Pagination<TRes> {
|
|
factory CopyWith$Input$Pagination(
|
|
Input$Pagination instance,
|
|
TRes Function(Input$Pagination) then,
|
|
) = _CopyWithImpl$Input$Pagination;
|
|
|
|
factory CopyWith$Input$Pagination.stub(TRes res) =
|
|
_CopyWithStubImpl$Input$Pagination;
|
|
|
|
TRes call({
|
|
int? offset,
|
|
int? limit,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Input$Pagination<TRes>
|
|
implements CopyWith$Input$Pagination<TRes> {
|
|
_CopyWithImpl$Input$Pagination(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Input$Pagination _instance;
|
|
|
|
final TRes Function(Input$Pagination) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? offset = _undefined,
|
|
Object? limit = _undefined,
|
|
}) =>
|
|
_then(Input$Pagination._({
|
|
..._instance._$data,
|
|
if (offset != _undefined && offset != null) 'offset': (offset as int),
|
|
if (limit != _undefined && limit != null) 'limit': (limit as int),
|
|
}));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Input$Pagination<TRes>
|
|
implements CopyWith$Input$Pagination<TRes> {
|
|
_CopyWithStubImpl$Input$Pagination(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
int? offset,
|
|
int? limit,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Input$StringFilter {
|
|
factory Input$StringFilter({
|
|
String? eq,
|
|
String? substr,
|
|
List<String>? $in,
|
|
}) =>
|
|
Input$StringFilter._({
|
|
if (eq != null) r'eq': eq,
|
|
if (substr != null) r'substr': substr,
|
|
if ($in != null) r'in': $in,
|
|
});
|
|
|
|
Input$StringFilter._(this._$data);
|
|
|
|
factory Input$StringFilter.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
if (data.containsKey('eq')) {
|
|
final l$eq = data['eq'];
|
|
result$data['eq'] = (l$eq as String?);
|
|
}
|
|
if (data.containsKey('substr')) {
|
|
final l$substr = data['substr'];
|
|
result$data['substr'] = (l$substr as String?);
|
|
}
|
|
if (data.containsKey('in')) {
|
|
final l$$in = data['in'];
|
|
result$data['in'] =
|
|
(l$$in as List<dynamic>?)?.map((e) => (e as String)).toList();
|
|
}
|
|
return Input$StringFilter._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
String? get eq => (_$data['eq'] as String?);
|
|
|
|
String? get substr => (_$data['substr'] as String?);
|
|
|
|
List<String>? get $in => (_$data['in'] as List<String>?);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
if (_$data.containsKey('eq')) {
|
|
final l$eq = eq;
|
|
result$data['eq'] = l$eq;
|
|
}
|
|
if (_$data.containsKey('substr')) {
|
|
final l$substr = substr;
|
|
result$data['substr'] = l$substr;
|
|
}
|
|
if (_$data.containsKey('in')) {
|
|
final l$$in = $in;
|
|
result$data['in'] = l$$in?.map((e) => e).toList();
|
|
}
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Input$StringFilter<Input$StringFilter> get copyWith =>
|
|
CopyWith$Input$StringFilter(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) {
|
|
return true;
|
|
}
|
|
if (!(other is Input$StringFilter) || runtimeType != other.runtimeType) {
|
|
return false;
|
|
}
|
|
final l$eq = eq;
|
|
final lOther$eq = other.eq;
|
|
if (_$data.containsKey('eq') != other._$data.containsKey('eq')) {
|
|
return false;
|
|
}
|
|
if (l$eq != lOther$eq) {
|
|
return false;
|
|
}
|
|
final l$substr = substr;
|
|
final lOther$substr = other.substr;
|
|
if (_$data.containsKey('substr') != other._$data.containsKey('substr')) {
|
|
return false;
|
|
}
|
|
if (l$substr != lOther$substr) {
|
|
return false;
|
|
}
|
|
final l$$in = $in;
|
|
final lOther$$in = other.$in;
|
|
if (_$data.containsKey('in') != other._$data.containsKey('in')) {
|
|
return false;
|
|
}
|
|
if (l$$in != null && lOther$$in != null) {
|
|
if (l$$in.length != lOther$$in.length) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < l$$in.length; i++) {
|
|
final l$$in$entry = l$$in[i];
|
|
final lOther$$in$entry = lOther$$in[i];
|
|
if (l$$in$entry != lOther$$in$entry) {
|
|
return false;
|
|
}
|
|
}
|
|
} else if (l$$in != lOther$$in) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$eq = eq;
|
|
final l$substr = substr;
|
|
final l$$in = $in;
|
|
return Object.hashAll([
|
|
_$data.containsKey('eq') ? l$eq : const {},
|
|
_$data.containsKey('substr') ? l$substr : const {},
|
|
_$data.containsKey('in')
|
|
? l$$in == null
|
|
? null
|
|
: Object.hashAll(l$$in.map((v) => v))
|
|
: const {},
|
|
]);
|
|
}
|
|
}
|
|
|
|
abstract class CopyWith$Input$StringFilter<TRes> {
|
|
factory CopyWith$Input$StringFilter(
|
|
Input$StringFilter instance,
|
|
TRes Function(Input$StringFilter) then,
|
|
) = _CopyWithImpl$Input$StringFilter;
|
|
|
|
factory CopyWith$Input$StringFilter.stub(TRes res) =
|
|
_CopyWithStubImpl$Input$StringFilter;
|
|
|
|
TRes call({
|
|
String? eq,
|
|
String? substr,
|
|
List<String>? $in,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Input$StringFilter<TRes>
|
|
implements CopyWith$Input$StringFilter<TRes> {
|
|
_CopyWithImpl$Input$StringFilter(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Input$StringFilter _instance;
|
|
|
|
final TRes Function(Input$StringFilter) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? eq = _undefined,
|
|
Object? substr = _undefined,
|
|
Object? $in = _undefined,
|
|
}) =>
|
|
_then(Input$StringFilter._({
|
|
..._instance._$data,
|
|
if (eq != _undefined) 'eq': (eq as String?),
|
|
if (substr != _undefined) 'substr': (substr as String?),
|
|
if ($in != _undefined) 'in': ($in as List<String>?),
|
|
}));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Input$StringFilter<TRes>
|
|
implements CopyWith$Input$StringFilter<TRes> {
|
|
_CopyWithStubImpl$Input$StringFilter(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
String? eq,
|
|
String? substr,
|
|
List<String>? $in,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Input$TorrentFilter {
|
|
factory Input$TorrentFilter({
|
|
bool? everything,
|
|
String? infohash,
|
|
}) =>
|
|
Input$TorrentFilter._({
|
|
if (everything != null) r'everything': everything,
|
|
if (infohash != null) r'infohash': infohash,
|
|
});
|
|
|
|
Input$TorrentFilter._(this._$data);
|
|
|
|
factory Input$TorrentFilter.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
if (data.containsKey('everything')) {
|
|
final l$everything = data['everything'];
|
|
result$data['everything'] = (l$everything as bool?);
|
|
}
|
|
if (data.containsKey('infohash')) {
|
|
final l$infohash = data['infohash'];
|
|
result$data['infohash'] = (l$infohash as String?);
|
|
}
|
|
return Input$TorrentFilter._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
bool? get everything => (_$data['everything'] as bool?);
|
|
|
|
String? get infohash => (_$data['infohash'] as String?);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
if (_$data.containsKey('everything')) {
|
|
final l$everything = everything;
|
|
result$data['everything'] = l$everything;
|
|
}
|
|
if (_$data.containsKey('infohash')) {
|
|
final l$infohash = infohash;
|
|
result$data['infohash'] = l$infohash;
|
|
}
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Input$TorrentFilter<Input$TorrentFilter> get copyWith =>
|
|
CopyWith$Input$TorrentFilter(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) {
|
|
return true;
|
|
}
|
|
if (!(other is Input$TorrentFilter) || runtimeType != other.runtimeType) {
|
|
return false;
|
|
}
|
|
final l$everything = everything;
|
|
final lOther$everything = other.everything;
|
|
if (_$data.containsKey('everything') !=
|
|
other._$data.containsKey('everything')) {
|
|
return false;
|
|
}
|
|
if (l$everything != lOther$everything) {
|
|
return false;
|
|
}
|
|
final l$infohash = infohash;
|
|
final lOther$infohash = other.infohash;
|
|
if (_$data.containsKey('infohash') !=
|
|
other._$data.containsKey('infohash')) {
|
|
return false;
|
|
}
|
|
if (l$infohash != lOther$infohash) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$everything = everything;
|
|
final l$infohash = infohash;
|
|
return Object.hashAll([
|
|
_$data.containsKey('everything') ? l$everything : const {},
|
|
_$data.containsKey('infohash') ? l$infohash : const {},
|
|
]);
|
|
}
|
|
}
|
|
|
|
abstract class CopyWith$Input$TorrentFilter<TRes> {
|
|
factory CopyWith$Input$TorrentFilter(
|
|
Input$TorrentFilter instance,
|
|
TRes Function(Input$TorrentFilter) then,
|
|
) = _CopyWithImpl$Input$TorrentFilter;
|
|
|
|
factory CopyWith$Input$TorrentFilter.stub(TRes res) =
|
|
_CopyWithStubImpl$Input$TorrentFilter;
|
|
|
|
TRes call({
|
|
bool? everything,
|
|
String? infohash,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Input$TorrentFilter<TRes>
|
|
implements CopyWith$Input$TorrentFilter<TRes> {
|
|
_CopyWithImpl$Input$TorrentFilter(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Input$TorrentFilter _instance;
|
|
|
|
final TRes Function(Input$TorrentFilter) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? everything = _undefined,
|
|
Object? infohash = _undefined,
|
|
}) =>
|
|
_then(Input$TorrentFilter._({
|
|
..._instance._$data,
|
|
if (everything != _undefined) 'everything': (everything as bool?),
|
|
if (infohash != _undefined) 'infohash': (infohash as String?),
|
|
}));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Input$TorrentFilter<TRes>
|
|
implements CopyWith$Input$TorrentFilter<TRes> {
|
|
_CopyWithStubImpl$Input$TorrentFilter(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
bool? everything,
|
|
String? infohash,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Input$TorrentsFilter {
|
|
factory Input$TorrentsFilter({
|
|
Input$StringFilter? infohash,
|
|
Input$StringFilter? name,
|
|
Input$IntFilter? bytesCompleted,
|
|
Input$IntFilter? bytesMissing,
|
|
Input$IntFilter? peersCount,
|
|
Input$BooleanFilter? downloading,
|
|
}) =>
|
|
Input$TorrentsFilter._({
|
|
if (infohash != null) r'infohash': infohash,
|
|
if (name != null) r'name': name,
|
|
if (bytesCompleted != null) r'bytesCompleted': bytesCompleted,
|
|
if (bytesMissing != null) r'bytesMissing': bytesMissing,
|
|
if (peersCount != null) r'peersCount': peersCount,
|
|
if (downloading != null) r'downloading': downloading,
|
|
});
|
|
|
|
Input$TorrentsFilter._(this._$data);
|
|
|
|
factory Input$TorrentsFilter.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
if (data.containsKey('infohash')) {
|
|
final l$infohash = data['infohash'];
|
|
result$data['infohash'] = l$infohash == null
|
|
? null
|
|
: Input$StringFilter.fromJson((l$infohash as Map<String, dynamic>));
|
|
}
|
|
if (data.containsKey('name')) {
|
|
final l$name = data['name'];
|
|
result$data['name'] = l$name == null
|
|
? null
|
|
: Input$StringFilter.fromJson((l$name as Map<String, dynamic>));
|
|
}
|
|
if (data.containsKey('bytesCompleted')) {
|
|
final l$bytesCompleted = data['bytesCompleted'];
|
|
result$data['bytesCompleted'] = l$bytesCompleted == null
|
|
? null
|
|
: Input$IntFilter.fromJson(
|
|
(l$bytesCompleted as Map<String, dynamic>));
|
|
}
|
|
if (data.containsKey('bytesMissing')) {
|
|
final l$bytesMissing = data['bytesMissing'];
|
|
result$data['bytesMissing'] = l$bytesMissing == null
|
|
? null
|
|
: Input$IntFilter.fromJson((l$bytesMissing as Map<String, dynamic>));
|
|
}
|
|
if (data.containsKey('peersCount')) {
|
|
final l$peersCount = data['peersCount'];
|
|
result$data['peersCount'] = l$peersCount == null
|
|
? null
|
|
: Input$IntFilter.fromJson((l$peersCount as Map<String, dynamic>));
|
|
}
|
|
if (data.containsKey('downloading')) {
|
|
final l$downloading = data['downloading'];
|
|
result$data['downloading'] = l$downloading == null
|
|
? null
|
|
: Input$BooleanFilter.fromJson(
|
|
(l$downloading as Map<String, dynamic>));
|
|
}
|
|
return Input$TorrentsFilter._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
Input$StringFilter? get infohash =>
|
|
(_$data['infohash'] as Input$StringFilter?);
|
|
|
|
Input$StringFilter? get name => (_$data['name'] as Input$StringFilter?);
|
|
|
|
Input$IntFilter? get bytesCompleted =>
|
|
(_$data['bytesCompleted'] as Input$IntFilter?);
|
|
|
|
Input$IntFilter? get bytesMissing =>
|
|
(_$data['bytesMissing'] as Input$IntFilter?);
|
|
|
|
Input$IntFilter? get peersCount => (_$data['peersCount'] as Input$IntFilter?);
|
|
|
|
Input$BooleanFilter? get downloading =>
|
|
(_$data['downloading'] as Input$BooleanFilter?);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
if (_$data.containsKey('infohash')) {
|
|
final l$infohash = infohash;
|
|
result$data['infohash'] = l$infohash?.toJson();
|
|
}
|
|
if (_$data.containsKey('name')) {
|
|
final l$name = name;
|
|
result$data['name'] = l$name?.toJson();
|
|
}
|
|
if (_$data.containsKey('bytesCompleted')) {
|
|
final l$bytesCompleted = bytesCompleted;
|
|
result$data['bytesCompleted'] = l$bytesCompleted?.toJson();
|
|
}
|
|
if (_$data.containsKey('bytesMissing')) {
|
|
final l$bytesMissing = bytesMissing;
|
|
result$data['bytesMissing'] = l$bytesMissing?.toJson();
|
|
}
|
|
if (_$data.containsKey('peersCount')) {
|
|
final l$peersCount = peersCount;
|
|
result$data['peersCount'] = l$peersCount?.toJson();
|
|
}
|
|
if (_$data.containsKey('downloading')) {
|
|
final l$downloading = downloading;
|
|
result$data['downloading'] = l$downloading?.toJson();
|
|
}
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Input$TorrentsFilter<Input$TorrentsFilter> get copyWith =>
|
|
CopyWith$Input$TorrentsFilter(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) {
|
|
return true;
|
|
}
|
|
if (!(other is Input$TorrentsFilter) || runtimeType != other.runtimeType) {
|
|
return false;
|
|
}
|
|
final l$infohash = infohash;
|
|
final lOther$infohash = other.infohash;
|
|
if (_$data.containsKey('infohash') !=
|
|
other._$data.containsKey('infohash')) {
|
|
return false;
|
|
}
|
|
if (l$infohash != lOther$infohash) {
|
|
return false;
|
|
}
|
|
final l$name = name;
|
|
final lOther$name = other.name;
|
|
if (_$data.containsKey('name') != other._$data.containsKey('name')) {
|
|
return false;
|
|
}
|
|
if (l$name != lOther$name) {
|
|
return false;
|
|
}
|
|
final l$bytesCompleted = bytesCompleted;
|
|
final lOther$bytesCompleted = other.bytesCompleted;
|
|
if (_$data.containsKey('bytesCompleted') !=
|
|
other._$data.containsKey('bytesCompleted')) {
|
|
return false;
|
|
}
|
|
if (l$bytesCompleted != lOther$bytesCompleted) {
|
|
return false;
|
|
}
|
|
final l$bytesMissing = bytesMissing;
|
|
final lOther$bytesMissing = other.bytesMissing;
|
|
if (_$data.containsKey('bytesMissing') !=
|
|
other._$data.containsKey('bytesMissing')) {
|
|
return false;
|
|
}
|
|
if (l$bytesMissing != lOther$bytesMissing) {
|
|
return false;
|
|
}
|
|
final l$peersCount = peersCount;
|
|
final lOther$peersCount = other.peersCount;
|
|
if (_$data.containsKey('peersCount') !=
|
|
other._$data.containsKey('peersCount')) {
|
|
return false;
|
|
}
|
|
if (l$peersCount != lOther$peersCount) {
|
|
return false;
|
|
}
|
|
final l$downloading = downloading;
|
|
final lOther$downloading = other.downloading;
|
|
if (_$data.containsKey('downloading') !=
|
|
other._$data.containsKey('downloading')) {
|
|
return false;
|
|
}
|
|
if (l$downloading != lOther$downloading) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$infohash = infohash;
|
|
final l$name = name;
|
|
final l$bytesCompleted = bytesCompleted;
|
|
final l$bytesMissing = bytesMissing;
|
|
final l$peersCount = peersCount;
|
|
final l$downloading = downloading;
|
|
return Object.hashAll([
|
|
_$data.containsKey('infohash') ? l$infohash : const {},
|
|
_$data.containsKey('name') ? l$name : const {},
|
|
_$data.containsKey('bytesCompleted') ? l$bytesCompleted : const {},
|
|
_$data.containsKey('bytesMissing') ? l$bytesMissing : const {},
|
|
_$data.containsKey('peersCount') ? l$peersCount : const {},
|
|
_$data.containsKey('downloading') ? l$downloading : const {},
|
|
]);
|
|
}
|
|
}
|
|
|
|
abstract class CopyWith$Input$TorrentsFilter<TRes> {
|
|
factory CopyWith$Input$TorrentsFilter(
|
|
Input$TorrentsFilter instance,
|
|
TRes Function(Input$TorrentsFilter) then,
|
|
) = _CopyWithImpl$Input$TorrentsFilter;
|
|
|
|
factory CopyWith$Input$TorrentsFilter.stub(TRes res) =
|
|
_CopyWithStubImpl$Input$TorrentsFilter;
|
|
|
|
TRes call({
|
|
Input$StringFilter? infohash,
|
|
Input$StringFilter? name,
|
|
Input$IntFilter? bytesCompleted,
|
|
Input$IntFilter? bytesMissing,
|
|
Input$IntFilter? peersCount,
|
|
Input$BooleanFilter? downloading,
|
|
});
|
|
CopyWith$Input$StringFilter<TRes> get infohash;
|
|
CopyWith$Input$StringFilter<TRes> get name;
|
|
CopyWith$Input$IntFilter<TRes> get bytesCompleted;
|
|
CopyWith$Input$IntFilter<TRes> get bytesMissing;
|
|
CopyWith$Input$IntFilter<TRes> get peersCount;
|
|
CopyWith$Input$BooleanFilter<TRes> get downloading;
|
|
}
|
|
|
|
class _CopyWithImpl$Input$TorrentsFilter<TRes>
|
|
implements CopyWith$Input$TorrentsFilter<TRes> {
|
|
_CopyWithImpl$Input$TorrentsFilter(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Input$TorrentsFilter _instance;
|
|
|
|
final TRes Function(Input$TorrentsFilter) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? infohash = _undefined,
|
|
Object? name = _undefined,
|
|
Object? bytesCompleted = _undefined,
|
|
Object? bytesMissing = _undefined,
|
|
Object? peersCount = _undefined,
|
|
Object? downloading = _undefined,
|
|
}) =>
|
|
_then(Input$TorrentsFilter._({
|
|
..._instance._$data,
|
|
if (infohash != _undefined)
|
|
'infohash': (infohash as Input$StringFilter?),
|
|
if (name != _undefined) 'name': (name as Input$StringFilter?),
|
|
if (bytesCompleted != _undefined)
|
|
'bytesCompleted': (bytesCompleted as Input$IntFilter?),
|
|
if (bytesMissing != _undefined)
|
|
'bytesMissing': (bytesMissing as Input$IntFilter?),
|
|
if (peersCount != _undefined)
|
|
'peersCount': (peersCount as Input$IntFilter?),
|
|
if (downloading != _undefined)
|
|
'downloading': (downloading as Input$BooleanFilter?),
|
|
}));
|
|
|
|
CopyWith$Input$StringFilter<TRes> get infohash {
|
|
final local$infohash = _instance.infohash;
|
|
return local$infohash == null
|
|
? CopyWith$Input$StringFilter.stub(_then(_instance))
|
|
: CopyWith$Input$StringFilter(local$infohash, (e) => call(infohash: e));
|
|
}
|
|
|
|
CopyWith$Input$StringFilter<TRes> get name {
|
|
final local$name = _instance.name;
|
|
return local$name == null
|
|
? CopyWith$Input$StringFilter.stub(_then(_instance))
|
|
: CopyWith$Input$StringFilter(local$name, (e) => call(name: e));
|
|
}
|
|
|
|
CopyWith$Input$IntFilter<TRes> get bytesCompleted {
|
|
final local$bytesCompleted = _instance.bytesCompleted;
|
|
return local$bytesCompleted == null
|
|
? CopyWith$Input$IntFilter.stub(_then(_instance))
|
|
: CopyWith$Input$IntFilter(
|
|
local$bytesCompleted, (e) => call(bytesCompleted: e));
|
|
}
|
|
|
|
CopyWith$Input$IntFilter<TRes> get bytesMissing {
|
|
final local$bytesMissing = _instance.bytesMissing;
|
|
return local$bytesMissing == null
|
|
? CopyWith$Input$IntFilter.stub(_then(_instance))
|
|
: CopyWith$Input$IntFilter(
|
|
local$bytesMissing, (e) => call(bytesMissing: e));
|
|
}
|
|
|
|
CopyWith$Input$IntFilter<TRes> get peersCount {
|
|
final local$peersCount = _instance.peersCount;
|
|
return local$peersCount == null
|
|
? CopyWith$Input$IntFilter.stub(_then(_instance))
|
|
: CopyWith$Input$IntFilter(
|
|
local$peersCount, (e) => call(peersCount: e));
|
|
}
|
|
|
|
CopyWith$Input$BooleanFilter<TRes> get downloading {
|
|
final local$downloading = _instance.downloading;
|
|
return local$downloading == null
|
|
? CopyWith$Input$BooleanFilter.stub(_then(_instance))
|
|
: CopyWith$Input$BooleanFilter(
|
|
local$downloading, (e) => call(downloading: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Input$TorrentsFilter<TRes>
|
|
implements CopyWith$Input$TorrentsFilter<TRes> {
|
|
_CopyWithStubImpl$Input$TorrentsFilter(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Input$StringFilter? infohash,
|
|
Input$StringFilter? name,
|
|
Input$IntFilter? bytesCompleted,
|
|
Input$IntFilter? bytesMissing,
|
|
Input$IntFilter? peersCount,
|
|
Input$BooleanFilter? downloading,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Input$StringFilter<TRes> get infohash =>
|
|
CopyWith$Input$StringFilter.stub(_res);
|
|
|
|
CopyWith$Input$StringFilter<TRes> get name =>
|
|
CopyWith$Input$StringFilter.stub(_res);
|
|
|
|
CopyWith$Input$IntFilter<TRes> get bytesCompleted =>
|
|
CopyWith$Input$IntFilter.stub(_res);
|
|
|
|
CopyWith$Input$IntFilter<TRes> get bytesMissing =>
|
|
CopyWith$Input$IntFilter.stub(_res);
|
|
|
|
CopyWith$Input$IntFilter<TRes> get peersCount =>
|
|
CopyWith$Input$IntFilter.stub(_res);
|
|
|
|
CopyWith$Input$BooleanFilter<TRes> get downloading =>
|
|
CopyWith$Input$BooleanFilter.stub(_res);
|
|
}
|
|
|
|
enum Enum$__TypeKind {
|
|
SCALAR,
|
|
OBJECT,
|
|
INTERFACE,
|
|
UNION,
|
|
ENUM,
|
|
INPUT_OBJECT,
|
|
LIST,
|
|
NON_NULL,
|
|
$unknown;
|
|
|
|
factory Enum$__TypeKind.fromJson(String value) =>
|
|
fromJson$Enum$__TypeKind(value);
|
|
|
|
String toJson() => toJson$Enum$__TypeKind(this);
|
|
}
|
|
|
|
String toJson$Enum$__TypeKind(Enum$__TypeKind e) {
|
|
switch (e) {
|
|
case Enum$__TypeKind.SCALAR:
|
|
return r'SCALAR';
|
|
case Enum$__TypeKind.OBJECT:
|
|
return r'OBJECT';
|
|
case Enum$__TypeKind.INTERFACE:
|
|
return r'INTERFACE';
|
|
case Enum$__TypeKind.UNION:
|
|
return r'UNION';
|
|
case Enum$__TypeKind.ENUM:
|
|
return r'ENUM';
|
|
case Enum$__TypeKind.INPUT_OBJECT:
|
|
return r'INPUT_OBJECT';
|
|
case Enum$__TypeKind.LIST:
|
|
return r'LIST';
|
|
case Enum$__TypeKind.NON_NULL:
|
|
return r'NON_NULL';
|
|
case Enum$__TypeKind.$unknown:
|
|
return r'$unknown';
|
|
}
|
|
}
|
|
|
|
Enum$__TypeKind fromJson$Enum$__TypeKind(String value) {
|
|
switch (value) {
|
|
case r'SCALAR':
|
|
return Enum$__TypeKind.SCALAR;
|
|
case r'OBJECT':
|
|
return Enum$__TypeKind.OBJECT;
|
|
case r'INTERFACE':
|
|
return Enum$__TypeKind.INTERFACE;
|
|
case r'UNION':
|
|
return Enum$__TypeKind.UNION;
|
|
case r'ENUM':
|
|
return Enum$__TypeKind.ENUM;
|
|
case r'INPUT_OBJECT':
|
|
return Enum$__TypeKind.INPUT_OBJECT;
|
|
case r'LIST':
|
|
return Enum$__TypeKind.LIST;
|
|
case r'NON_NULL':
|
|
return Enum$__TypeKind.NON_NULL;
|
|
default:
|
|
return Enum$__TypeKind.$unknown;
|
|
}
|
|
}
|
|
|
|
enum Enum$__DirectiveLocation {
|
|
QUERY,
|
|
MUTATION,
|
|
SUBSCRIPTION,
|
|
FIELD,
|
|
FRAGMENT_DEFINITION,
|
|
FRAGMENT_SPREAD,
|
|
INLINE_FRAGMENT,
|
|
VARIABLE_DEFINITION,
|
|
SCHEMA,
|
|
SCALAR,
|
|
OBJECT,
|
|
FIELD_DEFINITION,
|
|
ARGUMENT_DEFINITION,
|
|
INTERFACE,
|
|
UNION,
|
|
ENUM,
|
|
ENUM_VALUE,
|
|
INPUT_OBJECT,
|
|
INPUT_FIELD_DEFINITION,
|
|
$unknown;
|
|
|
|
factory Enum$__DirectiveLocation.fromJson(String value) =>
|
|
fromJson$Enum$__DirectiveLocation(value);
|
|
|
|
String toJson() => toJson$Enum$__DirectiveLocation(this);
|
|
}
|
|
|
|
String toJson$Enum$__DirectiveLocation(Enum$__DirectiveLocation e) {
|
|
switch (e) {
|
|
case Enum$__DirectiveLocation.QUERY:
|
|
return r'QUERY';
|
|
case Enum$__DirectiveLocation.MUTATION:
|
|
return r'MUTATION';
|
|
case Enum$__DirectiveLocation.SUBSCRIPTION:
|
|
return r'SUBSCRIPTION';
|
|
case Enum$__DirectiveLocation.FIELD:
|
|
return r'FIELD';
|
|
case Enum$__DirectiveLocation.FRAGMENT_DEFINITION:
|
|
return r'FRAGMENT_DEFINITION';
|
|
case Enum$__DirectiveLocation.FRAGMENT_SPREAD:
|
|
return r'FRAGMENT_SPREAD';
|
|
case Enum$__DirectiveLocation.INLINE_FRAGMENT:
|
|
return r'INLINE_FRAGMENT';
|
|
case Enum$__DirectiveLocation.VARIABLE_DEFINITION:
|
|
return r'VARIABLE_DEFINITION';
|
|
case Enum$__DirectiveLocation.SCHEMA:
|
|
return r'SCHEMA';
|
|
case Enum$__DirectiveLocation.SCALAR:
|
|
return r'SCALAR';
|
|
case Enum$__DirectiveLocation.OBJECT:
|
|
return r'OBJECT';
|
|
case Enum$__DirectiveLocation.FIELD_DEFINITION:
|
|
return r'FIELD_DEFINITION';
|
|
case Enum$__DirectiveLocation.ARGUMENT_DEFINITION:
|
|
return r'ARGUMENT_DEFINITION';
|
|
case Enum$__DirectiveLocation.INTERFACE:
|
|
return r'INTERFACE';
|
|
case Enum$__DirectiveLocation.UNION:
|
|
return r'UNION';
|
|
case Enum$__DirectiveLocation.ENUM:
|
|
return r'ENUM';
|
|
case Enum$__DirectiveLocation.ENUM_VALUE:
|
|
return r'ENUM_VALUE';
|
|
case Enum$__DirectiveLocation.INPUT_OBJECT:
|
|
return r'INPUT_OBJECT';
|
|
case Enum$__DirectiveLocation.INPUT_FIELD_DEFINITION:
|
|
return r'INPUT_FIELD_DEFINITION';
|
|
case Enum$__DirectiveLocation.$unknown:
|
|
return r'$unknown';
|
|
}
|
|
}
|
|
|
|
Enum$__DirectiveLocation fromJson$Enum$__DirectiveLocation(String value) {
|
|
switch (value) {
|
|
case r'QUERY':
|
|
return Enum$__DirectiveLocation.QUERY;
|
|
case r'MUTATION':
|
|
return Enum$__DirectiveLocation.MUTATION;
|
|
case r'SUBSCRIPTION':
|
|
return Enum$__DirectiveLocation.SUBSCRIPTION;
|
|
case r'FIELD':
|
|
return Enum$__DirectiveLocation.FIELD;
|
|
case r'FRAGMENT_DEFINITION':
|
|
return Enum$__DirectiveLocation.FRAGMENT_DEFINITION;
|
|
case r'FRAGMENT_SPREAD':
|
|
return Enum$__DirectiveLocation.FRAGMENT_SPREAD;
|
|
case r'INLINE_FRAGMENT':
|
|
return Enum$__DirectiveLocation.INLINE_FRAGMENT;
|
|
case r'VARIABLE_DEFINITION':
|
|
return Enum$__DirectiveLocation.VARIABLE_DEFINITION;
|
|
case r'SCHEMA':
|
|
return Enum$__DirectiveLocation.SCHEMA;
|
|
case r'SCALAR':
|
|
return Enum$__DirectiveLocation.SCALAR;
|
|
case r'OBJECT':
|
|
return Enum$__DirectiveLocation.OBJECT;
|
|
case r'FIELD_DEFINITION':
|
|
return Enum$__DirectiveLocation.FIELD_DEFINITION;
|
|
case r'ARGUMENT_DEFINITION':
|
|
return Enum$__DirectiveLocation.ARGUMENT_DEFINITION;
|
|
case r'INTERFACE':
|
|
return Enum$__DirectiveLocation.INTERFACE;
|
|
case r'UNION':
|
|
return Enum$__DirectiveLocation.UNION;
|
|
case r'ENUM':
|
|
return Enum$__DirectiveLocation.ENUM;
|
|
case r'ENUM_VALUE':
|
|
return Enum$__DirectiveLocation.ENUM_VALUE;
|
|
case r'INPUT_OBJECT':
|
|
return Enum$__DirectiveLocation.INPUT_OBJECT;
|
|
case r'INPUT_FIELD_DEFINITION':
|
|
return Enum$__DirectiveLocation.INPUT_FIELD_DEFINITION;
|
|
default:
|
|
return Enum$__DirectiveLocation.$unknown;
|
|
}
|
|
}
|
|
|
|
const possibleTypesMap = <String, Set<String>>{
|
|
'Dir': {
|
|
'ArchiveFS',
|
|
'ResolverFS',
|
|
'SimpleDir',
|
|
'TorrentFS',
|
|
},
|
|
'FsEntry': {
|
|
'ArchiveFS',
|
|
'ResolverFS',
|
|
'SimpleDir',
|
|
'SimpleFile',
|
|
'TorrentFS',
|
|
'TorrentFileEntry',
|
|
},
|
|
'File': {
|
|
'SimpleFile',
|
|
'TorrentFileEntry',
|
|
},
|
|
'Progress': {'TorrentProgress'},
|
|
};
|