content: // coverage:ignore-file
  // GENERATED CODE - DO NOT MODIFY BY HAND
  // dart format off
  // ignore_for_file: type=lint
  // ignore_for_file: unused_element, unnecessary_cast, override_on_non_overriding_member
  // ignore_for_file: strict_raw_type, inference_failure_on_untyped_parameter
  
  part of 'project.dart';
  
  class ProjectDataBaseMapper extends ClassMapperBase<ProjectDataBase> {
    ProjectDataBaseMapper._();
  
    static ProjectDataBaseMapper? _instance;
    static ProjectDataBaseMapper ensureInitialized() {
      if (_instance == null) {
        MapperContainer.globals.use(_instance = ProjectDataBaseMapper._());
        TutorialDataMapper.ensureInitialized();
        TutorialStepMapper.ensureInitialized();
        ProjectDataMapper.ensureInitialized();
      }
      return _instance!;
    }
  
    @override
    final String id = 'ProjectDataBase';
  
    @override
    final MappableFields<ProjectDataBase> fields = const {};
  
    static ProjectDataBase _instantiate(DecodingData data) {
      throw MapperException.missingSubclass(
        'ProjectDataBase',
        'type',
        '${data.value['type']}',
      );
    }
  
    @override
    final Function instantiate = _instantiate;
  
    static ProjectDataBase fromMap(Map<String, dynamic> map) {
      return ensureInitialized().decodeMap<ProjectDataBase>(map);
    }
  
    static ProjectDataBase fromJson(String json) {
      return ensureInitialized().decodeJson<ProjectDataBase>(json);
    }
  }
  
  mixin ProjectDataBaseMappable {}
  
  class ProjectDataMapper extends SubClassMapperBase<ProjectData> {
    ProjectDataMapper._();
  
    static ProjectDataMapper? _instance;
    static ProjectDataMapper ensureInitialized() {
      if (_instance == null) {
        MapperContainer.globals.use(_instance = ProjectDataMapper._());
        ProjectDataBaseMapper.ensureInitialized().addSubMapper(_instance!);
      }
      return _instance!;
    }
  
    @override
    final String id = 'ProjectData';
  
    static String? _$id(ProjectData v) => v.id;
    static const Field<ProjectData, String> _f$id = Field('id', _$id, opt: true);
    static String? _$description(ProjectData v) => v.description;
    static const Field<ProjectData, String> _f$description = Field(
      'description',
      _$description,
      opt: true,
    );
    static String? _$htmlFile(ProjectData v) => v.htmlFile;
    static const Field<ProjectData, String> _f$htmlFile = Field(
      'htmlFile',
      _$htmlFile,
      opt: true,
    );
    static String? _$cssFile(ProjectData v) => v.cssFile;
    static const Field<ProjectData, String> _f$cssFile = Field(
      'cssFile',
      _$cssFile,
      opt: true,
    );
    static String _$mainDartFile(ProjectData v) => v.mainDartFile;
    static const Field<ProjectData, String> _f$mainDartFile = Field(
      'mainDartFile',
      _$mainDartFile,
    );
    static Map<String, String> _$dartFiles(ProjectData v) => v.dartFiles;
    static const Field<ProjectData, Map<String, String>> _f$dartFiles = Field(
      'dartFiles',
      _$dartFiles,
      opt: true,
      def: const {},
    );
  
    @override
    final MappableFields<ProjectData> fields = const {
      #id: _f$id,
      #description: _f$description,
      #htmlFile: _f$htmlFile,
      #cssFile: _f$cssFile,
      #mainDartFile: _f$mainDartFile,
      #dartFiles: _f$dartFiles,
    };
  
    @override
    final String discriminatorKey = 'type';
    @override
    final dynamic discriminatorValue = 'ProjectData';
    @override
    late final ClassMapperBase superMapper =
        ProjectDataBaseMapper.ensureInitialized();
  
    static ProjectData _instantiate(DecodingData data) {
      return ProjectData(
        id: data.dec(_f$id),
        description: data.dec(_f$description),
        htmlFile: data.dec(_f$htmlFile),
        cssFile: data.dec(_f$cssFile),
        mainDartFile: data.dec(_f$mainDartFile),
        dartFiles: data.dec(_f$dartFiles),
      );
    }
  
    @override
    final Function instantiate = _instantiate;
  
    static ProjectData fromMap(Map<String, dynamic> map) {
      return ensureInitialized().decodeMap<ProjectData>(map);
    }
  
    static ProjectData fromJson(String json) {
      return ensureInitialized().decodeJson<ProjectData>(json);
    }
  }
  
  mixin ProjectDataMappable {
    String toJson() {
      return ProjectDataMapper.ensureInitialized().encodeJson<ProjectData>(
        this as ProjectData,
      );
    }
  
    Map<String, dynamic> toMap() {
      return ProjectDataMapper.ensureInitialized().encodeMap<ProjectData>(
        this as ProjectData,
      );
    }
  
    ProjectDataCopyWith<ProjectData, ProjectData, ProjectData> get copyWith =>
        _ProjectDataCopyWithImpl<ProjectData, ProjectData>(
          this as ProjectData,
          $identity,
          $identity,
        );
    @override
    String toString() {
      return ProjectDataMapper.ensureInitialized().stringifyValue(
        this as ProjectData,
      );
    }
  
    @override
    bool operator ==(Object other) {
      return ProjectDataMapper.ensureInitialized().equalsValue(
        this as ProjectData,
        other,
      );
    }
  
    @override
    int get hashCode {
      return ProjectDataMapper.ensureInitialized().hashValue(this as ProjectData);
    }
  }
  
  extension ProjectDataValueCopy<$R, $Out>
      on ObjectCopyWith<$R, ProjectData, $Out> {
    ProjectDataCopyWith<$R, ProjectData, $Out> get $asProjectData =>
        $base.as((v, t, t2) => _ProjectDataCopyWithImpl<$R, $Out>(v, t, t2));
  }
  
  abstract class ProjectDataCopyWith<$R, $In extends ProjectData, $Out>
      implements ClassCopyWith<$R, $In, $Out> {
    MapCopyWith<$R, String, String, ObjectCopyWith<$R, String, String>>
    get dartFiles;
    $R call({
      String? id,
      String? description,
      String? htmlFile,
      String? cssFile,
      String? mainDartFile,
      Map<String, String>? dartFiles,
    });
    ProjectDataCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(Then<$Out2, $R2> t);
  }
  
  class _ProjectDataCopyWithImpl<$R, $Out>
      extends ClassCopyWithBase<$R, ProjectData, $Out>
      implements ProjectDataCopyWith<$R, ProjectData, $Out> {
    _ProjectDataCopyWithImpl(super.value, super.then, super.then2);
  
    @override
    late final ClassMapperBase<ProjectData> $mapper =
        ProjectDataMapper.ensureInitialized();
    @override
    MapCopyWith<$R, String, String, ObjectCopyWith<$R, String, String>>
    get dartFiles => MapCopyWith(
      $value.dartFiles,
      (v, t) => ObjectCopyWith(v, $identity, t),
      (v) => call(dartFiles: v),
    );
    @override
    $R call({
      Object? id = $none,
      Object? description = $none,
      Object? htmlFile = $none,
      Object? cssFile = $none,
      String? mainDartFile,
      Map<String, String>? dartFiles,
    }) => $apply(
      FieldCopyWithData({
        if (id != $none) #id: id,
        if (description != $none) #description: description,
        if (htmlFile != $none) #htmlFile: htmlFile,
        if (cssFile != $none) #cssFile: cssFile,
        if (mainDartFile != null) #mainDartFile: mainDartFile,
        if (dartFiles != null) #dartFiles: dartFiles,
      }),
    );
    @override
    ProjectData $make(CopyWithData data) => ProjectData(
      id: data.get(#id, or: $value.id),
      description: data.get(#description, or: $value.description),
      htmlFile: data.get(#htmlFile, or: $value.htmlFile),
      cssFile: data.get(#cssFile, or: $value.cssFile),
      mainDartFile: data.get(#mainDartFile, or: $value.mainDartFile),
      dartFiles: data.get(#dartFiles, or: $value.dartFiles),
    );
  
    @override
    ProjectDataCopyWith<$R2, ProjectData, $Out2> $chain<$R2, $Out2>(
      Then<$Out2, $R2> t,
    ) => _ProjectDataCopyWithImpl<$R2, $Out2>($value, $cast, t);
  }
  
  