5625 lines
169 KiB
Dart
5625 lines
169 KiB
Dart
import 'dart:async';
|
|
import 'package:gql/ast.dart';
|
|
import 'package:graphql/client.dart' as graphql;
|
|
import 'schema.graphql.dart';
|
|
import 'server_api.graphql.dart';
|
|
import 'server_settings.graphql.dart';
|
|
|
|
class Query$AllServices {
|
|
Query$AllServices({
|
|
required this.services,
|
|
this.$__typename = 'Query',
|
|
});
|
|
|
|
factory Query$AllServices.fromJson(Map<String, dynamic> json) {
|
|
final l$services = json['services'];
|
|
final l$$__typename = json['__typename'];
|
|
return Query$AllServices(
|
|
services: Query$AllServices$services.fromJson(
|
|
(l$services as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Query$AllServices$services services;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$services = services;
|
|
_resultData['services'] = l$services.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
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: 'fragmentDnsRecords'),
|
|
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: 'canBeBackedUp'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null,
|
|
),
|
|
FieldNode(
|
|
name: NameNode(value: 'backupDescription'),
|
|
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,
|
|
),
|
|
]),
|
|
),
|
|
fragmentDefinitionfragmentDnsRecords,
|
|
]);
|
|
Query$AllServices _parserFn$Query$AllServices(Map<String, dynamic> data) =>
|
|
Query$AllServices.fromJson(data);
|
|
typedef OnQueryComplete$Query$AllServices = FutureOr<void> Function(
|
|
Map<String, dynamic>?,
|
|
Query$AllServices?,
|
|
);
|
|
|
|
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,
|
|
Query$AllServices? typedOptimisticResult,
|
|
Duration? pollInterval,
|
|
graphql.Context? context,
|
|
OnQueryComplete$Query$AllServices? onComplete,
|
|
graphql.OnQueryError? onError,
|
|
}) : onCompleteWithParsed = onComplete,
|
|
super(
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult ?? typedOptimisticResult?.toJson(),
|
|
pollInterval: pollInterval,
|
|
context: context,
|
|
onComplete: onComplete == null
|
|
? null
|
|
: (data) => onComplete(
|
|
data,
|
|
data == null ? null : _parserFn$Query$AllServices(data),
|
|
),
|
|
onError: onError,
|
|
document: documentNodeQueryAllServices,
|
|
parserFn: _parserFn$Query$AllServices,
|
|
);
|
|
|
|
final OnQueryComplete$Query$AllServices? onCompleteWithParsed;
|
|
|
|
@override
|
|
List<Object?> get properties => [
|
|
...super.onComplete == null
|
|
? super.properties
|
|
: super.properties.where((property) => property != onComplete),
|
|
onCompleteWithParsed,
|
|
];
|
|
}
|
|
|
|
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,
|
|
Query$AllServices? typedOptimisticResult,
|
|
graphql.Context? context,
|
|
Duration? pollInterval,
|
|
bool? eagerlyFetchResults,
|
|
bool carryForwardDataOnException = true,
|
|
bool fetchResults = false,
|
|
}) : super(
|
|
operationName: operationName,
|
|
fetchPolicy: fetchPolicy,
|
|
errorPolicy: errorPolicy,
|
|
cacheRereadPolicy: cacheRereadPolicy,
|
|
optimisticResult: optimisticResult ?? typedOptimisticResult?.toJson(),
|
|
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);
|
|
}
|
|
}
|
|
|
|
class Query$AllServices$services {
|
|
Query$AllServices$services({
|
|
required this.allServices,
|
|
this.$__typename = 'Services',
|
|
});
|
|
|
|
factory Query$AllServices$services.fromJson(Map<String, dynamic> json) {
|
|
final l$allServices = json['allServices'];
|
|
final l$$__typename = json['__typename'];
|
|
return Query$AllServices$services(
|
|
allServices: (l$allServices as List<dynamic>)
|
|
.map((e) => Query$AllServices$services$allServices.fromJson(
|
|
(e as Map<String, dynamic>)))
|
|
.toList(),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final List<Query$AllServices$services$allServices> allServices;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$allServices = allServices;
|
|
_resultData['allServices'] = l$allServices.map((e) => e.toJson()).toList();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
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;
|
|
}
|
|
|
|
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.canBeBackedUp,
|
|
required this.backupDescription,
|
|
required this.status,
|
|
required this.storageUsage,
|
|
required this.svgIcon,
|
|
this.url,
|
|
this.$__typename = 'Service',
|
|
});
|
|
|
|
factory Query$AllServices$services$allServices.fromJson(
|
|
Map<String, dynamic> json) {
|
|
final l$description = json['description'];
|
|
final l$displayName = json['displayName'];
|
|
final l$dnsRecords = json['dnsRecords'];
|
|
final l$id = json['id'];
|
|
final l$isEnabled = json['isEnabled'];
|
|
final l$isMovable = json['isMovable'];
|
|
final l$isRequired = json['isRequired'];
|
|
final l$canBeBackedUp = json['canBeBackedUp'];
|
|
final l$backupDescription = json['backupDescription'];
|
|
final l$status = json['status'];
|
|
final l$storageUsage = json['storageUsage'];
|
|
final l$svgIcon = json['svgIcon'];
|
|
final l$url = json['url'];
|
|
final l$$__typename = json['__typename'];
|
|
return Query$AllServices$services$allServices(
|
|
description: (l$description as String),
|
|
displayName: (l$displayName as String),
|
|
dnsRecords: (l$dnsRecords as List<dynamic>?)
|
|
?.map((e) =>
|
|
Fragment$fragmentDnsRecords.fromJson((e as Map<String, dynamic>)))
|
|
.toList(),
|
|
id: (l$id as String),
|
|
isEnabled: (l$isEnabled as bool),
|
|
isMovable: (l$isMovable as bool),
|
|
isRequired: (l$isRequired as bool),
|
|
canBeBackedUp: (l$canBeBackedUp as bool),
|
|
backupDescription: (l$backupDescription as String),
|
|
status: fromJson$Enum$ServiceStatusEnum((l$status as String)),
|
|
storageUsage:
|
|
Query$AllServices$services$allServices$storageUsage.fromJson(
|
|
(l$storageUsage as Map<String, dynamic>)),
|
|
svgIcon: (l$svgIcon as String),
|
|
url: (l$url as String?),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final String description;
|
|
|
|
final String displayName;
|
|
|
|
final List<Fragment$fragmentDnsRecords>? dnsRecords;
|
|
|
|
final String id;
|
|
|
|
final bool isEnabled;
|
|
|
|
final bool isMovable;
|
|
|
|
final bool isRequired;
|
|
|
|
final bool canBeBackedUp;
|
|
|
|
final String backupDescription;
|
|
|
|
final Enum$ServiceStatusEnum status;
|
|
|
|
final Query$AllServices$services$allServices$storageUsage storageUsage;
|
|
|
|
final String svgIcon;
|
|
|
|
final String? url;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$description = description;
|
|
_resultData['description'] = l$description;
|
|
final l$displayName = displayName;
|
|
_resultData['displayName'] = l$displayName;
|
|
final l$dnsRecords = dnsRecords;
|
|
_resultData['dnsRecords'] = l$dnsRecords?.map((e) => e.toJson()).toList();
|
|
final l$id = id;
|
|
_resultData['id'] = l$id;
|
|
final l$isEnabled = isEnabled;
|
|
_resultData['isEnabled'] = l$isEnabled;
|
|
final l$isMovable = isMovable;
|
|
_resultData['isMovable'] = l$isMovable;
|
|
final l$isRequired = isRequired;
|
|
_resultData['isRequired'] = l$isRequired;
|
|
final l$canBeBackedUp = canBeBackedUp;
|
|
_resultData['canBeBackedUp'] = l$canBeBackedUp;
|
|
final l$backupDescription = backupDescription;
|
|
_resultData['backupDescription'] = l$backupDescription;
|
|
final l$status = status;
|
|
_resultData['status'] = toJson$Enum$ServiceStatusEnum(l$status);
|
|
final l$storageUsage = storageUsage;
|
|
_resultData['storageUsage'] = l$storageUsage.toJson();
|
|
final l$svgIcon = svgIcon;
|
|
_resultData['svgIcon'] = l$svgIcon;
|
|
final l$url = url;
|
|
_resultData['url'] = l$url;
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$canBeBackedUp = canBeBackedUp;
|
|
final l$backupDescription = backupDescription;
|
|
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$canBeBackedUp,
|
|
l$backupDescription,
|
|
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$canBeBackedUp = canBeBackedUp;
|
|
final lOther$canBeBackedUp = other.canBeBackedUp;
|
|
if (l$canBeBackedUp != lOther$canBeBackedUp) {
|
|
return false;
|
|
}
|
|
final l$backupDescription = backupDescription;
|
|
final lOther$backupDescription = other.backupDescription;
|
|
if (l$backupDescription != lOther$backupDescription) {
|
|
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$fragmentDnsRecords>? dnsRecords,
|
|
String? id,
|
|
bool? isEnabled,
|
|
bool? isMovable,
|
|
bool? isRequired,
|
|
bool? canBeBackedUp,
|
|
String? backupDescription,
|
|
Enum$ServiceStatusEnum? status,
|
|
Query$AllServices$services$allServices$storageUsage? storageUsage,
|
|
String? svgIcon,
|
|
String? url,
|
|
String? $__typename,
|
|
});
|
|
TRes dnsRecords(
|
|
Iterable<Fragment$fragmentDnsRecords>? Function(
|
|
Iterable<
|
|
CopyWith$Fragment$fragmentDnsRecords<
|
|
Fragment$fragmentDnsRecords>>?)
|
|
_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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? description = _undefined,
|
|
Object? displayName = _undefined,
|
|
Object? dnsRecords = _undefined,
|
|
Object? id = _undefined,
|
|
Object? isEnabled = _undefined,
|
|
Object? isMovable = _undefined,
|
|
Object? isRequired = _undefined,
|
|
Object? canBeBackedUp = _undefined,
|
|
Object? backupDescription = _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$fragmentDnsRecords>?),
|
|
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),
|
|
canBeBackedUp: canBeBackedUp == _undefined || canBeBackedUp == null
|
|
? _instance.canBeBackedUp
|
|
: (canBeBackedUp as bool),
|
|
backupDescription:
|
|
backupDescription == _undefined || backupDescription == null
|
|
? _instance.backupDescription
|
|
: (backupDescription as String),
|
|
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$fragmentDnsRecords>? Function(
|
|
Iterable<
|
|
CopyWith$Fragment$fragmentDnsRecords<
|
|
Fragment$fragmentDnsRecords>>?)
|
|
_fn) =>
|
|
call(
|
|
dnsRecords: _fn(_instance.dnsRecords
|
|
?.map((e) => CopyWith$Fragment$fragmentDnsRecords(
|
|
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$fragmentDnsRecords>? dnsRecords,
|
|
String? id,
|
|
bool? isEnabled,
|
|
bool? isMovable,
|
|
bool? isRequired,
|
|
bool? canBeBackedUp,
|
|
String? backupDescription,
|
|
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);
|
|
}
|
|
|
|
class Query$AllServices$services$allServices$storageUsage {
|
|
Query$AllServices$services$allServices$storageUsage({
|
|
required this.title,
|
|
required this.usedSpace,
|
|
this.volume,
|
|
this.$__typename = 'ServiceStorageUsage',
|
|
});
|
|
|
|
factory Query$AllServices$services$allServices$storageUsage.fromJson(
|
|
Map<String, dynamic> json) {
|
|
final l$title = json['title'];
|
|
final l$usedSpace = json['usedSpace'];
|
|
final l$volume = json['volume'];
|
|
final l$$__typename = json['__typename'];
|
|
return Query$AllServices$services$allServices$storageUsage(
|
|
title: (l$title as String),
|
|
usedSpace: (l$usedSpace as String),
|
|
volume: l$volume == null
|
|
? null
|
|
: Query$AllServices$services$allServices$storageUsage$volume.fromJson(
|
|
(l$volume as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final String title;
|
|
|
|
final String usedSpace;
|
|
|
|
final Query$AllServices$services$allServices$storageUsage$volume? volume;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$title = title;
|
|
_resultData['title'] = l$title;
|
|
final l$usedSpace = usedSpace;
|
|
_resultData['usedSpace'] = l$usedSpace;
|
|
final l$volume = volume;
|
|
_resultData['volume'] = l$volume?.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
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);
|
|
}
|
|
|
|
class Query$AllServices$services$allServices$storageUsage$volume {
|
|
Query$AllServices$services$allServices$storageUsage$volume({
|
|
required this.name,
|
|
this.$__typename = 'StorageVolume',
|
|
});
|
|
|
|
factory Query$AllServices$services$allServices$storageUsage$volume.fromJson(
|
|
Map<String, dynamic> json) {
|
|
final l$name = json['name'];
|
|
final l$$__typename = json['__typename'];
|
|
return Query$AllServices$services$allServices$storageUsage$volume(
|
|
name: (l$name as String),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final String name;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$name = name;
|
|
_resultData['name'] = l$name;
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
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;
|
|
}
|
|
|
|
class Variables$Mutation$EnableService {
|
|
factory Variables$Mutation$EnableService({required String serviceId}) =>
|
|
Variables$Mutation$EnableService._({
|
|
r'serviceId': serviceId,
|
|
});
|
|
|
|
Variables$Mutation$EnableService._(this._$data);
|
|
|
|
factory Variables$Mutation$EnableService.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = data['serviceId'];
|
|
result$data['serviceId'] = (l$serviceId as String);
|
|
return Variables$Mutation$EnableService._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
String get serviceId => (_$data['serviceId'] as String);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = serviceId;
|
|
result$data['serviceId'] = l$serviceId;
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$EnableService<Variables$Mutation$EnableService>
|
|
get copyWith => CopyWith$Variables$Mutation$EnableService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@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;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$EnableService._({
|
|
..._instance._$data,
|
|
if (serviceId != _undefined && serviceId != null)
|
|
'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;
|
|
}
|
|
|
|
class Mutation$EnableService {
|
|
Mutation$EnableService({
|
|
required this.services,
|
|
this.$__typename = 'Mutation',
|
|
});
|
|
|
|
factory Mutation$EnableService.fromJson(Map<String, dynamic> json) {
|
|
final l$services = json['services'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$EnableService(
|
|
services: Mutation$EnableService$services.fromJson(
|
|
(l$services as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$EnableService$services services;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$services = services;
|
|
_resultData['services'] = l$services.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 Mutation$EnableService) ||
|
|
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$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$services? services,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$EnableService$services<TRes> get services;
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? services = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$EnableService(
|
|
services: services == _undefined || services == null
|
|
? _instance.services
|
|
: (services as Mutation$EnableService$services),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$EnableService$services<TRes> get services {
|
|
final local$services = _instance.services;
|
|
return CopyWith$Mutation$EnableService$services(
|
|
local$services, (e) => call(services: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$EnableService<TRes>
|
|
implements CopyWith$Mutation$EnableService<TRes> {
|
|
_CopyWithStubImpl$Mutation$EnableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$EnableService$services? services,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$EnableService$services<TRes> get services =>
|
|
CopyWith$Mutation$EnableService$services.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: 'services'),
|
|
alias: null,
|
|
arguments: [],
|
|
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,
|
|
),
|
|
]),
|
|
),
|
|
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(
|
|
Map<String, 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,
|
|
Mutation$EnableService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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,
|
|
Mutation$EnableService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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);
|
|
}
|
|
|
|
class Mutation$EnableService$services {
|
|
Mutation$EnableService$services({
|
|
required this.enableService,
|
|
this.$__typename = 'ServicesMutations',
|
|
});
|
|
|
|
factory Mutation$EnableService$services.fromJson(Map<String, dynamic> json) {
|
|
final l$enableService = json['enableService'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$EnableService$services(
|
|
enableService: Mutation$EnableService$services$enableService.fromJson(
|
|
(l$enableService as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$EnableService$services$enableService enableService;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$enableService = enableService;
|
|
_resultData['enableService'] = l$enableService.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services) ||
|
|
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$services
|
|
on Mutation$EnableService$services {
|
|
CopyWith$Mutation$EnableService$services<Mutation$EnableService$services>
|
|
get copyWith => CopyWith$Mutation$EnableService$services(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$EnableService$services<TRes> {
|
|
factory CopyWith$Mutation$EnableService$services(
|
|
Mutation$EnableService$services instance,
|
|
TRes Function(Mutation$EnableService$services) then,
|
|
) = _CopyWithImpl$Mutation$EnableService$services;
|
|
|
|
factory CopyWith$Mutation$EnableService$services.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$EnableService$services;
|
|
|
|
TRes call({
|
|
Mutation$EnableService$services$enableService? enableService,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$EnableService$services$enableService<TRes>
|
|
get enableService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$EnableService$services<TRes>
|
|
implements CopyWith$Mutation$EnableService$services<TRes> {
|
|
_CopyWithImpl$Mutation$EnableService$services(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$EnableService$services _instance;
|
|
|
|
final TRes Function(Mutation$EnableService$services) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? enableService = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$EnableService$services(
|
|
enableService: enableService == _undefined || enableService == null
|
|
? _instance.enableService
|
|
: (enableService as Mutation$EnableService$services$enableService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$EnableService$services$enableService<TRes>
|
|
get enableService {
|
|
final local$enableService = _instance.enableService;
|
|
return CopyWith$Mutation$EnableService$services$enableService(
|
|
local$enableService, (e) => call(enableService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$EnableService$services<TRes>
|
|
implements CopyWith$Mutation$EnableService$services<TRes> {
|
|
_CopyWithStubImpl$Mutation$EnableService$services(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$EnableService$services$enableService? enableService,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$EnableService$services$enableService<TRes>
|
|
get enableService =>
|
|
CopyWith$Mutation$EnableService$services$enableService.stub(_res);
|
|
}
|
|
|
|
class Mutation$EnableService$services$enableService
|
|
implements Fragment$basicMutationReturnFields$$ServiceMutationReturn {
|
|
Mutation$EnableService$services$enableService({
|
|
required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
this.$__typename = 'ServiceMutationReturn',
|
|
});
|
|
|
|
factory Mutation$EnableService$services$enableService.fromJson(
|
|
Map<String, dynamic> json) {
|
|
final l$code = json['code'];
|
|
final l$message = json['message'];
|
|
final l$success = json['success'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$EnableService$services$enableService(
|
|
code: (l$code as int),
|
|
message: (l$message as String),
|
|
success: (l$success as bool),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$code = code;
|
|
_resultData['code'] = l$code;
|
|
final l$message = message;
|
|
_resultData['message'] = l$message;
|
|
final l$success = success;
|
|
_resultData['success'] = l$success;
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services$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$services$enableService
|
|
on Mutation$EnableService$services$enableService {
|
|
CopyWith$Mutation$EnableService$services$enableService<
|
|
Mutation$EnableService$services$enableService>
|
|
get copyWith => CopyWith$Mutation$EnableService$services$enableService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$EnableService$services$enableService<TRes> {
|
|
factory CopyWith$Mutation$EnableService$services$enableService(
|
|
Mutation$EnableService$services$enableService instance,
|
|
TRes Function(Mutation$EnableService$services$enableService) then,
|
|
) = _CopyWithImpl$Mutation$EnableService$services$enableService;
|
|
|
|
factory CopyWith$Mutation$EnableService$services$enableService.stub(
|
|
TRes res) =
|
|
_CopyWithStubImpl$Mutation$EnableService$services$enableService;
|
|
|
|
TRes call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$EnableService$services$enableService<TRes>
|
|
implements CopyWith$Mutation$EnableService$services$enableService<TRes> {
|
|
_CopyWithImpl$Mutation$EnableService$services$enableService(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$EnableService$services$enableService _instance;
|
|
|
|
final TRes Function(Mutation$EnableService$services$enableService) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$EnableService$services$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$services$enableService<TRes>
|
|
implements CopyWith$Mutation$EnableService$services$enableService<TRes> {
|
|
_CopyWithStubImpl$Mutation$EnableService$services$enableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Variables$Mutation$DisableService {
|
|
factory Variables$Mutation$DisableService({required String serviceId}) =>
|
|
Variables$Mutation$DisableService._({
|
|
r'serviceId': serviceId,
|
|
});
|
|
|
|
Variables$Mutation$DisableService._(this._$data);
|
|
|
|
factory Variables$Mutation$DisableService.fromJson(
|
|
Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = data['serviceId'];
|
|
result$data['serviceId'] = (l$serviceId as String);
|
|
return Variables$Mutation$DisableService._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
String get serviceId => (_$data['serviceId'] as String);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = serviceId;
|
|
result$data['serviceId'] = l$serviceId;
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$DisableService<Variables$Mutation$DisableService>
|
|
get copyWith => CopyWith$Variables$Mutation$DisableService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@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;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$DisableService._({
|
|
..._instance._$data,
|
|
if (serviceId != _undefined && serviceId != null)
|
|
'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;
|
|
}
|
|
|
|
class Mutation$DisableService {
|
|
Mutation$DisableService({
|
|
required this.services,
|
|
this.$__typename = 'Mutation',
|
|
});
|
|
|
|
factory Mutation$DisableService.fromJson(Map<String, dynamic> json) {
|
|
final l$services = json['services'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$DisableService(
|
|
services: Mutation$DisableService$services.fromJson(
|
|
(l$services as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$DisableService$services services;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$services = services;
|
|
_resultData['services'] = l$services.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 Mutation$DisableService) ||
|
|
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$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$services? services,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$DisableService$services<TRes> get services;
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? services = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$DisableService(
|
|
services: services == _undefined || services == null
|
|
? _instance.services
|
|
: (services as Mutation$DisableService$services),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$DisableService$services<TRes> get services {
|
|
final local$services = _instance.services;
|
|
return CopyWith$Mutation$DisableService$services(
|
|
local$services, (e) => call(services: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$DisableService<TRes>
|
|
implements CopyWith$Mutation$DisableService<TRes> {
|
|
_CopyWithStubImpl$Mutation$DisableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$DisableService$services? services,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$DisableService$services<TRes> get services =>
|
|
CopyWith$Mutation$DisableService$services.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: 'services'),
|
|
alias: null,
|
|
arguments: [],
|
|
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,
|
|
),
|
|
]),
|
|
),
|
|
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(
|
|
Map<String, 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,
|
|
Mutation$DisableService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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,
|
|
Mutation$DisableService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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);
|
|
}
|
|
|
|
class Mutation$DisableService$services {
|
|
Mutation$DisableService$services({
|
|
required this.disableService,
|
|
this.$__typename = 'ServicesMutations',
|
|
});
|
|
|
|
factory Mutation$DisableService$services.fromJson(Map<String, dynamic> json) {
|
|
final l$disableService = json['disableService'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$DisableService$services(
|
|
disableService: Mutation$DisableService$services$disableService.fromJson(
|
|
(l$disableService as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$DisableService$services$disableService disableService;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$disableService = disableService;
|
|
_resultData['disableService'] = l$disableService.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services) ||
|
|
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$services
|
|
on Mutation$DisableService$services {
|
|
CopyWith$Mutation$DisableService$services<Mutation$DisableService$services>
|
|
get copyWith => CopyWith$Mutation$DisableService$services(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$DisableService$services<TRes> {
|
|
factory CopyWith$Mutation$DisableService$services(
|
|
Mutation$DisableService$services instance,
|
|
TRes Function(Mutation$DisableService$services) then,
|
|
) = _CopyWithImpl$Mutation$DisableService$services;
|
|
|
|
factory CopyWith$Mutation$DisableService$services.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$DisableService$services;
|
|
|
|
TRes call({
|
|
Mutation$DisableService$services$disableService? disableService,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$DisableService$services$disableService<TRes>
|
|
get disableService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$DisableService$services<TRes>
|
|
implements CopyWith$Mutation$DisableService$services<TRes> {
|
|
_CopyWithImpl$Mutation$DisableService$services(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$DisableService$services _instance;
|
|
|
|
final TRes Function(Mutation$DisableService$services) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? disableService = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$DisableService$services(
|
|
disableService: disableService == _undefined || disableService == null
|
|
? _instance.disableService
|
|
: (disableService
|
|
as Mutation$DisableService$services$disableService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$DisableService$services$disableService<TRes>
|
|
get disableService {
|
|
final local$disableService = _instance.disableService;
|
|
return CopyWith$Mutation$DisableService$services$disableService(
|
|
local$disableService, (e) => call(disableService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$DisableService$services<TRes>
|
|
implements CopyWith$Mutation$DisableService$services<TRes> {
|
|
_CopyWithStubImpl$Mutation$DisableService$services(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$DisableService$services$disableService? disableService,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$DisableService$services$disableService<TRes>
|
|
get disableService =>
|
|
CopyWith$Mutation$DisableService$services$disableService.stub(_res);
|
|
}
|
|
|
|
class Mutation$DisableService$services$disableService
|
|
implements Fragment$basicMutationReturnFields$$ServiceMutationReturn {
|
|
Mutation$DisableService$services$disableService({
|
|
required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
this.$__typename = 'ServiceMutationReturn',
|
|
});
|
|
|
|
factory Mutation$DisableService$services$disableService.fromJson(
|
|
Map<String, dynamic> json) {
|
|
final l$code = json['code'];
|
|
final l$message = json['message'];
|
|
final l$success = json['success'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$DisableService$services$disableService(
|
|
code: (l$code as int),
|
|
message: (l$message as String),
|
|
success: (l$success as bool),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$code = code;
|
|
_resultData['code'] = l$code;
|
|
final l$message = message;
|
|
_resultData['message'] = l$message;
|
|
final l$success = success;
|
|
_resultData['success'] = l$success;
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services$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$services$disableService
|
|
on Mutation$DisableService$services$disableService {
|
|
CopyWith$Mutation$DisableService$services$disableService<
|
|
Mutation$DisableService$services$disableService>
|
|
get copyWith => CopyWith$Mutation$DisableService$services$disableService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$DisableService$services$disableService<TRes> {
|
|
factory CopyWith$Mutation$DisableService$services$disableService(
|
|
Mutation$DisableService$services$disableService instance,
|
|
TRes Function(Mutation$DisableService$services$disableService) then,
|
|
) = _CopyWithImpl$Mutation$DisableService$services$disableService;
|
|
|
|
factory CopyWith$Mutation$DisableService$services$disableService.stub(
|
|
TRes res) =
|
|
_CopyWithStubImpl$Mutation$DisableService$services$disableService;
|
|
|
|
TRes call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$DisableService$services$disableService<TRes>
|
|
implements CopyWith$Mutation$DisableService$services$disableService<TRes> {
|
|
_CopyWithImpl$Mutation$DisableService$services$disableService(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$DisableService$services$disableService _instance;
|
|
|
|
final TRes Function(Mutation$DisableService$services$disableService) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$DisableService$services$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$services$disableService<TRes>
|
|
implements CopyWith$Mutation$DisableService$services$disableService<TRes> {
|
|
_CopyWithStubImpl$Mutation$DisableService$services$disableService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Variables$Mutation$StopService {
|
|
factory Variables$Mutation$StopService({required String serviceId}) =>
|
|
Variables$Mutation$StopService._({
|
|
r'serviceId': serviceId,
|
|
});
|
|
|
|
Variables$Mutation$StopService._(this._$data);
|
|
|
|
factory Variables$Mutation$StopService.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = data['serviceId'];
|
|
result$data['serviceId'] = (l$serviceId as String);
|
|
return Variables$Mutation$StopService._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
String get serviceId => (_$data['serviceId'] as String);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = serviceId;
|
|
result$data['serviceId'] = l$serviceId;
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$StopService<Variables$Mutation$StopService>
|
|
get copyWith => CopyWith$Variables$Mutation$StopService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@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;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$StopService._({
|
|
..._instance._$data,
|
|
if (serviceId != _undefined && serviceId != null)
|
|
'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;
|
|
}
|
|
|
|
class Mutation$StopService {
|
|
Mutation$StopService({
|
|
required this.services,
|
|
this.$__typename = 'Mutation',
|
|
});
|
|
|
|
factory Mutation$StopService.fromJson(Map<String, dynamic> json) {
|
|
final l$services = json['services'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$StopService(
|
|
services: Mutation$StopService$services.fromJson(
|
|
(l$services as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$StopService$services services;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$services = services;
|
|
_resultData['services'] = l$services.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 Mutation$StopService) || 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$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$services? services,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$StopService$services<TRes> get services;
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? services = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$StopService(
|
|
services: services == _undefined || services == null
|
|
? _instance.services
|
|
: (services as Mutation$StopService$services),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$StopService$services<TRes> get services {
|
|
final local$services = _instance.services;
|
|
return CopyWith$Mutation$StopService$services(
|
|
local$services, (e) => call(services: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$StopService<TRes>
|
|
implements CopyWith$Mutation$StopService<TRes> {
|
|
_CopyWithStubImpl$Mutation$StopService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$StopService$services? services,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$StopService$services<TRes> get services =>
|
|
CopyWith$Mutation$StopService$services.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: 'services'),
|
|
alias: null,
|
|
arguments: [],
|
|
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,
|
|
),
|
|
]),
|
|
),
|
|
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(
|
|
Map<String, 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,
|
|
Mutation$StopService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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,
|
|
Mutation$StopService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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);
|
|
}
|
|
|
|
class Mutation$StopService$services {
|
|
Mutation$StopService$services({
|
|
required this.stopService,
|
|
this.$__typename = 'ServicesMutations',
|
|
});
|
|
|
|
factory Mutation$StopService$services.fromJson(Map<String, dynamic> json) {
|
|
final l$stopService = json['stopService'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$StopService$services(
|
|
stopService: Mutation$StopService$services$stopService.fromJson(
|
|
(l$stopService as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$StopService$services$stopService stopService;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$stopService = stopService;
|
|
_resultData['stopService'] = l$stopService.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services) ||
|
|
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$services
|
|
on Mutation$StopService$services {
|
|
CopyWith$Mutation$StopService$services<Mutation$StopService$services>
|
|
get copyWith => CopyWith$Mutation$StopService$services(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$StopService$services<TRes> {
|
|
factory CopyWith$Mutation$StopService$services(
|
|
Mutation$StopService$services instance,
|
|
TRes Function(Mutation$StopService$services) then,
|
|
) = _CopyWithImpl$Mutation$StopService$services;
|
|
|
|
factory CopyWith$Mutation$StopService$services.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$StopService$services;
|
|
|
|
TRes call({
|
|
Mutation$StopService$services$stopService? stopService,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$StopService$services$stopService<TRes> get stopService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$StopService$services<TRes>
|
|
implements CopyWith$Mutation$StopService$services<TRes> {
|
|
_CopyWithImpl$Mutation$StopService$services(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$StopService$services _instance;
|
|
|
|
final TRes Function(Mutation$StopService$services) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? stopService = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$StopService$services(
|
|
stopService: stopService == _undefined || stopService == null
|
|
? _instance.stopService
|
|
: (stopService as Mutation$StopService$services$stopService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$StopService$services$stopService<TRes> get stopService {
|
|
final local$stopService = _instance.stopService;
|
|
return CopyWith$Mutation$StopService$services$stopService(
|
|
local$stopService, (e) => call(stopService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$StopService$services<TRes>
|
|
implements CopyWith$Mutation$StopService$services<TRes> {
|
|
_CopyWithStubImpl$Mutation$StopService$services(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$StopService$services$stopService? stopService,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$StopService$services$stopService<TRes> get stopService =>
|
|
CopyWith$Mutation$StopService$services$stopService.stub(_res);
|
|
}
|
|
|
|
class Mutation$StopService$services$stopService
|
|
implements Fragment$basicMutationReturnFields$$ServiceMutationReturn {
|
|
Mutation$StopService$services$stopService({
|
|
required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
this.$__typename = 'ServiceMutationReturn',
|
|
});
|
|
|
|
factory Mutation$StopService$services$stopService.fromJson(
|
|
Map<String, dynamic> json) {
|
|
final l$code = json['code'];
|
|
final l$message = json['message'];
|
|
final l$success = json['success'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$StopService$services$stopService(
|
|
code: (l$code as int),
|
|
message: (l$message as String),
|
|
success: (l$success as bool),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$code = code;
|
|
_resultData['code'] = l$code;
|
|
final l$message = message;
|
|
_resultData['message'] = l$message;
|
|
final l$success = success;
|
|
_resultData['success'] = l$success;
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services$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$services$stopService
|
|
on Mutation$StopService$services$stopService {
|
|
CopyWith$Mutation$StopService$services$stopService<
|
|
Mutation$StopService$services$stopService>
|
|
get copyWith => CopyWith$Mutation$StopService$services$stopService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$StopService$services$stopService<TRes> {
|
|
factory CopyWith$Mutation$StopService$services$stopService(
|
|
Mutation$StopService$services$stopService instance,
|
|
TRes Function(Mutation$StopService$services$stopService) then,
|
|
) = _CopyWithImpl$Mutation$StopService$services$stopService;
|
|
|
|
factory CopyWith$Mutation$StopService$services$stopService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$StopService$services$stopService;
|
|
|
|
TRes call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$StopService$services$stopService<TRes>
|
|
implements CopyWith$Mutation$StopService$services$stopService<TRes> {
|
|
_CopyWithImpl$Mutation$StopService$services$stopService(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$StopService$services$stopService _instance;
|
|
|
|
final TRes Function(Mutation$StopService$services$stopService) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$StopService$services$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$services$stopService<TRes>
|
|
implements CopyWith$Mutation$StopService$services$stopService<TRes> {
|
|
_CopyWithStubImpl$Mutation$StopService$services$stopService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Variables$Mutation$StartService {
|
|
factory Variables$Mutation$StartService({required String serviceId}) =>
|
|
Variables$Mutation$StartService._({
|
|
r'serviceId': serviceId,
|
|
});
|
|
|
|
Variables$Mutation$StartService._(this._$data);
|
|
|
|
factory Variables$Mutation$StartService.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = data['serviceId'];
|
|
result$data['serviceId'] = (l$serviceId as String);
|
|
return Variables$Mutation$StartService._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
String get serviceId => (_$data['serviceId'] as String);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = serviceId;
|
|
result$data['serviceId'] = l$serviceId;
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$StartService<Variables$Mutation$StartService>
|
|
get copyWith => CopyWith$Variables$Mutation$StartService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@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;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$StartService._({
|
|
..._instance._$data,
|
|
if (serviceId != _undefined && serviceId != null)
|
|
'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;
|
|
}
|
|
|
|
class Mutation$StartService {
|
|
Mutation$StartService({
|
|
required this.services,
|
|
this.$__typename = 'Mutation',
|
|
});
|
|
|
|
factory Mutation$StartService.fromJson(Map<String, dynamic> json) {
|
|
final l$services = json['services'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$StartService(
|
|
services: Mutation$StartService$services.fromJson(
|
|
(l$services as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$StartService$services services;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$services = services;
|
|
_resultData['services'] = l$services.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 Mutation$StartService) || 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$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$services? services,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$StartService$services<TRes> get services;
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? services = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$StartService(
|
|
services: services == _undefined || services == null
|
|
? _instance.services
|
|
: (services as Mutation$StartService$services),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$StartService$services<TRes> get services {
|
|
final local$services = _instance.services;
|
|
return CopyWith$Mutation$StartService$services(
|
|
local$services, (e) => call(services: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$StartService<TRes>
|
|
implements CopyWith$Mutation$StartService<TRes> {
|
|
_CopyWithStubImpl$Mutation$StartService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$StartService$services? services,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$StartService$services<TRes> get services =>
|
|
CopyWith$Mutation$StartService$services.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: 'services'),
|
|
alias: null,
|
|
arguments: [],
|
|
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,
|
|
),
|
|
]),
|
|
),
|
|
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(
|
|
Map<String, 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,
|
|
Mutation$StartService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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,
|
|
Mutation$StartService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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);
|
|
}
|
|
|
|
class Mutation$StartService$services {
|
|
Mutation$StartService$services({
|
|
required this.startService,
|
|
this.$__typename = 'ServicesMutations',
|
|
});
|
|
|
|
factory Mutation$StartService$services.fromJson(Map<String, dynamic> json) {
|
|
final l$startService = json['startService'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$StartService$services(
|
|
startService: Mutation$StartService$services$startService.fromJson(
|
|
(l$startService as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$StartService$services$startService startService;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$startService = startService;
|
|
_resultData['startService'] = l$startService.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services) ||
|
|
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$services
|
|
on Mutation$StartService$services {
|
|
CopyWith$Mutation$StartService$services<Mutation$StartService$services>
|
|
get copyWith => CopyWith$Mutation$StartService$services(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$StartService$services<TRes> {
|
|
factory CopyWith$Mutation$StartService$services(
|
|
Mutation$StartService$services instance,
|
|
TRes Function(Mutation$StartService$services) then,
|
|
) = _CopyWithImpl$Mutation$StartService$services;
|
|
|
|
factory CopyWith$Mutation$StartService$services.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$StartService$services;
|
|
|
|
TRes call({
|
|
Mutation$StartService$services$startService? startService,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$StartService$services$startService<TRes> get startService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$StartService$services<TRes>
|
|
implements CopyWith$Mutation$StartService$services<TRes> {
|
|
_CopyWithImpl$Mutation$StartService$services(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$StartService$services _instance;
|
|
|
|
final TRes Function(Mutation$StartService$services) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? startService = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$StartService$services(
|
|
startService: startService == _undefined || startService == null
|
|
? _instance.startService
|
|
: (startService as Mutation$StartService$services$startService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$StartService$services$startService<TRes> get startService {
|
|
final local$startService = _instance.startService;
|
|
return CopyWith$Mutation$StartService$services$startService(
|
|
local$startService, (e) => call(startService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$StartService$services<TRes>
|
|
implements CopyWith$Mutation$StartService$services<TRes> {
|
|
_CopyWithStubImpl$Mutation$StartService$services(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$StartService$services$startService? startService,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$StartService$services$startService<TRes> get startService =>
|
|
CopyWith$Mutation$StartService$services$startService.stub(_res);
|
|
}
|
|
|
|
class Mutation$StartService$services$startService
|
|
implements Fragment$basicMutationReturnFields$$ServiceMutationReturn {
|
|
Mutation$StartService$services$startService({
|
|
required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
this.$__typename = 'ServiceMutationReturn',
|
|
});
|
|
|
|
factory Mutation$StartService$services$startService.fromJson(
|
|
Map<String, dynamic> json) {
|
|
final l$code = json['code'];
|
|
final l$message = json['message'];
|
|
final l$success = json['success'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$StartService$services$startService(
|
|
code: (l$code as int),
|
|
message: (l$message as String),
|
|
success: (l$success as bool),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$code = code;
|
|
_resultData['code'] = l$code;
|
|
final l$message = message;
|
|
_resultData['message'] = l$message;
|
|
final l$success = success;
|
|
_resultData['success'] = l$success;
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services$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$services$startService
|
|
on Mutation$StartService$services$startService {
|
|
CopyWith$Mutation$StartService$services$startService<
|
|
Mutation$StartService$services$startService>
|
|
get copyWith => CopyWith$Mutation$StartService$services$startService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$StartService$services$startService<TRes> {
|
|
factory CopyWith$Mutation$StartService$services$startService(
|
|
Mutation$StartService$services$startService instance,
|
|
TRes Function(Mutation$StartService$services$startService) then,
|
|
) = _CopyWithImpl$Mutation$StartService$services$startService;
|
|
|
|
factory CopyWith$Mutation$StartService$services$startService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$StartService$services$startService;
|
|
|
|
TRes call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$StartService$services$startService<TRes>
|
|
implements CopyWith$Mutation$StartService$services$startService<TRes> {
|
|
_CopyWithImpl$Mutation$StartService$services$startService(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$StartService$services$startService _instance;
|
|
|
|
final TRes Function(Mutation$StartService$services$startService) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$StartService$services$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$services$startService<TRes>
|
|
implements CopyWith$Mutation$StartService$services$startService<TRes> {
|
|
_CopyWithStubImpl$Mutation$StartService$services$startService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Variables$Mutation$RestartService {
|
|
factory Variables$Mutation$RestartService({required String serviceId}) =>
|
|
Variables$Mutation$RestartService._({
|
|
r'serviceId': serviceId,
|
|
});
|
|
|
|
Variables$Mutation$RestartService._(this._$data);
|
|
|
|
factory Variables$Mutation$RestartService.fromJson(
|
|
Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = data['serviceId'];
|
|
result$data['serviceId'] = (l$serviceId as String);
|
|
return Variables$Mutation$RestartService._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
String get serviceId => (_$data['serviceId'] as String);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
final l$serviceId = serviceId;
|
|
result$data['serviceId'] = l$serviceId;
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$RestartService<Variables$Mutation$RestartService>
|
|
get copyWith => CopyWith$Variables$Mutation$RestartService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@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;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$serviceId = serviceId;
|
|
return Object.hashAll([l$serviceId]);
|
|
}
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({Object? serviceId = _undefined}) =>
|
|
_then(Variables$Mutation$RestartService._({
|
|
..._instance._$data,
|
|
if (serviceId != _undefined && serviceId != null)
|
|
'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;
|
|
}
|
|
|
|
class Mutation$RestartService {
|
|
Mutation$RestartService({
|
|
required this.services,
|
|
this.$__typename = 'Mutation',
|
|
});
|
|
|
|
factory Mutation$RestartService.fromJson(Map<String, dynamic> json) {
|
|
final l$services = json['services'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$RestartService(
|
|
services: Mutation$RestartService$services.fromJson(
|
|
(l$services as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$RestartService$services services;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$services = services;
|
|
_resultData['services'] = l$services.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 Mutation$RestartService) ||
|
|
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$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$services? services,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$RestartService$services<TRes> get services;
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? services = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$RestartService(
|
|
services: services == _undefined || services == null
|
|
? _instance.services
|
|
: (services as Mutation$RestartService$services),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$RestartService$services<TRes> get services {
|
|
final local$services = _instance.services;
|
|
return CopyWith$Mutation$RestartService$services(
|
|
local$services, (e) => call(services: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$RestartService<TRes>
|
|
implements CopyWith$Mutation$RestartService<TRes> {
|
|
_CopyWithStubImpl$Mutation$RestartService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$RestartService$services? services,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$RestartService$services<TRes> get services =>
|
|
CopyWith$Mutation$RestartService$services.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: 'services'),
|
|
alias: null,
|
|
arguments: [],
|
|
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,
|
|
),
|
|
]),
|
|
),
|
|
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(
|
|
Map<String, 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,
|
|
Mutation$RestartService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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,
|
|
Mutation$RestartService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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);
|
|
}
|
|
|
|
class Mutation$RestartService$services {
|
|
Mutation$RestartService$services({
|
|
required this.restartService,
|
|
this.$__typename = 'ServicesMutations',
|
|
});
|
|
|
|
factory Mutation$RestartService$services.fromJson(Map<String, dynamic> json) {
|
|
final l$restartService = json['restartService'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$RestartService$services(
|
|
restartService: Mutation$RestartService$services$restartService.fromJson(
|
|
(l$restartService as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$RestartService$services$restartService restartService;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$restartService = restartService;
|
|
_resultData['restartService'] = l$restartService.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services) ||
|
|
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$services
|
|
on Mutation$RestartService$services {
|
|
CopyWith$Mutation$RestartService$services<Mutation$RestartService$services>
|
|
get copyWith => CopyWith$Mutation$RestartService$services(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$RestartService$services<TRes> {
|
|
factory CopyWith$Mutation$RestartService$services(
|
|
Mutation$RestartService$services instance,
|
|
TRes Function(Mutation$RestartService$services) then,
|
|
) = _CopyWithImpl$Mutation$RestartService$services;
|
|
|
|
factory CopyWith$Mutation$RestartService$services.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$RestartService$services;
|
|
|
|
TRes call({
|
|
Mutation$RestartService$services$restartService? restartService,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$RestartService$services$restartService<TRes>
|
|
get restartService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$RestartService$services<TRes>
|
|
implements CopyWith$Mutation$RestartService$services<TRes> {
|
|
_CopyWithImpl$Mutation$RestartService$services(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$RestartService$services _instance;
|
|
|
|
final TRes Function(Mutation$RestartService$services) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? restartService = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$RestartService$services(
|
|
restartService: restartService == _undefined || restartService == null
|
|
? _instance.restartService
|
|
: (restartService
|
|
as Mutation$RestartService$services$restartService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$RestartService$services$restartService<TRes>
|
|
get restartService {
|
|
final local$restartService = _instance.restartService;
|
|
return CopyWith$Mutation$RestartService$services$restartService(
|
|
local$restartService, (e) => call(restartService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$RestartService$services<TRes>
|
|
implements CopyWith$Mutation$RestartService$services<TRes> {
|
|
_CopyWithStubImpl$Mutation$RestartService$services(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$RestartService$services$restartService? restartService,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$RestartService$services$restartService<TRes>
|
|
get restartService =>
|
|
CopyWith$Mutation$RestartService$services$restartService.stub(_res);
|
|
}
|
|
|
|
class Mutation$RestartService$services$restartService
|
|
implements Fragment$basicMutationReturnFields$$ServiceMutationReturn {
|
|
Mutation$RestartService$services$restartService({
|
|
required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
this.$__typename = 'ServiceMutationReturn',
|
|
});
|
|
|
|
factory Mutation$RestartService$services$restartService.fromJson(
|
|
Map<String, dynamic> json) {
|
|
final l$code = json['code'];
|
|
final l$message = json['message'];
|
|
final l$success = json['success'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$RestartService$services$restartService(
|
|
code: (l$code as int),
|
|
message: (l$message as String),
|
|
success: (l$success as bool),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$code = code;
|
|
_resultData['code'] = l$code;
|
|
final l$message = message;
|
|
_resultData['message'] = l$message;
|
|
final l$success = success;
|
|
_resultData['success'] = l$success;
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services$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$services$restartService
|
|
on Mutation$RestartService$services$restartService {
|
|
CopyWith$Mutation$RestartService$services$restartService<
|
|
Mutation$RestartService$services$restartService>
|
|
get copyWith => CopyWith$Mutation$RestartService$services$restartService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$RestartService$services$restartService<TRes> {
|
|
factory CopyWith$Mutation$RestartService$services$restartService(
|
|
Mutation$RestartService$services$restartService instance,
|
|
TRes Function(Mutation$RestartService$services$restartService) then,
|
|
) = _CopyWithImpl$Mutation$RestartService$services$restartService;
|
|
|
|
factory CopyWith$Mutation$RestartService$services$restartService.stub(
|
|
TRes res) =
|
|
_CopyWithStubImpl$Mutation$RestartService$services$restartService;
|
|
|
|
TRes call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
});
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$RestartService$services$restartService<TRes>
|
|
implements CopyWith$Mutation$RestartService$services$restartService<TRes> {
|
|
_CopyWithImpl$Mutation$RestartService$services$restartService(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$RestartService$services$restartService _instance;
|
|
|
|
final TRes Function(Mutation$RestartService$services$restartService) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$RestartService$services$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$services$restartService<TRes>
|
|
implements CopyWith$Mutation$RestartService$services$restartService<TRes> {
|
|
_CopyWithStubImpl$Mutation$RestartService$services$restartService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
}
|
|
|
|
class Variables$Mutation$MoveService {
|
|
factory Variables$Mutation$MoveService(
|
|
{required Input$MoveServiceInput input}) =>
|
|
Variables$Mutation$MoveService._({
|
|
r'input': input,
|
|
});
|
|
|
|
Variables$Mutation$MoveService._(this._$data);
|
|
|
|
factory Variables$Mutation$MoveService.fromJson(Map<String, dynamic> data) {
|
|
final result$data = <String, dynamic>{};
|
|
final l$input = data['input'];
|
|
result$data['input'] =
|
|
Input$MoveServiceInput.fromJson((l$input as Map<String, dynamic>));
|
|
return Variables$Mutation$MoveService._(result$data);
|
|
}
|
|
|
|
Map<String, dynamic> _$data;
|
|
|
|
Input$MoveServiceInput get input =>
|
|
(_$data['input'] as Input$MoveServiceInput);
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final result$data = <String, dynamic>{};
|
|
final l$input = input;
|
|
result$data['input'] = l$input.toJson();
|
|
return result$data;
|
|
}
|
|
|
|
CopyWith$Variables$Mutation$MoveService<Variables$Mutation$MoveService>
|
|
get copyWith => CopyWith$Variables$Mutation$MoveService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
|
|
@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;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
final l$input = input;
|
|
return Object.hashAll([l$input]);
|
|
}
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({Object? input = _undefined}) =>
|
|
_then(Variables$Mutation$MoveService._({
|
|
..._instance._$data,
|
|
if (input != _undefined && input != null)
|
|
'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;
|
|
}
|
|
|
|
class Mutation$MoveService {
|
|
Mutation$MoveService({
|
|
required this.services,
|
|
this.$__typename = 'Mutation',
|
|
});
|
|
|
|
factory Mutation$MoveService.fromJson(Map<String, dynamic> json) {
|
|
final l$services = json['services'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$MoveService(
|
|
services: Mutation$MoveService$services.fromJson(
|
|
(l$services as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$MoveService$services services;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$services = services;
|
|
_resultData['services'] = l$services.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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 Mutation$MoveService) || 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$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$services? services,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$MoveService$services<TRes> get services;
|
|
}
|
|
|
|
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 = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? services = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$MoveService(
|
|
services: services == _undefined || services == null
|
|
? _instance.services
|
|
: (services as Mutation$MoveService$services),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$MoveService$services<TRes> get services {
|
|
final local$services = _instance.services;
|
|
return CopyWith$Mutation$MoveService$services(
|
|
local$services, (e) => call(services: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$MoveService<TRes>
|
|
implements CopyWith$Mutation$MoveService<TRes> {
|
|
_CopyWithStubImpl$Mutation$MoveService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$MoveService$services? services,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$MoveService$services<TRes> get services =>
|
|
CopyWith$Mutation$MoveService$services.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: 'services'),
|
|
alias: null,
|
|
arguments: [],
|
|
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: [
|
|
FragmentSpreadNode(
|
|
name: NameNode(value: 'basicApiJobsFields'),
|
|
directives: [],
|
|
),
|
|
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,
|
|
),
|
|
]),
|
|
),
|
|
FieldNode(
|
|
name: NameNode(value: '__typename'),
|
|
alias: null,
|
|
arguments: [],
|
|
directives: [],
|
|
selectionSet: null,
|
|
),
|
|
]),
|
|
),
|
|
fragmentDefinitionbasicMutationReturnFields,
|
|
fragmentDefinitionbasicApiJobsFields,
|
|
]);
|
|
Mutation$MoveService _parserFn$Mutation$MoveService(
|
|
Map<String, dynamic> data) =>
|
|
Mutation$MoveService.fromJson(data);
|
|
typedef OnMutationCompleted$Mutation$MoveService = FutureOr<void> Function(
|
|
Map<String, 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,
|
|
Mutation$MoveService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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,
|
|
Mutation$MoveService? typedOptimisticResult,
|
|
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 ?? typedOptimisticResult?.toJson(),
|
|
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);
|
|
}
|
|
|
|
class Mutation$MoveService$services {
|
|
Mutation$MoveService$services({
|
|
required this.moveService,
|
|
this.$__typename = 'ServicesMutations',
|
|
});
|
|
|
|
factory Mutation$MoveService$services.fromJson(Map<String, dynamic> json) {
|
|
final l$moveService = json['moveService'];
|
|
final l$$__typename = json['__typename'];
|
|
return Mutation$MoveService$services(
|
|
moveService: Mutation$MoveService$services$moveService.fromJson(
|
|
(l$moveService as Map<String, dynamic>)),
|
|
$__typename: (l$$__typename as String),
|
|
);
|
|
}
|
|
|
|
final Mutation$MoveService$services$moveService moveService;
|
|
|
|
final String $__typename;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$moveService = moveService;
|
|
_resultData['moveService'] = l$moveService.toJson();
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services) ||
|
|
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$services
|
|
on Mutation$MoveService$services {
|
|
CopyWith$Mutation$MoveService$services<Mutation$MoveService$services>
|
|
get copyWith => CopyWith$Mutation$MoveService$services(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$MoveService$services<TRes> {
|
|
factory CopyWith$Mutation$MoveService$services(
|
|
Mutation$MoveService$services instance,
|
|
TRes Function(Mutation$MoveService$services) then,
|
|
) = _CopyWithImpl$Mutation$MoveService$services;
|
|
|
|
factory CopyWith$Mutation$MoveService$services.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$MoveService$services;
|
|
|
|
TRes call({
|
|
Mutation$MoveService$services$moveService? moveService,
|
|
String? $__typename,
|
|
});
|
|
CopyWith$Mutation$MoveService$services$moveService<TRes> get moveService;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$MoveService$services<TRes>
|
|
implements CopyWith$Mutation$MoveService$services<TRes> {
|
|
_CopyWithImpl$Mutation$MoveService$services(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$MoveService$services _instance;
|
|
|
|
final TRes Function(Mutation$MoveService$services) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? moveService = _undefined,
|
|
Object? $__typename = _undefined,
|
|
}) =>
|
|
_then(Mutation$MoveService$services(
|
|
moveService: moveService == _undefined || moveService == null
|
|
? _instance.moveService
|
|
: (moveService as Mutation$MoveService$services$moveService),
|
|
$__typename: $__typename == _undefined || $__typename == null
|
|
? _instance.$__typename
|
|
: ($__typename as String),
|
|
));
|
|
|
|
CopyWith$Mutation$MoveService$services$moveService<TRes> get moveService {
|
|
final local$moveService = _instance.moveService;
|
|
return CopyWith$Mutation$MoveService$services$moveService(
|
|
local$moveService, (e) => call(moveService: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$MoveService$services<TRes>
|
|
implements CopyWith$Mutation$MoveService$services<TRes> {
|
|
_CopyWithStubImpl$Mutation$MoveService$services(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
Mutation$MoveService$services$moveService? moveService,
|
|
String? $__typename,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Mutation$MoveService$services$moveService<TRes> get moveService =>
|
|
CopyWith$Mutation$MoveService$services$moveService.stub(_res);
|
|
}
|
|
|
|
class Mutation$MoveService$services$moveService
|
|
implements Fragment$basicMutationReturnFields$$ServiceJobMutationReturn {
|
|
Mutation$MoveService$services$moveService({
|
|
required this.code,
|
|
required this.message,
|
|
required this.success,
|
|
this.$__typename = 'ServiceJobMutationReturn',
|
|
this.job,
|
|
});
|
|
|
|
factory Mutation$MoveService$services$moveService.fromJson(
|
|
Map<String, dynamic> json) {
|
|
final l$code = json['code'];
|
|
final l$message = json['message'];
|
|
final l$success = json['success'];
|
|
final l$$__typename = json['__typename'];
|
|
final l$job = json['job'];
|
|
return Mutation$MoveService$services$moveService(
|
|
code: (l$code as int),
|
|
message: (l$message as String),
|
|
success: (l$success as bool),
|
|
$__typename: (l$$__typename as String),
|
|
job: l$job == null
|
|
? null
|
|
: Fragment$basicApiJobsFields.fromJson(
|
|
(l$job as Map<String, dynamic>)),
|
|
);
|
|
}
|
|
|
|
final int code;
|
|
|
|
final String message;
|
|
|
|
final bool success;
|
|
|
|
final String $__typename;
|
|
|
|
final Fragment$basicApiJobsFields? job;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
final _resultData = <String, dynamic>{};
|
|
final l$code = code;
|
|
_resultData['code'] = l$code;
|
|
final l$message = message;
|
|
_resultData['message'] = l$message;
|
|
final l$success = success;
|
|
_resultData['success'] = l$success;
|
|
final l$$__typename = $__typename;
|
|
_resultData['__typename'] = l$$__typename;
|
|
final l$job = job;
|
|
_resultData['job'] = l$job?.toJson();
|
|
return _resultData;
|
|
}
|
|
|
|
@override
|
|
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$services$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$services$moveService
|
|
on Mutation$MoveService$services$moveService {
|
|
CopyWith$Mutation$MoveService$services$moveService<
|
|
Mutation$MoveService$services$moveService>
|
|
get copyWith => CopyWith$Mutation$MoveService$services$moveService(
|
|
this,
|
|
(i) => i,
|
|
);
|
|
}
|
|
|
|
abstract class CopyWith$Mutation$MoveService$services$moveService<TRes> {
|
|
factory CopyWith$Mutation$MoveService$services$moveService(
|
|
Mutation$MoveService$services$moveService instance,
|
|
TRes Function(Mutation$MoveService$services$moveService) then,
|
|
) = _CopyWithImpl$Mutation$MoveService$services$moveService;
|
|
|
|
factory CopyWith$Mutation$MoveService$services$moveService.stub(TRes res) =
|
|
_CopyWithStubImpl$Mutation$MoveService$services$moveService;
|
|
|
|
TRes call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
Fragment$basicApiJobsFields? job,
|
|
});
|
|
CopyWith$Fragment$basicApiJobsFields<TRes> get job;
|
|
}
|
|
|
|
class _CopyWithImpl$Mutation$MoveService$services$moveService<TRes>
|
|
implements CopyWith$Mutation$MoveService$services$moveService<TRes> {
|
|
_CopyWithImpl$Mutation$MoveService$services$moveService(
|
|
this._instance,
|
|
this._then,
|
|
);
|
|
|
|
final Mutation$MoveService$services$moveService _instance;
|
|
|
|
final TRes Function(Mutation$MoveService$services$moveService) _then;
|
|
|
|
static const _undefined = <dynamic, dynamic>{};
|
|
|
|
TRes call({
|
|
Object? code = _undefined,
|
|
Object? message = _undefined,
|
|
Object? success = _undefined,
|
|
Object? $__typename = _undefined,
|
|
Object? job = _undefined,
|
|
}) =>
|
|
_then(Mutation$MoveService$services$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 Fragment$basicApiJobsFields?),
|
|
));
|
|
|
|
CopyWith$Fragment$basicApiJobsFields<TRes> get job {
|
|
final local$job = _instance.job;
|
|
return local$job == null
|
|
? CopyWith$Fragment$basicApiJobsFields.stub(_then(_instance))
|
|
: CopyWith$Fragment$basicApiJobsFields(local$job, (e) => call(job: e));
|
|
}
|
|
}
|
|
|
|
class _CopyWithStubImpl$Mutation$MoveService$services$moveService<TRes>
|
|
implements CopyWith$Mutation$MoveService$services$moveService<TRes> {
|
|
_CopyWithStubImpl$Mutation$MoveService$services$moveService(this._res);
|
|
|
|
TRes _res;
|
|
|
|
call({
|
|
int? code,
|
|
String? message,
|
|
bool? success,
|
|
String? $__typename,
|
|
Fragment$basicApiJobsFields? job,
|
|
}) =>
|
|
_res;
|
|
|
|
CopyWith$Fragment$basicApiJobsFields<TRes> get job =>
|
|
CopyWith$Fragment$basicApiJobsFields.stub(_res);
|
|
}
|