import 'dart:async';
import 'package:gql/ast.dart';
import 'package:graphql/client.dart' as graphql;
import 'package:selfprivacy/utils/scalars.dart';
import 'schema.graphql.dart';
import 'server_api.graphql.dart';

class Fragment$genericBackupConfigReturn {
  Fragment$genericBackupConfigReturn({
    required this.code,
    required this.message,
    required this.success,
    this.configuration,
    this.$__typename = 'GenericBackupConfigReturn',
  });

  factory Fragment$genericBackupConfigReturn.fromJson(
      Map<String, dynamic> json) {
    final l$code = json['code'];
    final l$message = json['message'];
    final l$success = json['success'];
    final l$configuration = json['configuration'];
    final l$$__typename = json['__typename'];
    return Fragment$genericBackupConfigReturn(
      code: (l$code as int),
      message: (l$message as String),
      success: (l$success as bool),
      configuration: l$configuration == null
          ? null
          : Fragment$genericBackupConfigReturn$configuration.fromJson(
              (l$configuration as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final int code;

  final String message;

  final bool success;

  final Fragment$genericBackupConfigReturn$configuration? configuration;

  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$configuration = configuration;
    _resultData['configuration'] = l$configuration?.toJson();
    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$configuration = configuration;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$code,
      l$message,
      l$success,
      l$configuration,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Fragment$genericBackupConfigReturn) ||
        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$configuration = configuration;
    final lOther$configuration = other.configuration;
    if (l$configuration != lOther$configuration) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Fragment$genericBackupConfigReturn
    on Fragment$genericBackupConfigReturn {
  CopyWith$Fragment$genericBackupConfigReturn<
          Fragment$genericBackupConfigReturn>
      get copyWith => CopyWith$Fragment$genericBackupConfigReturn(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Fragment$genericBackupConfigReturn<TRes> {
  factory CopyWith$Fragment$genericBackupConfigReturn(
    Fragment$genericBackupConfigReturn instance,
    TRes Function(Fragment$genericBackupConfigReturn) then,
  ) = _CopyWithImpl$Fragment$genericBackupConfigReturn;

  factory CopyWith$Fragment$genericBackupConfigReturn.stub(TRes res) =
      _CopyWithStubImpl$Fragment$genericBackupConfigReturn;

  TRes call({
    int? code,
    String? message,
    bool? success,
    Fragment$genericBackupConfigReturn$configuration? configuration,
    String? $__typename,
  });
  CopyWith$Fragment$genericBackupConfigReturn$configuration<TRes>
      get configuration;
}

class _CopyWithImpl$Fragment$genericBackupConfigReturn<TRes>
    implements CopyWith$Fragment$genericBackupConfigReturn<TRes> {
  _CopyWithImpl$Fragment$genericBackupConfigReturn(
    this._instance,
    this._then,
  );

  final Fragment$genericBackupConfigReturn _instance;

  final TRes Function(Fragment$genericBackupConfigReturn) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? code = _undefined,
    Object? message = _undefined,
    Object? success = _undefined,
    Object? configuration = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Fragment$genericBackupConfigReturn(
        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),
        configuration: configuration == _undefined
            ? _instance.configuration
            : (configuration
                as Fragment$genericBackupConfigReturn$configuration?),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Fragment$genericBackupConfigReturn$configuration<TRes>
      get configuration {
    final local$configuration = _instance.configuration;
    return local$configuration == null
        ? CopyWith$Fragment$genericBackupConfigReturn$configuration.stub(
            _then(_instance))
        : CopyWith$Fragment$genericBackupConfigReturn$configuration(
            local$configuration, (e) => call(configuration: e));
  }
}

class _CopyWithStubImpl$Fragment$genericBackupConfigReturn<TRes>
    implements CopyWith$Fragment$genericBackupConfigReturn<TRes> {
  _CopyWithStubImpl$Fragment$genericBackupConfigReturn(this._res);

  TRes _res;

  call({
    int? code,
    String? message,
    bool? success,
    Fragment$genericBackupConfigReturn$configuration? configuration,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Fragment$genericBackupConfigReturn$configuration<TRes>
      get configuration =>
          CopyWith$Fragment$genericBackupConfigReturn$configuration.stub(_res);
}

const fragmentDefinitiongenericBackupConfigReturn = FragmentDefinitionNode(
  name: NameNode(value: 'genericBackupConfigReturn'),
  typeCondition: TypeConditionNode(
      on: NamedTypeNode(
    name: NameNode(value: 'GenericBackupConfigReturn'),
    isNonNull: false,
  )),
  directives: [],
  selectionSet: SelectionSetNode(selections: [
    FieldNode(
      name: NameNode(value: 'code'),
      alias: null,
      arguments: [],
      directives: [],
      selectionSet: null,
    ),
    FieldNode(
      name: NameNode(value: 'message'),
      alias: null,
      arguments: [],
      directives: [],
      selectionSet: null,
    ),
    FieldNode(
      name: NameNode(value: 'success'),
      alias: null,
      arguments: [],
      directives: [],
      selectionSet: null,
    ),
    FieldNode(
      name: NameNode(value: 'configuration'),
      alias: null,
      arguments: [],
      directives: [],
      selectionSet: SelectionSetNode(selections: [
        FieldNode(
          name: NameNode(value: 'provider'),
          alias: null,
          arguments: [],
          directives: [],
          selectionSet: null,
        ),
        FieldNode(
          name: NameNode(value: 'encryptionKey'),
          alias: null,
          arguments: [],
          directives: [],
          selectionSet: null,
        ),
        FieldNode(
          name: NameNode(value: 'isInitialized'),
          alias: null,
          arguments: [],
          directives: [],
          selectionSet: null,
        ),
        FieldNode(
          name: NameNode(value: 'autobackupPeriod'),
          alias: null,
          arguments: [],
          directives: [],
          selectionSet: null,
        ),
        FieldNode(
          name: NameNode(value: 'locationName'),
          alias: null,
          arguments: [],
          directives: [],
          selectionSet: null,
        ),
        FieldNode(
          name: NameNode(value: 'locationId'),
          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,
    ),
  ]),
);
const documentNodeFragmentgenericBackupConfigReturn =
    DocumentNode(definitions: [
  fragmentDefinitiongenericBackupConfigReturn,
]);

extension ClientExtension$Fragment$genericBackupConfigReturn
    on graphql.GraphQLClient {
  void writeFragment$genericBackupConfigReturn({
    required Fragment$genericBackupConfigReturn data,
    required Map<String, dynamic> idFields,
    bool broadcast = true,
  }) =>
      this.writeFragment(
        graphql.FragmentRequest(
          idFields: idFields,
          fragment: const graphql.Fragment(
            fragmentName: 'genericBackupConfigReturn',
            document: documentNodeFragmentgenericBackupConfigReturn,
          ),
        ),
        data: data.toJson(),
        broadcast: broadcast,
      );
  Fragment$genericBackupConfigReturn? readFragment$genericBackupConfigReturn({
    required Map<String, dynamic> idFields,
    bool optimistic = true,
  }) {
    final result = this.readFragment(
      graphql.FragmentRequest(
        idFields: idFields,
        fragment: const graphql.Fragment(
          fragmentName: 'genericBackupConfigReturn',
          document: documentNodeFragmentgenericBackupConfigReturn,
        ),
      ),
      optimistic: optimistic,
    );
    return result == null
        ? null
        : Fragment$genericBackupConfigReturn.fromJson(result);
  }
}

class Fragment$genericBackupConfigReturn$configuration {
  Fragment$genericBackupConfigReturn$configuration({
    required this.provider,
    required this.encryptionKey,
    required this.isInitialized,
    this.autobackupPeriod,
    this.locationName,
    this.locationId,
    this.$__typename = 'BackupConfiguration',
  });

  factory Fragment$genericBackupConfigReturn$configuration.fromJson(
      Map<String, dynamic> json) {
    final l$provider = json['provider'];
    final l$encryptionKey = json['encryptionKey'];
    final l$isInitialized = json['isInitialized'];
    final l$autobackupPeriod = json['autobackupPeriod'];
    final l$locationName = json['locationName'];
    final l$locationId = json['locationId'];
    final l$$__typename = json['__typename'];
    return Fragment$genericBackupConfigReturn$configuration(
      provider: fromJson$Enum$BackupProvider((l$provider as String)),
      encryptionKey: (l$encryptionKey as String),
      isInitialized: (l$isInitialized as bool),
      autobackupPeriod: (l$autobackupPeriod as int?),
      locationName: (l$locationName as String?),
      locationId: (l$locationId as String?),
      $__typename: (l$$__typename as String),
    );
  }

  final Enum$BackupProvider provider;

  final String encryptionKey;

  final bool isInitialized;

  final int? autobackupPeriod;

  final String? locationName;

  final String? locationId;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$provider = provider;
    _resultData['provider'] = toJson$Enum$BackupProvider(l$provider);
    final l$encryptionKey = encryptionKey;
    _resultData['encryptionKey'] = l$encryptionKey;
    final l$isInitialized = isInitialized;
    _resultData['isInitialized'] = l$isInitialized;
    final l$autobackupPeriod = autobackupPeriod;
    _resultData['autobackupPeriod'] = l$autobackupPeriod;
    final l$locationName = locationName;
    _resultData['locationName'] = l$locationName;
    final l$locationId = locationId;
    _resultData['locationId'] = l$locationId;
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$provider = provider;
    final l$encryptionKey = encryptionKey;
    final l$isInitialized = isInitialized;
    final l$autobackupPeriod = autobackupPeriod;
    final l$locationName = locationName;
    final l$locationId = locationId;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$provider,
      l$encryptionKey,
      l$isInitialized,
      l$autobackupPeriod,
      l$locationName,
      l$locationId,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Fragment$genericBackupConfigReturn$configuration) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$provider = provider;
    final lOther$provider = other.provider;
    if (l$provider != lOther$provider) {
      return false;
    }
    final l$encryptionKey = encryptionKey;
    final lOther$encryptionKey = other.encryptionKey;
    if (l$encryptionKey != lOther$encryptionKey) {
      return false;
    }
    final l$isInitialized = isInitialized;
    final lOther$isInitialized = other.isInitialized;
    if (l$isInitialized != lOther$isInitialized) {
      return false;
    }
    final l$autobackupPeriod = autobackupPeriod;
    final lOther$autobackupPeriod = other.autobackupPeriod;
    if (l$autobackupPeriod != lOther$autobackupPeriod) {
      return false;
    }
    final l$locationName = locationName;
    final lOther$locationName = other.locationName;
    if (l$locationName != lOther$locationName) {
      return false;
    }
    final l$locationId = locationId;
    final lOther$locationId = other.locationId;
    if (l$locationId != lOther$locationId) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Fragment$genericBackupConfigReturn$configuration
    on Fragment$genericBackupConfigReturn$configuration {
  CopyWith$Fragment$genericBackupConfigReturn$configuration<
          Fragment$genericBackupConfigReturn$configuration>
      get copyWith => CopyWith$Fragment$genericBackupConfigReturn$configuration(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Fragment$genericBackupConfigReturn$configuration<TRes> {
  factory CopyWith$Fragment$genericBackupConfigReturn$configuration(
    Fragment$genericBackupConfigReturn$configuration instance,
    TRes Function(Fragment$genericBackupConfigReturn$configuration) then,
  ) = _CopyWithImpl$Fragment$genericBackupConfigReturn$configuration;

  factory CopyWith$Fragment$genericBackupConfigReturn$configuration.stub(
          TRes res) =
      _CopyWithStubImpl$Fragment$genericBackupConfigReturn$configuration;

  TRes call({
    Enum$BackupProvider? provider,
    String? encryptionKey,
    bool? isInitialized,
    int? autobackupPeriod,
    String? locationName,
    String? locationId,
    String? $__typename,
  });
}

class _CopyWithImpl$Fragment$genericBackupConfigReturn$configuration<TRes>
    implements CopyWith$Fragment$genericBackupConfigReturn$configuration<TRes> {
  _CopyWithImpl$Fragment$genericBackupConfigReturn$configuration(
    this._instance,
    this._then,
  );

  final Fragment$genericBackupConfigReturn$configuration _instance;

  final TRes Function(Fragment$genericBackupConfigReturn$configuration) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? provider = _undefined,
    Object? encryptionKey = _undefined,
    Object? isInitialized = _undefined,
    Object? autobackupPeriod = _undefined,
    Object? locationName = _undefined,
    Object? locationId = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Fragment$genericBackupConfigReturn$configuration(
        provider: provider == _undefined || provider == null
            ? _instance.provider
            : (provider as Enum$BackupProvider),
        encryptionKey: encryptionKey == _undefined || encryptionKey == null
            ? _instance.encryptionKey
            : (encryptionKey as String),
        isInitialized: isInitialized == _undefined || isInitialized == null
            ? _instance.isInitialized
            : (isInitialized as bool),
        autobackupPeriod: autobackupPeriod == _undefined
            ? _instance.autobackupPeriod
            : (autobackupPeriod as int?),
        locationName: locationName == _undefined
            ? _instance.locationName
            : (locationName as String?),
        locationId: locationId == _undefined
            ? _instance.locationId
            : (locationId as String?),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
}

class _CopyWithStubImpl$Fragment$genericBackupConfigReturn$configuration<TRes>
    implements CopyWith$Fragment$genericBackupConfigReturn$configuration<TRes> {
  _CopyWithStubImpl$Fragment$genericBackupConfigReturn$configuration(this._res);

  TRes _res;

  call({
    Enum$BackupProvider? provider,
    String? encryptionKey,
    bool? isInitialized,
    int? autobackupPeriod,
    String? locationName,
    String? locationId,
    String? $__typename,
  }) =>
      _res;
}

class Query$BackupConfiguration {
  Query$BackupConfiguration({
    required this.backup,
    this.$__typename = 'Query',
  });

  factory Query$BackupConfiguration.fromJson(Map<String, dynamic> json) {
    final l$backup = json['backup'];
    final l$$__typename = json['__typename'];
    return Query$BackupConfiguration(
      backup: Query$BackupConfiguration$backup.fromJson(
          (l$backup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Query$BackupConfiguration$backup backup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$backup = backup;
    _resultData['backup'] = l$backup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$backup = backup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$backup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Query$BackupConfiguration) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$backup = backup;
    final lOther$backup = other.backup;
    if (l$backup != lOther$backup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Query$BackupConfiguration
    on Query$BackupConfiguration {
  CopyWith$Query$BackupConfiguration<Query$BackupConfiguration> get copyWith =>
      CopyWith$Query$BackupConfiguration(
        this,
        (i) => i,
      );
}

abstract class CopyWith$Query$BackupConfiguration<TRes> {
  factory CopyWith$Query$BackupConfiguration(
    Query$BackupConfiguration instance,
    TRes Function(Query$BackupConfiguration) then,
  ) = _CopyWithImpl$Query$BackupConfiguration;

  factory CopyWith$Query$BackupConfiguration.stub(TRes res) =
      _CopyWithStubImpl$Query$BackupConfiguration;

  TRes call({
    Query$BackupConfiguration$backup? backup,
    String? $__typename,
  });
  CopyWith$Query$BackupConfiguration$backup<TRes> get backup;
}

class _CopyWithImpl$Query$BackupConfiguration<TRes>
    implements CopyWith$Query$BackupConfiguration<TRes> {
  _CopyWithImpl$Query$BackupConfiguration(
    this._instance,
    this._then,
  );

  final Query$BackupConfiguration _instance;

  final TRes Function(Query$BackupConfiguration) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? backup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Query$BackupConfiguration(
        backup: backup == _undefined || backup == null
            ? _instance.backup
            : (backup as Query$BackupConfiguration$backup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Query$BackupConfiguration$backup<TRes> get backup {
    final local$backup = _instance.backup;
    return CopyWith$Query$BackupConfiguration$backup(
        local$backup, (e) => call(backup: e));
  }
}

class _CopyWithStubImpl$Query$BackupConfiguration<TRes>
    implements CopyWith$Query$BackupConfiguration<TRes> {
  _CopyWithStubImpl$Query$BackupConfiguration(this._res);

  TRes _res;

  call({
    Query$BackupConfiguration$backup? backup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Query$BackupConfiguration$backup<TRes> get backup =>
      CopyWith$Query$BackupConfiguration$backup.stub(_res);
}

const documentNodeQueryBackupConfiguration = DocumentNode(definitions: [
  OperationDefinitionNode(
    type: OperationType.query,
    name: NameNode(value: 'BackupConfiguration'),
    variableDefinitions: [],
    directives: [],
    selectionSet: SelectionSetNode(selections: [
      FieldNode(
        name: NameNode(value: 'backup'),
        alias: null,
        arguments: [],
        directives: [],
        selectionSet: SelectionSetNode(selections: [
          FieldNode(
            name: NameNode(value: 'configuration'),
            alias: null,
            arguments: [],
            directives: [],
            selectionSet: SelectionSetNode(selections: [
              FieldNode(
                name: NameNode(value: 'autobackupPeriod'),
                alias: null,
                arguments: [],
                directives: [],
                selectionSet: null,
              ),
              FieldNode(
                name: NameNode(value: 'encryptionKey'),
                alias: null,
                arguments: [],
                directives: [],
                selectionSet: null,
              ),
              FieldNode(
                name: NameNode(value: 'isInitialized'),
                alias: null,
                arguments: [],
                directives: [],
                selectionSet: null,
              ),
              FieldNode(
                name: NameNode(value: 'locationId'),
                alias: null,
                arguments: [],
                directives: [],
                selectionSet: null,
              ),
              FieldNode(
                name: NameNode(value: 'locationName'),
                alias: null,
                arguments: [],
                directives: [],
                selectionSet: null,
              ),
              FieldNode(
                name: NameNode(value: 'provider'),
                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,
      ),
    ]),
  ),
]);
Query$BackupConfiguration _parserFn$Query$BackupConfiguration(
        Map<String, dynamic> data) =>
    Query$BackupConfiguration.fromJson(data);
typedef OnQueryComplete$Query$BackupConfiguration = FutureOr<void> Function(
  Map<String, dynamic>?,
  Query$BackupConfiguration?,
);

class Options$Query$BackupConfiguration
    extends graphql.QueryOptions<Query$BackupConfiguration> {
  Options$Query$BackupConfiguration({
    String? operationName,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Query$BackupConfiguration? typedOptimisticResult,
    Duration? pollInterval,
    graphql.Context? context,
    OnQueryComplete$Query$BackupConfiguration? 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$BackupConfiguration(data),
                  ),
          onError: onError,
          document: documentNodeQueryBackupConfiguration,
          parserFn: _parserFn$Query$BackupConfiguration,
        );

  final OnQueryComplete$Query$BackupConfiguration? onCompleteWithParsed;

  @override
  List<Object?> get properties => [
        ...super.onComplete == null
            ? super.properties
            : super.properties.where((property) => property != onComplete),
        onCompleteWithParsed,
      ];
}

class WatchOptions$Query$BackupConfiguration
    extends graphql.WatchQueryOptions<Query$BackupConfiguration> {
  WatchOptions$Query$BackupConfiguration({
    String? operationName,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Query$BackupConfiguration? 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: documentNodeQueryBackupConfiguration,
          pollInterval: pollInterval,
          eagerlyFetchResults: eagerlyFetchResults,
          carryForwardDataOnException: carryForwardDataOnException,
          fetchResults: fetchResults,
          parserFn: _parserFn$Query$BackupConfiguration,
        );
}

class FetchMoreOptions$Query$BackupConfiguration
    extends graphql.FetchMoreOptions {
  FetchMoreOptions$Query$BackupConfiguration(
      {required graphql.UpdateQuery updateQuery})
      : super(
          updateQuery: updateQuery,
          document: documentNodeQueryBackupConfiguration,
        );
}

extension ClientExtension$Query$BackupConfiguration on graphql.GraphQLClient {
  Future<graphql.QueryResult<Query$BackupConfiguration>>
      query$BackupConfiguration(
              [Options$Query$BackupConfiguration? options]) async =>
          await this.query(options ?? Options$Query$BackupConfiguration());
  graphql.ObservableQuery<Query$BackupConfiguration>
      watchQuery$BackupConfiguration(
              [WatchOptions$Query$BackupConfiguration? options]) =>
          this.watchQuery(options ?? WatchOptions$Query$BackupConfiguration());
  void writeQuery$BackupConfiguration({
    required Query$BackupConfiguration data,
    bool broadcast = true,
  }) =>
      this.writeQuery(
        graphql.Request(
            operation: graphql.Operation(
                document: documentNodeQueryBackupConfiguration)),
        data: data.toJson(),
        broadcast: broadcast,
      );
  Query$BackupConfiguration? readQuery$BackupConfiguration(
      {bool optimistic = true}) {
    final result = this.readQuery(
      graphql.Request(
          operation: graphql.Operation(
              document: documentNodeQueryBackupConfiguration)),
      optimistic: optimistic,
    );
    return result == null ? null : Query$BackupConfiguration.fromJson(result);
  }
}

class Query$BackupConfiguration$backup {
  Query$BackupConfiguration$backup({
    required this.configuration,
    this.$__typename = 'Backup',
  });

  factory Query$BackupConfiguration$backup.fromJson(Map<String, dynamic> json) {
    final l$configuration = json['configuration'];
    final l$$__typename = json['__typename'];
    return Query$BackupConfiguration$backup(
      configuration: Query$BackupConfiguration$backup$configuration.fromJson(
          (l$configuration as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Query$BackupConfiguration$backup$configuration configuration;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$configuration = configuration;
    _resultData['configuration'] = l$configuration.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$configuration = configuration;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$configuration,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Query$BackupConfiguration$backup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$configuration = configuration;
    final lOther$configuration = other.configuration;
    if (l$configuration != lOther$configuration) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Query$BackupConfiguration$backup
    on Query$BackupConfiguration$backup {
  CopyWith$Query$BackupConfiguration$backup<Query$BackupConfiguration$backup>
      get copyWith => CopyWith$Query$BackupConfiguration$backup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Query$BackupConfiguration$backup<TRes> {
  factory CopyWith$Query$BackupConfiguration$backup(
    Query$BackupConfiguration$backup instance,
    TRes Function(Query$BackupConfiguration$backup) then,
  ) = _CopyWithImpl$Query$BackupConfiguration$backup;

  factory CopyWith$Query$BackupConfiguration$backup.stub(TRes res) =
      _CopyWithStubImpl$Query$BackupConfiguration$backup;

  TRes call({
    Query$BackupConfiguration$backup$configuration? configuration,
    String? $__typename,
  });
  CopyWith$Query$BackupConfiguration$backup$configuration<TRes>
      get configuration;
}

class _CopyWithImpl$Query$BackupConfiguration$backup<TRes>
    implements CopyWith$Query$BackupConfiguration$backup<TRes> {
  _CopyWithImpl$Query$BackupConfiguration$backup(
    this._instance,
    this._then,
  );

  final Query$BackupConfiguration$backup _instance;

  final TRes Function(Query$BackupConfiguration$backup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? configuration = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Query$BackupConfiguration$backup(
        configuration: configuration == _undefined || configuration == null
            ? _instance.configuration
            : (configuration as Query$BackupConfiguration$backup$configuration),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Query$BackupConfiguration$backup$configuration<TRes>
      get configuration {
    final local$configuration = _instance.configuration;
    return CopyWith$Query$BackupConfiguration$backup$configuration(
        local$configuration, (e) => call(configuration: e));
  }
}

class _CopyWithStubImpl$Query$BackupConfiguration$backup<TRes>
    implements CopyWith$Query$BackupConfiguration$backup<TRes> {
  _CopyWithStubImpl$Query$BackupConfiguration$backup(this._res);

  TRes _res;

  call({
    Query$BackupConfiguration$backup$configuration? configuration,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Query$BackupConfiguration$backup$configuration<TRes>
      get configuration =>
          CopyWith$Query$BackupConfiguration$backup$configuration.stub(_res);
}

class Query$BackupConfiguration$backup$configuration {
  Query$BackupConfiguration$backup$configuration({
    this.autobackupPeriod,
    required this.encryptionKey,
    required this.isInitialized,
    this.locationId,
    this.locationName,
    required this.provider,
    this.$__typename = 'BackupConfiguration',
  });

  factory Query$BackupConfiguration$backup$configuration.fromJson(
      Map<String, dynamic> json) {
    final l$autobackupPeriod = json['autobackupPeriod'];
    final l$encryptionKey = json['encryptionKey'];
    final l$isInitialized = json['isInitialized'];
    final l$locationId = json['locationId'];
    final l$locationName = json['locationName'];
    final l$provider = json['provider'];
    final l$$__typename = json['__typename'];
    return Query$BackupConfiguration$backup$configuration(
      autobackupPeriod: (l$autobackupPeriod as int?),
      encryptionKey: (l$encryptionKey as String),
      isInitialized: (l$isInitialized as bool),
      locationId: (l$locationId as String?),
      locationName: (l$locationName as String?),
      provider: fromJson$Enum$BackupProvider((l$provider as String)),
      $__typename: (l$$__typename as String),
    );
  }

  final int? autobackupPeriod;

  final String encryptionKey;

  final bool isInitialized;

  final String? locationId;

  final String? locationName;

  final Enum$BackupProvider provider;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$autobackupPeriod = autobackupPeriod;
    _resultData['autobackupPeriod'] = l$autobackupPeriod;
    final l$encryptionKey = encryptionKey;
    _resultData['encryptionKey'] = l$encryptionKey;
    final l$isInitialized = isInitialized;
    _resultData['isInitialized'] = l$isInitialized;
    final l$locationId = locationId;
    _resultData['locationId'] = l$locationId;
    final l$locationName = locationName;
    _resultData['locationName'] = l$locationName;
    final l$provider = provider;
    _resultData['provider'] = toJson$Enum$BackupProvider(l$provider);
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$autobackupPeriod = autobackupPeriod;
    final l$encryptionKey = encryptionKey;
    final l$isInitialized = isInitialized;
    final l$locationId = locationId;
    final l$locationName = locationName;
    final l$provider = provider;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$autobackupPeriod,
      l$encryptionKey,
      l$isInitialized,
      l$locationId,
      l$locationName,
      l$provider,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Query$BackupConfiguration$backup$configuration) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$autobackupPeriod = autobackupPeriod;
    final lOther$autobackupPeriod = other.autobackupPeriod;
    if (l$autobackupPeriod != lOther$autobackupPeriod) {
      return false;
    }
    final l$encryptionKey = encryptionKey;
    final lOther$encryptionKey = other.encryptionKey;
    if (l$encryptionKey != lOther$encryptionKey) {
      return false;
    }
    final l$isInitialized = isInitialized;
    final lOther$isInitialized = other.isInitialized;
    if (l$isInitialized != lOther$isInitialized) {
      return false;
    }
    final l$locationId = locationId;
    final lOther$locationId = other.locationId;
    if (l$locationId != lOther$locationId) {
      return false;
    }
    final l$locationName = locationName;
    final lOther$locationName = other.locationName;
    if (l$locationName != lOther$locationName) {
      return false;
    }
    final l$provider = provider;
    final lOther$provider = other.provider;
    if (l$provider != lOther$provider) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Query$BackupConfiguration$backup$configuration
    on Query$BackupConfiguration$backup$configuration {
  CopyWith$Query$BackupConfiguration$backup$configuration<
          Query$BackupConfiguration$backup$configuration>
      get copyWith => CopyWith$Query$BackupConfiguration$backup$configuration(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Query$BackupConfiguration$backup$configuration<TRes> {
  factory CopyWith$Query$BackupConfiguration$backup$configuration(
    Query$BackupConfiguration$backup$configuration instance,
    TRes Function(Query$BackupConfiguration$backup$configuration) then,
  ) = _CopyWithImpl$Query$BackupConfiguration$backup$configuration;

  factory CopyWith$Query$BackupConfiguration$backup$configuration.stub(
          TRes res) =
      _CopyWithStubImpl$Query$BackupConfiguration$backup$configuration;

  TRes call({
    int? autobackupPeriod,
    String? encryptionKey,
    bool? isInitialized,
    String? locationId,
    String? locationName,
    Enum$BackupProvider? provider,
    String? $__typename,
  });
}

class _CopyWithImpl$Query$BackupConfiguration$backup$configuration<TRes>
    implements CopyWith$Query$BackupConfiguration$backup$configuration<TRes> {
  _CopyWithImpl$Query$BackupConfiguration$backup$configuration(
    this._instance,
    this._then,
  );

  final Query$BackupConfiguration$backup$configuration _instance;

  final TRes Function(Query$BackupConfiguration$backup$configuration) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? autobackupPeriod = _undefined,
    Object? encryptionKey = _undefined,
    Object? isInitialized = _undefined,
    Object? locationId = _undefined,
    Object? locationName = _undefined,
    Object? provider = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Query$BackupConfiguration$backup$configuration(
        autobackupPeriod: autobackupPeriod == _undefined
            ? _instance.autobackupPeriod
            : (autobackupPeriod as int?),
        encryptionKey: encryptionKey == _undefined || encryptionKey == null
            ? _instance.encryptionKey
            : (encryptionKey as String),
        isInitialized: isInitialized == _undefined || isInitialized == null
            ? _instance.isInitialized
            : (isInitialized as bool),
        locationId: locationId == _undefined
            ? _instance.locationId
            : (locationId as String?),
        locationName: locationName == _undefined
            ? _instance.locationName
            : (locationName as String?),
        provider: provider == _undefined || provider == null
            ? _instance.provider
            : (provider as Enum$BackupProvider),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
}

class _CopyWithStubImpl$Query$BackupConfiguration$backup$configuration<TRes>
    implements CopyWith$Query$BackupConfiguration$backup$configuration<TRes> {
  _CopyWithStubImpl$Query$BackupConfiguration$backup$configuration(this._res);

  TRes _res;

  call({
    int? autobackupPeriod,
    String? encryptionKey,
    bool? isInitialized,
    String? locationId,
    String? locationName,
    Enum$BackupProvider? provider,
    String? $__typename,
  }) =>
      _res;
}

class Query$AllBackupSnapshots {
  Query$AllBackupSnapshots({
    required this.backup,
    this.$__typename = 'Query',
  });

  factory Query$AllBackupSnapshots.fromJson(Map<String, dynamic> json) {
    final l$backup = json['backup'];
    final l$$__typename = json['__typename'];
    return Query$AllBackupSnapshots(
      backup: Query$AllBackupSnapshots$backup.fromJson(
          (l$backup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Query$AllBackupSnapshots$backup backup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$backup = backup;
    _resultData['backup'] = l$backup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$backup = backup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$backup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Query$AllBackupSnapshots) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$backup = backup;
    final lOther$backup = other.backup;
    if (l$backup != lOther$backup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Query$AllBackupSnapshots
    on Query$AllBackupSnapshots {
  CopyWith$Query$AllBackupSnapshots<Query$AllBackupSnapshots> get copyWith =>
      CopyWith$Query$AllBackupSnapshots(
        this,
        (i) => i,
      );
}

abstract class CopyWith$Query$AllBackupSnapshots<TRes> {
  factory CopyWith$Query$AllBackupSnapshots(
    Query$AllBackupSnapshots instance,
    TRes Function(Query$AllBackupSnapshots) then,
  ) = _CopyWithImpl$Query$AllBackupSnapshots;

  factory CopyWith$Query$AllBackupSnapshots.stub(TRes res) =
      _CopyWithStubImpl$Query$AllBackupSnapshots;

  TRes call({
    Query$AllBackupSnapshots$backup? backup,
    String? $__typename,
  });
  CopyWith$Query$AllBackupSnapshots$backup<TRes> get backup;
}

class _CopyWithImpl$Query$AllBackupSnapshots<TRes>
    implements CopyWith$Query$AllBackupSnapshots<TRes> {
  _CopyWithImpl$Query$AllBackupSnapshots(
    this._instance,
    this._then,
  );

  final Query$AllBackupSnapshots _instance;

  final TRes Function(Query$AllBackupSnapshots) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? backup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Query$AllBackupSnapshots(
        backup: backup == _undefined || backup == null
            ? _instance.backup
            : (backup as Query$AllBackupSnapshots$backup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Query$AllBackupSnapshots$backup<TRes> get backup {
    final local$backup = _instance.backup;
    return CopyWith$Query$AllBackupSnapshots$backup(
        local$backup, (e) => call(backup: e));
  }
}

class _CopyWithStubImpl$Query$AllBackupSnapshots<TRes>
    implements CopyWith$Query$AllBackupSnapshots<TRes> {
  _CopyWithStubImpl$Query$AllBackupSnapshots(this._res);

  TRes _res;

  call({
    Query$AllBackupSnapshots$backup? backup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Query$AllBackupSnapshots$backup<TRes> get backup =>
      CopyWith$Query$AllBackupSnapshots$backup.stub(_res);
}

const documentNodeQueryAllBackupSnapshots = DocumentNode(definitions: [
  OperationDefinitionNode(
    type: OperationType.query,
    name: NameNode(value: 'AllBackupSnapshots'),
    variableDefinitions: [],
    directives: [],
    selectionSet: SelectionSetNode(selections: [
      FieldNode(
        name: NameNode(value: 'backup'),
        alias: null,
        arguments: [],
        directives: [],
        selectionSet: SelectionSetNode(selections: [
          FieldNode(
            name: NameNode(value: 'allSnapshots'),
            alias: null,
            arguments: [],
            directives: [],
            selectionSet: SelectionSetNode(selections: [
              FieldNode(
                name: NameNode(value: 'id'),
                alias: null,
                arguments: [],
                directives: [],
                selectionSet: null,
              ),
              FieldNode(
                name: NameNode(value: 'createdAt'),
                alias: null,
                arguments: [],
                directives: [],
                selectionSet: null,
              ),
              FieldNode(
                name: NameNode(value: 'service'),
                alias: null,
                arguments: [],
                directives: [],
                selectionSet: SelectionSetNode(selections: [
                  FieldNode(
                    name: NameNode(value: 'displayName'),
                    alias: null,
                    arguments: [],
                    directives: [],
                    selectionSet: null,
                  ),
                  FieldNode(
                    name: NameNode(value: 'id'),
                    alias: null,
                    arguments: [],
                    directives: [],
                    selectionSet: null,
                  ),
                  FieldNode(
                    name: NameNode(value: '__typename'),
                    alias: null,
                    arguments: [],
                    directives: [],
                    selectionSet: null,
                  ),
                ]),
              ),
              FieldNode(
                name: NameNode(value: 'reason'),
                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,
      ),
    ]),
  ),
]);
Query$AllBackupSnapshots _parserFn$Query$AllBackupSnapshots(
        Map<String, dynamic> data) =>
    Query$AllBackupSnapshots.fromJson(data);
typedef OnQueryComplete$Query$AllBackupSnapshots = FutureOr<void> Function(
  Map<String, dynamic>?,
  Query$AllBackupSnapshots?,
);

class Options$Query$AllBackupSnapshots
    extends graphql.QueryOptions<Query$AllBackupSnapshots> {
  Options$Query$AllBackupSnapshots({
    String? operationName,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Query$AllBackupSnapshots? typedOptimisticResult,
    Duration? pollInterval,
    graphql.Context? context,
    OnQueryComplete$Query$AllBackupSnapshots? 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$AllBackupSnapshots(data),
                  ),
          onError: onError,
          document: documentNodeQueryAllBackupSnapshots,
          parserFn: _parserFn$Query$AllBackupSnapshots,
        );

  final OnQueryComplete$Query$AllBackupSnapshots? onCompleteWithParsed;

  @override
  List<Object?> get properties => [
        ...super.onComplete == null
            ? super.properties
            : super.properties.where((property) => property != onComplete),
        onCompleteWithParsed,
      ];
}

class WatchOptions$Query$AllBackupSnapshots
    extends graphql.WatchQueryOptions<Query$AllBackupSnapshots> {
  WatchOptions$Query$AllBackupSnapshots({
    String? operationName,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Query$AllBackupSnapshots? 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: documentNodeQueryAllBackupSnapshots,
          pollInterval: pollInterval,
          eagerlyFetchResults: eagerlyFetchResults,
          carryForwardDataOnException: carryForwardDataOnException,
          fetchResults: fetchResults,
          parserFn: _parserFn$Query$AllBackupSnapshots,
        );
}

class FetchMoreOptions$Query$AllBackupSnapshots
    extends graphql.FetchMoreOptions {
  FetchMoreOptions$Query$AllBackupSnapshots(
      {required graphql.UpdateQuery updateQuery})
      : super(
          updateQuery: updateQuery,
          document: documentNodeQueryAllBackupSnapshots,
        );
}

extension ClientExtension$Query$AllBackupSnapshots on graphql.GraphQLClient {
  Future<graphql.QueryResult<Query$AllBackupSnapshots>>
      query$AllBackupSnapshots(
              [Options$Query$AllBackupSnapshots? options]) async =>
          await this.query(options ?? Options$Query$AllBackupSnapshots());
  graphql.ObservableQuery<Query$AllBackupSnapshots>
      watchQuery$AllBackupSnapshots(
              [WatchOptions$Query$AllBackupSnapshots? options]) =>
          this.watchQuery(options ?? WatchOptions$Query$AllBackupSnapshots());
  void writeQuery$AllBackupSnapshots({
    required Query$AllBackupSnapshots data,
    bool broadcast = true,
  }) =>
      this.writeQuery(
        graphql.Request(
            operation: graphql.Operation(
                document: documentNodeQueryAllBackupSnapshots)),
        data: data.toJson(),
        broadcast: broadcast,
      );
  Query$AllBackupSnapshots? readQuery$AllBackupSnapshots(
      {bool optimistic = true}) {
    final result = this.readQuery(
      graphql.Request(
          operation:
              graphql.Operation(document: documentNodeQueryAllBackupSnapshots)),
      optimistic: optimistic,
    );
    return result == null ? null : Query$AllBackupSnapshots.fromJson(result);
  }
}

class Query$AllBackupSnapshots$backup {
  Query$AllBackupSnapshots$backup({
    required this.allSnapshots,
    this.$__typename = 'Backup',
  });

  factory Query$AllBackupSnapshots$backup.fromJson(Map<String, dynamic> json) {
    final l$allSnapshots = json['allSnapshots'];
    final l$$__typename = json['__typename'];
    return Query$AllBackupSnapshots$backup(
      allSnapshots: (l$allSnapshots as List<dynamic>)
          .map((e) => Query$AllBackupSnapshots$backup$allSnapshots.fromJson(
              (e as Map<String, dynamic>)))
          .toList(),
      $__typename: (l$$__typename as String),
    );
  }

  final List<Query$AllBackupSnapshots$backup$allSnapshots> allSnapshots;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$allSnapshots = allSnapshots;
    _resultData['allSnapshots'] =
        l$allSnapshots.map((e) => e.toJson()).toList();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$allSnapshots = allSnapshots;
    final l$$__typename = $__typename;
    return Object.hashAll([
      Object.hashAll(l$allSnapshots.map((v) => v)),
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Query$AllBackupSnapshots$backup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$allSnapshots = allSnapshots;
    final lOther$allSnapshots = other.allSnapshots;
    if (l$allSnapshots.length != lOther$allSnapshots.length) {
      return false;
    }
    for (int i = 0; i < l$allSnapshots.length; i++) {
      final l$allSnapshots$entry = l$allSnapshots[i];
      final lOther$allSnapshots$entry = lOther$allSnapshots[i];
      if (l$allSnapshots$entry != lOther$allSnapshots$entry) {
        return false;
      }
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Query$AllBackupSnapshots$backup
    on Query$AllBackupSnapshots$backup {
  CopyWith$Query$AllBackupSnapshots$backup<Query$AllBackupSnapshots$backup>
      get copyWith => CopyWith$Query$AllBackupSnapshots$backup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Query$AllBackupSnapshots$backup<TRes> {
  factory CopyWith$Query$AllBackupSnapshots$backup(
    Query$AllBackupSnapshots$backup instance,
    TRes Function(Query$AllBackupSnapshots$backup) then,
  ) = _CopyWithImpl$Query$AllBackupSnapshots$backup;

  factory CopyWith$Query$AllBackupSnapshots$backup.stub(TRes res) =
      _CopyWithStubImpl$Query$AllBackupSnapshots$backup;

  TRes call({
    List<Query$AllBackupSnapshots$backup$allSnapshots>? allSnapshots,
    String? $__typename,
  });
  TRes allSnapshots(
      Iterable<Query$AllBackupSnapshots$backup$allSnapshots> Function(
              Iterable<
                  CopyWith$Query$AllBackupSnapshots$backup$allSnapshots<
                      Query$AllBackupSnapshots$backup$allSnapshots>>)
          _fn);
}

class _CopyWithImpl$Query$AllBackupSnapshots$backup<TRes>
    implements CopyWith$Query$AllBackupSnapshots$backup<TRes> {
  _CopyWithImpl$Query$AllBackupSnapshots$backup(
    this._instance,
    this._then,
  );

  final Query$AllBackupSnapshots$backup _instance;

  final TRes Function(Query$AllBackupSnapshots$backup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? allSnapshots = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Query$AllBackupSnapshots$backup(
        allSnapshots: allSnapshots == _undefined || allSnapshots == null
            ? _instance.allSnapshots
            : (allSnapshots
                as List<Query$AllBackupSnapshots$backup$allSnapshots>),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  TRes allSnapshots(
          Iterable<Query$AllBackupSnapshots$backup$allSnapshots> Function(
                  Iterable<
                      CopyWith$Query$AllBackupSnapshots$backup$allSnapshots<
                          Query$AllBackupSnapshots$backup$allSnapshots>>)
              _fn) =>
      call(
          allSnapshots: _fn(_instance.allSnapshots
              .map((e) => CopyWith$Query$AllBackupSnapshots$backup$allSnapshots(
                    e,
                    (i) => i,
                  ))).toList());
}

class _CopyWithStubImpl$Query$AllBackupSnapshots$backup<TRes>
    implements CopyWith$Query$AllBackupSnapshots$backup<TRes> {
  _CopyWithStubImpl$Query$AllBackupSnapshots$backup(this._res);

  TRes _res;

  call({
    List<Query$AllBackupSnapshots$backup$allSnapshots>? allSnapshots,
    String? $__typename,
  }) =>
      _res;
  allSnapshots(_fn) => _res;
}

class Query$AllBackupSnapshots$backup$allSnapshots {
  Query$AllBackupSnapshots$backup$allSnapshots({
    required this.id,
    required this.createdAt,
    required this.service,
    required this.reason,
    this.$__typename = 'SnapshotInfo',
  });

  factory Query$AllBackupSnapshots$backup$allSnapshots.fromJson(
      Map<String, dynamic> json) {
    final l$id = json['id'];
    final l$createdAt = json['createdAt'];
    final l$service = json['service'];
    final l$reason = json['reason'];
    final l$$__typename = json['__typename'];
    return Query$AllBackupSnapshots$backup$allSnapshots(
      id: (l$id as String),
      createdAt: dateTimeFromJson(l$createdAt),
      service: Query$AllBackupSnapshots$backup$allSnapshots$service.fromJson(
          (l$service as Map<String, dynamic>)),
      reason: fromJson$Enum$BackupReason((l$reason as String)),
      $__typename: (l$$__typename as String),
    );
  }

  final String id;

  final DateTime createdAt;

  final Query$AllBackupSnapshots$backup$allSnapshots$service service;

  final Enum$BackupReason reason;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$id = id;
    _resultData['id'] = l$id;
    final l$createdAt = createdAt;
    _resultData['createdAt'] = dateTimeToJson(l$createdAt);
    final l$service = service;
    _resultData['service'] = l$service.toJson();
    final l$reason = reason;
    _resultData['reason'] = toJson$Enum$BackupReason(l$reason);
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$id = id;
    final l$createdAt = createdAt;
    final l$service = service;
    final l$reason = reason;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$id,
      l$createdAt,
      l$service,
      l$reason,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Query$AllBackupSnapshots$backup$allSnapshots) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$id = id;
    final lOther$id = other.id;
    if (l$id != lOther$id) {
      return false;
    }
    final l$createdAt = createdAt;
    final lOther$createdAt = other.createdAt;
    if (l$createdAt != lOther$createdAt) {
      return false;
    }
    final l$service = service;
    final lOther$service = other.service;
    if (l$service != lOther$service) {
      return false;
    }
    final l$reason = reason;
    final lOther$reason = other.reason;
    if (l$reason != lOther$reason) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Query$AllBackupSnapshots$backup$allSnapshots
    on Query$AllBackupSnapshots$backup$allSnapshots {
  CopyWith$Query$AllBackupSnapshots$backup$allSnapshots<
          Query$AllBackupSnapshots$backup$allSnapshots>
      get copyWith => CopyWith$Query$AllBackupSnapshots$backup$allSnapshots(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Query$AllBackupSnapshots$backup$allSnapshots<TRes> {
  factory CopyWith$Query$AllBackupSnapshots$backup$allSnapshots(
    Query$AllBackupSnapshots$backup$allSnapshots instance,
    TRes Function(Query$AllBackupSnapshots$backup$allSnapshots) then,
  ) = _CopyWithImpl$Query$AllBackupSnapshots$backup$allSnapshots;

  factory CopyWith$Query$AllBackupSnapshots$backup$allSnapshots.stub(TRes res) =
      _CopyWithStubImpl$Query$AllBackupSnapshots$backup$allSnapshots;

  TRes call({
    String? id,
    DateTime? createdAt,
    Query$AllBackupSnapshots$backup$allSnapshots$service? service,
    Enum$BackupReason? reason,
    String? $__typename,
  });
  CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service<TRes>
      get service;
}

class _CopyWithImpl$Query$AllBackupSnapshots$backup$allSnapshots<TRes>
    implements CopyWith$Query$AllBackupSnapshots$backup$allSnapshots<TRes> {
  _CopyWithImpl$Query$AllBackupSnapshots$backup$allSnapshots(
    this._instance,
    this._then,
  );

  final Query$AllBackupSnapshots$backup$allSnapshots _instance;

  final TRes Function(Query$AllBackupSnapshots$backup$allSnapshots) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? id = _undefined,
    Object? createdAt = _undefined,
    Object? service = _undefined,
    Object? reason = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Query$AllBackupSnapshots$backup$allSnapshots(
        id: id == _undefined || id == null ? _instance.id : (id as String),
        createdAt: createdAt == _undefined || createdAt == null
            ? _instance.createdAt
            : (createdAt as DateTime),
        service: service == _undefined || service == null
            ? _instance.service
            : (service as Query$AllBackupSnapshots$backup$allSnapshots$service),
        reason: reason == _undefined || reason == null
            ? _instance.reason
            : (reason as Enum$BackupReason),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service<TRes>
      get service {
    final local$service = _instance.service;
    return CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service(
        local$service, (e) => call(service: e));
  }
}

class _CopyWithStubImpl$Query$AllBackupSnapshots$backup$allSnapshots<TRes>
    implements CopyWith$Query$AllBackupSnapshots$backup$allSnapshots<TRes> {
  _CopyWithStubImpl$Query$AllBackupSnapshots$backup$allSnapshots(this._res);

  TRes _res;

  call({
    String? id,
    DateTime? createdAt,
    Query$AllBackupSnapshots$backup$allSnapshots$service? service,
    Enum$BackupReason? reason,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service<TRes>
      get service =>
          CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service.stub(
              _res);
}

class Query$AllBackupSnapshots$backup$allSnapshots$service {
  Query$AllBackupSnapshots$backup$allSnapshots$service({
    required this.displayName,
    required this.id,
    this.$__typename = 'Service',
  });

  factory Query$AllBackupSnapshots$backup$allSnapshots$service.fromJson(
      Map<String, dynamic> json) {
    final l$displayName = json['displayName'];
    final l$id = json['id'];
    final l$$__typename = json['__typename'];
    return Query$AllBackupSnapshots$backup$allSnapshots$service(
      displayName: (l$displayName as String),
      id: (l$id as String),
      $__typename: (l$$__typename as String),
    );
  }

  final String displayName;

  final String id;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$displayName = displayName;
    _resultData['displayName'] = l$displayName;
    final l$id = id;
    _resultData['id'] = l$id;
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$displayName = displayName;
    final l$id = id;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$displayName,
      l$id,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Query$AllBackupSnapshots$backup$allSnapshots$service) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$displayName = displayName;
    final lOther$displayName = other.displayName;
    if (l$displayName != lOther$displayName) {
      return false;
    }
    final l$id = id;
    final lOther$id = other.id;
    if (l$id != lOther$id) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Query$AllBackupSnapshots$backup$allSnapshots$service
    on Query$AllBackupSnapshots$backup$allSnapshots$service {
  CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service<
          Query$AllBackupSnapshots$backup$allSnapshots$service>
      get copyWith =>
          CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service<
    TRes> {
  factory CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service(
    Query$AllBackupSnapshots$backup$allSnapshots$service instance,
    TRes Function(Query$AllBackupSnapshots$backup$allSnapshots$service) then,
  ) = _CopyWithImpl$Query$AllBackupSnapshots$backup$allSnapshots$service;

  factory CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service.stub(
          TRes res) =
      _CopyWithStubImpl$Query$AllBackupSnapshots$backup$allSnapshots$service;

  TRes call({
    String? displayName,
    String? id,
    String? $__typename,
  });
}

class _CopyWithImpl$Query$AllBackupSnapshots$backup$allSnapshots$service<TRes>
    implements
        CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service<TRes> {
  _CopyWithImpl$Query$AllBackupSnapshots$backup$allSnapshots$service(
    this._instance,
    this._then,
  );

  final Query$AllBackupSnapshots$backup$allSnapshots$service _instance;

  final TRes Function(Query$AllBackupSnapshots$backup$allSnapshots$service)
      _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? displayName = _undefined,
    Object? id = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Query$AllBackupSnapshots$backup$allSnapshots$service(
        displayName: displayName == _undefined || displayName == null
            ? _instance.displayName
            : (displayName as String),
        id: id == _undefined || id == null ? _instance.id : (id as String),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
}

class _CopyWithStubImpl$Query$AllBackupSnapshots$backup$allSnapshots$service<
        TRes>
    implements
        CopyWith$Query$AllBackupSnapshots$backup$allSnapshots$service<TRes> {
  _CopyWithStubImpl$Query$AllBackupSnapshots$backup$allSnapshots$service(
      this._res);

  TRes _res;

  call({
    String? displayName,
    String? id,
    String? $__typename,
  }) =>
      _res;
}

class Mutation$ForceSnapshotsReload {
  Mutation$ForceSnapshotsReload({
    required this.backup,
    this.$__typename = 'Mutation',
  });

  factory Mutation$ForceSnapshotsReload.fromJson(Map<String, dynamic> json) {
    final l$backup = json['backup'];
    final l$$__typename = json['__typename'];
    return Mutation$ForceSnapshotsReload(
      backup: Mutation$ForceSnapshotsReload$backup.fromJson(
          (l$backup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$ForceSnapshotsReload$backup backup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$backup = backup;
    _resultData['backup'] = l$backup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$backup = backup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$backup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$ForceSnapshotsReload) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$backup = backup;
    final lOther$backup = other.backup;
    if (l$backup != lOther$backup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$ForceSnapshotsReload
    on Mutation$ForceSnapshotsReload {
  CopyWith$Mutation$ForceSnapshotsReload<Mutation$ForceSnapshotsReload>
      get copyWith => CopyWith$Mutation$ForceSnapshotsReload(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$ForceSnapshotsReload<TRes> {
  factory CopyWith$Mutation$ForceSnapshotsReload(
    Mutation$ForceSnapshotsReload instance,
    TRes Function(Mutation$ForceSnapshotsReload) then,
  ) = _CopyWithImpl$Mutation$ForceSnapshotsReload;

  factory CopyWith$Mutation$ForceSnapshotsReload.stub(TRes res) =
      _CopyWithStubImpl$Mutation$ForceSnapshotsReload;

  TRes call({
    Mutation$ForceSnapshotsReload$backup? backup,
    String? $__typename,
  });
  CopyWith$Mutation$ForceSnapshotsReload$backup<TRes> get backup;
}

class _CopyWithImpl$Mutation$ForceSnapshotsReload<TRes>
    implements CopyWith$Mutation$ForceSnapshotsReload<TRes> {
  _CopyWithImpl$Mutation$ForceSnapshotsReload(
    this._instance,
    this._then,
  );

  final Mutation$ForceSnapshotsReload _instance;

  final TRes Function(Mutation$ForceSnapshotsReload) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? backup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$ForceSnapshotsReload(
        backup: backup == _undefined || backup == null
            ? _instance.backup
            : (backup as Mutation$ForceSnapshotsReload$backup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$ForceSnapshotsReload$backup<TRes> get backup {
    final local$backup = _instance.backup;
    return CopyWith$Mutation$ForceSnapshotsReload$backup(
        local$backup, (e) => call(backup: e));
  }
}

class _CopyWithStubImpl$Mutation$ForceSnapshotsReload<TRes>
    implements CopyWith$Mutation$ForceSnapshotsReload<TRes> {
  _CopyWithStubImpl$Mutation$ForceSnapshotsReload(this._res);

  TRes _res;

  call({
    Mutation$ForceSnapshotsReload$backup? backup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$ForceSnapshotsReload$backup<TRes> get backup =>
      CopyWith$Mutation$ForceSnapshotsReload$backup.stub(_res);
}

const documentNodeMutationForceSnapshotsReload = DocumentNode(definitions: [
  OperationDefinitionNode(
    type: OperationType.mutation,
    name: NameNode(value: 'ForceSnapshotsReload'),
    variableDefinitions: [],
    directives: [],
    selectionSet: SelectionSetNode(selections: [
      FieldNode(
        name: NameNode(value: 'backup'),
        alias: null,
        arguments: [],
        directives: [],
        selectionSet: SelectionSetNode(selections: [
          FieldNode(
            name: NameNode(value: 'forceSnapshotsReload'),
            alias: null,
            arguments: [],
            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$ForceSnapshotsReload _parserFn$Mutation$ForceSnapshotsReload(
        Map<String, dynamic> data) =>
    Mutation$ForceSnapshotsReload.fromJson(data);
typedef OnMutationCompleted$Mutation$ForceSnapshotsReload = FutureOr<void>
    Function(
  Map<String, dynamic>?,
  Mutation$ForceSnapshotsReload?,
);

class Options$Mutation$ForceSnapshotsReload
    extends graphql.MutationOptions<Mutation$ForceSnapshotsReload> {
  Options$Mutation$ForceSnapshotsReload({
    String? operationName,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$ForceSnapshotsReload? typedOptimisticResult,
    graphql.Context? context,
    OnMutationCompleted$Mutation$ForceSnapshotsReload? onCompleted,
    graphql.OnMutationUpdate<Mutation$ForceSnapshotsReload>? update,
    graphql.OnError? onError,
  })  : onCompletedWithParsed = onCompleted,
        super(
          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$ForceSnapshotsReload(data),
                  ),
          update: update,
          onError: onError,
          document: documentNodeMutationForceSnapshotsReload,
          parserFn: _parserFn$Mutation$ForceSnapshotsReload,
        );

  final OnMutationCompleted$Mutation$ForceSnapshotsReload?
      onCompletedWithParsed;

  @override
  List<Object?> get properties => [
        ...super.onCompleted == null
            ? super.properties
            : super.properties.where((property) => property != onCompleted),
        onCompletedWithParsed,
      ];
}

class WatchOptions$Mutation$ForceSnapshotsReload
    extends graphql.WatchQueryOptions<Mutation$ForceSnapshotsReload> {
  WatchOptions$Mutation$ForceSnapshotsReload({
    String? operationName,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$ForceSnapshotsReload? 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: documentNodeMutationForceSnapshotsReload,
          pollInterval: pollInterval,
          eagerlyFetchResults: eagerlyFetchResults,
          carryForwardDataOnException: carryForwardDataOnException,
          fetchResults: fetchResults,
          parserFn: _parserFn$Mutation$ForceSnapshotsReload,
        );
}

extension ClientExtension$Mutation$ForceSnapshotsReload
    on graphql.GraphQLClient {
  Future<graphql.QueryResult<Mutation$ForceSnapshotsReload>>
      mutate$ForceSnapshotsReload(
              [Options$Mutation$ForceSnapshotsReload? options]) async =>
          await this.mutate(options ?? Options$Mutation$ForceSnapshotsReload());
  graphql.ObservableQuery<Mutation$ForceSnapshotsReload>
      watchMutation$ForceSnapshotsReload(
              [WatchOptions$Mutation$ForceSnapshotsReload? options]) =>
          this.watchMutation(
              options ?? WatchOptions$Mutation$ForceSnapshotsReload());
}

class Mutation$ForceSnapshotsReload$backup {
  Mutation$ForceSnapshotsReload$backup({
    required this.forceSnapshotsReload,
    this.$__typename = 'BackupMutations',
  });

  factory Mutation$ForceSnapshotsReload$backup.fromJson(
      Map<String, dynamic> json) {
    final l$forceSnapshotsReload = json['forceSnapshotsReload'];
    final l$$__typename = json['__typename'];
    return Mutation$ForceSnapshotsReload$backup(
      forceSnapshotsReload:
          Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload.fromJson(
              (l$forceSnapshotsReload as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload
      forceSnapshotsReload;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$forceSnapshotsReload = forceSnapshotsReload;
    _resultData['forceSnapshotsReload'] = l$forceSnapshotsReload.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$forceSnapshotsReload = forceSnapshotsReload;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$forceSnapshotsReload,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$ForceSnapshotsReload$backup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$forceSnapshotsReload = forceSnapshotsReload;
    final lOther$forceSnapshotsReload = other.forceSnapshotsReload;
    if (l$forceSnapshotsReload != lOther$forceSnapshotsReload) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$ForceSnapshotsReload$backup
    on Mutation$ForceSnapshotsReload$backup {
  CopyWith$Mutation$ForceSnapshotsReload$backup<
          Mutation$ForceSnapshotsReload$backup>
      get copyWith => CopyWith$Mutation$ForceSnapshotsReload$backup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$ForceSnapshotsReload$backup<TRes> {
  factory CopyWith$Mutation$ForceSnapshotsReload$backup(
    Mutation$ForceSnapshotsReload$backup instance,
    TRes Function(Mutation$ForceSnapshotsReload$backup) then,
  ) = _CopyWithImpl$Mutation$ForceSnapshotsReload$backup;

  factory CopyWith$Mutation$ForceSnapshotsReload$backup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$ForceSnapshotsReload$backup;

  TRes call({
    Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload?
        forceSnapshotsReload,
    String? $__typename,
  });
  CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload<TRes>
      get forceSnapshotsReload;
}

class _CopyWithImpl$Mutation$ForceSnapshotsReload$backup<TRes>
    implements CopyWith$Mutation$ForceSnapshotsReload$backup<TRes> {
  _CopyWithImpl$Mutation$ForceSnapshotsReload$backup(
    this._instance,
    this._then,
  );

  final Mutation$ForceSnapshotsReload$backup _instance;

  final TRes Function(Mutation$ForceSnapshotsReload$backup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? forceSnapshotsReload = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$ForceSnapshotsReload$backup(
        forceSnapshotsReload: forceSnapshotsReload == _undefined ||
                forceSnapshotsReload == null
            ? _instance.forceSnapshotsReload
            : (forceSnapshotsReload
                as Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload<TRes>
      get forceSnapshotsReload {
    final local$forceSnapshotsReload = _instance.forceSnapshotsReload;
    return CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload(
        local$forceSnapshotsReload, (e) => call(forceSnapshotsReload: e));
  }
}

class _CopyWithStubImpl$Mutation$ForceSnapshotsReload$backup<TRes>
    implements CopyWith$Mutation$ForceSnapshotsReload$backup<TRes> {
  _CopyWithStubImpl$Mutation$ForceSnapshotsReload$backup(this._res);

  TRes _res;

  call({
    Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload?
        forceSnapshotsReload,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload<TRes>
      get forceSnapshotsReload =>
          CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload
              .stub(_res);
}

class Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload
    implements Fragment$basicMutationReturnFields$$GenericMutationReturn {
  Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload({
    required this.code,
    required this.message,
    required this.success,
    this.$__typename = 'GenericMutationReturn',
  });

  factory Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload.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$ForceSnapshotsReload$backup$forceSnapshotsReload(
      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$ForceSnapshotsReload$backup$forceSnapshotsReload) ||
        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$ForceSnapshotsReload$backup$forceSnapshotsReload
    on Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload {
  CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload<
          Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload>
      get copyWith =>
          CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload<
    TRes> {
  factory CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload(
    Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload instance,
    TRes Function(Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload)
        then,
  ) = _CopyWithImpl$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload;

  factory CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload.stub(
          TRes res) =
      _CopyWithStubImpl$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload;

  TRes call({
    int? code,
    String? message,
    bool? success,
    String? $__typename,
  });
}

class _CopyWithImpl$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload<
        TRes>
    implements
        CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload<
            TRes> {
  _CopyWithImpl$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload(
    this._instance,
    this._then,
  );

  final Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload _instance;

  final TRes Function(Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload)
      _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? code = _undefined,
    Object? message = _undefined,
    Object? success = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload(
        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$ForceSnapshotsReload$backup$forceSnapshotsReload<
        TRes>
    implements
        CopyWith$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload<
            TRes> {
  _CopyWithStubImpl$Mutation$ForceSnapshotsReload$backup$forceSnapshotsReload(
      this._res);

  TRes _res;

  call({
    int? code,
    String? message,
    bool? success,
    String? $__typename,
  }) =>
      _res;
}

class Variables$Mutation$StartBackup {
  factory Variables$Mutation$StartBackup({required String serviceId}) =>
      Variables$Mutation$StartBackup._({
        r'serviceId': serviceId,
      });

  Variables$Mutation$StartBackup._(this._$data);

  factory Variables$Mutation$StartBackup.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$StartBackup._(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$StartBackup<Variables$Mutation$StartBackup>
      get copyWith => CopyWith$Variables$Mutation$StartBackup(
            this,
            (i) => i,
          );
  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Variables$Mutation$StartBackup) ||
        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$StartBackup<TRes> {
  factory CopyWith$Variables$Mutation$StartBackup(
    Variables$Mutation$StartBackup instance,
    TRes Function(Variables$Mutation$StartBackup) then,
  ) = _CopyWithImpl$Variables$Mutation$StartBackup;

  factory CopyWith$Variables$Mutation$StartBackup.stub(TRes res) =
      _CopyWithStubImpl$Variables$Mutation$StartBackup;

  TRes call({String? serviceId});
}

class _CopyWithImpl$Variables$Mutation$StartBackup<TRes>
    implements CopyWith$Variables$Mutation$StartBackup<TRes> {
  _CopyWithImpl$Variables$Mutation$StartBackup(
    this._instance,
    this._then,
  );

  final Variables$Mutation$StartBackup _instance;

  final TRes Function(Variables$Mutation$StartBackup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({Object? serviceId = _undefined}) =>
      _then(Variables$Mutation$StartBackup._({
        ..._instance._$data,
        if (serviceId != _undefined && serviceId != null)
          'serviceId': (serviceId as String),
      }));
}

class _CopyWithStubImpl$Variables$Mutation$StartBackup<TRes>
    implements CopyWith$Variables$Mutation$StartBackup<TRes> {
  _CopyWithStubImpl$Variables$Mutation$StartBackup(this._res);

  TRes _res;

  call({String? serviceId}) => _res;
}

class Mutation$StartBackup {
  Mutation$StartBackup({
    required this.backup,
    this.$__typename = 'Mutation',
  });

  factory Mutation$StartBackup.fromJson(Map<String, dynamic> json) {
    final l$backup = json['backup'];
    final l$$__typename = json['__typename'];
    return Mutation$StartBackup(
      backup: Mutation$StartBackup$backup.fromJson(
          (l$backup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$StartBackup$backup backup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$backup = backup;
    _resultData['backup'] = l$backup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$backup = backup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$backup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$StartBackup) || runtimeType != other.runtimeType) {
      return false;
    }
    final l$backup = backup;
    final lOther$backup = other.backup;
    if (l$backup != lOther$backup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$StartBackup on Mutation$StartBackup {
  CopyWith$Mutation$StartBackup<Mutation$StartBackup> get copyWith =>
      CopyWith$Mutation$StartBackup(
        this,
        (i) => i,
      );
}

abstract class CopyWith$Mutation$StartBackup<TRes> {
  factory CopyWith$Mutation$StartBackup(
    Mutation$StartBackup instance,
    TRes Function(Mutation$StartBackup) then,
  ) = _CopyWithImpl$Mutation$StartBackup;

  factory CopyWith$Mutation$StartBackup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$StartBackup;

  TRes call({
    Mutation$StartBackup$backup? backup,
    String? $__typename,
  });
  CopyWith$Mutation$StartBackup$backup<TRes> get backup;
}

class _CopyWithImpl$Mutation$StartBackup<TRes>
    implements CopyWith$Mutation$StartBackup<TRes> {
  _CopyWithImpl$Mutation$StartBackup(
    this._instance,
    this._then,
  );

  final Mutation$StartBackup _instance;

  final TRes Function(Mutation$StartBackup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? backup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$StartBackup(
        backup: backup == _undefined || backup == null
            ? _instance.backup
            : (backup as Mutation$StartBackup$backup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$StartBackup$backup<TRes> get backup {
    final local$backup = _instance.backup;
    return CopyWith$Mutation$StartBackup$backup(
        local$backup, (e) => call(backup: e));
  }
}

class _CopyWithStubImpl$Mutation$StartBackup<TRes>
    implements CopyWith$Mutation$StartBackup<TRes> {
  _CopyWithStubImpl$Mutation$StartBackup(this._res);

  TRes _res;

  call({
    Mutation$StartBackup$backup? backup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$StartBackup$backup<TRes> get backup =>
      CopyWith$Mutation$StartBackup$backup.stub(_res);
}

const documentNodeMutationStartBackup = DocumentNode(definitions: [
  OperationDefinitionNode(
    type: OperationType.mutation,
    name: NameNode(value: 'StartBackup'),
    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: 'backup'),
        alias: null,
        arguments: [],
        directives: [],
        selectionSet: SelectionSetNode(selections: [
          FieldNode(
            name: NameNode(value: 'startBackup'),
            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: '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$StartBackup _parserFn$Mutation$StartBackup(
        Map<String, dynamic> data) =>
    Mutation$StartBackup.fromJson(data);
typedef OnMutationCompleted$Mutation$StartBackup = FutureOr<void> Function(
  Map<String, dynamic>?,
  Mutation$StartBackup?,
);

class Options$Mutation$StartBackup
    extends graphql.MutationOptions<Mutation$StartBackup> {
  Options$Mutation$StartBackup({
    String? operationName,
    required Variables$Mutation$StartBackup variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$StartBackup? typedOptimisticResult,
    graphql.Context? context,
    OnMutationCompleted$Mutation$StartBackup? onCompleted,
    graphql.OnMutationUpdate<Mutation$StartBackup>? 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$StartBackup(data),
                  ),
          update: update,
          onError: onError,
          document: documentNodeMutationStartBackup,
          parserFn: _parserFn$Mutation$StartBackup,
        );

  final OnMutationCompleted$Mutation$StartBackup? onCompletedWithParsed;

  @override
  List<Object?> get properties => [
        ...super.onCompleted == null
            ? super.properties
            : super.properties.where((property) => property != onCompleted),
        onCompletedWithParsed,
      ];
}

class WatchOptions$Mutation$StartBackup
    extends graphql.WatchQueryOptions<Mutation$StartBackup> {
  WatchOptions$Mutation$StartBackup({
    String? operationName,
    required Variables$Mutation$StartBackup variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$StartBackup? 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: documentNodeMutationStartBackup,
          pollInterval: pollInterval,
          eagerlyFetchResults: eagerlyFetchResults,
          carryForwardDataOnException: carryForwardDataOnException,
          fetchResults: fetchResults,
          parserFn: _parserFn$Mutation$StartBackup,
        );
}

extension ClientExtension$Mutation$StartBackup on graphql.GraphQLClient {
  Future<graphql.QueryResult<Mutation$StartBackup>> mutate$StartBackup(
          Options$Mutation$StartBackup options) async =>
      await this.mutate(options);
  graphql.ObservableQuery<Mutation$StartBackup> watchMutation$StartBackup(
          WatchOptions$Mutation$StartBackup options) =>
      this.watchMutation(options);
}

class Mutation$StartBackup$backup {
  Mutation$StartBackup$backup({
    required this.startBackup,
    this.$__typename = 'BackupMutations',
  });

  factory Mutation$StartBackup$backup.fromJson(Map<String, dynamic> json) {
    final l$startBackup = json['startBackup'];
    final l$$__typename = json['__typename'];
    return Mutation$StartBackup$backup(
      startBackup: Mutation$StartBackup$backup$startBackup.fromJson(
          (l$startBackup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$StartBackup$backup$startBackup startBackup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$startBackup = startBackup;
    _resultData['startBackup'] = l$startBackup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$startBackup = startBackup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$startBackup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$StartBackup$backup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$startBackup = startBackup;
    final lOther$startBackup = other.startBackup;
    if (l$startBackup != lOther$startBackup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$StartBackup$backup
    on Mutation$StartBackup$backup {
  CopyWith$Mutation$StartBackup$backup<Mutation$StartBackup$backup>
      get copyWith => CopyWith$Mutation$StartBackup$backup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$StartBackup$backup<TRes> {
  factory CopyWith$Mutation$StartBackup$backup(
    Mutation$StartBackup$backup instance,
    TRes Function(Mutation$StartBackup$backup) then,
  ) = _CopyWithImpl$Mutation$StartBackup$backup;

  factory CopyWith$Mutation$StartBackup$backup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$StartBackup$backup;

  TRes call({
    Mutation$StartBackup$backup$startBackup? startBackup,
    String? $__typename,
  });
  CopyWith$Mutation$StartBackup$backup$startBackup<TRes> get startBackup;
}

class _CopyWithImpl$Mutation$StartBackup$backup<TRes>
    implements CopyWith$Mutation$StartBackup$backup<TRes> {
  _CopyWithImpl$Mutation$StartBackup$backup(
    this._instance,
    this._then,
  );

  final Mutation$StartBackup$backup _instance;

  final TRes Function(Mutation$StartBackup$backup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? startBackup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$StartBackup$backup(
        startBackup: startBackup == _undefined || startBackup == null
            ? _instance.startBackup
            : (startBackup as Mutation$StartBackup$backup$startBackup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$StartBackup$backup$startBackup<TRes> get startBackup {
    final local$startBackup = _instance.startBackup;
    return CopyWith$Mutation$StartBackup$backup$startBackup(
        local$startBackup, (e) => call(startBackup: e));
  }
}

class _CopyWithStubImpl$Mutation$StartBackup$backup<TRes>
    implements CopyWith$Mutation$StartBackup$backup<TRes> {
  _CopyWithStubImpl$Mutation$StartBackup$backup(this._res);

  TRes _res;

  call({
    Mutation$StartBackup$backup$startBackup? startBackup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$StartBackup$backup$startBackup<TRes> get startBackup =>
      CopyWith$Mutation$StartBackup$backup$startBackup.stub(_res);
}

class Mutation$StartBackup$backup$startBackup
    implements Fragment$basicMutationReturnFields$$GenericJobMutationReturn {
  Mutation$StartBackup$backup$startBackup({
    required this.code,
    required this.message,
    required this.success,
    this.$__typename = 'GenericJobMutationReturn',
    this.job,
  });

  factory Mutation$StartBackup$backup$startBackup.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$StartBackup$backup$startBackup(
      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$StartBackup$backup$startBackup) ||
        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$StartBackup$backup$startBackup
    on Mutation$StartBackup$backup$startBackup {
  CopyWith$Mutation$StartBackup$backup$startBackup<
          Mutation$StartBackup$backup$startBackup>
      get copyWith => CopyWith$Mutation$StartBackup$backup$startBackup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$StartBackup$backup$startBackup<TRes> {
  factory CopyWith$Mutation$StartBackup$backup$startBackup(
    Mutation$StartBackup$backup$startBackup instance,
    TRes Function(Mutation$StartBackup$backup$startBackup) then,
  ) = _CopyWithImpl$Mutation$StartBackup$backup$startBackup;

  factory CopyWith$Mutation$StartBackup$backup$startBackup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$StartBackup$backup$startBackup;

  TRes call({
    int? code,
    String? message,
    bool? success,
    String? $__typename,
    Fragment$basicApiJobsFields? job,
  });
  CopyWith$Fragment$basicApiJobsFields<TRes> get job;
}

class _CopyWithImpl$Mutation$StartBackup$backup$startBackup<TRes>
    implements CopyWith$Mutation$StartBackup$backup$startBackup<TRes> {
  _CopyWithImpl$Mutation$StartBackup$backup$startBackup(
    this._instance,
    this._then,
  );

  final Mutation$StartBackup$backup$startBackup _instance;

  final TRes Function(Mutation$StartBackup$backup$startBackup) _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$StartBackup$backup$startBackup(
        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$StartBackup$backup$startBackup<TRes>
    implements CopyWith$Mutation$StartBackup$backup$startBackup<TRes> {
  _CopyWithStubImpl$Mutation$StartBackup$backup$startBackup(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);
}

class Variables$Mutation$SetAutobackupPeriod {
  factory Variables$Mutation$SetAutobackupPeriod({int? period}) =>
      Variables$Mutation$SetAutobackupPeriod._({
        if (period != null) r'period': period,
      });

  Variables$Mutation$SetAutobackupPeriod._(this._$data);

  factory Variables$Mutation$SetAutobackupPeriod.fromJson(
      Map<String, dynamic> data) {
    final result$data = <String, dynamic>{};
    if (data.containsKey('period')) {
      final l$period = data['period'];
      result$data['period'] = (l$period as int?);
    }
    return Variables$Mutation$SetAutobackupPeriod._(result$data);
  }

  Map<String, dynamic> _$data;

  int? get period => (_$data['period'] as int?);
  Map<String, dynamic> toJson() {
    final result$data = <String, dynamic>{};
    if (_$data.containsKey('period')) {
      final l$period = period;
      result$data['period'] = l$period;
    }
    return result$data;
  }

  CopyWith$Variables$Mutation$SetAutobackupPeriod<
          Variables$Mutation$SetAutobackupPeriod>
      get copyWith => CopyWith$Variables$Mutation$SetAutobackupPeriod(
            this,
            (i) => i,
          );
  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Variables$Mutation$SetAutobackupPeriod) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$period = period;
    final lOther$period = other.period;
    if (_$data.containsKey('period') != other._$data.containsKey('period')) {
      return false;
    }
    if (l$period != lOther$period) {
      return false;
    }
    return true;
  }

  @override
  int get hashCode {
    final l$period = period;
    return Object.hashAll([_$data.containsKey('period') ? l$period : const {}]);
  }
}

abstract class CopyWith$Variables$Mutation$SetAutobackupPeriod<TRes> {
  factory CopyWith$Variables$Mutation$SetAutobackupPeriod(
    Variables$Mutation$SetAutobackupPeriod instance,
    TRes Function(Variables$Mutation$SetAutobackupPeriod) then,
  ) = _CopyWithImpl$Variables$Mutation$SetAutobackupPeriod;

  factory CopyWith$Variables$Mutation$SetAutobackupPeriod.stub(TRes res) =
      _CopyWithStubImpl$Variables$Mutation$SetAutobackupPeriod;

  TRes call({int? period});
}

class _CopyWithImpl$Variables$Mutation$SetAutobackupPeriod<TRes>
    implements CopyWith$Variables$Mutation$SetAutobackupPeriod<TRes> {
  _CopyWithImpl$Variables$Mutation$SetAutobackupPeriod(
    this._instance,
    this._then,
  );

  final Variables$Mutation$SetAutobackupPeriod _instance;

  final TRes Function(Variables$Mutation$SetAutobackupPeriod) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({Object? period = _undefined}) =>
      _then(Variables$Mutation$SetAutobackupPeriod._({
        ..._instance._$data,
        if (period != _undefined) 'period': (period as int?),
      }));
}

class _CopyWithStubImpl$Variables$Mutation$SetAutobackupPeriod<TRes>
    implements CopyWith$Variables$Mutation$SetAutobackupPeriod<TRes> {
  _CopyWithStubImpl$Variables$Mutation$SetAutobackupPeriod(this._res);

  TRes _res;

  call({int? period}) => _res;
}

class Mutation$SetAutobackupPeriod {
  Mutation$SetAutobackupPeriod({
    required this.backup,
    this.$__typename = 'Mutation',
  });

  factory Mutation$SetAutobackupPeriod.fromJson(Map<String, dynamic> json) {
    final l$backup = json['backup'];
    final l$$__typename = json['__typename'];
    return Mutation$SetAutobackupPeriod(
      backup: Mutation$SetAutobackupPeriod$backup.fromJson(
          (l$backup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$SetAutobackupPeriod$backup backup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$backup = backup;
    _resultData['backup'] = l$backup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$backup = backup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$backup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$SetAutobackupPeriod) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$backup = backup;
    final lOther$backup = other.backup;
    if (l$backup != lOther$backup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$SetAutobackupPeriod
    on Mutation$SetAutobackupPeriod {
  CopyWith$Mutation$SetAutobackupPeriod<Mutation$SetAutobackupPeriod>
      get copyWith => CopyWith$Mutation$SetAutobackupPeriod(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$SetAutobackupPeriod<TRes> {
  factory CopyWith$Mutation$SetAutobackupPeriod(
    Mutation$SetAutobackupPeriod instance,
    TRes Function(Mutation$SetAutobackupPeriod) then,
  ) = _CopyWithImpl$Mutation$SetAutobackupPeriod;

  factory CopyWith$Mutation$SetAutobackupPeriod.stub(TRes res) =
      _CopyWithStubImpl$Mutation$SetAutobackupPeriod;

  TRes call({
    Mutation$SetAutobackupPeriod$backup? backup,
    String? $__typename,
  });
  CopyWith$Mutation$SetAutobackupPeriod$backup<TRes> get backup;
}

class _CopyWithImpl$Mutation$SetAutobackupPeriod<TRes>
    implements CopyWith$Mutation$SetAutobackupPeriod<TRes> {
  _CopyWithImpl$Mutation$SetAutobackupPeriod(
    this._instance,
    this._then,
  );

  final Mutation$SetAutobackupPeriod _instance;

  final TRes Function(Mutation$SetAutobackupPeriod) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? backup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$SetAutobackupPeriod(
        backup: backup == _undefined || backup == null
            ? _instance.backup
            : (backup as Mutation$SetAutobackupPeriod$backup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$SetAutobackupPeriod$backup<TRes> get backup {
    final local$backup = _instance.backup;
    return CopyWith$Mutation$SetAutobackupPeriod$backup(
        local$backup, (e) => call(backup: e));
  }
}

class _CopyWithStubImpl$Mutation$SetAutobackupPeriod<TRes>
    implements CopyWith$Mutation$SetAutobackupPeriod<TRes> {
  _CopyWithStubImpl$Mutation$SetAutobackupPeriod(this._res);

  TRes _res;

  call({
    Mutation$SetAutobackupPeriod$backup? backup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$SetAutobackupPeriod$backup<TRes> get backup =>
      CopyWith$Mutation$SetAutobackupPeriod$backup.stub(_res);
}

const documentNodeMutationSetAutobackupPeriod = DocumentNode(definitions: [
  OperationDefinitionNode(
    type: OperationType.mutation,
    name: NameNode(value: 'SetAutobackupPeriod'),
    variableDefinitions: [
      VariableDefinitionNode(
        variable: VariableNode(name: NameNode(value: 'period')),
        type: NamedTypeNode(
          name: NameNode(value: 'Int'),
          isNonNull: false,
        ),
        defaultValue: DefaultValueNode(value: NullValueNode()),
        directives: [],
      )
    ],
    directives: [],
    selectionSet: SelectionSetNode(selections: [
      FieldNode(
        name: NameNode(value: 'backup'),
        alias: null,
        arguments: [],
        directives: [],
        selectionSet: SelectionSetNode(selections: [
          FieldNode(
            name: NameNode(value: 'setAutobackupPeriod'),
            alias: null,
            arguments: [
              ArgumentNode(
                name: NameNode(value: 'period'),
                value: VariableNode(name: NameNode(value: 'period')),
              )
            ],
            directives: [],
            selectionSet: SelectionSetNode(selections: [
              FragmentSpreadNode(
                name: NameNode(value: 'genericBackupConfigReturn'),
                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,
      ),
    ]),
  ),
  fragmentDefinitiongenericBackupConfigReturn,
]);
Mutation$SetAutobackupPeriod _parserFn$Mutation$SetAutobackupPeriod(
        Map<String, dynamic> data) =>
    Mutation$SetAutobackupPeriod.fromJson(data);
typedef OnMutationCompleted$Mutation$SetAutobackupPeriod = FutureOr<void>
    Function(
  Map<String, dynamic>?,
  Mutation$SetAutobackupPeriod?,
);

class Options$Mutation$SetAutobackupPeriod
    extends graphql.MutationOptions<Mutation$SetAutobackupPeriod> {
  Options$Mutation$SetAutobackupPeriod({
    String? operationName,
    Variables$Mutation$SetAutobackupPeriod? variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$SetAutobackupPeriod? typedOptimisticResult,
    graphql.Context? context,
    OnMutationCompleted$Mutation$SetAutobackupPeriod? onCompleted,
    graphql.OnMutationUpdate<Mutation$SetAutobackupPeriod>? 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$SetAutobackupPeriod(data),
                  ),
          update: update,
          onError: onError,
          document: documentNodeMutationSetAutobackupPeriod,
          parserFn: _parserFn$Mutation$SetAutobackupPeriod,
        );

  final OnMutationCompleted$Mutation$SetAutobackupPeriod? onCompletedWithParsed;

  @override
  List<Object?> get properties => [
        ...super.onCompleted == null
            ? super.properties
            : super.properties.where((property) => property != onCompleted),
        onCompletedWithParsed,
      ];
}

class WatchOptions$Mutation$SetAutobackupPeriod
    extends graphql.WatchQueryOptions<Mutation$SetAutobackupPeriod> {
  WatchOptions$Mutation$SetAutobackupPeriod({
    String? operationName,
    Variables$Mutation$SetAutobackupPeriod? variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$SetAutobackupPeriod? 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: documentNodeMutationSetAutobackupPeriod,
          pollInterval: pollInterval,
          eagerlyFetchResults: eagerlyFetchResults,
          carryForwardDataOnException: carryForwardDataOnException,
          fetchResults: fetchResults,
          parserFn: _parserFn$Mutation$SetAutobackupPeriod,
        );
}

extension ClientExtension$Mutation$SetAutobackupPeriod
    on graphql.GraphQLClient {
  Future<graphql.QueryResult<Mutation$SetAutobackupPeriod>>
      mutate$SetAutobackupPeriod(
              [Options$Mutation$SetAutobackupPeriod? options]) async =>
          await this.mutate(options ?? Options$Mutation$SetAutobackupPeriod());
  graphql.ObservableQuery<Mutation$SetAutobackupPeriod>
      watchMutation$SetAutobackupPeriod(
              [WatchOptions$Mutation$SetAutobackupPeriod? options]) =>
          this.watchMutation(
              options ?? WatchOptions$Mutation$SetAutobackupPeriod());
}

class Mutation$SetAutobackupPeriod$backup {
  Mutation$SetAutobackupPeriod$backup({
    required this.setAutobackupPeriod,
    this.$__typename = 'BackupMutations',
  });

  factory Mutation$SetAutobackupPeriod$backup.fromJson(
      Map<String, dynamic> json) {
    final l$setAutobackupPeriod = json['setAutobackupPeriod'];
    final l$$__typename = json['__typename'];
    return Mutation$SetAutobackupPeriod$backup(
      setAutobackupPeriod: Fragment$genericBackupConfigReturn.fromJson(
          (l$setAutobackupPeriod as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Fragment$genericBackupConfigReturn setAutobackupPeriod;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$setAutobackupPeriod = setAutobackupPeriod;
    _resultData['setAutobackupPeriod'] = l$setAutobackupPeriod.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$setAutobackupPeriod = setAutobackupPeriod;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$setAutobackupPeriod,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$SetAutobackupPeriod$backup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$setAutobackupPeriod = setAutobackupPeriod;
    final lOther$setAutobackupPeriod = other.setAutobackupPeriod;
    if (l$setAutobackupPeriod != lOther$setAutobackupPeriod) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$SetAutobackupPeriod$backup
    on Mutation$SetAutobackupPeriod$backup {
  CopyWith$Mutation$SetAutobackupPeriod$backup<
          Mutation$SetAutobackupPeriod$backup>
      get copyWith => CopyWith$Mutation$SetAutobackupPeriod$backup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$SetAutobackupPeriod$backup<TRes> {
  factory CopyWith$Mutation$SetAutobackupPeriod$backup(
    Mutation$SetAutobackupPeriod$backup instance,
    TRes Function(Mutation$SetAutobackupPeriod$backup) then,
  ) = _CopyWithImpl$Mutation$SetAutobackupPeriod$backup;

  factory CopyWith$Mutation$SetAutobackupPeriod$backup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$SetAutobackupPeriod$backup;

  TRes call({
    Fragment$genericBackupConfigReturn? setAutobackupPeriod,
    String? $__typename,
  });
  CopyWith$Fragment$genericBackupConfigReturn<TRes> get setAutobackupPeriod;
}

class _CopyWithImpl$Mutation$SetAutobackupPeriod$backup<TRes>
    implements CopyWith$Mutation$SetAutobackupPeriod$backup<TRes> {
  _CopyWithImpl$Mutation$SetAutobackupPeriod$backup(
    this._instance,
    this._then,
  );

  final Mutation$SetAutobackupPeriod$backup _instance;

  final TRes Function(Mutation$SetAutobackupPeriod$backup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? setAutobackupPeriod = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$SetAutobackupPeriod$backup(
        setAutobackupPeriod:
            setAutobackupPeriod == _undefined || setAutobackupPeriod == null
                ? _instance.setAutobackupPeriod
                : (setAutobackupPeriod as Fragment$genericBackupConfigReturn),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Fragment$genericBackupConfigReturn<TRes> get setAutobackupPeriod {
    final local$setAutobackupPeriod = _instance.setAutobackupPeriod;
    return CopyWith$Fragment$genericBackupConfigReturn(
        local$setAutobackupPeriod, (e) => call(setAutobackupPeriod: e));
  }
}

class _CopyWithStubImpl$Mutation$SetAutobackupPeriod$backup<TRes>
    implements CopyWith$Mutation$SetAutobackupPeriod$backup<TRes> {
  _CopyWithStubImpl$Mutation$SetAutobackupPeriod$backup(this._res);

  TRes _res;

  call({
    Fragment$genericBackupConfigReturn? setAutobackupPeriod,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Fragment$genericBackupConfigReturn<TRes> get setAutobackupPeriod =>
      CopyWith$Fragment$genericBackupConfigReturn.stub(_res);
}

class Mutation$RemoveRepository {
  Mutation$RemoveRepository({
    required this.backup,
    this.$__typename = 'Mutation',
  });

  factory Mutation$RemoveRepository.fromJson(Map<String, dynamic> json) {
    final l$backup = json['backup'];
    final l$$__typename = json['__typename'];
    return Mutation$RemoveRepository(
      backup: Mutation$RemoveRepository$backup.fromJson(
          (l$backup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$RemoveRepository$backup backup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$backup = backup;
    _resultData['backup'] = l$backup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$backup = backup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$backup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$RemoveRepository) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$backup = backup;
    final lOther$backup = other.backup;
    if (l$backup != lOther$backup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$RemoveRepository
    on Mutation$RemoveRepository {
  CopyWith$Mutation$RemoveRepository<Mutation$RemoveRepository> get copyWith =>
      CopyWith$Mutation$RemoveRepository(
        this,
        (i) => i,
      );
}

abstract class CopyWith$Mutation$RemoveRepository<TRes> {
  factory CopyWith$Mutation$RemoveRepository(
    Mutation$RemoveRepository instance,
    TRes Function(Mutation$RemoveRepository) then,
  ) = _CopyWithImpl$Mutation$RemoveRepository;

  factory CopyWith$Mutation$RemoveRepository.stub(TRes res) =
      _CopyWithStubImpl$Mutation$RemoveRepository;

  TRes call({
    Mutation$RemoveRepository$backup? backup,
    String? $__typename,
  });
  CopyWith$Mutation$RemoveRepository$backup<TRes> get backup;
}

class _CopyWithImpl$Mutation$RemoveRepository<TRes>
    implements CopyWith$Mutation$RemoveRepository<TRes> {
  _CopyWithImpl$Mutation$RemoveRepository(
    this._instance,
    this._then,
  );

  final Mutation$RemoveRepository _instance;

  final TRes Function(Mutation$RemoveRepository) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? backup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$RemoveRepository(
        backup: backup == _undefined || backup == null
            ? _instance.backup
            : (backup as Mutation$RemoveRepository$backup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$RemoveRepository$backup<TRes> get backup {
    final local$backup = _instance.backup;
    return CopyWith$Mutation$RemoveRepository$backup(
        local$backup, (e) => call(backup: e));
  }
}

class _CopyWithStubImpl$Mutation$RemoveRepository<TRes>
    implements CopyWith$Mutation$RemoveRepository<TRes> {
  _CopyWithStubImpl$Mutation$RemoveRepository(this._res);

  TRes _res;

  call({
    Mutation$RemoveRepository$backup? backup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$RemoveRepository$backup<TRes> get backup =>
      CopyWith$Mutation$RemoveRepository$backup.stub(_res);
}

const documentNodeMutationRemoveRepository = DocumentNode(definitions: [
  OperationDefinitionNode(
    type: OperationType.mutation,
    name: NameNode(value: 'RemoveRepository'),
    variableDefinitions: [],
    directives: [],
    selectionSet: SelectionSetNode(selections: [
      FieldNode(
        name: NameNode(value: 'backup'),
        alias: null,
        arguments: [],
        directives: [],
        selectionSet: SelectionSetNode(selections: [
          FieldNode(
            name: NameNode(value: 'removeRepository'),
            alias: null,
            arguments: [],
            directives: [],
            selectionSet: SelectionSetNode(selections: [
              FragmentSpreadNode(
                name: NameNode(value: 'genericBackupConfigReturn'),
                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,
      ),
    ]),
  ),
  fragmentDefinitiongenericBackupConfigReturn,
]);
Mutation$RemoveRepository _parserFn$Mutation$RemoveRepository(
        Map<String, dynamic> data) =>
    Mutation$RemoveRepository.fromJson(data);
typedef OnMutationCompleted$Mutation$RemoveRepository = FutureOr<void> Function(
  Map<String, dynamic>?,
  Mutation$RemoveRepository?,
);

class Options$Mutation$RemoveRepository
    extends graphql.MutationOptions<Mutation$RemoveRepository> {
  Options$Mutation$RemoveRepository({
    String? operationName,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$RemoveRepository? typedOptimisticResult,
    graphql.Context? context,
    OnMutationCompleted$Mutation$RemoveRepository? onCompleted,
    graphql.OnMutationUpdate<Mutation$RemoveRepository>? update,
    graphql.OnError? onError,
  })  : onCompletedWithParsed = onCompleted,
        super(
          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$RemoveRepository(data),
                  ),
          update: update,
          onError: onError,
          document: documentNodeMutationRemoveRepository,
          parserFn: _parserFn$Mutation$RemoveRepository,
        );

  final OnMutationCompleted$Mutation$RemoveRepository? onCompletedWithParsed;

  @override
  List<Object?> get properties => [
        ...super.onCompleted == null
            ? super.properties
            : super.properties.where((property) => property != onCompleted),
        onCompletedWithParsed,
      ];
}

class WatchOptions$Mutation$RemoveRepository
    extends graphql.WatchQueryOptions<Mutation$RemoveRepository> {
  WatchOptions$Mutation$RemoveRepository({
    String? operationName,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$RemoveRepository? 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: documentNodeMutationRemoveRepository,
          pollInterval: pollInterval,
          eagerlyFetchResults: eagerlyFetchResults,
          carryForwardDataOnException: carryForwardDataOnException,
          fetchResults: fetchResults,
          parserFn: _parserFn$Mutation$RemoveRepository,
        );
}

extension ClientExtension$Mutation$RemoveRepository on graphql.GraphQLClient {
  Future<graphql.QueryResult<Mutation$RemoveRepository>>
      mutate$RemoveRepository(
              [Options$Mutation$RemoveRepository? options]) async =>
          await this.mutate(options ?? Options$Mutation$RemoveRepository());
  graphql.ObservableQuery<
      Mutation$RemoveRepository> watchMutation$RemoveRepository(
          [WatchOptions$Mutation$RemoveRepository? options]) =>
      this.watchMutation(options ?? WatchOptions$Mutation$RemoveRepository());
}

class Mutation$RemoveRepository$backup {
  Mutation$RemoveRepository$backup({
    required this.removeRepository,
    this.$__typename = 'BackupMutations',
  });

  factory Mutation$RemoveRepository$backup.fromJson(Map<String, dynamic> json) {
    final l$removeRepository = json['removeRepository'];
    final l$$__typename = json['__typename'];
    return Mutation$RemoveRepository$backup(
      removeRepository: Fragment$genericBackupConfigReturn.fromJson(
          (l$removeRepository as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Fragment$genericBackupConfigReturn removeRepository;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$removeRepository = removeRepository;
    _resultData['removeRepository'] = l$removeRepository.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$removeRepository = removeRepository;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$removeRepository,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$RemoveRepository$backup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$removeRepository = removeRepository;
    final lOther$removeRepository = other.removeRepository;
    if (l$removeRepository != lOther$removeRepository) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$RemoveRepository$backup
    on Mutation$RemoveRepository$backup {
  CopyWith$Mutation$RemoveRepository$backup<Mutation$RemoveRepository$backup>
      get copyWith => CopyWith$Mutation$RemoveRepository$backup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$RemoveRepository$backup<TRes> {
  factory CopyWith$Mutation$RemoveRepository$backup(
    Mutation$RemoveRepository$backup instance,
    TRes Function(Mutation$RemoveRepository$backup) then,
  ) = _CopyWithImpl$Mutation$RemoveRepository$backup;

  factory CopyWith$Mutation$RemoveRepository$backup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$RemoveRepository$backup;

  TRes call({
    Fragment$genericBackupConfigReturn? removeRepository,
    String? $__typename,
  });
  CopyWith$Fragment$genericBackupConfigReturn<TRes> get removeRepository;
}

class _CopyWithImpl$Mutation$RemoveRepository$backup<TRes>
    implements CopyWith$Mutation$RemoveRepository$backup<TRes> {
  _CopyWithImpl$Mutation$RemoveRepository$backup(
    this._instance,
    this._then,
  );

  final Mutation$RemoveRepository$backup _instance;

  final TRes Function(Mutation$RemoveRepository$backup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? removeRepository = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$RemoveRepository$backup(
        removeRepository:
            removeRepository == _undefined || removeRepository == null
                ? _instance.removeRepository
                : (removeRepository as Fragment$genericBackupConfigReturn),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Fragment$genericBackupConfigReturn<TRes> get removeRepository {
    final local$removeRepository = _instance.removeRepository;
    return CopyWith$Fragment$genericBackupConfigReturn(
        local$removeRepository, (e) => call(removeRepository: e));
  }
}

class _CopyWithStubImpl$Mutation$RemoveRepository$backup<TRes>
    implements CopyWith$Mutation$RemoveRepository$backup<TRes> {
  _CopyWithStubImpl$Mutation$RemoveRepository$backup(this._res);

  TRes _res;

  call({
    Fragment$genericBackupConfigReturn? removeRepository,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Fragment$genericBackupConfigReturn<TRes> get removeRepository =>
      CopyWith$Fragment$genericBackupConfigReturn.stub(_res);
}

class Variables$Mutation$InitializeRepository {
  factory Variables$Mutation$InitializeRepository(
          {required Input$InitializeRepositoryInput repository}) =>
      Variables$Mutation$InitializeRepository._({
        r'repository': repository,
      });

  Variables$Mutation$InitializeRepository._(this._$data);

  factory Variables$Mutation$InitializeRepository.fromJson(
      Map<String, dynamic> data) {
    final result$data = <String, dynamic>{};
    final l$repository = data['repository'];
    result$data['repository'] = Input$InitializeRepositoryInput.fromJson(
        (l$repository as Map<String, dynamic>));
    return Variables$Mutation$InitializeRepository._(result$data);
  }

  Map<String, dynamic> _$data;

  Input$InitializeRepositoryInput get repository =>
      (_$data['repository'] as Input$InitializeRepositoryInput);
  Map<String, dynamic> toJson() {
    final result$data = <String, dynamic>{};
    final l$repository = repository;
    result$data['repository'] = l$repository.toJson();
    return result$data;
  }

  CopyWith$Variables$Mutation$InitializeRepository<
          Variables$Mutation$InitializeRepository>
      get copyWith => CopyWith$Variables$Mutation$InitializeRepository(
            this,
            (i) => i,
          );
  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Variables$Mutation$InitializeRepository) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$repository = repository;
    final lOther$repository = other.repository;
    if (l$repository != lOther$repository) {
      return false;
    }
    return true;
  }

  @override
  int get hashCode {
    final l$repository = repository;
    return Object.hashAll([l$repository]);
  }
}

abstract class CopyWith$Variables$Mutation$InitializeRepository<TRes> {
  factory CopyWith$Variables$Mutation$InitializeRepository(
    Variables$Mutation$InitializeRepository instance,
    TRes Function(Variables$Mutation$InitializeRepository) then,
  ) = _CopyWithImpl$Variables$Mutation$InitializeRepository;

  factory CopyWith$Variables$Mutation$InitializeRepository.stub(TRes res) =
      _CopyWithStubImpl$Variables$Mutation$InitializeRepository;

  TRes call({Input$InitializeRepositoryInput? repository});
}

class _CopyWithImpl$Variables$Mutation$InitializeRepository<TRes>
    implements CopyWith$Variables$Mutation$InitializeRepository<TRes> {
  _CopyWithImpl$Variables$Mutation$InitializeRepository(
    this._instance,
    this._then,
  );

  final Variables$Mutation$InitializeRepository _instance;

  final TRes Function(Variables$Mutation$InitializeRepository) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({Object? repository = _undefined}) =>
      _then(Variables$Mutation$InitializeRepository._({
        ..._instance._$data,
        if (repository != _undefined && repository != null)
          'repository': (repository as Input$InitializeRepositoryInput),
      }));
}

class _CopyWithStubImpl$Variables$Mutation$InitializeRepository<TRes>
    implements CopyWith$Variables$Mutation$InitializeRepository<TRes> {
  _CopyWithStubImpl$Variables$Mutation$InitializeRepository(this._res);

  TRes _res;

  call({Input$InitializeRepositoryInput? repository}) => _res;
}

class Mutation$InitializeRepository {
  Mutation$InitializeRepository({
    required this.backup,
    this.$__typename = 'Mutation',
  });

  factory Mutation$InitializeRepository.fromJson(Map<String, dynamic> json) {
    final l$backup = json['backup'];
    final l$$__typename = json['__typename'];
    return Mutation$InitializeRepository(
      backup: Mutation$InitializeRepository$backup.fromJson(
          (l$backup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$InitializeRepository$backup backup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$backup = backup;
    _resultData['backup'] = l$backup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$backup = backup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$backup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$InitializeRepository) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$backup = backup;
    final lOther$backup = other.backup;
    if (l$backup != lOther$backup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$InitializeRepository
    on Mutation$InitializeRepository {
  CopyWith$Mutation$InitializeRepository<Mutation$InitializeRepository>
      get copyWith => CopyWith$Mutation$InitializeRepository(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$InitializeRepository<TRes> {
  factory CopyWith$Mutation$InitializeRepository(
    Mutation$InitializeRepository instance,
    TRes Function(Mutation$InitializeRepository) then,
  ) = _CopyWithImpl$Mutation$InitializeRepository;

  factory CopyWith$Mutation$InitializeRepository.stub(TRes res) =
      _CopyWithStubImpl$Mutation$InitializeRepository;

  TRes call({
    Mutation$InitializeRepository$backup? backup,
    String? $__typename,
  });
  CopyWith$Mutation$InitializeRepository$backup<TRes> get backup;
}

class _CopyWithImpl$Mutation$InitializeRepository<TRes>
    implements CopyWith$Mutation$InitializeRepository<TRes> {
  _CopyWithImpl$Mutation$InitializeRepository(
    this._instance,
    this._then,
  );

  final Mutation$InitializeRepository _instance;

  final TRes Function(Mutation$InitializeRepository) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? backup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$InitializeRepository(
        backup: backup == _undefined || backup == null
            ? _instance.backup
            : (backup as Mutation$InitializeRepository$backup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$InitializeRepository$backup<TRes> get backup {
    final local$backup = _instance.backup;
    return CopyWith$Mutation$InitializeRepository$backup(
        local$backup, (e) => call(backup: e));
  }
}

class _CopyWithStubImpl$Mutation$InitializeRepository<TRes>
    implements CopyWith$Mutation$InitializeRepository<TRes> {
  _CopyWithStubImpl$Mutation$InitializeRepository(this._res);

  TRes _res;

  call({
    Mutation$InitializeRepository$backup? backup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$InitializeRepository$backup<TRes> get backup =>
      CopyWith$Mutation$InitializeRepository$backup.stub(_res);
}

const documentNodeMutationInitializeRepository = DocumentNode(definitions: [
  OperationDefinitionNode(
    type: OperationType.mutation,
    name: NameNode(value: 'InitializeRepository'),
    variableDefinitions: [
      VariableDefinitionNode(
        variable: VariableNode(name: NameNode(value: 'repository')),
        type: NamedTypeNode(
          name: NameNode(value: 'InitializeRepositoryInput'),
          isNonNull: true,
        ),
        defaultValue: DefaultValueNode(value: null),
        directives: [],
      )
    ],
    directives: [],
    selectionSet: SelectionSetNode(selections: [
      FieldNode(
        name: NameNode(value: 'backup'),
        alias: null,
        arguments: [],
        directives: [],
        selectionSet: SelectionSetNode(selections: [
          FieldNode(
            name: NameNode(value: 'initializeRepository'),
            alias: null,
            arguments: [
              ArgumentNode(
                name: NameNode(value: 'repository'),
                value: VariableNode(name: NameNode(value: 'repository')),
              )
            ],
            directives: [],
            selectionSet: SelectionSetNode(selections: [
              FragmentSpreadNode(
                name: NameNode(value: 'genericBackupConfigReturn'),
                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,
      ),
    ]),
  ),
  fragmentDefinitiongenericBackupConfigReturn,
]);
Mutation$InitializeRepository _parserFn$Mutation$InitializeRepository(
        Map<String, dynamic> data) =>
    Mutation$InitializeRepository.fromJson(data);
typedef OnMutationCompleted$Mutation$InitializeRepository = FutureOr<void>
    Function(
  Map<String, dynamic>?,
  Mutation$InitializeRepository?,
);

class Options$Mutation$InitializeRepository
    extends graphql.MutationOptions<Mutation$InitializeRepository> {
  Options$Mutation$InitializeRepository({
    String? operationName,
    required Variables$Mutation$InitializeRepository variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$InitializeRepository? typedOptimisticResult,
    graphql.Context? context,
    OnMutationCompleted$Mutation$InitializeRepository? onCompleted,
    graphql.OnMutationUpdate<Mutation$InitializeRepository>? 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$InitializeRepository(data),
                  ),
          update: update,
          onError: onError,
          document: documentNodeMutationInitializeRepository,
          parserFn: _parserFn$Mutation$InitializeRepository,
        );

  final OnMutationCompleted$Mutation$InitializeRepository?
      onCompletedWithParsed;

  @override
  List<Object?> get properties => [
        ...super.onCompleted == null
            ? super.properties
            : super.properties.where((property) => property != onCompleted),
        onCompletedWithParsed,
      ];
}

class WatchOptions$Mutation$InitializeRepository
    extends graphql.WatchQueryOptions<Mutation$InitializeRepository> {
  WatchOptions$Mutation$InitializeRepository({
    String? operationName,
    required Variables$Mutation$InitializeRepository variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$InitializeRepository? 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: documentNodeMutationInitializeRepository,
          pollInterval: pollInterval,
          eagerlyFetchResults: eagerlyFetchResults,
          carryForwardDataOnException: carryForwardDataOnException,
          fetchResults: fetchResults,
          parserFn: _parserFn$Mutation$InitializeRepository,
        );
}

extension ClientExtension$Mutation$InitializeRepository
    on graphql.GraphQLClient {
  Future<graphql.QueryResult<Mutation$InitializeRepository>>
      mutate$InitializeRepository(
              Options$Mutation$InitializeRepository options) async =>
          await this.mutate(options);
  graphql.ObservableQuery<Mutation$InitializeRepository>
      watchMutation$InitializeRepository(
              WatchOptions$Mutation$InitializeRepository options) =>
          this.watchMutation(options);
}

class Mutation$InitializeRepository$backup {
  Mutation$InitializeRepository$backup({
    required this.initializeRepository,
    this.$__typename = 'BackupMutations',
  });

  factory Mutation$InitializeRepository$backup.fromJson(
      Map<String, dynamic> json) {
    final l$initializeRepository = json['initializeRepository'];
    final l$$__typename = json['__typename'];
    return Mutation$InitializeRepository$backup(
      initializeRepository: Fragment$genericBackupConfigReturn.fromJson(
          (l$initializeRepository as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Fragment$genericBackupConfigReturn initializeRepository;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$initializeRepository = initializeRepository;
    _resultData['initializeRepository'] = l$initializeRepository.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$initializeRepository = initializeRepository;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$initializeRepository,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$InitializeRepository$backup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$initializeRepository = initializeRepository;
    final lOther$initializeRepository = other.initializeRepository;
    if (l$initializeRepository != lOther$initializeRepository) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$InitializeRepository$backup
    on Mutation$InitializeRepository$backup {
  CopyWith$Mutation$InitializeRepository$backup<
          Mutation$InitializeRepository$backup>
      get copyWith => CopyWith$Mutation$InitializeRepository$backup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$InitializeRepository$backup<TRes> {
  factory CopyWith$Mutation$InitializeRepository$backup(
    Mutation$InitializeRepository$backup instance,
    TRes Function(Mutation$InitializeRepository$backup) then,
  ) = _CopyWithImpl$Mutation$InitializeRepository$backup;

  factory CopyWith$Mutation$InitializeRepository$backup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$InitializeRepository$backup;

  TRes call({
    Fragment$genericBackupConfigReturn? initializeRepository,
    String? $__typename,
  });
  CopyWith$Fragment$genericBackupConfigReturn<TRes> get initializeRepository;
}

class _CopyWithImpl$Mutation$InitializeRepository$backup<TRes>
    implements CopyWith$Mutation$InitializeRepository$backup<TRes> {
  _CopyWithImpl$Mutation$InitializeRepository$backup(
    this._instance,
    this._then,
  );

  final Mutation$InitializeRepository$backup _instance;

  final TRes Function(Mutation$InitializeRepository$backup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? initializeRepository = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$InitializeRepository$backup(
        initializeRepository:
            initializeRepository == _undefined || initializeRepository == null
                ? _instance.initializeRepository
                : (initializeRepository as Fragment$genericBackupConfigReturn),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Fragment$genericBackupConfigReturn<TRes> get initializeRepository {
    final local$initializeRepository = _instance.initializeRepository;
    return CopyWith$Fragment$genericBackupConfigReturn(
        local$initializeRepository, (e) => call(initializeRepository: e));
  }
}

class _CopyWithStubImpl$Mutation$InitializeRepository$backup<TRes>
    implements CopyWith$Mutation$InitializeRepository$backup<TRes> {
  _CopyWithStubImpl$Mutation$InitializeRepository$backup(this._res);

  TRes _res;

  call({
    Fragment$genericBackupConfigReturn? initializeRepository,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Fragment$genericBackupConfigReturn<TRes> get initializeRepository =>
      CopyWith$Fragment$genericBackupConfigReturn.stub(_res);
}

class Variables$Mutation$RestoreBackup {
  factory Variables$Mutation$RestoreBackup({
    required String snapshotId,
    required Enum$RestoreStrategy strategy,
  }) =>
      Variables$Mutation$RestoreBackup._({
        r'snapshotId': snapshotId,
        r'strategy': strategy,
      });

  Variables$Mutation$RestoreBackup._(this._$data);

  factory Variables$Mutation$RestoreBackup.fromJson(Map<String, dynamic> data) {
    final result$data = <String, dynamic>{};
    final l$snapshotId = data['snapshotId'];
    result$data['snapshotId'] = (l$snapshotId as String);
    final l$strategy = data['strategy'];
    result$data['strategy'] =
        fromJson$Enum$RestoreStrategy((l$strategy as String));
    return Variables$Mutation$RestoreBackup._(result$data);
  }

  Map<String, dynamic> _$data;

  String get snapshotId => (_$data['snapshotId'] as String);
  Enum$RestoreStrategy get strategy =>
      (_$data['strategy'] as Enum$RestoreStrategy);
  Map<String, dynamic> toJson() {
    final result$data = <String, dynamic>{};
    final l$snapshotId = snapshotId;
    result$data['snapshotId'] = l$snapshotId;
    final l$strategy = strategy;
    result$data['strategy'] = toJson$Enum$RestoreStrategy(l$strategy);
    return result$data;
  }

  CopyWith$Variables$Mutation$RestoreBackup<Variables$Mutation$RestoreBackup>
      get copyWith => CopyWith$Variables$Mutation$RestoreBackup(
            this,
            (i) => i,
          );
  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Variables$Mutation$RestoreBackup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$snapshotId = snapshotId;
    final lOther$snapshotId = other.snapshotId;
    if (l$snapshotId != lOther$snapshotId) {
      return false;
    }
    final l$strategy = strategy;
    final lOther$strategy = other.strategy;
    if (l$strategy != lOther$strategy) {
      return false;
    }
    return true;
  }

  @override
  int get hashCode {
    final l$snapshotId = snapshotId;
    final l$strategy = strategy;
    return Object.hashAll([
      l$snapshotId,
      l$strategy,
    ]);
  }
}

abstract class CopyWith$Variables$Mutation$RestoreBackup<TRes> {
  factory CopyWith$Variables$Mutation$RestoreBackup(
    Variables$Mutation$RestoreBackup instance,
    TRes Function(Variables$Mutation$RestoreBackup) then,
  ) = _CopyWithImpl$Variables$Mutation$RestoreBackup;

  factory CopyWith$Variables$Mutation$RestoreBackup.stub(TRes res) =
      _CopyWithStubImpl$Variables$Mutation$RestoreBackup;

  TRes call({
    String? snapshotId,
    Enum$RestoreStrategy? strategy,
  });
}

class _CopyWithImpl$Variables$Mutation$RestoreBackup<TRes>
    implements CopyWith$Variables$Mutation$RestoreBackup<TRes> {
  _CopyWithImpl$Variables$Mutation$RestoreBackup(
    this._instance,
    this._then,
  );

  final Variables$Mutation$RestoreBackup _instance;

  final TRes Function(Variables$Mutation$RestoreBackup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? snapshotId = _undefined,
    Object? strategy = _undefined,
  }) =>
      _then(Variables$Mutation$RestoreBackup._({
        ..._instance._$data,
        if (snapshotId != _undefined && snapshotId != null)
          'snapshotId': (snapshotId as String),
        if (strategy != _undefined && strategy != null)
          'strategy': (strategy as Enum$RestoreStrategy),
      }));
}

class _CopyWithStubImpl$Variables$Mutation$RestoreBackup<TRes>
    implements CopyWith$Variables$Mutation$RestoreBackup<TRes> {
  _CopyWithStubImpl$Variables$Mutation$RestoreBackup(this._res);

  TRes _res;

  call({
    String? snapshotId,
    Enum$RestoreStrategy? strategy,
  }) =>
      _res;
}

class Mutation$RestoreBackup {
  Mutation$RestoreBackup({
    required this.backup,
    this.$__typename = 'Mutation',
  });

  factory Mutation$RestoreBackup.fromJson(Map<String, dynamic> json) {
    final l$backup = json['backup'];
    final l$$__typename = json['__typename'];
    return Mutation$RestoreBackup(
      backup: Mutation$RestoreBackup$backup.fromJson(
          (l$backup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$RestoreBackup$backup backup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$backup = backup;
    _resultData['backup'] = l$backup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$backup = backup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$backup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$RestoreBackup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$backup = backup;
    final lOther$backup = other.backup;
    if (l$backup != lOther$backup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$RestoreBackup on Mutation$RestoreBackup {
  CopyWith$Mutation$RestoreBackup<Mutation$RestoreBackup> get copyWith =>
      CopyWith$Mutation$RestoreBackup(
        this,
        (i) => i,
      );
}

abstract class CopyWith$Mutation$RestoreBackup<TRes> {
  factory CopyWith$Mutation$RestoreBackup(
    Mutation$RestoreBackup instance,
    TRes Function(Mutation$RestoreBackup) then,
  ) = _CopyWithImpl$Mutation$RestoreBackup;

  factory CopyWith$Mutation$RestoreBackup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$RestoreBackup;

  TRes call({
    Mutation$RestoreBackup$backup? backup,
    String? $__typename,
  });
  CopyWith$Mutation$RestoreBackup$backup<TRes> get backup;
}

class _CopyWithImpl$Mutation$RestoreBackup<TRes>
    implements CopyWith$Mutation$RestoreBackup<TRes> {
  _CopyWithImpl$Mutation$RestoreBackup(
    this._instance,
    this._then,
  );

  final Mutation$RestoreBackup _instance;

  final TRes Function(Mutation$RestoreBackup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? backup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$RestoreBackup(
        backup: backup == _undefined || backup == null
            ? _instance.backup
            : (backup as Mutation$RestoreBackup$backup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$RestoreBackup$backup<TRes> get backup {
    final local$backup = _instance.backup;
    return CopyWith$Mutation$RestoreBackup$backup(
        local$backup, (e) => call(backup: e));
  }
}

class _CopyWithStubImpl$Mutation$RestoreBackup<TRes>
    implements CopyWith$Mutation$RestoreBackup<TRes> {
  _CopyWithStubImpl$Mutation$RestoreBackup(this._res);

  TRes _res;

  call({
    Mutation$RestoreBackup$backup? backup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$RestoreBackup$backup<TRes> get backup =>
      CopyWith$Mutation$RestoreBackup$backup.stub(_res);
}

const documentNodeMutationRestoreBackup = DocumentNode(definitions: [
  OperationDefinitionNode(
    type: OperationType.mutation,
    name: NameNode(value: 'RestoreBackup'),
    variableDefinitions: [
      VariableDefinitionNode(
        variable: VariableNode(name: NameNode(value: 'snapshotId')),
        type: NamedTypeNode(
          name: NameNode(value: 'String'),
          isNonNull: true,
        ),
        defaultValue: DefaultValueNode(value: null),
        directives: [],
      ),
      VariableDefinitionNode(
        variable: VariableNode(name: NameNode(value: 'strategy')),
        type: NamedTypeNode(
          name: NameNode(value: 'RestoreStrategy'),
          isNonNull: true,
        ),
        defaultValue: DefaultValueNode(
            value: EnumValueNode(
                name: NameNode(value: 'DOWNLOAD_VERIFY_OVERWRITE'))),
        directives: [],
      ),
    ],
    directives: [],
    selectionSet: SelectionSetNode(selections: [
      FieldNode(
        name: NameNode(value: 'backup'),
        alias: null,
        arguments: [],
        directives: [],
        selectionSet: SelectionSetNode(selections: [
          FieldNode(
            name: NameNode(value: 'restoreBackup'),
            alias: null,
            arguments: [
              ArgumentNode(
                name: NameNode(value: 'snapshotId'),
                value: VariableNode(name: NameNode(value: 'snapshotId')),
              ),
              ArgumentNode(
                name: NameNode(value: 'strategy'),
                value: VariableNode(name: NameNode(value: 'strategy')),
              ),
            ],
            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$RestoreBackup _parserFn$Mutation$RestoreBackup(
        Map<String, dynamic> data) =>
    Mutation$RestoreBackup.fromJson(data);
typedef OnMutationCompleted$Mutation$RestoreBackup = FutureOr<void> Function(
  Map<String, dynamic>?,
  Mutation$RestoreBackup?,
);

class Options$Mutation$RestoreBackup
    extends graphql.MutationOptions<Mutation$RestoreBackup> {
  Options$Mutation$RestoreBackup({
    String? operationName,
    required Variables$Mutation$RestoreBackup variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$RestoreBackup? typedOptimisticResult,
    graphql.Context? context,
    OnMutationCompleted$Mutation$RestoreBackup? onCompleted,
    graphql.OnMutationUpdate<Mutation$RestoreBackup>? 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$RestoreBackup(data),
                  ),
          update: update,
          onError: onError,
          document: documentNodeMutationRestoreBackup,
          parserFn: _parserFn$Mutation$RestoreBackup,
        );

  final OnMutationCompleted$Mutation$RestoreBackup? onCompletedWithParsed;

  @override
  List<Object?> get properties => [
        ...super.onCompleted == null
            ? super.properties
            : super.properties.where((property) => property != onCompleted),
        onCompletedWithParsed,
      ];
}

class WatchOptions$Mutation$RestoreBackup
    extends graphql.WatchQueryOptions<Mutation$RestoreBackup> {
  WatchOptions$Mutation$RestoreBackup({
    String? operationName,
    required Variables$Mutation$RestoreBackup variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$RestoreBackup? 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: documentNodeMutationRestoreBackup,
          pollInterval: pollInterval,
          eagerlyFetchResults: eagerlyFetchResults,
          carryForwardDataOnException: carryForwardDataOnException,
          fetchResults: fetchResults,
          parserFn: _parserFn$Mutation$RestoreBackup,
        );
}

extension ClientExtension$Mutation$RestoreBackup on graphql.GraphQLClient {
  Future<graphql.QueryResult<Mutation$RestoreBackup>> mutate$RestoreBackup(
          Options$Mutation$RestoreBackup options) async =>
      await this.mutate(options);
  graphql.ObservableQuery<Mutation$RestoreBackup> watchMutation$RestoreBackup(
          WatchOptions$Mutation$RestoreBackup options) =>
      this.watchMutation(options);
}

class Mutation$RestoreBackup$backup {
  Mutation$RestoreBackup$backup({
    required this.restoreBackup,
    this.$__typename = 'BackupMutations',
  });

  factory Mutation$RestoreBackup$backup.fromJson(Map<String, dynamic> json) {
    final l$restoreBackup = json['restoreBackup'];
    final l$$__typename = json['__typename'];
    return Mutation$RestoreBackup$backup(
      restoreBackup: Mutation$RestoreBackup$backup$restoreBackup.fromJson(
          (l$restoreBackup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$RestoreBackup$backup$restoreBackup restoreBackup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$restoreBackup = restoreBackup;
    _resultData['restoreBackup'] = l$restoreBackup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$restoreBackup = restoreBackup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$restoreBackup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$RestoreBackup$backup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$restoreBackup = restoreBackup;
    final lOther$restoreBackup = other.restoreBackup;
    if (l$restoreBackup != lOther$restoreBackup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$RestoreBackup$backup
    on Mutation$RestoreBackup$backup {
  CopyWith$Mutation$RestoreBackup$backup<Mutation$RestoreBackup$backup>
      get copyWith => CopyWith$Mutation$RestoreBackup$backup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$RestoreBackup$backup<TRes> {
  factory CopyWith$Mutation$RestoreBackup$backup(
    Mutation$RestoreBackup$backup instance,
    TRes Function(Mutation$RestoreBackup$backup) then,
  ) = _CopyWithImpl$Mutation$RestoreBackup$backup;

  factory CopyWith$Mutation$RestoreBackup$backup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$RestoreBackup$backup;

  TRes call({
    Mutation$RestoreBackup$backup$restoreBackup? restoreBackup,
    String? $__typename,
  });
  CopyWith$Mutation$RestoreBackup$backup$restoreBackup<TRes> get restoreBackup;
}

class _CopyWithImpl$Mutation$RestoreBackup$backup<TRes>
    implements CopyWith$Mutation$RestoreBackup$backup<TRes> {
  _CopyWithImpl$Mutation$RestoreBackup$backup(
    this._instance,
    this._then,
  );

  final Mutation$RestoreBackup$backup _instance;

  final TRes Function(Mutation$RestoreBackup$backup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? restoreBackup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$RestoreBackup$backup(
        restoreBackup: restoreBackup == _undefined || restoreBackup == null
            ? _instance.restoreBackup
            : (restoreBackup as Mutation$RestoreBackup$backup$restoreBackup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$RestoreBackup$backup$restoreBackup<TRes> get restoreBackup {
    final local$restoreBackup = _instance.restoreBackup;
    return CopyWith$Mutation$RestoreBackup$backup$restoreBackup(
        local$restoreBackup, (e) => call(restoreBackup: e));
  }
}

class _CopyWithStubImpl$Mutation$RestoreBackup$backup<TRes>
    implements CopyWith$Mutation$RestoreBackup$backup<TRes> {
  _CopyWithStubImpl$Mutation$RestoreBackup$backup(this._res);

  TRes _res;

  call({
    Mutation$RestoreBackup$backup$restoreBackup? restoreBackup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$RestoreBackup$backup$restoreBackup<TRes>
      get restoreBackup =>
          CopyWith$Mutation$RestoreBackup$backup$restoreBackup.stub(_res);
}

class Mutation$RestoreBackup$backup$restoreBackup
    implements Fragment$basicMutationReturnFields$$GenericJobMutationReturn {
  Mutation$RestoreBackup$backup$restoreBackup({
    required this.code,
    required this.message,
    required this.success,
    this.$__typename = 'GenericJobMutationReturn',
    this.job,
  });

  factory Mutation$RestoreBackup$backup$restoreBackup.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$RestoreBackup$backup$restoreBackup(
      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$RestoreBackup$backup$restoreBackup) ||
        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$RestoreBackup$backup$restoreBackup
    on Mutation$RestoreBackup$backup$restoreBackup {
  CopyWith$Mutation$RestoreBackup$backup$restoreBackup<
          Mutation$RestoreBackup$backup$restoreBackup>
      get copyWith => CopyWith$Mutation$RestoreBackup$backup$restoreBackup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$RestoreBackup$backup$restoreBackup<TRes> {
  factory CopyWith$Mutation$RestoreBackup$backup$restoreBackup(
    Mutation$RestoreBackup$backup$restoreBackup instance,
    TRes Function(Mutation$RestoreBackup$backup$restoreBackup) then,
  ) = _CopyWithImpl$Mutation$RestoreBackup$backup$restoreBackup;

  factory CopyWith$Mutation$RestoreBackup$backup$restoreBackup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$RestoreBackup$backup$restoreBackup;

  TRes call({
    int? code,
    String? message,
    bool? success,
    String? $__typename,
    Fragment$basicApiJobsFields? job,
  });
  CopyWith$Fragment$basicApiJobsFields<TRes> get job;
}

class _CopyWithImpl$Mutation$RestoreBackup$backup$restoreBackup<TRes>
    implements CopyWith$Mutation$RestoreBackup$backup$restoreBackup<TRes> {
  _CopyWithImpl$Mutation$RestoreBackup$backup$restoreBackup(
    this._instance,
    this._then,
  );

  final Mutation$RestoreBackup$backup$restoreBackup _instance;

  final TRes Function(Mutation$RestoreBackup$backup$restoreBackup) _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$RestoreBackup$backup$restoreBackup(
        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$RestoreBackup$backup$restoreBackup<TRes>
    implements CopyWith$Mutation$RestoreBackup$backup$restoreBackup<TRes> {
  _CopyWithStubImpl$Mutation$RestoreBackup$backup$restoreBackup(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);
}

class Variables$Mutation$ForgetSnapshot {
  factory Variables$Mutation$ForgetSnapshot({required String snapshotId}) =>
      Variables$Mutation$ForgetSnapshot._({
        r'snapshotId': snapshotId,
      });

  Variables$Mutation$ForgetSnapshot._(this._$data);

  factory Variables$Mutation$ForgetSnapshot.fromJson(
      Map<String, dynamic> data) {
    final result$data = <String, dynamic>{};
    final l$snapshotId = data['snapshotId'];
    result$data['snapshotId'] = (l$snapshotId as String);
    return Variables$Mutation$ForgetSnapshot._(result$data);
  }

  Map<String, dynamic> _$data;

  String get snapshotId => (_$data['snapshotId'] as String);
  Map<String, dynamic> toJson() {
    final result$data = <String, dynamic>{};
    final l$snapshotId = snapshotId;
    result$data['snapshotId'] = l$snapshotId;
    return result$data;
  }

  CopyWith$Variables$Mutation$ForgetSnapshot<Variables$Mutation$ForgetSnapshot>
      get copyWith => CopyWith$Variables$Mutation$ForgetSnapshot(
            this,
            (i) => i,
          );
  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Variables$Mutation$ForgetSnapshot) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$snapshotId = snapshotId;
    final lOther$snapshotId = other.snapshotId;
    if (l$snapshotId != lOther$snapshotId) {
      return false;
    }
    return true;
  }

  @override
  int get hashCode {
    final l$snapshotId = snapshotId;
    return Object.hashAll([l$snapshotId]);
  }
}

abstract class CopyWith$Variables$Mutation$ForgetSnapshot<TRes> {
  factory CopyWith$Variables$Mutation$ForgetSnapshot(
    Variables$Mutation$ForgetSnapshot instance,
    TRes Function(Variables$Mutation$ForgetSnapshot) then,
  ) = _CopyWithImpl$Variables$Mutation$ForgetSnapshot;

  factory CopyWith$Variables$Mutation$ForgetSnapshot.stub(TRes res) =
      _CopyWithStubImpl$Variables$Mutation$ForgetSnapshot;

  TRes call({String? snapshotId});
}

class _CopyWithImpl$Variables$Mutation$ForgetSnapshot<TRes>
    implements CopyWith$Variables$Mutation$ForgetSnapshot<TRes> {
  _CopyWithImpl$Variables$Mutation$ForgetSnapshot(
    this._instance,
    this._then,
  );

  final Variables$Mutation$ForgetSnapshot _instance;

  final TRes Function(Variables$Mutation$ForgetSnapshot) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({Object? snapshotId = _undefined}) =>
      _then(Variables$Mutation$ForgetSnapshot._({
        ..._instance._$data,
        if (snapshotId != _undefined && snapshotId != null)
          'snapshotId': (snapshotId as String),
      }));
}

class _CopyWithStubImpl$Variables$Mutation$ForgetSnapshot<TRes>
    implements CopyWith$Variables$Mutation$ForgetSnapshot<TRes> {
  _CopyWithStubImpl$Variables$Mutation$ForgetSnapshot(this._res);

  TRes _res;

  call({String? snapshotId}) => _res;
}

class Mutation$ForgetSnapshot {
  Mutation$ForgetSnapshot({
    required this.backup,
    this.$__typename = 'Mutation',
  });

  factory Mutation$ForgetSnapshot.fromJson(Map<String, dynamic> json) {
    final l$backup = json['backup'];
    final l$$__typename = json['__typename'];
    return Mutation$ForgetSnapshot(
      backup: Mutation$ForgetSnapshot$backup.fromJson(
          (l$backup as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$ForgetSnapshot$backup backup;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$backup = backup;
    _resultData['backup'] = l$backup.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$backup = backup;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$backup,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$ForgetSnapshot) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$backup = backup;
    final lOther$backup = other.backup;
    if (l$backup != lOther$backup) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$ForgetSnapshot on Mutation$ForgetSnapshot {
  CopyWith$Mutation$ForgetSnapshot<Mutation$ForgetSnapshot> get copyWith =>
      CopyWith$Mutation$ForgetSnapshot(
        this,
        (i) => i,
      );
}

abstract class CopyWith$Mutation$ForgetSnapshot<TRes> {
  factory CopyWith$Mutation$ForgetSnapshot(
    Mutation$ForgetSnapshot instance,
    TRes Function(Mutation$ForgetSnapshot) then,
  ) = _CopyWithImpl$Mutation$ForgetSnapshot;

  factory CopyWith$Mutation$ForgetSnapshot.stub(TRes res) =
      _CopyWithStubImpl$Mutation$ForgetSnapshot;

  TRes call({
    Mutation$ForgetSnapshot$backup? backup,
    String? $__typename,
  });
  CopyWith$Mutation$ForgetSnapshot$backup<TRes> get backup;
}

class _CopyWithImpl$Mutation$ForgetSnapshot<TRes>
    implements CopyWith$Mutation$ForgetSnapshot<TRes> {
  _CopyWithImpl$Mutation$ForgetSnapshot(
    this._instance,
    this._then,
  );

  final Mutation$ForgetSnapshot _instance;

  final TRes Function(Mutation$ForgetSnapshot) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? backup = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$ForgetSnapshot(
        backup: backup == _undefined || backup == null
            ? _instance.backup
            : (backup as Mutation$ForgetSnapshot$backup),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$ForgetSnapshot$backup<TRes> get backup {
    final local$backup = _instance.backup;
    return CopyWith$Mutation$ForgetSnapshot$backup(
        local$backup, (e) => call(backup: e));
  }
}

class _CopyWithStubImpl$Mutation$ForgetSnapshot<TRes>
    implements CopyWith$Mutation$ForgetSnapshot<TRes> {
  _CopyWithStubImpl$Mutation$ForgetSnapshot(this._res);

  TRes _res;

  call({
    Mutation$ForgetSnapshot$backup? backup,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$ForgetSnapshot$backup<TRes> get backup =>
      CopyWith$Mutation$ForgetSnapshot$backup.stub(_res);
}

const documentNodeMutationForgetSnapshot = DocumentNode(definitions: [
  OperationDefinitionNode(
    type: OperationType.mutation,
    name: NameNode(value: 'ForgetSnapshot'),
    variableDefinitions: [
      VariableDefinitionNode(
        variable: VariableNode(name: NameNode(value: 'snapshotId')),
        type: NamedTypeNode(
          name: NameNode(value: 'String'),
          isNonNull: true,
        ),
        defaultValue: DefaultValueNode(value: null),
        directives: [],
      )
    ],
    directives: [],
    selectionSet: SelectionSetNode(selections: [
      FieldNode(
        name: NameNode(value: 'backup'),
        alias: null,
        arguments: [],
        directives: [],
        selectionSet: SelectionSetNode(selections: [
          FieldNode(
            name: NameNode(value: 'forgetSnapshot'),
            alias: null,
            arguments: [
              ArgumentNode(
                name: NameNode(value: 'snapshotId'),
                value: VariableNode(name: NameNode(value: 'snapshotId')),
              )
            ],
            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$ForgetSnapshot _parserFn$Mutation$ForgetSnapshot(
        Map<String, dynamic> data) =>
    Mutation$ForgetSnapshot.fromJson(data);
typedef OnMutationCompleted$Mutation$ForgetSnapshot = FutureOr<void> Function(
  Map<String, dynamic>?,
  Mutation$ForgetSnapshot?,
);

class Options$Mutation$ForgetSnapshot
    extends graphql.MutationOptions<Mutation$ForgetSnapshot> {
  Options$Mutation$ForgetSnapshot({
    String? operationName,
    required Variables$Mutation$ForgetSnapshot variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$ForgetSnapshot? typedOptimisticResult,
    graphql.Context? context,
    OnMutationCompleted$Mutation$ForgetSnapshot? onCompleted,
    graphql.OnMutationUpdate<Mutation$ForgetSnapshot>? 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$ForgetSnapshot(data),
                  ),
          update: update,
          onError: onError,
          document: documentNodeMutationForgetSnapshot,
          parserFn: _parserFn$Mutation$ForgetSnapshot,
        );

  final OnMutationCompleted$Mutation$ForgetSnapshot? onCompletedWithParsed;

  @override
  List<Object?> get properties => [
        ...super.onCompleted == null
            ? super.properties
            : super.properties.where((property) => property != onCompleted),
        onCompletedWithParsed,
      ];
}

class WatchOptions$Mutation$ForgetSnapshot
    extends graphql.WatchQueryOptions<Mutation$ForgetSnapshot> {
  WatchOptions$Mutation$ForgetSnapshot({
    String? operationName,
    required Variables$Mutation$ForgetSnapshot variables,
    graphql.FetchPolicy? fetchPolicy,
    graphql.ErrorPolicy? errorPolicy,
    graphql.CacheRereadPolicy? cacheRereadPolicy,
    Object? optimisticResult,
    Mutation$ForgetSnapshot? 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: documentNodeMutationForgetSnapshot,
          pollInterval: pollInterval,
          eagerlyFetchResults: eagerlyFetchResults,
          carryForwardDataOnException: carryForwardDataOnException,
          fetchResults: fetchResults,
          parserFn: _parserFn$Mutation$ForgetSnapshot,
        );
}

extension ClientExtension$Mutation$ForgetSnapshot on graphql.GraphQLClient {
  Future<graphql.QueryResult<Mutation$ForgetSnapshot>> mutate$ForgetSnapshot(
          Options$Mutation$ForgetSnapshot options) async =>
      await this.mutate(options);
  graphql.ObservableQuery<Mutation$ForgetSnapshot> watchMutation$ForgetSnapshot(
          WatchOptions$Mutation$ForgetSnapshot options) =>
      this.watchMutation(options);
}

class Mutation$ForgetSnapshot$backup {
  Mutation$ForgetSnapshot$backup({
    required this.forgetSnapshot,
    this.$__typename = 'BackupMutations',
  });

  factory Mutation$ForgetSnapshot$backup.fromJson(Map<String, dynamic> json) {
    final l$forgetSnapshot = json['forgetSnapshot'];
    final l$$__typename = json['__typename'];
    return Mutation$ForgetSnapshot$backup(
      forgetSnapshot: Mutation$ForgetSnapshot$backup$forgetSnapshot.fromJson(
          (l$forgetSnapshot as Map<String, dynamic>)),
      $__typename: (l$$__typename as String),
    );
  }

  final Mutation$ForgetSnapshot$backup$forgetSnapshot forgetSnapshot;

  final String $__typename;

  Map<String, dynamic> toJson() {
    final _resultData = <String, dynamic>{};
    final l$forgetSnapshot = forgetSnapshot;
    _resultData['forgetSnapshot'] = l$forgetSnapshot.toJson();
    final l$$__typename = $__typename;
    _resultData['__typename'] = l$$__typename;
    return _resultData;
  }

  @override
  int get hashCode {
    final l$forgetSnapshot = forgetSnapshot;
    final l$$__typename = $__typename;
    return Object.hashAll([
      l$forgetSnapshot,
      l$$__typename,
    ]);
  }

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) {
      return true;
    }
    if (!(other is Mutation$ForgetSnapshot$backup) ||
        runtimeType != other.runtimeType) {
      return false;
    }
    final l$forgetSnapshot = forgetSnapshot;
    final lOther$forgetSnapshot = other.forgetSnapshot;
    if (l$forgetSnapshot != lOther$forgetSnapshot) {
      return false;
    }
    final l$$__typename = $__typename;
    final lOther$$__typename = other.$__typename;
    if (l$$__typename != lOther$$__typename) {
      return false;
    }
    return true;
  }
}

extension UtilityExtension$Mutation$ForgetSnapshot$backup
    on Mutation$ForgetSnapshot$backup {
  CopyWith$Mutation$ForgetSnapshot$backup<Mutation$ForgetSnapshot$backup>
      get copyWith => CopyWith$Mutation$ForgetSnapshot$backup(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$ForgetSnapshot$backup<TRes> {
  factory CopyWith$Mutation$ForgetSnapshot$backup(
    Mutation$ForgetSnapshot$backup instance,
    TRes Function(Mutation$ForgetSnapshot$backup) then,
  ) = _CopyWithImpl$Mutation$ForgetSnapshot$backup;

  factory CopyWith$Mutation$ForgetSnapshot$backup.stub(TRes res) =
      _CopyWithStubImpl$Mutation$ForgetSnapshot$backup;

  TRes call({
    Mutation$ForgetSnapshot$backup$forgetSnapshot? forgetSnapshot,
    String? $__typename,
  });
  CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot<TRes>
      get forgetSnapshot;
}

class _CopyWithImpl$Mutation$ForgetSnapshot$backup<TRes>
    implements CopyWith$Mutation$ForgetSnapshot$backup<TRes> {
  _CopyWithImpl$Mutation$ForgetSnapshot$backup(
    this._instance,
    this._then,
  );

  final Mutation$ForgetSnapshot$backup _instance;

  final TRes Function(Mutation$ForgetSnapshot$backup) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? forgetSnapshot = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$ForgetSnapshot$backup(
        forgetSnapshot: forgetSnapshot == _undefined || forgetSnapshot == null
            ? _instance.forgetSnapshot
            : (forgetSnapshot as Mutation$ForgetSnapshot$backup$forgetSnapshot),
        $__typename: $__typename == _undefined || $__typename == null
            ? _instance.$__typename
            : ($__typename as String),
      ));
  CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot<TRes>
      get forgetSnapshot {
    final local$forgetSnapshot = _instance.forgetSnapshot;
    return CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot(
        local$forgetSnapshot, (e) => call(forgetSnapshot: e));
  }
}

class _CopyWithStubImpl$Mutation$ForgetSnapshot$backup<TRes>
    implements CopyWith$Mutation$ForgetSnapshot$backup<TRes> {
  _CopyWithStubImpl$Mutation$ForgetSnapshot$backup(this._res);

  TRes _res;

  call({
    Mutation$ForgetSnapshot$backup$forgetSnapshot? forgetSnapshot,
    String? $__typename,
  }) =>
      _res;
  CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot<TRes>
      get forgetSnapshot =>
          CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot.stub(_res);
}

class Mutation$ForgetSnapshot$backup$forgetSnapshot
    implements Fragment$basicMutationReturnFields$$GenericMutationReturn {
  Mutation$ForgetSnapshot$backup$forgetSnapshot({
    required this.code,
    required this.message,
    required this.success,
    this.$__typename = 'GenericMutationReturn',
  });

  factory Mutation$ForgetSnapshot$backup$forgetSnapshot.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$ForgetSnapshot$backup$forgetSnapshot(
      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$ForgetSnapshot$backup$forgetSnapshot) ||
        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$ForgetSnapshot$backup$forgetSnapshot
    on Mutation$ForgetSnapshot$backup$forgetSnapshot {
  CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot<
          Mutation$ForgetSnapshot$backup$forgetSnapshot>
      get copyWith => CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot(
            this,
            (i) => i,
          );
}

abstract class CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot<TRes> {
  factory CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot(
    Mutation$ForgetSnapshot$backup$forgetSnapshot instance,
    TRes Function(Mutation$ForgetSnapshot$backup$forgetSnapshot) then,
  ) = _CopyWithImpl$Mutation$ForgetSnapshot$backup$forgetSnapshot;

  factory CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot.stub(
          TRes res) =
      _CopyWithStubImpl$Mutation$ForgetSnapshot$backup$forgetSnapshot;

  TRes call({
    int? code,
    String? message,
    bool? success,
    String? $__typename,
  });
}

class _CopyWithImpl$Mutation$ForgetSnapshot$backup$forgetSnapshot<TRes>
    implements CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot<TRes> {
  _CopyWithImpl$Mutation$ForgetSnapshot$backup$forgetSnapshot(
    this._instance,
    this._then,
  );

  final Mutation$ForgetSnapshot$backup$forgetSnapshot _instance;

  final TRes Function(Mutation$ForgetSnapshot$backup$forgetSnapshot) _then;

  static const _undefined = <dynamic, dynamic>{};

  TRes call({
    Object? code = _undefined,
    Object? message = _undefined,
    Object? success = _undefined,
    Object? $__typename = _undefined,
  }) =>
      _then(Mutation$ForgetSnapshot$backup$forgetSnapshot(
        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$ForgetSnapshot$backup$forgetSnapshot<TRes>
    implements CopyWith$Mutation$ForgetSnapshot$backup$forgetSnapshot<TRes> {
  _CopyWithStubImpl$Mutation$ForgetSnapshot$backup$forgetSnapshot(this._res);

  TRes _res;

  call({
    int? code,
    String? message,
    bool? success,
    String? $__typename,
  }) =>
      _res;
}