mirror of
https://git.selfprivacy.org/kherel/selfprivacy.org.app.git
synced 2024-11-08 01:43:13 +00:00
3973 lines
139 KiB
Dart
3973 lines
139 KiB
Dart
import 'dart:async';
|
|
import 'package:gql/ast.dart';
|
|
import 'package:graphql/client.dart' as graphql;
|
|
import 'package:json_annotation/json_annotation.dart';
|
|
import 'package:selfprivacy/utils/scalars.dart';
|
|
import 'schema.graphql.dart';
|
|
part 'services.graphql.g.dart';
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Fragment$basicMutationReturnFields {
|
|
Fragment$basicMutationReturnFields(
|
|
{required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
required this.$__typename});
|
|
|
|
@override
|
|
factory Fragment$basicMutationReturnFields.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Fragment$basicMutationReturnFieldsFromJson(json);
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Fragment$basicMutationReturnFieldsToJson(this);
|
|
int get hashCode {
|
|
final l$code = code;
|
|
final l$message = message;
|
|
final l$success = success;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$code, l$message, l$success, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Fragment$basicMutationReturnFields) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$code = code;
|
|
final lOther$code = other.code;
|
|
if (l$code != lOther$code) return false;
|
|
final l$message = message;
|
|
final lOther$message = other.message;
|
|
if (l$message != lOther$message) return false;
|
|
final l$success = success;
|
|
final lOther$success = other.success;
|
|
if (l$success != lOther$success) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Fragment$basicMutationReturnFields
|
|
on Fragment$basicMutationReturnFields {
|
|
CopyWith$Fragment$basicMutationReturnFields<
|
|
Fragment$basicMutationReturnFields>
|
|
get copyWith =>
|
|
CopyWith$Fragment$basicMutationReturnFields(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Fragment$basicMutationReturnFields<TRes> {
|
|
factory CopyWith$Fragment$basicMutationReturnFields(
|
|
Fragment$basicMutationReturnFields instance,
|
|
TRes Function(Fragment$basicMutationReturnFields) then) =
|
|
_CopyWithImpl$Fragment$basicMutationReturnFields;
|
|
|
|
factory CopyWith$Fragment$basicMutationReturnFields.stub(TRes res) =
|
|
_CopyWithStubImpl$Fragment$basicMutationReturnFields;
|
|
|
|
TRes call({int? code, String? message, bool? success, String? $__typename});
|
|
}
|
|
|
|
class _CopyWithImpl$Fragment$basicMutationReturnFields<TRes>
|
|
implements CopyWith$Fragment$basicMutationReturnFields<TRes> {
|
|
_CopyWithImpl$Fragment$basicMutationReturnFields(this._instance, this._then);
|
|
|
|
final Fragment$basicMutationReturnFields _instance;
|
|
|
|
final TRes Function(Fragment$basicMutationReturnFields) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Fragment$basicMutationReturnFields(
|
|
code: code == _undefined || code == null
|
|
? _instance.code
|
|
: (code as int),
|
|
message: message == _undefined || message == null
|
|
? _instance.message
|
|
: (message as String),
|
|
success: success == _undefined || success == null
|
|
? _instance.success
|
|
: (success as bool),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Fragment$basicMutationReturnFields<TRes>
|
|
implements CopyWith$Fragment$basicMutationReturnFields<TRes> {
|
|
_CopyWithStubImpl$Fragment$basicMutationReturnFields(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({int? code, String? message, bool? success, String? $__typename}) =>
|
|
_res;
|
|
}
|
|
|
|
const fragmentDefinitionbasicMutationReturnFields = FragmentDefinitionNode(
|
|
name: NameNode(value: 'basicMutationReturnFields'),
|
|
typeCondition: TypeConditionNode(
|
|
on: NamedTypeNode(
|
|
name: NameNode(value: 'MutationReturnInterface'),
|
|
isNonNull: false)),
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'code'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'message'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'success'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
]));
|
|
const documentNodeFragmentbasicMutationReturnFields =
|
|
DocumentNode(definitions: [
|
|
fragmentDefinitionbasicMutationReturnFields,
|
|
]);
|
|
|
|
extension ClientExtension$Fragment$basicMutationReturnFields
|
|
on graphql.GraphQLClient {
|
|
void writeFragment$basicMutationReturnFields(
|
|
{required Fragment$basicMutationReturnFields data,
|
|
required Map<String, dynamic> idFields,
|
|
bool broadcast = true}) =>
|
|
this.writeFragment(
|
|
graphql.FragmentRequest(
|
|
idFields: idFields,
|
|
fragment: const graphql.Fragment(
|
|
fragmentName: 'basicMutationReturnFields',
|
|
document: documentNodeFragmentbasicMutationReturnFields)),
|
|
data: data.toJson(),
|
|
broadcast: broadcast);
|
|
Fragment$basicMutationReturnFields? readFragment$basicMutationReturnFields(
|
|
{required Map<String, dynamic> idFields, bool optimistic = true}) {
|
|
final result = this.readFragment(
|
|
graphql.FragmentRequest(
|
|
idFields: idFields,
|
|
fragment: const graphql.Fragment(
|
|
fragmentName: 'basicMutationReturnFields',
|
|
document: documentNodeFragmentbasicMutationReturnFields)),
|
|
optimistic: optimistic);
|
|
return result == null
|
|
? null
|
|
: Fragment$basicMutationReturnFields.fromJson(result);
|
|
}
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Query$AllServices {
|
|
Query$AllServices({required this.services, required this.$__typename});
|
|
|
|
@override
|
|
factory Query$AllServices.fromJson(Map<String, dynamic> json) =>
|
|
_$Query$AllServicesFromJson(json);
|
|
|
|
final Query$AllServices$services services;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() => _$Query$AllServicesToJson(this);
|
|
int get hashCode {
|
|
final l$services = services;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$services, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Query$AllServices) || runtimeType != other.runtimeType)
|
|
return false;
|
|
final l$services = services;
|
|
final lOther$services = other.services;
|
|
if (l$services != lOther$services) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Query$AllServices on Query$AllServices {
|
|
CopyWith$Query$AllServices<Query$AllServices> get copyWith =>
|
|
CopyWith$Query$AllServices(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Query$AllServices<TRes> {
|
|
factory CopyWith$Query$AllServices(
|
|
Query$AllServices instance, TRes Function(Query$AllServices) then) =
|
|
_CopyWithImpl$Query$AllServices;
|
|
|
|
factory CopyWith$Query$AllServices.stub(TRes res) =
|
|
_CopyWithStubImpl$Query$AllServices;
|
|
|
|
TRes call({Query$AllServices$services? services, String? $__typename});
|
|
CopyWith$Query$AllServices$services<TRes> get services;
|
|
}
|
|
|
|
class _CopyWithImpl$Query$AllServices<TRes>
|
|
implements CopyWith$Query$AllServices<TRes> {
|
|
_CopyWithImpl$Query$AllServices(this._instance, this._then);
|
|
|
|
final Query$AllServices _instance;
|
|
|
|
final TRes Function(Query$AllServices) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? services = _undefined, Object? $__typename = _undefined}) =>
|
|
_then(Query$AllServices(
|
|
services: services == _undefined || services == null
|
|
? _instance.services
|
|
: (services as Query$AllServices$services),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
CopyWith$Query$AllServices$services<TRes> get services {
|
|
final local$services = _instance.services;
|
|
return CopyWith$Query$AllServices$services(
|
|
local$services, (e) => call(services: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Query$AllServices<TRes>
|
|
implements CopyWith$Query$AllServices<TRes> {
|
|
_CopyWithStubImpl$Query$AllServices(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({Query$AllServices$services? services, String? $__typename}) => _res;
|
|
CopyWith$Query$AllServices$services<TRes> get services =>
|
|
CopyWith$Query$AllServices$services.stub(_res);
|
|
}
|
|
|
|
const documentNodeQueryAllServices = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.query,
|
|
name: NameNode(value: 'AllServices'),
|
|
variableDefinitions: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'services'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'allServices'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'description'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'displayName'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'dnsRecords'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FragmentSpreadNode(
|
|
name: NameNode(value: 'dnsRecordFields'),
|
|
directives: []),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: 'id'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'isEnabled'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'isMovable'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'isRequired'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'status'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'storageUsage'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'title'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'usedSpace'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'volume'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'name'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: 'svgIcon'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'url'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
fragmentDefinitiondnsRecordFields,
|
|
]);
|
|
Query$AllServices _parserFn$Query$AllServices(Map<String, dynamic> data) =>
|
|
Query$AllServices.fromJson(data);
|
|
|
|
class Options$Query$AllServices
|
|
extends graphql.QueryOptions<Query$AllServices> {
|
|
Options$Query$AllServices(
|
|
{String? operationName,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
Duration? pollInterval,
|
|
graphql.Context? context})
|
|
: super(
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
pollInterval: pollInterval,
|
|
context: context,
|
|
document: documentNodeQueryAllServices,
|
|
parserFn: _parserFn$Query$AllServices);
|
|
}
|
|
|
|
class WatchOptions$Query$AllServices
|
|
extends graphql.WatchQueryOptions<Query$AllServices> {
|
|
WatchOptions$Query$AllServices(
|
|
{String? operationName,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
Duration? pollInterval,
|
|
bool? eagerlyFetchResults,
|
|
bool carryForwardDataOnException = true,
|
|
bool fetchResults = false})
|
|
: super(
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
document: documentNodeQueryAllServices,
|
|
pollInterval: pollInterval,
|
|
eagerlyFetchResults: eagerlyFetchResults,
|
|
carryForwardDataOnException: carryForwardDataOnException,
|
|
fetchResults: fetchResults,
|
|
parserFn: _parserFn$Query$AllServices);
|
|
}
|
|
|
|
class FetchMoreOptions$Query$AllServices extends graphql.FetchMoreOptions {
|
|
FetchMoreOptions$Query$AllServices({required graphql.UpdateQuery updateQuery})
|
|
: super(updateQuery: updateQuery, document: documentNodeQueryAllServices);
|
|
}
|
|
|
|
extension ClientExtension$Query$AllServices on graphql.GraphQLClient {
|
|
Future<graphql.QueryResult<Query$AllServices>> query$AllServices(
|
|
[Options$Query$AllServices? options]) async =>
|
|
await this.query(options ?? Options$Query$AllServices());
|
|
graphql.ObservableQuery<Query$AllServices> watchQuery$AllServices(
|
|
[WatchOptions$Query$AllServices? options]) =>
|
|
this.watchQuery(options ?? WatchOptions$Query$AllServices());
|
|
void writeQuery$AllServices(
|
|
{required Query$AllServices data, bool broadcast = true}) =>
|
|
this.writeQuery(
|
|
graphql.Request(
|
|
operation:
|
|
graphql.Operation(document: documentNodeQueryAllServices)),
|
|
data: data.toJson(),
|
|
broadcast: broadcast);
|
|
Query$AllServices? readQuery$AllServices({bool optimistic = true}) {
|
|
final result = this.readQuery(
|
|
graphql.Request(
|
|
operation:
|
|
graphql.Operation(document: documentNodeQueryAllServices)),
|
|
optimistic: optimistic);
|
|
return result == null ? null : Query$AllServices.fromJson(result);
|
|
}
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Query$AllServices$services {
|
|
Query$AllServices$services(
|
|
{required this.allServices, required this.$__typename});
|
|
|
|
@override
|
|
factory Query$AllServices$services.fromJson(Map<String, dynamic> json) =>
|
|
_$Query$AllServices$servicesFromJson(json);
|
|
|
|
final List<Query$AllServices$services$allServices> allServices;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() => _$Query$AllServices$servicesToJson(this);
|
|
int get hashCode {
|
|
final l$allServices = allServices;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll(
|
|
[Object.hashAll(l$allServices.map((v) => v)), l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Query$AllServices$services) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$allServices = allServices;
|
|
final lOther$allServices = other.allServices;
|
|
if (l$allServices.length != lOther$allServices.length) return false;
|
|
for (int i = 0; i < l$allServices.length; i++) {
|
|
final l$allServices$entry = l$allServices[i];
|
|
final lOther$allServices$entry = lOther$allServices[i];
|
|
if (l$allServices$entry != lOther$allServices$entry) return false;
|
|
}
|
|
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Query$AllServices$services
|
|
on Query$AllServices$services {
|
|
CopyWith$Query$AllServices$services<Query$AllServices$services>
|
|
get copyWith => CopyWith$Query$AllServices$services(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Query$AllServices$services<TRes> {
|
|
factory CopyWith$Query$AllServices$services(
|
|
Query$AllServices$services instance,
|
|
TRes Function(Query$AllServices$services) then) =
|
|
_CopyWithImpl$Query$AllServices$services;
|
|
|
|
factory CopyWith$Query$AllServices$services.stub(TRes res) =
|
|
_CopyWithStubImpl$Query$AllServices$services;
|
|
|
|
TRes call(
|
|
{List<Query$AllServices$services$allServices>? allServices,
|
|
String? $__typename});
|
|
TRes allServices(
|
|
Iterable<Query$AllServices$services$allServices> Function(
|
|
Iterable<
|
|
CopyWith$Query$AllServices$services$allServices<
|
|
Query$AllServices$services$allServices>>)
|
|
_fn);
|
|
}
|
|
|
|
class _CopyWithImpl$Query$AllServices$services<TRes>
|
|
implements CopyWith$Query$AllServices$services<TRes> {
|
|
_CopyWithImpl$Query$AllServices$services(this._instance, this._then);
|
|
|
|
final Query$AllServices$services _instance;
|
|
|
|
final TRes Function(Query$AllServices$services) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? allServices = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Query$AllServices$services(
|
|
allServices: allServices == _undefined || allServices == null
|
|
? _instance.allServices
|
|
: (allServices as List<Query$AllServices$services$allServices>),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
TRes allServices(
|
|
Iterable<Query$AllServices$services$allServices> Function(
|
|
Iterable<
|
|
CopyWith$Query$AllServices$services$allServices<
|
|
Query$AllServices$services$allServices>>)
|
|
_fn) =>
|
|
call(
|
|
allServices: _fn(_instance.allServices.map((e) =>
|
|
CopyWith$Query$AllServices$services$allServices(e, (i) => i)))
|
|
.toList());
|
|
}
|
|
|
|
class _CopyWithStubImpl$Query$AllServices$services<TRes>
|
|
implements CopyWith$Query$AllServices$services<TRes> {
|
|
_CopyWithStubImpl$Query$AllServices$services(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call(
|
|
{List<Query$AllServices$services$allServices>? allServices,
|
|
String? $__typename}) =>
|
|
_res;
|
|
allServices(_fn) => _res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Query$AllServices$services$allServices {
|
|
Query$AllServices$services$allServices(
|
|
{required this.description,
|
|
required this.displayName,
|
|
this.dnsRecords,
|
|
required this.id,
|
|
required this.isEnabled,
|
|
required this.isMovable,
|
|
required this.isRequired,
|
|
required this.status,
|
|
required this.storageUsage,
|
|
required this.svgIcon,
|
|
this.url,
|
|
required this.$__typename});
|
|
|
|
@override
|
|
factory Query$AllServices$services$allServices.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Query$AllServices$services$allServicesFromJson(json);
|
|
|
|
final String description;
|
|
|
|
final String displayName;
|
|
|
|
final List<Fragment$dnsRecordFields>? dnsRecords;
|
|
|
|
final String id;
|
|
|
|
final bool isEnabled;
|
|
|
|
final bool isMovable;
|
|
|
|
final bool isRequired;
|
|
|
|
@JsonKey(unknownEnumValue: Enum$ServiceStatusEnum.$unknown)
|
|
final Enum$ServiceStatusEnum status;
|
|
|
|
final Query$AllServices$services$allServices$storageUsage storageUsage;
|
|
|
|
final String svgIcon;
|
|
|
|
final String? url;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Query$AllServices$services$allServicesToJson(this);
|
|
int get hashCode {
|
|
final l$description = description;
|
|
final l$displayName = displayName;
|
|
final l$dnsRecords = dnsRecords;
|
|
final l$id = id;
|
|
final l$isEnabled = isEnabled;
|
|
final l$isMovable = isMovable;
|
|
final l$isRequired = isRequired;
|
|
final l$status = status;
|
|
final l$storageUsage = storageUsage;
|
|
final l$svgIcon = svgIcon;
|
|
final l$url = url;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([
|
|
l$description,
|
|
l$displayName,
|
|
l$dnsRecords == null ? null : Object.hashAll(l$dnsRecords.map((v) => v)),
|
|
l$id,
|
|
l$isEnabled,
|
|
l$isMovable,
|
|
l$isRequired,
|
|
l$status,
|
|
l$storageUsage,
|
|
l$svgIcon,
|
|
l$url,
|
|
l$$__typename
|
|
]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Query$AllServices$services$allServices) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$description = description;
|
|
final lOther$description = other.description;
|
|
if (l$description != lOther$description) return false;
|
|
final l$displayName = displayName;
|
|
final lOther$displayName = other.displayName;
|
|
if (l$displayName != lOther$displayName) return false;
|
|
final l$dnsRecords = dnsRecords;
|
|
final lOther$dnsRecords = other.dnsRecords;
|
|
if (l$dnsRecords != null && lOther$dnsRecords != null) {
|
|
if (l$dnsRecords.length != lOther$dnsRecords.length) return false;
|
|
for (int i = 0; i < l$dnsRecords.length; i++) {
|
|
final l$dnsRecords$entry = l$dnsRecords[i];
|
|
final lOther$dnsRecords$entry = lOther$dnsRecords[i];
|
|
if (l$dnsRecords$entry != lOther$dnsRecords$entry) return false;
|
|
}
|
|
} else if (l$dnsRecords != lOther$dnsRecords) {
|
|
return false;
|
|
}
|
|
|
|
final l$id = id;
|
|
final lOther$id = other.id;
|
|
if (l$id != lOther$id) return false;
|
|
final l$isEnabled = isEnabled;
|
|
final lOther$isEnabled = other.isEnabled;
|
|
if (l$isEnabled != lOther$isEnabled) return false;
|
|
final l$isMovable = isMovable;
|
|
final lOther$isMovable = other.isMovable;
|
|
if (l$isMovable != lOther$isMovable) return false;
|
|
final l$isRequired = isRequired;
|
|
final lOther$isRequired = other.isRequired;
|
|
if (l$isRequired != lOther$isRequired) return false;
|
|
final l$status = status;
|
|
final lOther$status = other.status;
|
|
if (l$status != lOther$status) return false;
|
|
final l$storageUsage = storageUsage;
|
|
final lOther$storageUsage = other.storageUsage;
|
|
if (l$storageUsage != lOther$storageUsage) return false;
|
|
final l$svgIcon = svgIcon;
|
|
final lOther$svgIcon = other.svgIcon;
|
|
if (l$svgIcon != lOther$svgIcon) return false;
|
|
final l$url = url;
|
|
final lOther$url = other.url;
|
|
if (l$url != lOther$url) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Query$AllServices$services$allServices
|
|
on Query$AllServices$services$allServices {
|
|
CopyWith$Query$AllServices$services$allServices<
|
|
Query$AllServices$services$allServices>
|
|
get copyWith =>
|
|
CopyWith$Query$AllServices$services$allServices(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Query$AllServices$services$allServices<TRes> {
|
|
factory CopyWith$Query$AllServices$services$allServices(
|
|
Query$AllServices$services$allServices instance,
|
|
TRes Function(Query$AllServices$services$allServices) then) =
|
|
_CopyWithImpl$Query$AllServices$services$allServices;
|
|
|
|
factory CopyWith$Query$AllServices$services$allServices.stub(TRes res) =
|
|
_CopyWithStubImpl$Query$AllServices$services$allServices;
|
|
|
|
TRes call(
|
|
{String? description,
|
|
String? displayName,
|
|
List<Fragment$dnsRecordFields>? dnsRecords,
|
|
String? id,
|
|
bool? isEnabled,
|
|
bool? isMovable,
|
|
bool? isRequired,
|
|
Enum$ServiceStatusEnum? status,
|
|
Query$AllServices$services$allServices$storageUsage? storageUsage,
|
|
String? svgIcon,
|
|
String? url,
|
|
String? $__typename});
|
|
TRes dnsRecords(
|
|
Iterable<Fragment$dnsRecordFields>? Function(
|
|
Iterable<
|
|
CopyWith$Fragment$dnsRecordFields<Fragment$dnsRecordFields>>?)
|
|
_fn);
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage<TRes>
|
|
get storageUsage;
|
|
}
|
|
|
|
class _CopyWithImpl$Query$AllServices$services$allServices<TRes>
|
|
implements CopyWith$Query$AllServices$services$allServices<TRes> {
|
|
_CopyWithImpl$Query$AllServices$services$allServices(
|
|
this._instance, this._then);
|
|
|
|
final Query$AllServices$services$allServices _instance;
|
|
|
|
final TRes Function(Query$AllServices$services$allServices) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? description = _undefined,
|
|
Object? displayName = _undefined,
|
|
Object? dnsRecords = _undefined,
|
|
Object? id = _undefined,
|
|
Object? isEnabled = _undefined,
|
|
Object? isMovable = _undefined,
|
|
Object? isRequired = _undefined,
|
|
Object? status = _undefined,
|
|
Object? storageUsage = _undefined,
|
|
Object? svgIcon = _undefined,
|
|
Object? url = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Query$AllServices$services$allServices(
|
|
description: description == _undefined || description == null
|
|
? _instance.description
|
|
: (description as String),
|
|
displayName: displayName == _undefined || displayName == null
|
|
? _instance.displayName
|
|
: (displayName as String),
|
|
dnsRecords: dnsRecords == _undefined
|
|
? _instance.dnsRecords
|
|
: (dnsRecords as List<Fragment$dnsRecordFields>?),
|
|
id: id == _undefined || id == null ? _instance.id : (id as String),
|
|
isEnabled: isEnabled == _undefined || isEnabled == null
|
|
? _instance.isEnabled
|
|
: (isEnabled as bool),
|
|
isMovable: isMovable == _undefined || isMovable == null
|
|
? _instance.isMovable
|
|
: (isMovable as bool),
|
|
isRequired: isRequired == _undefined || isRequired == null
|
|
? _instance.isRequired
|
|
: (isRequired as bool),
|
|
status: status == _undefined || status == null
|
|
? _instance.status
|
|
: (status as Enum$ServiceStatusEnum),
|
|
storageUsage: storageUsage == _undefined || storageUsage == null
|
|
? _instance.storageUsage
|
|
: (storageUsage
|
|
as Query$AllServices$services$allServices$storageUsage),
|
|
svgIcon: svgIcon == _undefined || svgIcon == null
|
|
? _instance.svgIcon
|
|
: (svgIcon as String),
|
|
url: url == _undefined ? _instance.url : (url as String?),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
TRes dnsRecords(
|
|
Iterable<Fragment$dnsRecordFields>? Function(
|
|
Iterable<
|
|
CopyWith$Fragment$dnsRecordFields<
|
|
Fragment$dnsRecordFields>>?)
|
|
_fn) =>
|
|
call(
|
|
dnsRecords: _fn(_instance.dnsRecords
|
|
?.map((e) => CopyWith$Fragment$dnsRecordFields(e, (i) => i)))
|
|
?.toList());
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage<TRes>
|
|
get storageUsage {
|
|
final local$storageUsage = _instance.storageUsage;
|
|
return CopyWith$Query$AllServices$services$allServices$storageUsage(
|
|
local$storageUsage, (e) => call(storageUsage: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Query$AllServices$services$allServices<TRes>
|
|
implements CopyWith$Query$AllServices$services$allServices<TRes> {
|
|
_CopyWithStubImpl$Query$AllServices$services$allServices(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call(
|
|
{String? description,
|
|
String? displayName,
|
|
List<Fragment$dnsRecordFields>? dnsRecords,
|
|
String? id,
|
|
bool? isEnabled,
|
|
bool? isMovable,
|
|
bool? isRequired,
|
|
Enum$ServiceStatusEnum? status,
|
|
Query$AllServices$services$allServices$storageUsage? storageUsage,
|
|
String? svgIcon,
|
|
String? url,
|
|
String? $__typename}) =>
|
|
_res;
|
|
dnsRecords(_fn) => _res;
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage<TRes>
|
|
get storageUsage =>
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage.stub(
|
|
_res);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Query$AllServices$services$allServices$storageUsage {
|
|
Query$AllServices$services$allServices$storageUsage(
|
|
{required this.title,
|
|
required this.usedSpace,
|
|
this.volume,
|
|
required this.$__typename});
|
|
|
|
@override
|
|
factory Query$AllServices$services$allServices$storageUsage.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Query$AllServices$services$allServices$storageUsageFromJson(json);
|
|
|
|
final String title;
|
|
|
|
final String usedSpace;
|
|
|
|
final Query$AllServices$services$allServices$storageUsage$volume? volume;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Query$AllServices$services$allServices$storageUsageToJson(this);
|
|
int get hashCode {
|
|
final l$title = title;
|
|
final l$usedSpace = usedSpace;
|
|
final l$volume = volume;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$title, l$usedSpace, l$volume, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Query$AllServices$services$allServices$storageUsage) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$title = title;
|
|
final lOther$title = other.title;
|
|
if (l$title != lOther$title) return false;
|
|
final l$usedSpace = usedSpace;
|
|
final lOther$usedSpace = other.usedSpace;
|
|
if (l$usedSpace != lOther$usedSpace) return false;
|
|
final l$volume = volume;
|
|
final lOther$volume = other.volume;
|
|
if (l$volume != lOther$volume) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Query$AllServices$services$allServices$storageUsage
|
|
on Query$AllServices$services$allServices$storageUsage {
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage<
|
|
Query$AllServices$services$allServices$storageUsage>
|
|
get copyWith =>
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage(
|
|
this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Query$AllServices$services$allServices$storageUsage<
|
|
TRes> {
|
|
factory CopyWith$Query$AllServices$services$allServices$storageUsage(
|
|
Query$AllServices$services$allServices$storageUsage instance,
|
|
TRes Function(Query$AllServices$services$allServices$storageUsage)
|
|
then) =
|
|
_CopyWithImpl$Query$AllServices$services$allServices$storageUsage;
|
|
|
|
factory CopyWith$Query$AllServices$services$allServices$storageUsage.stub(
|
|
TRes res) =
|
|
_CopyWithStubImpl$Query$AllServices$services$allServices$storageUsage;
|
|
|
|
TRes call(
|
|
{String? title,
|
|
String? usedSpace,
|
|
Query$AllServices$services$allServices$storageUsage$volume? volume,
|
|
String? $__typename});
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage$volume<TRes>
|
|
get volume;
|
|
}
|
|
|
|
class _CopyWithImpl$Query$AllServices$services$allServices$storageUsage<TRes>
|
|
implements
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage<TRes> {
|
|
_CopyWithImpl$Query$AllServices$services$allServices$storageUsage(
|
|
this._instance, this._then);
|
|
|
|
final Query$AllServices$services$allServices$storageUsage _instance;
|
|
|
|
final TRes Function(Query$AllServices$services$allServices$storageUsage)
|
|
_then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? title = _undefined,
|
|
Object? usedSpace = _undefined,
|
|
Object? volume = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Query$AllServices$services$allServices$storageUsage(
|
|
title: title == _undefined || title == null
|
|
? _instance.title
|
|
: (title as String),
|
|
usedSpace: usedSpace == _undefined || usedSpace == null
|
|
? _instance.usedSpace
|
|
: (usedSpace as String),
|
|
volume: volume == _undefined
|
|
? _instance.volume
|
|
: (volume
|
|
as Query$AllServices$services$allServices$storageUsage$volume?),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage$volume<TRes>
|
|
get volume {
|
|
final local$volume = _instance.volume;
|
|
return local$volume == null
|
|
? CopyWith$Query$AllServices$services$allServices$storageUsage$volume
|
|
.stub(_then(_instance))
|
|
: CopyWith$Query$AllServices$services$allServices$storageUsage$volume(
|
|
local$volume, (e) => call(volume: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Query$AllServices$services$allServices$storageUsage<
|
|
TRes>
|
|
implements
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage<TRes> {
|
|
_CopyWithStubImpl$Query$AllServices$services$allServices$storageUsage(
|
|
this._res);
|
|
|
|
TRes _res;
|
|
|
|
call(
|
|
{String? title,
|
|
String? usedSpace,
|
|
Query$AllServices$services$allServices$storageUsage$volume? volume,
|
|
String? $__typename}) =>
|
|
_res;
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage$volume<TRes>
|
|
get volume =>
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage$volume
|
|
.stub(_res);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Query$AllServices$services$allServices$storageUsage$volume {
|
|
Query$AllServices$services$allServices$storageUsage$volume(
|
|
{required this.name, required this.$__typename});
|
|
|
|
@override
|
|
factory Query$AllServices$services$allServices$storageUsage$volume.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Query$AllServices$services$allServices$storageUsage$volumeFromJson(
|
|
json);
|
|
|
|
final String name;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Query$AllServices$services$allServices$storageUsage$volumeToJson(this);
|
|
int get hashCode {
|
|
final l$name = name;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$name, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other
|
|
is Query$AllServices$services$allServices$storageUsage$volume) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$name = name;
|
|
final lOther$name = other.name;
|
|
if (l$name != lOther$name) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Query$AllServices$services$allServices$storageUsage$volume
|
|
on Query$AllServices$services$allServices$storageUsage$volume {
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage$volume<
|
|
Query$AllServices$services$allServices$storageUsage$volume>
|
|
get copyWith =>
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage$volume(
|
|
this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Query$AllServices$services$allServices$storageUsage$volume<
|
|
TRes> {
|
|
factory CopyWith$Query$AllServices$services$allServices$storageUsage$volume(
|
|
Query$AllServices$services$allServices$storageUsage$volume instance,
|
|
TRes Function(
|
|
Query$AllServices$services$allServices$storageUsage$volume)
|
|
then) =
|
|
_CopyWithImpl$Query$AllServices$services$allServices$storageUsage$volume;
|
|
|
|
factory CopyWith$Query$AllServices$services$allServices$storageUsage$volume.stub(
|
|
TRes res) =
|
|
_CopyWithStubImpl$Query$AllServices$services$allServices$storageUsage$volume;
|
|
|
|
TRes call({String? name, String? $__typename});
|
|
}
|
|
|
|
class _CopyWithImpl$Query$AllServices$services$allServices$storageUsage$volume<
|
|
TRes>
|
|
implements
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage$volume<
|
|
TRes> {
|
|
_CopyWithImpl$Query$AllServices$services$allServices$storageUsage$volume(
|
|
this._instance, this._then);
|
|
|
|
final Query$AllServices$services$allServices$storageUsage$volume _instance;
|
|
|
|
final TRes Function(
|
|
Query$AllServices$services$allServices$storageUsage$volume) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call({Object? name = _undefined, Object? $__typename = _undefined}) =>
|
|
_then(Query$AllServices$services$allServices$storageUsage$volume(
|
|
name: name == _undefined || name == null
|
|
? _instance.name
|
|
: (name as String),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Query$AllServices$services$allServices$storageUsage$volume<
|
|
TRes>
|
|
implements
|
|
CopyWith$Query$AllServices$services$allServices$storageUsage$volume<
|
|
TRes> {
|
|
_CopyWithStubImpl$Query$AllServices$services$allServices$storageUsage$volume(
|
|
this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({String? name, String? $__typename}) => _res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Variables$Mutation$EnableService {
|
|
Variables$Mutation$EnableService({required this.serviceId});
|
|
|
|
@override
|
|
factory Variables$Mutation$EnableService.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Variables$Mutation$EnableServiceFromJson(json);
|
|
|
|
final String serviceId;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Variables$Mutation$EnableServiceToJson(this);
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Variables$Mutation$EnableService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$serviceId = serviceId;
|
|
final lOther$serviceId = other.serviceId;
|
|
if (l$serviceId != lOther$serviceId) return false;
|
|
return true;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$EnableService<Variables$Mutation$EnableService>
|
|
get copyWith => CopyWith$Variables$Mutation$EnableService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Variables$Mutation$EnableService<TRes> {
|
|
factory CopyWith$Variables$Mutation$EnableService(
|
|
Variables$Mutation$EnableService instance,
|
|
TRes Function(Variables$Mutation$EnableService) then) =
|
|
_CopyWithImpl$Variables$Mutation$EnableService;
|
|
|
|
factory CopyWith$Variables$Mutation$EnableService.stub(TRes res) =
|
|
_CopyWithStubImpl$Variables$Mutation$EnableService;
|
|
|
|
TRes call({String? serviceId});
|
|
}
|
|
|
|
class _CopyWithImpl$Variables$Mutation$EnableService<TRes>
|
|
implements CopyWith$Variables$Mutation$EnableService<TRes> {
|
|
_CopyWithImpl$Variables$Mutation$EnableService(this._instance, this._then);
|
|
|
|
final Variables$Mutation$EnableService _instance;
|
|
|
|
final TRes Function(Variables$Mutation$EnableService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$EnableService(
|
|
serviceId: serviceId == _undefined || serviceId == null
|
|
? _instance.serviceId
|
|
: (serviceId as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Variables$Mutation$EnableService<TRes>
|
|
implements CopyWith$Variables$Mutation$EnableService<TRes> {
|
|
_CopyWithStubImpl$Variables$Mutation$EnableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({String? serviceId}) => _res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$EnableService {
|
|
Mutation$EnableService(
|
|
{required this.enableService, required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$EnableService.fromJson(Map<String, dynamic> json) =>
|
|
_$Mutation$EnableServiceFromJson(json);
|
|
|
|
final Mutation$EnableService$enableService enableService;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() => _$Mutation$EnableServiceToJson(this);
|
|
int get hashCode {
|
|
final l$enableService = enableService;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$enableService, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$EnableService) || runtimeType != other.runtimeType)
|
|
return false;
|
|
final l$enableService = enableService;
|
|
final lOther$enableService = other.enableService;
|
|
if (l$enableService != lOther$enableService) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$EnableService on Mutation$EnableService {
|
|
CopyWith$Mutation$EnableService<Mutation$EnableService> get copyWith =>
|
|
CopyWith$Mutation$EnableService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$EnableService<TRes> {
|
|
factory CopyWith$Mutation$EnableService(Mutation$EnableService instance,
|
|
TRes Function(Mutation$EnableService) then) =
|
|
_CopyWithImpl$Mutation$EnableService;
|
|
|
|
factory CopyWith$Mutation$EnableService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$EnableService;
|
|
|
|
TRes call(
|
|
{Mutation$EnableService$enableService? enableService,
|
|
String? $__typename});
|
|
CopyWith$Mutation$EnableService$enableService<TRes> get enableService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$EnableService<TRes>
|
|
implements CopyWith$Mutation$EnableService<TRes> {
|
|
_CopyWithImpl$Mutation$EnableService(this._instance, this._then);
|
|
|
|
final Mutation$EnableService _instance;
|
|
|
|
final TRes Function(Mutation$EnableService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? enableService = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$EnableService(
|
|
enableService: enableService == _undefined || enableService == null
|
|
? _instance.enableService
|
|
: (enableService as Mutation$EnableService$enableService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
CopyWith$Mutation$EnableService$enableService<TRes> get enableService {
|
|
final local$enableService = _instance.enableService;
|
|
return CopyWith$Mutation$EnableService$enableService(
|
|
local$enableService, (e) => call(enableService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$EnableService<TRes>
|
|
implements CopyWith$Mutation$EnableService<TRes> {
|
|
_CopyWithStubImpl$Mutation$EnableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call(
|
|
{Mutation$EnableService$enableService? enableService,
|
|
String? $__typename}) =>
|
|
_res;
|
|
CopyWith$Mutation$EnableService$enableService<TRes> get enableService =>
|
|
CopyWith$Mutation$EnableService$enableService.stub(_res);
|
|
}
|
|
|
|
const documentNodeMutationEnableService = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.mutation,
|
|
name: NameNode(value: 'EnableService'),
|
|
variableDefinitions: [
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'serviceId')),
|
|
type:
|
|
NamedTypeNode(name: NameNode(value: 'String'), isNonNull: true),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: [])
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'enableService'),
|
|
alias: null,
|
|
arguments: [
|
|
ArgumentNode(
|
|
name: NameNode(value: 'serviceId'),
|
|
value: VariableNode(name: NameNode(value: 'serviceId')))
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FragmentSpreadNode(
|
|
name: NameNode(value: 'basicMutationReturnFields'),
|
|
directives: []),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
fragmentDefinitionbasicMutationReturnFields,
|
|
]);
|
|
Mutation$EnableService _parserFn$Mutation$EnableService(
|
|
Map<String, dynamic> data) =>
|
|
Mutation$EnableService.fromJson(data);
|
|
typedef OnMutationCompleted$Mutation$EnableService = FutureOr<void> Function(
|
|
dynamic, Mutation$EnableService?);
|
|
|
|
class Options$Mutation$EnableService
|
|
extends graphql.MutationOptions<Mutation$EnableService> {
|
|
Options$Mutation$EnableService(
|
|
{String? operationName,
|
|
required Variables$Mutation$EnableService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
OnMutationCompleted$Mutation$EnableService? onCompleted,
|
|
graphql.OnMutationUpdate<Mutation$EnableService>? update,
|
|
graphql.OnError? onError})
|
|
: onCompletedWithParsed = onCompleted,
|
|
super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
onCompleted: onCompleted == null
|
|
? null
|
|
: (data) => onCompleted(
|
|
data,
|
|
data == null
|
|
? null
|
|
: _parserFn$Mutation$EnableService(data)),
|
|
update: update,
|
|
onError: onError,
|
|
document: documentNodeMutationEnableService,
|
|
parserFn: _parserFn$Mutation$EnableService);
|
|
|
|
final OnMutationCompleted$Mutation$EnableService? onCompletedWithParsed;
|
|
|
|
@override
|
|
List<Object?> get properties => [
|
|
...super.onCompleted == null
|
|
? super.properties
|
|
: super.properties.where((property) => property != onCompleted),
|
|
onCompletedWithParsed
|
|
];
|
|
}
|
|
|
|
class WatchOptions$Mutation$EnableService
|
|
extends graphql.WatchQueryOptions<Mutation$EnableService> {
|
|
WatchOptions$Mutation$EnableService(
|
|
{String? operationName,
|
|
required Variables$Mutation$EnableService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
Duration? pollInterval,
|
|
bool? eagerlyFetchResults,
|
|
bool carryForwardDataOnException = true,
|
|
bool fetchResults = false})
|
|
: super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
document: documentNodeMutationEnableService,
|
|
pollInterval: pollInterval,
|
|
eagerlyFetchResults: eagerlyFetchResults,
|
|
carryForwardDataOnException: carryForwardDataOnException,
|
|
fetchResults: fetchResults,
|
|
parserFn: _parserFn$Mutation$EnableService);
|
|
}
|
|
|
|
extension ClientExtension$Mutation$EnableService on graphql.GraphQLClient {
|
|
Future<graphql.QueryResult<Mutation$EnableService>> mutate$EnableService(
|
|
Options$Mutation$EnableService options) async =>
|
|
await this.mutate(options);
|
|
graphql.ObservableQuery<Mutation$EnableService> watchMutation$EnableService(
|
|
WatchOptions$Mutation$EnableService options) =>
|
|
this.watchMutation(options);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$EnableService$enableService
|
|
implements Fragment$basicMutationReturnFields {
|
|
Mutation$EnableService$enableService(
|
|
{required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$EnableService$enableService.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Mutation$EnableService$enableServiceFromJson(json);
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Mutation$EnableService$enableServiceToJson(this);
|
|
int get hashCode {
|
|
final l$code = code;
|
|
final l$message = message;
|
|
final l$success = success;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$code, l$message, l$success, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$EnableService$enableService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$code = code;
|
|
final lOther$code = other.code;
|
|
if (l$code != lOther$code) return false;
|
|
final l$message = message;
|
|
final lOther$message = other.message;
|
|
if (l$message != lOther$message) return false;
|
|
final l$success = success;
|
|
final lOther$success = other.success;
|
|
if (l$success != lOther$success) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$EnableService$enableService
|
|
on Mutation$EnableService$enableService {
|
|
CopyWith$Mutation$EnableService$enableService<
|
|
Mutation$EnableService$enableService>
|
|
get copyWith =>
|
|
CopyWith$Mutation$EnableService$enableService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$EnableService$enableService<TRes> {
|
|
factory CopyWith$Mutation$EnableService$enableService(
|
|
Mutation$EnableService$enableService instance,
|
|
TRes Function(Mutation$EnableService$enableService) then) =
|
|
_CopyWithImpl$Mutation$EnableService$enableService;
|
|
|
|
factory CopyWith$Mutation$EnableService$enableService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$EnableService$enableService;
|
|
|
|
TRes call({int? code, String? message, bool? success, String? $__typename});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$EnableService$enableService<TRes>
|
|
implements CopyWith$Mutation$EnableService$enableService<TRes> {
|
|
_CopyWithImpl$Mutation$EnableService$enableService(
|
|
this._instance, this._then);
|
|
|
|
final Mutation$EnableService$enableService _instance;
|
|
|
|
final TRes Function(Mutation$EnableService$enableService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$EnableService$enableService(
|
|
code: code == _undefined || code == null
|
|
? _instance.code
|
|
: (code as int),
|
|
message: message == _undefined || message == null
|
|
? _instance.message
|
|
: (message as String),
|
|
success: success == _undefined || success == null
|
|
? _instance.success
|
|
: (success as bool),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$EnableService$enableService<TRes>
|
|
implements CopyWith$Mutation$EnableService$enableService<TRes> {
|
|
_CopyWithStubImpl$Mutation$EnableService$enableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({int? code, String? message, bool? success, String? $__typename}) =>
|
|
_res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Variables$Mutation$DisableService {
|
|
Variables$Mutation$DisableService({required this.serviceId});
|
|
|
|
@override
|
|
factory Variables$Mutation$DisableService.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Variables$Mutation$DisableServiceFromJson(json);
|
|
|
|
final String serviceId;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Variables$Mutation$DisableServiceToJson(this);
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Variables$Mutation$DisableService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$serviceId = serviceId;
|
|
final lOther$serviceId = other.serviceId;
|
|
if (l$serviceId != lOther$serviceId) return false;
|
|
return true;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$DisableService<Variables$Mutation$DisableService>
|
|
get copyWith =>
|
|
CopyWith$Variables$Mutation$DisableService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Variables$Mutation$DisableService<TRes> {
|
|
factory CopyWith$Variables$Mutation$DisableService(
|
|
Variables$Mutation$DisableService instance,
|
|
TRes Function(Variables$Mutation$DisableService) then) =
|
|
_CopyWithImpl$Variables$Mutation$DisableService;
|
|
|
|
factory CopyWith$Variables$Mutation$DisableService.stub(TRes res) =
|
|
_CopyWithStubImpl$Variables$Mutation$DisableService;
|
|
|
|
TRes call({String? serviceId});
|
|
}
|
|
|
|
class _CopyWithImpl$Variables$Mutation$DisableService<TRes>
|
|
implements CopyWith$Variables$Mutation$DisableService<TRes> {
|
|
_CopyWithImpl$Variables$Mutation$DisableService(this._instance, this._then);
|
|
|
|
final Variables$Mutation$DisableService _instance;
|
|
|
|
final TRes Function(Variables$Mutation$DisableService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$DisableService(
|
|
serviceId: serviceId == _undefined || serviceId == null
|
|
? _instance.serviceId
|
|
: (serviceId as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Variables$Mutation$DisableService<TRes>
|
|
implements CopyWith$Variables$Mutation$DisableService<TRes> {
|
|
_CopyWithStubImpl$Variables$Mutation$DisableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({String? serviceId}) => _res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$DisableService {
|
|
Mutation$DisableService(
|
|
{required this.disableService, required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$DisableService.fromJson(Map<String, dynamic> json) =>
|
|
_$Mutation$DisableServiceFromJson(json);
|
|
|
|
final Mutation$DisableService$disableService disableService;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() => _$Mutation$DisableServiceToJson(this);
|
|
int get hashCode {
|
|
final l$disableService = disableService;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$disableService, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$DisableService) || runtimeType != other.runtimeType)
|
|
return false;
|
|
final l$disableService = disableService;
|
|
final lOther$disableService = other.disableService;
|
|
if (l$disableService != lOther$disableService) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$DisableService on Mutation$DisableService {
|
|
CopyWith$Mutation$DisableService<Mutation$DisableService> get copyWith =>
|
|
CopyWith$Mutation$DisableService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$DisableService<TRes> {
|
|
factory CopyWith$Mutation$DisableService(Mutation$DisableService instance,
|
|
TRes Function(Mutation$DisableService) then) =
|
|
_CopyWithImpl$Mutation$DisableService;
|
|
|
|
factory CopyWith$Mutation$DisableService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$DisableService;
|
|
|
|
TRes call(
|
|
{Mutation$DisableService$disableService? disableService,
|
|
String? $__typename});
|
|
CopyWith$Mutation$DisableService$disableService<TRes> get disableService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$DisableService<TRes>
|
|
implements CopyWith$Mutation$DisableService<TRes> {
|
|
_CopyWithImpl$Mutation$DisableService(this._instance, this._then);
|
|
|
|
final Mutation$DisableService _instance;
|
|
|
|
final TRes Function(Mutation$DisableService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? disableService = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$DisableService(
|
|
disableService: disableService == _undefined || disableService == null
|
|
? _instance.disableService
|
|
: (disableService as Mutation$DisableService$disableService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
CopyWith$Mutation$DisableService$disableService<TRes> get disableService {
|
|
final local$disableService = _instance.disableService;
|
|
return CopyWith$Mutation$DisableService$disableService(
|
|
local$disableService, (e) => call(disableService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$DisableService<TRes>
|
|
implements CopyWith$Mutation$DisableService<TRes> {
|
|
_CopyWithStubImpl$Mutation$DisableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call(
|
|
{Mutation$DisableService$disableService? disableService,
|
|
String? $__typename}) =>
|
|
_res;
|
|
CopyWith$Mutation$DisableService$disableService<TRes> get disableService =>
|
|
CopyWith$Mutation$DisableService$disableService.stub(_res);
|
|
}
|
|
|
|
const documentNodeMutationDisableService = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.mutation,
|
|
name: NameNode(value: 'DisableService'),
|
|
variableDefinitions: [
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'serviceId')),
|
|
type:
|
|
NamedTypeNode(name: NameNode(value: 'String'), isNonNull: true),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: [])
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'disableService'),
|
|
alias: null,
|
|
arguments: [
|
|
ArgumentNode(
|
|
name: NameNode(value: 'serviceId'),
|
|
value: VariableNode(name: NameNode(value: 'serviceId')))
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FragmentSpreadNode(
|
|
name: NameNode(value: 'basicMutationReturnFields'),
|
|
directives: []),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
fragmentDefinitionbasicMutationReturnFields,
|
|
]);
|
|
Mutation$DisableService _parserFn$Mutation$DisableService(
|
|
Map<String, dynamic> data) =>
|
|
Mutation$DisableService.fromJson(data);
|
|
typedef OnMutationCompleted$Mutation$DisableService = FutureOr<void> Function(
|
|
dynamic, Mutation$DisableService?);
|
|
|
|
class Options$Mutation$DisableService
|
|
extends graphql.MutationOptions<Mutation$DisableService> {
|
|
Options$Mutation$DisableService(
|
|
{String? operationName,
|
|
required Variables$Mutation$DisableService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
OnMutationCompleted$Mutation$DisableService? onCompleted,
|
|
graphql.OnMutationUpdate<Mutation$DisableService>? update,
|
|
graphql.OnError? onError})
|
|
: onCompletedWithParsed = onCompleted,
|
|
super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
onCompleted: onCompleted == null
|
|
? null
|
|
: (data) => onCompleted(
|
|
data,
|
|
data == null
|
|
? null
|
|
: _parserFn$Mutation$DisableService(data)),
|
|
update: update,
|
|
onError: onError,
|
|
document: documentNodeMutationDisableService,
|
|
parserFn: _parserFn$Mutation$DisableService);
|
|
|
|
final OnMutationCompleted$Mutation$DisableService? onCompletedWithParsed;
|
|
|
|
@override
|
|
List<Object?> get properties => [
|
|
...super.onCompleted == null
|
|
? super.properties
|
|
: super.properties.where((property) => property != onCompleted),
|
|
onCompletedWithParsed
|
|
];
|
|
}
|
|
|
|
class WatchOptions$Mutation$DisableService
|
|
extends graphql.WatchQueryOptions<Mutation$DisableService> {
|
|
WatchOptions$Mutation$DisableService(
|
|
{String? operationName,
|
|
required Variables$Mutation$DisableService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
Duration? pollInterval,
|
|
bool? eagerlyFetchResults,
|
|
bool carryForwardDataOnException = true,
|
|
bool fetchResults = false})
|
|
: super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
document: documentNodeMutationDisableService,
|
|
pollInterval: pollInterval,
|
|
eagerlyFetchResults: eagerlyFetchResults,
|
|
carryForwardDataOnException: carryForwardDataOnException,
|
|
fetchResults: fetchResults,
|
|
parserFn: _parserFn$Mutation$DisableService);
|
|
}
|
|
|
|
extension ClientExtension$Mutation$DisableService on graphql.GraphQLClient {
|
|
Future<graphql.QueryResult<Mutation$DisableService>> mutate$DisableService(
|
|
Options$Mutation$DisableService options) async =>
|
|
await this.mutate(options);
|
|
graphql.ObservableQuery<Mutation$DisableService> watchMutation$DisableService(
|
|
WatchOptions$Mutation$DisableService options) =>
|
|
this.watchMutation(options);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$DisableService$disableService
|
|
implements Fragment$basicMutationReturnFields {
|
|
Mutation$DisableService$disableService(
|
|
{required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$DisableService$disableService.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Mutation$DisableService$disableServiceFromJson(json);
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Mutation$DisableService$disableServiceToJson(this);
|
|
int get hashCode {
|
|
final l$code = code;
|
|
final l$message = message;
|
|
final l$success = success;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$code, l$message, l$success, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$DisableService$disableService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$code = code;
|
|
final lOther$code = other.code;
|
|
if (l$code != lOther$code) return false;
|
|
final l$message = message;
|
|
final lOther$message = other.message;
|
|
if (l$message != lOther$message) return false;
|
|
final l$success = success;
|
|
final lOther$success = other.success;
|
|
if (l$success != lOther$success) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$DisableService$disableService
|
|
on Mutation$DisableService$disableService {
|
|
CopyWith$Mutation$DisableService$disableService<
|
|
Mutation$DisableService$disableService>
|
|
get copyWith =>
|
|
CopyWith$Mutation$DisableService$disableService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$DisableService$disableService<TRes> {
|
|
factory CopyWith$Mutation$DisableService$disableService(
|
|
Mutation$DisableService$disableService instance,
|
|
TRes Function(Mutation$DisableService$disableService) then) =
|
|
_CopyWithImpl$Mutation$DisableService$disableService;
|
|
|
|
factory CopyWith$Mutation$DisableService$disableService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$DisableService$disableService;
|
|
|
|
TRes call({int? code, String? message, bool? success, String? $__typename});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$DisableService$disableService<TRes>
|
|
implements CopyWith$Mutation$DisableService$disableService<TRes> {
|
|
_CopyWithImpl$Mutation$DisableService$disableService(
|
|
this._instance, this._then);
|
|
|
|
final Mutation$DisableService$disableService _instance;
|
|
|
|
final TRes Function(Mutation$DisableService$disableService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$DisableService$disableService(
|
|
code: code == _undefined || code == null
|
|
? _instance.code
|
|
: (code as int),
|
|
message: message == _undefined || message == null
|
|
? _instance.message
|
|
: (message as String),
|
|
success: success == _undefined || success == null
|
|
? _instance.success
|
|
: (success as bool),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$DisableService$disableService<TRes>
|
|
implements CopyWith$Mutation$DisableService$disableService<TRes> {
|
|
_CopyWithStubImpl$Mutation$DisableService$disableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({int? code, String? message, bool? success, String? $__typename}) =>
|
|
_res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Variables$Mutation$StopService {
|
|
Variables$Mutation$StopService({required this.serviceId});
|
|
|
|
@override
|
|
factory Variables$Mutation$StopService.fromJson(Map<String, dynamic> json) =>
|
|
_$Variables$Mutation$StopServiceFromJson(json);
|
|
|
|
final String serviceId;
|
|
|
|
Map<String, dynamic> toJson() => _$Variables$Mutation$StopServiceToJson(this);
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Variables$Mutation$StopService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$serviceId = serviceId;
|
|
final lOther$serviceId = other.serviceId;
|
|
if (l$serviceId != lOther$serviceId) return false;
|
|
return true;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$StopService<Variables$Mutation$StopService>
|
|
get copyWith => CopyWith$Variables$Mutation$StopService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Variables$Mutation$StopService<TRes> {
|
|
factory CopyWith$Variables$Mutation$StopService(
|
|
Variables$Mutation$StopService instance,
|
|
TRes Function(Variables$Mutation$StopService) then) =
|
|
_CopyWithImpl$Variables$Mutation$StopService;
|
|
|
|
factory CopyWith$Variables$Mutation$StopService.stub(TRes res) =
|
|
_CopyWithStubImpl$Variables$Mutation$StopService;
|
|
|
|
TRes call({String? serviceId});
|
|
}
|
|
|
|
class _CopyWithImpl$Variables$Mutation$StopService<TRes>
|
|
implements CopyWith$Variables$Mutation$StopService<TRes> {
|
|
_CopyWithImpl$Variables$Mutation$StopService(this._instance, this._then);
|
|
|
|
final Variables$Mutation$StopService _instance;
|
|
|
|
final TRes Function(Variables$Mutation$StopService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$StopService(
|
|
serviceId: serviceId == _undefined || serviceId == null
|
|
? _instance.serviceId
|
|
: (serviceId as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Variables$Mutation$StopService<TRes>
|
|
implements CopyWith$Variables$Mutation$StopService<TRes> {
|
|
_CopyWithStubImpl$Variables$Mutation$StopService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({String? serviceId}) => _res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$StopService {
|
|
Mutation$StopService({required this.stopService, required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$StopService.fromJson(Map<String, dynamic> json) =>
|
|
_$Mutation$StopServiceFromJson(json);
|
|
|
|
final Mutation$StopService$stopService stopService;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() => _$Mutation$StopServiceToJson(this);
|
|
int get hashCode {
|
|
final l$stopService = stopService;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$stopService, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$StopService) || runtimeType != other.runtimeType)
|
|
return false;
|
|
final l$stopService = stopService;
|
|
final lOther$stopService = other.stopService;
|
|
if (l$stopService != lOther$stopService) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$StopService on Mutation$StopService {
|
|
CopyWith$Mutation$StopService<Mutation$StopService> get copyWith =>
|
|
CopyWith$Mutation$StopService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$StopService<TRes> {
|
|
factory CopyWith$Mutation$StopService(Mutation$StopService instance,
|
|
TRes Function(Mutation$StopService) then) =
|
|
_CopyWithImpl$Mutation$StopService;
|
|
|
|
factory CopyWith$Mutation$StopService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$StopService;
|
|
|
|
TRes call(
|
|
{Mutation$StopService$stopService? stopService, String? $__typename});
|
|
CopyWith$Mutation$StopService$stopService<TRes> get stopService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$StopService<TRes>
|
|
implements CopyWith$Mutation$StopService<TRes> {
|
|
_CopyWithImpl$Mutation$StopService(this._instance, this._then);
|
|
|
|
final Mutation$StopService _instance;
|
|
|
|
final TRes Function(Mutation$StopService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? stopService = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$StopService(
|
|
stopService: stopService == _undefined || stopService == null
|
|
? _instance.stopService
|
|
: (stopService as Mutation$StopService$stopService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
CopyWith$Mutation$StopService$stopService<TRes> get stopService {
|
|
final local$stopService = _instance.stopService;
|
|
return CopyWith$Mutation$StopService$stopService(
|
|
local$stopService, (e) => call(stopService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$StopService<TRes>
|
|
implements CopyWith$Mutation$StopService<TRes> {
|
|
_CopyWithStubImpl$Mutation$StopService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({Mutation$StopService$stopService? stopService, String? $__typename}) =>
|
|
_res;
|
|
CopyWith$Mutation$StopService$stopService<TRes> get stopService =>
|
|
CopyWith$Mutation$StopService$stopService.stub(_res);
|
|
}
|
|
|
|
const documentNodeMutationStopService = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.mutation,
|
|
name: NameNode(value: 'StopService'),
|
|
variableDefinitions: [
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'serviceId')),
|
|
type:
|
|
NamedTypeNode(name: NameNode(value: 'String'), isNonNull: true),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: [])
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'stopService'),
|
|
alias: null,
|
|
arguments: [
|
|
ArgumentNode(
|
|
name: NameNode(value: 'serviceId'),
|
|
value: VariableNode(name: NameNode(value: 'serviceId')))
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FragmentSpreadNode(
|
|
name: NameNode(value: 'basicMutationReturnFields'),
|
|
directives: []),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
fragmentDefinitionbasicMutationReturnFields,
|
|
]);
|
|
Mutation$StopService _parserFn$Mutation$StopService(
|
|
Map<String, dynamic> data) =>
|
|
Mutation$StopService.fromJson(data);
|
|
typedef OnMutationCompleted$Mutation$StopService = FutureOr<void> Function(
|
|
dynamic, Mutation$StopService?);
|
|
|
|
class Options$Mutation$StopService
|
|
extends graphql.MutationOptions<Mutation$StopService> {
|
|
Options$Mutation$StopService(
|
|
{String? operationName,
|
|
required Variables$Mutation$StopService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
OnMutationCompleted$Mutation$StopService? onCompleted,
|
|
graphql.OnMutationUpdate<Mutation$StopService>? update,
|
|
graphql.OnError? onError})
|
|
: onCompletedWithParsed = onCompleted,
|
|
super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
onCompleted: onCompleted == null
|
|
? null
|
|
: (data) => onCompleted(data,
|
|
data == null ? null : _parserFn$Mutation$StopService(data)),
|
|
update: update,
|
|
onError: onError,
|
|
document: documentNodeMutationStopService,
|
|
parserFn: _parserFn$Mutation$StopService);
|
|
|
|
final OnMutationCompleted$Mutation$StopService? onCompletedWithParsed;
|
|
|
|
@override
|
|
List<Object?> get properties => [
|
|
...super.onCompleted == null
|
|
? super.properties
|
|
: super.properties.where((property) => property != onCompleted),
|
|
onCompletedWithParsed
|
|
];
|
|
}
|
|
|
|
class WatchOptions$Mutation$StopService
|
|
extends graphql.WatchQueryOptions<Mutation$StopService> {
|
|
WatchOptions$Mutation$StopService(
|
|
{String? operationName,
|
|
required Variables$Mutation$StopService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
Duration? pollInterval,
|
|
bool? eagerlyFetchResults,
|
|
bool carryForwardDataOnException = true,
|
|
bool fetchResults = false})
|
|
: super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
document: documentNodeMutationStopService,
|
|
pollInterval: pollInterval,
|
|
eagerlyFetchResults: eagerlyFetchResults,
|
|
carryForwardDataOnException: carryForwardDataOnException,
|
|
fetchResults: fetchResults,
|
|
parserFn: _parserFn$Mutation$StopService);
|
|
}
|
|
|
|
extension ClientExtension$Mutation$StopService on graphql.GraphQLClient {
|
|
Future<graphql.QueryResult<Mutation$StopService>> mutate$StopService(
|
|
Options$Mutation$StopService options) async =>
|
|
await this.mutate(options);
|
|
graphql.ObservableQuery<Mutation$StopService> watchMutation$StopService(
|
|
WatchOptions$Mutation$StopService options) =>
|
|
this.watchMutation(options);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$StopService$stopService
|
|
implements Fragment$basicMutationReturnFields {
|
|
Mutation$StopService$stopService(
|
|
{required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$StopService$stopService.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Mutation$StopService$stopServiceFromJson(json);
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Mutation$StopService$stopServiceToJson(this);
|
|
int get hashCode {
|
|
final l$code = code;
|
|
final l$message = message;
|
|
final l$success = success;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$code, l$message, l$success, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$StopService$stopService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$code = code;
|
|
final lOther$code = other.code;
|
|
if (l$code != lOther$code) return false;
|
|
final l$message = message;
|
|
final lOther$message = other.message;
|
|
if (l$message != lOther$message) return false;
|
|
final l$success = success;
|
|
final lOther$success = other.success;
|
|
if (l$success != lOther$success) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$StopService$stopService
|
|
on Mutation$StopService$stopService {
|
|
CopyWith$Mutation$StopService$stopService<Mutation$StopService$stopService>
|
|
get copyWith => CopyWith$Mutation$StopService$stopService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$StopService$stopService<TRes> {
|
|
factory CopyWith$Mutation$StopService$stopService(
|
|
Mutation$StopService$stopService instance,
|
|
TRes Function(Mutation$StopService$stopService) then) =
|
|
_CopyWithImpl$Mutation$StopService$stopService;
|
|
|
|
factory CopyWith$Mutation$StopService$stopService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$StopService$stopService;
|
|
|
|
TRes call({int? code, String? message, bool? success, String? $__typename});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$StopService$stopService<TRes>
|
|
implements CopyWith$Mutation$StopService$stopService<TRes> {
|
|
_CopyWithImpl$Mutation$StopService$stopService(this._instance, this._then);
|
|
|
|
final Mutation$StopService$stopService _instance;
|
|
|
|
final TRes Function(Mutation$StopService$stopService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$StopService$stopService(
|
|
code: code == _undefined || code == null
|
|
? _instance.code
|
|
: (code as int),
|
|
message: message == _undefined || message == null
|
|
? _instance.message
|
|
: (message as String),
|
|
success: success == _undefined || success == null
|
|
? _instance.success
|
|
: (success as bool),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$StopService$stopService<TRes>
|
|
implements CopyWith$Mutation$StopService$stopService<TRes> {
|
|
_CopyWithStubImpl$Mutation$StopService$stopService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({int? code, String? message, bool? success, String? $__typename}) =>
|
|
_res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Variables$Mutation$StartService {
|
|
Variables$Mutation$StartService({required this.serviceId});
|
|
|
|
@override
|
|
factory Variables$Mutation$StartService.fromJson(Map<String, dynamic> json) =>
|
|
_$Variables$Mutation$StartServiceFromJson(json);
|
|
|
|
final String serviceId;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Variables$Mutation$StartServiceToJson(this);
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Variables$Mutation$StartService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$serviceId = serviceId;
|
|
final lOther$serviceId = other.serviceId;
|
|
if (l$serviceId != lOther$serviceId) return false;
|
|
return true;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$StartService<Variables$Mutation$StartService>
|
|
get copyWith => CopyWith$Variables$Mutation$StartService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Variables$Mutation$StartService<TRes> {
|
|
factory CopyWith$Variables$Mutation$StartService(
|
|
Variables$Mutation$StartService instance,
|
|
TRes Function(Variables$Mutation$StartService) then) =
|
|
_CopyWithImpl$Variables$Mutation$StartService;
|
|
|
|
factory CopyWith$Variables$Mutation$StartService.stub(TRes res) =
|
|
_CopyWithStubImpl$Variables$Mutation$StartService;
|
|
|
|
TRes call({String? serviceId});
|
|
}
|
|
|
|
class _CopyWithImpl$Variables$Mutation$StartService<TRes>
|
|
implements CopyWith$Variables$Mutation$StartService<TRes> {
|
|
_CopyWithImpl$Variables$Mutation$StartService(this._instance, this._then);
|
|
|
|
final Variables$Mutation$StartService _instance;
|
|
|
|
final TRes Function(Variables$Mutation$StartService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$StartService(
|
|
serviceId: serviceId == _undefined || serviceId == null
|
|
? _instance.serviceId
|
|
: (serviceId as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Variables$Mutation$StartService<TRes>
|
|
implements CopyWith$Variables$Mutation$StartService<TRes> {
|
|
_CopyWithStubImpl$Variables$Mutation$StartService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({String? serviceId}) => _res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$StartService {
|
|
Mutation$StartService(
|
|
{required this.startService, required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$StartService.fromJson(Map<String, dynamic> json) =>
|
|
_$Mutation$StartServiceFromJson(json);
|
|
|
|
final Mutation$StartService$startService startService;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() => _$Mutation$StartServiceToJson(this);
|
|
int get hashCode {
|
|
final l$startService = startService;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$startService, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$StartService) || runtimeType != other.runtimeType)
|
|
return false;
|
|
final l$startService = startService;
|
|
final lOther$startService = other.startService;
|
|
if (l$startService != lOther$startService) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$StartService on Mutation$StartService {
|
|
CopyWith$Mutation$StartService<Mutation$StartService> get copyWith =>
|
|
CopyWith$Mutation$StartService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$StartService<TRes> {
|
|
factory CopyWith$Mutation$StartService(Mutation$StartService instance,
|
|
TRes Function(Mutation$StartService) then) =
|
|
_CopyWithImpl$Mutation$StartService;
|
|
|
|
factory CopyWith$Mutation$StartService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$StartService;
|
|
|
|
TRes call(
|
|
{Mutation$StartService$startService? startService, String? $__typename});
|
|
CopyWith$Mutation$StartService$startService<TRes> get startService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$StartService<TRes>
|
|
implements CopyWith$Mutation$StartService<TRes> {
|
|
_CopyWithImpl$Mutation$StartService(this._instance, this._then);
|
|
|
|
final Mutation$StartService _instance;
|
|
|
|
final TRes Function(Mutation$StartService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? startService = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$StartService(
|
|
startService: startService == _undefined || startService == null
|
|
? _instance.startService
|
|
: (startService as Mutation$StartService$startService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
CopyWith$Mutation$StartService$startService<TRes> get startService {
|
|
final local$startService = _instance.startService;
|
|
return CopyWith$Mutation$StartService$startService(
|
|
local$startService, (e) => call(startService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$StartService<TRes>
|
|
implements CopyWith$Mutation$StartService<TRes> {
|
|
_CopyWithStubImpl$Mutation$StartService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call(
|
|
{Mutation$StartService$startService? startService,
|
|
String? $__typename}) =>
|
|
_res;
|
|
CopyWith$Mutation$StartService$startService<TRes> get startService =>
|
|
CopyWith$Mutation$StartService$startService.stub(_res);
|
|
}
|
|
|
|
const documentNodeMutationStartService = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.mutation,
|
|
name: NameNode(value: 'StartService'),
|
|
variableDefinitions: [
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'serviceId')),
|
|
type:
|
|
NamedTypeNode(name: NameNode(value: 'String'), isNonNull: true),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: [])
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'startService'),
|
|
alias: null,
|
|
arguments: [
|
|
ArgumentNode(
|
|
name: NameNode(value: 'serviceId'),
|
|
value: VariableNode(name: NameNode(value: 'serviceId')))
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FragmentSpreadNode(
|
|
name: NameNode(value: 'basicMutationReturnFields'),
|
|
directives: []),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
fragmentDefinitionbasicMutationReturnFields,
|
|
]);
|
|
Mutation$StartService _parserFn$Mutation$StartService(
|
|
Map<String, dynamic> data) =>
|
|
Mutation$StartService.fromJson(data);
|
|
typedef OnMutationCompleted$Mutation$StartService = FutureOr<void> Function(
|
|
dynamic, Mutation$StartService?);
|
|
|
|
class Options$Mutation$StartService
|
|
extends graphql.MutationOptions<Mutation$StartService> {
|
|
Options$Mutation$StartService(
|
|
{String? operationName,
|
|
required Variables$Mutation$StartService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
OnMutationCompleted$Mutation$StartService? onCompleted,
|
|
graphql.OnMutationUpdate<Mutation$StartService>? update,
|
|
graphql.OnError? onError})
|
|
: onCompletedWithParsed = onCompleted,
|
|
super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
onCompleted: onCompleted == null
|
|
? null
|
|
: (data) => onCompleted(
|
|
data,
|
|
data == null
|
|
? null
|
|
: _parserFn$Mutation$StartService(data)),
|
|
update: update,
|
|
onError: onError,
|
|
document: documentNodeMutationStartService,
|
|
parserFn: _parserFn$Mutation$StartService);
|
|
|
|
final OnMutationCompleted$Mutation$StartService? onCompletedWithParsed;
|
|
|
|
@override
|
|
List<Object?> get properties => [
|
|
...super.onCompleted == null
|
|
? super.properties
|
|
: super.properties.where((property) => property != onCompleted),
|
|
onCompletedWithParsed
|
|
];
|
|
}
|
|
|
|
class WatchOptions$Mutation$StartService
|
|
extends graphql.WatchQueryOptions<Mutation$StartService> {
|
|
WatchOptions$Mutation$StartService(
|
|
{String? operationName,
|
|
required Variables$Mutation$StartService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
Duration? pollInterval,
|
|
bool? eagerlyFetchResults,
|
|
bool carryForwardDataOnException = true,
|
|
bool fetchResults = false})
|
|
: super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
document: documentNodeMutationStartService,
|
|
pollInterval: pollInterval,
|
|
eagerlyFetchResults: eagerlyFetchResults,
|
|
carryForwardDataOnException: carryForwardDataOnException,
|
|
fetchResults: fetchResults,
|
|
parserFn: _parserFn$Mutation$StartService);
|
|
}
|
|
|
|
extension ClientExtension$Mutation$StartService on graphql.GraphQLClient {
|
|
Future<graphql.QueryResult<Mutation$StartService>> mutate$StartService(
|
|
Options$Mutation$StartService options) async =>
|
|
await this.mutate(options);
|
|
graphql.ObservableQuery<Mutation$StartService> watchMutation$StartService(
|
|
WatchOptions$Mutation$StartService options) =>
|
|
this.watchMutation(options);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$StartService$startService
|
|
implements Fragment$basicMutationReturnFields {
|
|
Mutation$StartService$startService(
|
|
{required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$StartService$startService.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Mutation$StartService$startServiceFromJson(json);
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Mutation$StartService$startServiceToJson(this);
|
|
int get hashCode {
|
|
final l$code = code;
|
|
final l$message = message;
|
|
final l$success = success;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$code, l$message, l$success, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$StartService$startService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$code = code;
|
|
final lOther$code = other.code;
|
|
if (l$code != lOther$code) return false;
|
|
final l$message = message;
|
|
final lOther$message = other.message;
|
|
if (l$message != lOther$message) return false;
|
|
final l$success = success;
|
|
final lOther$success = other.success;
|
|
if (l$success != lOther$success) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$StartService$startService
|
|
on Mutation$StartService$startService {
|
|
CopyWith$Mutation$StartService$startService<
|
|
Mutation$StartService$startService>
|
|
get copyWith =>
|
|
CopyWith$Mutation$StartService$startService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$StartService$startService<TRes> {
|
|
factory CopyWith$Mutation$StartService$startService(
|
|
Mutation$StartService$startService instance,
|
|
TRes Function(Mutation$StartService$startService) then) =
|
|
_CopyWithImpl$Mutation$StartService$startService;
|
|
|
|
factory CopyWith$Mutation$StartService$startService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$StartService$startService;
|
|
|
|
TRes call({int? code, String? message, bool? success, String? $__typename});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$StartService$startService<TRes>
|
|
implements CopyWith$Mutation$StartService$startService<TRes> {
|
|
_CopyWithImpl$Mutation$StartService$startService(this._instance, this._then);
|
|
|
|
final Mutation$StartService$startService _instance;
|
|
|
|
final TRes Function(Mutation$StartService$startService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$StartService$startService(
|
|
code: code == _undefined || code == null
|
|
? _instance.code
|
|
: (code as int),
|
|
message: message == _undefined || message == null
|
|
? _instance.message
|
|
: (message as String),
|
|
success: success == _undefined || success == null
|
|
? _instance.success
|
|
: (success as bool),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$StartService$startService<TRes>
|
|
implements CopyWith$Mutation$StartService$startService<TRes> {
|
|
_CopyWithStubImpl$Mutation$StartService$startService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({int? code, String? message, bool? success, String? $__typename}) =>
|
|
_res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Variables$Mutation$RestartService {
|
|
Variables$Mutation$RestartService({required this.serviceId});
|
|
|
|
@override
|
|
factory Variables$Mutation$RestartService.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Variables$Mutation$RestartServiceFromJson(json);
|
|
|
|
final String serviceId;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Variables$Mutation$RestartServiceToJson(this);
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Variables$Mutation$RestartService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$serviceId = serviceId;
|
|
final lOther$serviceId = other.serviceId;
|
|
if (l$serviceId != lOther$serviceId) return false;
|
|
return true;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$RestartService<Variables$Mutation$RestartService>
|
|
get copyWith =>
|
|
CopyWith$Variables$Mutation$RestartService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Variables$Mutation$RestartService<TRes> {
|
|
factory CopyWith$Variables$Mutation$RestartService(
|
|
Variables$Mutation$RestartService instance,
|
|
TRes Function(Variables$Mutation$RestartService) then) =
|
|
_CopyWithImpl$Variables$Mutation$RestartService;
|
|
|
|
factory CopyWith$Variables$Mutation$RestartService.stub(TRes res) =
|
|
_CopyWithStubImpl$Variables$Mutation$RestartService;
|
|
|
|
TRes call({String? serviceId});
|
|
}
|
|
|
|
class _CopyWithImpl$Variables$Mutation$RestartService<TRes>
|
|
implements CopyWith$Variables$Mutation$RestartService<TRes> {
|
|
_CopyWithImpl$Variables$Mutation$RestartService(this._instance, this._then);
|
|
|
|
final Variables$Mutation$RestartService _instance;
|
|
|
|
final TRes Function(Variables$Mutation$RestartService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$RestartService(
|
|
serviceId: serviceId == _undefined || serviceId == null
|
|
? _instance.serviceId
|
|
: (serviceId as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Variables$Mutation$RestartService<TRes>
|
|
implements CopyWith$Variables$Mutation$RestartService<TRes> {
|
|
_CopyWithStubImpl$Variables$Mutation$RestartService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({String? serviceId}) => _res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$RestartService {
|
|
Mutation$RestartService(
|
|
{required this.restartService, required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$RestartService.fromJson(Map<String, dynamic> json) =>
|
|
_$Mutation$RestartServiceFromJson(json);
|
|
|
|
final Mutation$RestartService$restartService restartService;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() => _$Mutation$RestartServiceToJson(this);
|
|
int get hashCode {
|
|
final l$restartService = restartService;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$restartService, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$RestartService) || runtimeType != other.runtimeType)
|
|
return false;
|
|
final l$restartService = restartService;
|
|
final lOther$restartService = other.restartService;
|
|
if (l$restartService != lOther$restartService) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$RestartService on Mutation$RestartService {
|
|
CopyWith$Mutation$RestartService<Mutation$RestartService> get copyWith =>
|
|
CopyWith$Mutation$RestartService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$RestartService<TRes> {
|
|
factory CopyWith$Mutation$RestartService(Mutation$RestartService instance,
|
|
TRes Function(Mutation$RestartService) then) =
|
|
_CopyWithImpl$Mutation$RestartService;
|
|
|
|
factory CopyWith$Mutation$RestartService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$RestartService;
|
|
|
|
TRes call(
|
|
{Mutation$RestartService$restartService? restartService,
|
|
String? $__typename});
|
|
CopyWith$Mutation$RestartService$restartService<TRes> get restartService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$RestartService<TRes>
|
|
implements CopyWith$Mutation$RestartService<TRes> {
|
|
_CopyWithImpl$Mutation$RestartService(this._instance, this._then);
|
|
|
|
final Mutation$RestartService _instance;
|
|
|
|
final TRes Function(Mutation$RestartService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? restartService = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$RestartService(
|
|
restartService: restartService == _undefined || restartService == null
|
|
? _instance.restartService
|
|
: (restartService as Mutation$RestartService$restartService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
CopyWith$Mutation$RestartService$restartService<TRes> get restartService {
|
|
final local$restartService = _instance.restartService;
|
|
return CopyWith$Mutation$RestartService$restartService(
|
|
local$restartService, (e) => call(restartService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$RestartService<TRes>
|
|
implements CopyWith$Mutation$RestartService<TRes> {
|
|
_CopyWithStubImpl$Mutation$RestartService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call(
|
|
{Mutation$RestartService$restartService? restartService,
|
|
String? $__typename}) =>
|
|
_res;
|
|
CopyWith$Mutation$RestartService$restartService<TRes> get restartService =>
|
|
CopyWith$Mutation$RestartService$restartService.stub(_res);
|
|
}
|
|
|
|
const documentNodeMutationRestartService = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.mutation,
|
|
name: NameNode(value: 'RestartService'),
|
|
variableDefinitions: [
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'serviceId')),
|
|
type:
|
|
NamedTypeNode(name: NameNode(value: 'String'), isNonNull: true),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: [])
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'restartService'),
|
|
alias: null,
|
|
arguments: [
|
|
ArgumentNode(
|
|
name: NameNode(value: 'serviceId'),
|
|
value: VariableNode(name: NameNode(value: 'serviceId')))
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FragmentSpreadNode(
|
|
name: NameNode(value: 'basicMutationReturnFields'),
|
|
directives: []),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
fragmentDefinitionbasicMutationReturnFields,
|
|
]);
|
|
Mutation$RestartService _parserFn$Mutation$RestartService(
|
|
Map<String, dynamic> data) =>
|
|
Mutation$RestartService.fromJson(data);
|
|
typedef OnMutationCompleted$Mutation$RestartService = FutureOr<void> Function(
|
|
dynamic, Mutation$RestartService?);
|
|
|
|
class Options$Mutation$RestartService
|
|
extends graphql.MutationOptions<Mutation$RestartService> {
|
|
Options$Mutation$RestartService(
|
|
{String? operationName,
|
|
required Variables$Mutation$RestartService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
OnMutationCompleted$Mutation$RestartService? onCompleted,
|
|
graphql.OnMutationUpdate<Mutation$RestartService>? update,
|
|
graphql.OnError? onError})
|
|
: onCompletedWithParsed = onCompleted,
|
|
super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
onCompleted: onCompleted == null
|
|
? null
|
|
: (data) => onCompleted(
|
|
data,
|
|
data == null
|
|
? null
|
|
: _parserFn$Mutation$RestartService(data)),
|
|
update: update,
|
|
onError: onError,
|
|
document: documentNodeMutationRestartService,
|
|
parserFn: _parserFn$Mutation$RestartService);
|
|
|
|
final OnMutationCompleted$Mutation$RestartService? onCompletedWithParsed;
|
|
|
|
@override
|
|
List<Object?> get properties => [
|
|
...super.onCompleted == null
|
|
? super.properties
|
|
: super.properties.where((property) => property != onCompleted),
|
|
onCompletedWithParsed
|
|
];
|
|
}
|
|
|
|
class WatchOptions$Mutation$RestartService
|
|
extends graphql.WatchQueryOptions<Mutation$RestartService> {
|
|
WatchOptions$Mutation$RestartService(
|
|
{String? operationName,
|
|
required Variables$Mutation$RestartService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
Duration? pollInterval,
|
|
bool? eagerlyFetchResults,
|
|
bool carryForwardDataOnException = true,
|
|
bool fetchResults = false})
|
|
: super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
document: documentNodeMutationRestartService,
|
|
pollInterval: pollInterval,
|
|
eagerlyFetchResults: eagerlyFetchResults,
|
|
carryForwardDataOnException: carryForwardDataOnException,
|
|
fetchResults: fetchResults,
|
|
parserFn: _parserFn$Mutation$RestartService);
|
|
}
|
|
|
|
extension ClientExtension$Mutation$RestartService on graphql.GraphQLClient {
|
|
Future<graphql.QueryResult<Mutation$RestartService>> mutate$RestartService(
|
|
Options$Mutation$RestartService options) async =>
|
|
await this.mutate(options);
|
|
graphql.ObservableQuery<Mutation$RestartService> watchMutation$RestartService(
|
|
WatchOptions$Mutation$RestartService options) =>
|
|
this.watchMutation(options);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$RestartService$restartService
|
|
implements Fragment$basicMutationReturnFields {
|
|
Mutation$RestartService$restartService(
|
|
{required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$RestartService$restartService.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Mutation$RestartService$restartServiceFromJson(json);
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Mutation$RestartService$restartServiceToJson(this);
|
|
int get hashCode {
|
|
final l$code = code;
|
|
final l$message = message;
|
|
final l$success = success;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$code, l$message, l$success, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$RestartService$restartService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$code = code;
|
|
final lOther$code = other.code;
|
|
if (l$code != lOther$code) return false;
|
|
final l$message = message;
|
|
final lOther$message = other.message;
|
|
if (l$message != lOther$message) return false;
|
|
final l$success = success;
|
|
final lOther$success = other.success;
|
|
if (l$success != lOther$success) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$RestartService$restartService
|
|
on Mutation$RestartService$restartService {
|
|
CopyWith$Mutation$RestartService$restartService<
|
|
Mutation$RestartService$restartService>
|
|
get copyWith =>
|
|
CopyWith$Mutation$RestartService$restartService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$RestartService$restartService<TRes> {
|
|
factory CopyWith$Mutation$RestartService$restartService(
|
|
Mutation$RestartService$restartService instance,
|
|
TRes Function(Mutation$RestartService$restartService) then) =
|
|
_CopyWithImpl$Mutation$RestartService$restartService;
|
|
|
|
factory CopyWith$Mutation$RestartService$restartService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$RestartService$restartService;
|
|
|
|
TRes call({int? code, String? message, bool? success, String? $__typename});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$RestartService$restartService<TRes>
|
|
implements CopyWith$Mutation$RestartService$restartService<TRes> {
|
|
_CopyWithImpl$Mutation$RestartService$restartService(
|
|
this._instance, this._then);
|
|
|
|
final Mutation$RestartService$restartService _instance;
|
|
|
|
final TRes Function(Mutation$RestartService$restartService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$RestartService$restartService(
|
|
code: code == _undefined || code == null
|
|
? _instance.code
|
|
: (code as int),
|
|
message: message == _undefined || message == null
|
|
? _instance.message
|
|
: (message as String),
|
|
success: success == _undefined || success == null
|
|
? _instance.success
|
|
: (success as bool),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$RestartService$restartService<TRes>
|
|
implements CopyWith$Mutation$RestartService$restartService<TRes> {
|
|
_CopyWithStubImpl$Mutation$RestartService$restartService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({int? code, String? message, bool? success, String? $__typename}) =>
|
|
_res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Variables$Mutation$MoveService {
|
|
Variables$Mutation$MoveService({required this.input});
|
|
|
|
@override
|
|
factory Variables$Mutation$MoveService.fromJson(Map<String, dynamic> json) =>
|
|
_$Variables$Mutation$MoveServiceFromJson(json);
|
|
|
|
final Input$MoveServiceInput input;
|
|
|
|
Map<String, dynamic> toJson() => _$Variables$Mutation$MoveServiceToJson(this);
|
|
int get hashCode {
|
|
final l$input = input;
|
|
return Object.hashAll([l$input]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Variables$Mutation$MoveService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$input = input;
|
|
final lOther$input = other.input;
|
|
if (l$input != lOther$input) return false;
|
|
return true;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$MoveService<Variables$Mutation$MoveService>
|
|
get copyWith => CopyWith$Variables$Mutation$MoveService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Variables$Mutation$MoveService<TRes> {
|
|
factory CopyWith$Variables$Mutation$MoveService(
|
|
Variables$Mutation$MoveService instance,
|
|
TRes Function(Variables$Mutation$MoveService) then) =
|
|
_CopyWithImpl$Variables$Mutation$MoveService;
|
|
|
|
factory CopyWith$Variables$Mutation$MoveService.stub(TRes res) =
|
|
_CopyWithStubImpl$Variables$Mutation$MoveService;
|
|
|
|
TRes call({Input$MoveServiceInput? input});
|
|
}
|
|
|
|
class _CopyWithImpl$Variables$Mutation$MoveService<TRes>
|
|
implements CopyWith$Variables$Mutation$MoveService<TRes> {
|
|
_CopyWithImpl$Variables$Mutation$MoveService(this._instance, this._then);
|
|
|
|
final Variables$Mutation$MoveService _instance;
|
|
|
|
final TRes Function(Variables$Mutation$MoveService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call({Object? input = _undefined}) =>
|
|
_then(Variables$Mutation$MoveService(
|
|
input: input == _undefined || input == null
|
|
? _instance.input
|
|
: (input as Input$MoveServiceInput)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Variables$Mutation$MoveService<TRes>
|
|
implements CopyWith$Variables$Mutation$MoveService<TRes> {
|
|
_CopyWithStubImpl$Variables$Mutation$MoveService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({Input$MoveServiceInput? input}) => _res;
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$MoveService {
|
|
Mutation$MoveService({required this.moveService, required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$MoveService.fromJson(Map<String, dynamic> json) =>
|
|
_$Mutation$MoveServiceFromJson(json);
|
|
|
|
final Mutation$MoveService$moveService moveService;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() => _$Mutation$MoveServiceToJson(this);
|
|
int get hashCode {
|
|
final l$moveService = moveService;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([l$moveService, l$$__typename]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$MoveService) || runtimeType != other.runtimeType)
|
|
return false;
|
|
final l$moveService = moveService;
|
|
final lOther$moveService = other.moveService;
|
|
if (l$moveService != lOther$moveService) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$MoveService on Mutation$MoveService {
|
|
CopyWith$Mutation$MoveService<Mutation$MoveService> get copyWith =>
|
|
CopyWith$Mutation$MoveService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$MoveService<TRes> {
|
|
factory CopyWith$Mutation$MoveService(Mutation$MoveService instance,
|
|
TRes Function(Mutation$MoveService) then) =
|
|
_CopyWithImpl$Mutation$MoveService;
|
|
|
|
factory CopyWith$Mutation$MoveService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$MoveService;
|
|
|
|
TRes call(
|
|
{Mutation$MoveService$moveService? moveService, String? $__typename});
|
|
CopyWith$Mutation$MoveService$moveService<TRes> get moveService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$MoveService<TRes>
|
|
implements CopyWith$Mutation$MoveService<TRes> {
|
|
_CopyWithImpl$Mutation$MoveService(this._instance, this._then);
|
|
|
|
final Mutation$MoveService _instance;
|
|
|
|
final TRes Function(Mutation$MoveService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? moveService = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$MoveService(
|
|
moveService: moveService == _undefined || moveService == null
|
|
? _instance.moveService
|
|
: (moveService as Mutation$MoveService$moveService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
CopyWith$Mutation$MoveService$moveService<TRes> get moveService {
|
|
final local$moveService = _instance.moveService;
|
|
return CopyWith$Mutation$MoveService$moveService(
|
|
local$moveService, (e) => call(moveService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$MoveService<TRes>
|
|
implements CopyWith$Mutation$MoveService<TRes> {
|
|
_CopyWithStubImpl$Mutation$MoveService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({Mutation$MoveService$moveService? moveService, String? $__typename}) =>
|
|
_res;
|
|
CopyWith$Mutation$MoveService$moveService<TRes> get moveService =>
|
|
CopyWith$Mutation$MoveService$moveService.stub(_res);
|
|
}
|
|
|
|
const documentNodeMutationMoveService = DocumentNode(definitions: [
|
|
OperationDefinitionNode(
|
|
type: OperationType.mutation,
|
|
name: NameNode(value: 'MoveService'),
|
|
variableDefinitions: [
|
|
VariableDefinitionNode(
|
|
variable: VariableNode(name: NameNode(value: 'input')),
|
|
type: NamedTypeNode(
|
|
name: NameNode(value: 'MoveServiceInput'), isNonNull: true),
|
|
defaultValue: DefaultValueNode(value: null),
|
|
directives: [])
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'moveService'),
|
|
alias: null,
|
|
arguments: [
|
|
ArgumentNode(
|
|
name: NameNode(value: 'input'),
|
|
value: VariableNode(name: NameNode(value: 'input')))
|
|
],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FragmentSpreadNode(
|
|
name: NameNode(value: 'basicMutationReturnFields'),
|
|
directives: []),
|
|
FieldNode(
|
|
name: NameNode(value: 'job'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: SelectionSetNode(selections: [
|
|
FieldNode(
|
|
name: NameNode(value: 'createdAt'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'description'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'error'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'finishedAt'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'name'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'progress'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'result'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'status'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'statusText'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'uid'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: 'updatedAt'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null)
|
|
])),
|
|
fragmentDefinitionbasicMutationReturnFields,
|
|
]);
|
|
Mutation$MoveService _parserFn$Mutation$MoveService(
|
|
Map<String, dynamic> data) =>
|
|
Mutation$MoveService.fromJson(data);
|
|
typedef OnMutationCompleted$Mutation$MoveService = FutureOr<void> Function(
|
|
dynamic, Mutation$MoveService?);
|
|
|
|
class Options$Mutation$MoveService
|
|
extends graphql.MutationOptions<Mutation$MoveService> {
|
|
Options$Mutation$MoveService(
|
|
{String? operationName,
|
|
required Variables$Mutation$MoveService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
OnMutationCompleted$Mutation$MoveService? onCompleted,
|
|
graphql.OnMutationUpdate<Mutation$MoveService>? update,
|
|
graphql.OnError? onError})
|
|
: onCompletedWithParsed = onCompleted,
|
|
super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
onCompleted: onCompleted == null
|
|
? null
|
|
: (data) => onCompleted(data,
|
|
data == null ? null : _parserFn$Mutation$MoveService(data)),
|
|
update: update,
|
|
onError: onError,
|
|
document: documentNodeMutationMoveService,
|
|
parserFn: _parserFn$Mutation$MoveService);
|
|
|
|
final OnMutationCompleted$Mutation$MoveService? onCompletedWithParsed;
|
|
|
|
@override
|
|
List<Object?> get properties => [
|
|
...super.onCompleted == null
|
|
? super.properties
|
|
: super.properties.where((property) => property != onCompleted),
|
|
onCompletedWithParsed
|
|
];
|
|
}
|
|
|
|
class WatchOptions$Mutation$MoveService
|
|
extends graphql.WatchQueryOptions<Mutation$MoveService> {
|
|
WatchOptions$Mutation$MoveService(
|
|
{String? operationName,
|
|
required Variables$Mutation$MoveService variables,
|
|
graphql.FetchPolicy? fetchPolicy,
|
|
graphql.ErrorPolicy? errorPolicy,
|
|
graphql.CacheRereadPolicy? cacheRereadPolicy,
|
|
Object? optimisticResult,
|
|
graphql.Context? context,
|
|
Duration? pollInterval,
|
|
bool? eagerlyFetchResults,
|
|
bool carryForwardDataOnException = true,
|
|
bool fetchResults = false})
|
|
: super(
|
|
variables: variables.toJson(),
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult,
|
|
context: context,
|
|
document: documentNodeMutationMoveService,
|
|
pollInterval: pollInterval,
|
|
eagerlyFetchResults: eagerlyFetchResults,
|
|
carryForwardDataOnException: carryForwardDataOnException,
|
|
fetchResults: fetchResults,
|
|
parserFn: _parserFn$Mutation$MoveService);
|
|
}
|
|
|
|
extension ClientExtension$Mutation$MoveService on graphql.GraphQLClient {
|
|
Future<graphql.QueryResult<Mutation$MoveService>> mutate$MoveService(
|
|
Options$Mutation$MoveService options) async =>
|
|
await this.mutate(options);
|
|
graphql.ObservableQuery<Mutation$MoveService> watchMutation$MoveService(
|
|
WatchOptions$Mutation$MoveService options) =>
|
|
this.watchMutation(options);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$MoveService$moveService
|
|
implements Fragment$basicMutationReturnFields {
|
|
Mutation$MoveService$moveService(
|
|
{required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
required this.$__typename,
|
|
this.job});
|
|
|
|
@override
|
|
factory Mutation$MoveService$moveService.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Mutation$MoveService$moveServiceFromJson(json);
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
final Mutation$MoveService$moveService$job? job;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Mutation$MoveService$moveServiceToJson(this);
|
|
int get hashCode {
|
|
final l$code = code;
|
|
final l$message = message;
|
|
final l$success = success;
|
|
final l$$__typename = $__typename;
|
|
final l$job = job;
|
|
return Object.hashAll([l$code, l$message, l$success, l$$__typename, l$job]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$MoveService$moveService) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$code = code;
|
|
final lOther$code = other.code;
|
|
if (l$code != lOther$code) return false;
|
|
final l$message = message;
|
|
final lOther$message = other.message;
|
|
if (l$message != lOther$message) return false;
|
|
final l$success = success;
|
|
final lOther$success = other.success;
|
|
if (l$success != lOther$success) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
final l$job = job;
|
|
final lOther$job = other.job;
|
|
if (l$job != lOther$job) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$MoveService$moveService
|
|
on Mutation$MoveService$moveService {
|
|
CopyWith$Mutation$MoveService$moveService<Mutation$MoveService$moveService>
|
|
get copyWith => CopyWith$Mutation$MoveService$moveService(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$MoveService$moveService<TRes> {
|
|
factory CopyWith$Mutation$MoveService$moveService(
|
|
Mutation$MoveService$moveService instance,
|
|
TRes Function(Mutation$MoveService$moveService) then) =
|
|
_CopyWithImpl$Mutation$MoveService$moveService;
|
|
|
|
factory CopyWith$Mutation$MoveService$moveService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$MoveService$moveService;
|
|
|
|
TRes call(
|
|
{int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
Mutation$MoveService$moveService$job? job});
|
|
CopyWith$Mutation$MoveService$moveService$job<TRes> get job;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$MoveService$moveService<TRes>
|
|
implements CopyWith$Mutation$MoveService$moveService<TRes> {
|
|
_CopyWithImpl$Mutation$MoveService$moveService(this._instance, this._then);
|
|
|
|
final Mutation$MoveService$moveService _instance;
|
|
|
|
final TRes Function(Mutation$MoveService$moveService) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined,
|
|
Object? job = _undefined}) =>
|
|
_then(Mutation$MoveService$moveService(
|
|
code: code == _undefined || code == null
|
|
? _instance.code
|
|
: (code as int),
|
|
message: message == _undefined || message == null
|
|
? _instance.message
|
|
: (message as String),
|
|
success: success == _undefined || success == null
|
|
? _instance.success
|
|
: (success as bool),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
job: job == _undefined
|
|
? _instance.job
|
|
: (job as Mutation$MoveService$moveService$job?)));
|
|
CopyWith$Mutation$MoveService$moveService$job<TRes> get job {
|
|
final local$job = _instance.job;
|
|
return local$job == null
|
|
? CopyWith$Mutation$MoveService$moveService$job.stub(_then(_instance))
|
|
: CopyWith$Mutation$MoveService$moveService$job(
|
|
local$job, (e) => call(job: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$MoveService$moveService<TRes>
|
|
implements CopyWith$Mutation$MoveService$moveService<TRes> {
|
|
_CopyWithStubImpl$Mutation$MoveService$moveService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call(
|
|
{int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
Mutation$MoveService$moveService$job? job}) =>
|
|
_res;
|
|
CopyWith$Mutation$MoveService$moveService$job<TRes> get job =>
|
|
CopyWith$Mutation$MoveService$moveService$job.stub(_res);
|
|
}
|
|
|
|
@JsonSerializable(explicitToJson: true)
|
|
class Mutation$MoveService$moveService$job {
|
|
Mutation$MoveService$moveService$job(
|
|
{required this.createdAt,
|
|
required this.description,
|
|
this.error,
|
|
this.finishedAt,
|
|
required this.name,
|
|
this.progress,
|
|
this.result,
|
|
required this.status,
|
|
this.statusText,
|
|
required this.uid,
|
|
required this.updatedAt,
|
|
required this.$__typename});
|
|
|
|
@override
|
|
factory Mutation$MoveService$moveService$job.fromJson(
|
|
Map<String, dynamic> json) =>
|
|
_$Mutation$MoveService$moveService$jobFromJson(json);
|
|
|
|
@JsonKey(fromJson: dateTimeFromJson, toJson: dateTimeToJson)
|
|
final DateTime createdAt;
|
|
|
|
final String description;
|
|
|
|
final String? error;
|
|
|
|
@JsonKey(
|
|
fromJson: _nullable$dateTimeFromJson, toJson: _nullable$dateTimeToJson)
|
|
final DateTime? finishedAt;
|
|
|
|
final String name;
|
|
|
|
final int? progress;
|
|
|
|
final String? result;
|
|
|
|
final String status;
|
|
|
|
final String? statusText;
|
|
|
|
final String uid;
|
|
|
|
@JsonKey(fromJson: dateTimeFromJson, toJson: dateTimeToJson)
|
|
final DateTime updatedAt;
|
|
|
|
@JsonKey(name: '__typename')
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() =>
|
|
_$Mutation$MoveService$moveService$jobToJson(this);
|
|
int get hashCode {
|
|
final l$createdAt = createdAt;
|
|
final l$description = description;
|
|
final l$error = error;
|
|
final l$finishedAt = finishedAt;
|
|
final l$name = name;
|
|
final l$progress = progress;
|
|
final l$result = result;
|
|
final l$status = status;
|
|
final l$statusText = statusText;
|
|
final l$uid = uid;
|
|
final l$updatedAt = updatedAt;
|
|
final l$$__typename = $__typename;
|
|
return Object.hashAll([
|
|
l$createdAt,
|
|
l$description,
|
|
l$error,
|
|
l$finishedAt,
|
|
l$name,
|
|
l$progress,
|
|
l$result,
|
|
l$status,
|
|
l$statusText,
|
|
l$uid,
|
|
l$updatedAt,
|
|
l$$__typename
|
|
]);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) return true;
|
|
if (!(other is Mutation$MoveService$moveService$job) ||
|
|
runtimeType != other.runtimeType) return false;
|
|
final l$createdAt = createdAt;
|
|
final lOther$createdAt = other.createdAt;
|
|
if (l$createdAt != lOther$createdAt) return false;
|
|
final l$description = description;
|
|
final lOther$description = other.description;
|
|
if (l$description != lOther$description) return false;
|
|
final l$error = error;
|
|
final lOther$error = other.error;
|
|
if (l$error != lOther$error) return false;
|
|
final l$finishedAt = finishedAt;
|
|
final lOther$finishedAt = other.finishedAt;
|
|
if (l$finishedAt != lOther$finishedAt) return false;
|
|
final l$name = name;
|
|
final lOther$name = other.name;
|
|
if (l$name != lOther$name) return false;
|
|
final l$progress = progress;
|
|
final lOther$progress = other.progress;
|
|
if (l$progress != lOther$progress) return false;
|
|
final l$result = result;
|
|
final lOther$result = other.result;
|
|
if (l$result != lOther$result) return false;
|
|
final l$status = status;
|
|
final lOther$status = other.status;
|
|
if (l$status != lOther$status) return false;
|
|
final l$statusText = statusText;
|
|
final lOther$statusText = other.statusText;
|
|
if (l$statusText != lOther$statusText) return false;
|
|
final l$uid = uid;
|
|
final lOther$uid = other.uid;
|
|
if (l$uid != lOther$uid) return false;
|
|
final l$updatedAt = updatedAt;
|
|
final lOther$updatedAt = other.updatedAt;
|
|
if (l$updatedAt != lOther$updatedAt) return false;
|
|
final l$$__typename = $__typename;
|
|
final lOther$$__typename = other.$__typename;
|
|
if (l$$__typename != lOther$$__typename) return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
extension UtilityExtension$Mutation$MoveService$moveService$job
|
|
on Mutation$MoveService$moveService$job {
|
|
CopyWith$Mutation$MoveService$moveService$job<
|
|
Mutation$MoveService$moveService$job>
|
|
get copyWith =>
|
|
CopyWith$Mutation$MoveService$moveService$job(this, (i) => i);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$MoveService$moveService$job<TRes> {
|
|
factory CopyWith$Mutation$MoveService$moveService$job(
|
|
Mutation$MoveService$moveService$job instance,
|
|
TRes Function(Mutation$MoveService$moveService$job) then) =
|
|
_CopyWithImpl$Mutation$MoveService$moveService$job;
|
|
|
|
factory CopyWith$Mutation$MoveService$moveService$job.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$MoveService$moveService$job;
|
|
|
|
TRes call(
|
|
{DateTime? createdAt,
|
|
String? description,
|
|
String? error,
|
|
DateTime? finishedAt,
|
|
String? name,
|
|
int? progress,
|
|
String? result,
|
|
String? status,
|
|
String? statusText,
|
|
String? uid,
|
|
DateTime? updatedAt,
|
|
String? $__typename});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$MoveService$moveService$job<TRes>
|
|
implements CopyWith$Mutation$MoveService$moveService$job<TRes> {
|
|
_CopyWithImpl$Mutation$MoveService$moveService$job(
|
|
this._instance, this._then);
|
|
|
|
final Mutation$MoveService$moveService$job _instance;
|
|
|
|
final TRes Function(Mutation$MoveService$moveService$job) _then;
|
|
|
|
static const _undefined = {};
|
|
|
|
TRes call(
|
|
{Object? createdAt = _undefined,
|
|
Object? description = _undefined,
|
|
Object? error = _undefined,
|
|
Object? finishedAt = _undefined,
|
|
Object? name = _undefined,
|
|
Object? progress = _undefined,
|
|
Object? result = _undefined,
|
|
Object? status = _undefined,
|
|
Object? statusText = _undefined,
|
|
Object? uid = _undefined,
|
|
Object? updatedAt = _undefined,
|
|
Object? $__typename = _undefined}) =>
|
|
_then(Mutation$MoveService$moveService$job(
|
|
createdAt: createdAt == _undefined || createdAt == null
|
|
? _instance.createdAt
|
|
: (createdAt as DateTime),
|
|
description: description == _undefined || description == null
|
|
? _instance.description
|
|
: (description as String),
|
|
error: error == _undefined ? _instance.error : (error as String?),
|
|
finishedAt: finishedAt == _undefined
|
|
? _instance.finishedAt
|
|
: (finishedAt as DateTime?),
|
|
name: name == _undefined || name == null
|
|
? _instance.name
|
|
: (name as String),
|
|
progress:
|
|
progress == _undefined ? _instance.progress : (progress as int?),
|
|
result: result == _undefined ? _instance.result : (result as String?),
|
|
status: status == _undefined || status == null
|
|
? _instance.status
|
|
: (status as String),
|
|
statusText: statusText == _undefined
|
|
? _instance.statusText
|
|
: (statusText as String?),
|
|
uid: uid == _undefined || uid == null
|
|
? _instance.uid
|
|
: (uid as String),
|
|
updatedAt: updatedAt == _undefined || updatedAt == null
|
|
? _instance.updatedAt
|
|
: (updatedAt as DateTime),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String)));
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$MoveService$moveService$job<TRes>
|
|
implements CopyWith$Mutation$MoveService$moveService$job<TRes> {
|
|
_CopyWithStubImpl$Mutation$MoveService$moveService$job(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call(
|
|
{DateTime? createdAt,
|
|
String? description,
|
|
String? error,
|
|
DateTime? finishedAt,
|
|
String? name,
|
|
int? progress,
|
|
String? result,
|
|
String? status,
|
|
String? statusText,
|
|
String? uid,
|
|
DateTime? updatedAt,
|
|
String? $__typename}) =>
|
|
_res;
|
|
}
|
|
|
|
DateTime? _nullable$dateTimeFromJson(dynamic data) =>
|
|
data == null ? null : dateTimeFromJson(data);
|
|
dynamic _nullable$dateTimeToJson(DateTime? data) =>
|
|
data == null ? null : dateTimeToJson(data);
|