build_config/lib/src/builder_definition.g.dart

// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'builder_definition.dart';

// **************************************************************************
// JsonSerializableGenerator
// **************************************************************************

BuilderDefinition _$BuilderDefinitionFromJson(Map json) {
  return $checkedNew('BuilderDefinition', json, () {
    $checkKeys(json, allowedKeys: const [
      'builder_factories',
      'import',
      'build_extensions',
      'target',
      'auto_apply',
      'required_inputs',
      'runs_before',
      'applies_builders',
      'is_optional',
      'build_to',
      'defaults'
    ], requiredKeys: const [
      'builder_factories',
      'import',
      'build_extensions'
    ], disallowNullValues: const [
      'builder_factories',
      'import',
      'build_extensions'
    ]);
    final val = BuilderDefinition(
        builderFactories: $checkedConvert(json, 'builder_factories',
            (v) => (v as List).map((e) => e as String).toList()),
        buildExtensions: $checkedConvert(
            json,
            'build_extensions',
            (v) => (v as Map).map((k, e) => MapEntry(
                k as String, (e as List).map((e) => e as String).toList()))),
        import: $checkedConvert(json, 'import', (v) => v as String),
        target: $checkedConvert(json, 'target', (v) => v as String),
        autoApply: $checkedConvert(json, 'auto_apply',
            (v) => _$enumDecodeNullable(_$AutoApplyEnumMap, v)),
        requiredInputs: $checkedConvert(json, 'required_inputs',
            (v) => (v as List)?.map((e) => e as String)),
        runsBefore: $checkedConvert(
            json, 'runs_before', (v) => (v as List)?.map((e) => e as String)),
        appliesBuilders: $checkedConvert(json, 'applies_builders',
            (v) => (v as List)?.map((e) => e as String)),
        isOptional: $checkedConvert(json, 'is_optional', (v) => v as bool),
        buildTo: $checkedConvert(
            json, 'build_to', (v) => _$enumDecodeNullable(_$BuildToEnumMap, v)),
        defaults: $checkedConvert(
            json,
            'defaults',
            (v) => v == null
                ? null
                : TargetBuilderConfigDefaults.fromJson(v as Map)));
    return val;
  }, fieldKeyMap: const {
    'builderFactories': 'builder_factories',
    'buildExtensions': 'build_extensions',
    'autoApply': 'auto_apply',
    'requiredInputs': 'required_inputs',
    'runsBefore': 'runs_before',
    'appliesBuilders': 'applies_builders',
    'isOptional': 'is_optional',
    'buildTo': 'build_to'
  });
}

T _$enumDecode<T>(Map<T, dynamic> enumValues, dynamic source) {
  if (source == null) {
    throw ArgumentError('A value must be provided. Supported values: '
        '${enumValues.values.join(', ')}');
  }
  return enumValues.entries
      .singleWhere((e) => e.value == source,
          orElse: () => throw ArgumentError(
              '`$source` is not one of the supported values: '
              '${enumValues.values.join(', ')}'))
      .key;
}

T _$enumDecodeNullable<T>(Map<T, dynamic> enumValues, dynamic source) {
  if (source == null) {
    return null;
  }
  return _$enumDecode<T>(enumValues, source);
}

const _$AutoApplyEnumMap = <AutoApply, dynamic>{
  AutoApply.none: 'none',
  AutoApply.dependents: 'dependents',
  AutoApply.allPackages: 'all_packages',
  AutoApply.rootPackage: 'root_package'
};

const _$BuildToEnumMap = <BuildTo, dynamic>{
  BuildTo.source: 'source',
  BuildTo.cache: 'cache'
};

PostProcessBuilderDefinition _$PostProcessBuilderDefinitionFromJson(Map json) {
  return $checkedNew('PostProcessBuilderDefinition', json, () {
    $checkKeys(json, allowedKeys: const [
      'builder_factory',
      'import',
      'input_extensions',
      'target',
      'defaults'
    ], requiredKeys: const [
      'builder_factory',
      'import'
    ], disallowNullValues: const [
      'builder_factory',
      'import'
    ]);
    final val = PostProcessBuilderDefinition(
        builderFactory:
            $checkedConvert(json, 'builder_factory', (v) => v as String),
        import: $checkedConvert(json, 'import', (v) => v as String),
        inputExtensions: $checkedConvert(json, 'input_extensions',
            (v) => (v as List)?.map((e) => e as String)),
        target: $checkedConvert(json, 'target', (v) => v as String),
        defaults: $checkedConvert(
            json,
            'defaults',
            (v) => v == null
                ? null
                : TargetBuilderConfigDefaults.fromJson(v as Map)));
    return val;
  }, fieldKeyMap: const {
    'builderFactory': 'builder_factory',
    'inputExtensions': 'input_extensions'
  });
}

TargetBuilderConfigDefaults _$TargetBuilderConfigDefaultsFromJson(Map json) {
  return $checkedNew('TargetBuilderConfigDefaults', json, () {
    $checkKeys(json, allowedKeys: const [
      'generate_for',
      'options',
      'dev_options',
      'release_options'
    ]);
    final val = TargetBuilderConfigDefaults(
        generateFor: $checkedConvert(json, 'generate_for',
            (v) => v == null ? null : InputSet.fromJson(v)),
        options: $checkedConvert(json, 'options',
            (v) => (v as Map)?.map((k, e) => MapEntry(k as String, e))),
        devOptions: $checkedConvert(json, 'dev_options',
            (v) => (v as Map)?.map((k, e) => MapEntry(k as String, e))),
        releaseOptions: $checkedConvert(json, 'release_options',
            (v) => (v as Map)?.map((k, e) => MapEntry(k as String, e))));
    return val;
  }, fieldKeyMap: const {
    'generateFor': 'generate_for',
    'devOptions': 'dev_options',
    'releaseOptions': 'release_options'
  });
}