//
// AUTO-GENERATED FILE, DO NOT MODIFY!
//
// @dart=2.12

// ignore_for_file: unused_element, unused_import
// ignore_for_file: always_put_required_named_parameters_first
// ignore_for_file: constant_identifier_names
// ignore_for_file: lines_longer_than_80_chars

part of lol;

class WithEnums {
  /// Returns a new [WithEnums] instance.
  WithEnums({
    this.stringEnum = const WithEnumsStringEnumEnum._('strC'),
    this.intEnum = WithEnumsIntEnumEnum.number2,
    this.boolEnum = true,
  });

  WithEnumsStringEnumEnum stringEnum;

  WithEnumsIntEnumEnum intEnum;

  bool boolEnum;

  @override
  bool operator ==(Object other) => identical(this, other) || other is WithEnums && other.stringEnum == stringEnum && other.intEnum == intEnum && other.boolEnum == boolEnum;

  @override
  int get hashCode =>
      // ignore: unnecessary_parenthesis
      (stringEnum.hashCode) + (intEnum.hashCode) + (boolEnum.hashCode);

  @override
  String toString() => 'WithEnums[stringEnum=$stringEnum, intEnum=$intEnum, boolEnum=$boolEnum]';

  Map<String, dynamic> toJson() {
    final json = <String, dynamic>{};
    json[r'stringEnum'] = this.stringEnum;
    json[r'intEnum'] = this.intEnum;
    json[r'boolEnum'] = this.boolEnum;
    return json;
  }

  /// Returns a new [WithEnums] instance and imports its values from
  /// [value] if it's a [Map], null otherwise.
  // ignore: prefer_constructors_over_static_methods
  static WithEnums? fromJson(dynamic value) {
    if (value is Map) {
      final json = value.cast<String, dynamic>();

      // Ensure that the map contains the required keys.
      // Note 1: the values aren't checked for validity beyond being non-null.
      // Note 2: this code is stripped in release mode!
      assert(() {
        requiredKeys.forEach((key) {
          assert(json.containsKey(key), 'Required key "WithEnums[$key]" is missing from JSON.');
          assert(json[key] != null, 'Required key "WithEnums[$key]" has a null value in JSON.');
        });
        return true;
      }());

      return WithEnums(
        stringEnum: WithEnumsStringEnumEnum.fromJson(json[r'stringEnum']) ?? const WithEnumsStringEnumEnum._('strC'),
        intEnum: WithEnumsIntEnumEnum.fromJson(json[r'intEnum']) ?? WithEnumsIntEnumEnum.number2,
        boolEnum: mapValueOfType<bool>(json, r'boolEnum') ?? true,
      );
    }
    return null;
  }

  static List<WithEnums> listFromJson(
    dynamic json, {
    bool growable = false,
  }) {
    final result = <WithEnums>[];
    if (json is List && json.isNotEmpty) {
      for (final row in json) {
        final value = WithEnums.fromJson(row);
        if (value != null) {
          result.add(value);
        }
      }
    }
    return result.toList(growable: growable);
  }

  static Map<String, WithEnums> mapFromJson(dynamic json) {
    final map = <String, WithEnums>{};
    if (json is Map && json.isNotEmpty) {
      json = json.cast<String, dynamic>(); // ignore: parameter_assignments
      for (final entry in json.entries) {
        final value = WithEnums.fromJson(entry.value);
        if (value != null) {
          map[entry.key] = value;
        }
      }
    }
    return map;
  }

  // maps a json object with a list of WithEnums-objects as value to a dart map
  static Map<String, List<WithEnums>> mapListFromJson(
    dynamic json, {
    bool growable = false,
  }) {
    final map = <String, List<WithEnums>>{};
    if (json is Map && json.isNotEmpty) {
      // ignore: parameter_assignments
      json = json.cast<String, dynamic>();
      for (final entry in json.entries) {
        map[entry.key] = WithEnums.listFromJson(
          entry.value,
          growable: growable,
        );
      }
    }
    return map;
  }

  /// The list of required keys that must be present in a JSON.
  static const requiredKeys = <String>{};
}

class WithEnumsStringEnumEnum {
  /// Instantiate a new enum with the provided [value].
  const WithEnumsStringEnumEnum._(this.value);

  /// The underlying value of this enum member.
  final String value;

  @override
  String toString() => value;

  String toJson() => value;

  static const strA = WithEnumsStringEnumEnum._(r'strA');
  static const strB = WithEnumsStringEnumEnum._(r'strB');
  static const strC = WithEnumsStringEnumEnum._(r'strC');

  /// List of all possible values in this [enum][WithEnumsStringEnumEnum].
  static const values = <WithEnumsStringEnumEnum>[
    strA,
    strB,
    strC,
  ];

  static WithEnumsStringEnumEnum? fromJson(dynamic value) => WithEnumsStringEnumEnumTypeTransformer().decode(value);

  static List<WithEnumsStringEnumEnum> listFromJson(
    dynamic json, {
    bool growable = false,
  }) {
    final result = <WithEnumsStringEnumEnum>[];
    if (json is List && json.isNotEmpty) {
      for (final row in json) {
        final value = WithEnumsStringEnumEnum.fromJson(row);
        if (value != null) {
          result.add(value);
        }
      }
    }
    return result.toList(growable: growable);
  }

  @override
  bool operator ==(Object other) => identical(this, other) || other is WithEnumsStringEnumEnum && other.value == value;

  @override
  int get hashCode => value.hashCode;
}

/// Transformation class that can [encode] an instance of [WithEnumsStringEnumEnum] to String,
/// and [decode] dynamic data back to [WithEnumsStringEnumEnum].
class WithEnumsStringEnumEnumTypeTransformer {
  factory WithEnumsStringEnumEnumTypeTransformer() => _instance ??= const WithEnumsStringEnumEnumTypeTransformer._();

  const WithEnumsStringEnumEnumTypeTransformer._();

  String encode(WithEnumsStringEnumEnum data) => data.value;

  /// Decodes a [dynamic value][data] to a WithEnumsStringEnumEnum.
  ///
  /// If [allowNull] is true and the [dynamic value][data] cannot be decoded successfully,
  /// then null is returned. However, if [allowNull] is false and the [dynamic value][data]
  /// cannot be decoded successfully, then an [UnimplementedError] is thrown.
  ///
  /// The [allowNull] is very handy when an API changes and a new enum value is added or removed,
  /// and users are still using an old app with the old code.
  WithEnumsStringEnumEnum? decode(dynamic data, {bool allowNull = true}) {
    if (data != null) {
      switch (data) {
        case r'strA':
          return WithEnumsStringEnumEnum.strA;
        case r'strB':
          return WithEnumsStringEnumEnum.strB;
        case r'strC':
          return WithEnumsStringEnumEnum.strC;
        default:
          if (!allowNull) {
            throw ArgumentError('Unknown enum value to decode: $data');
          }
      }
    }
    return null;
  }

  /// Singleton [WithEnumsStringEnumEnumTypeTransformer] instance.
  static WithEnumsStringEnumEnumTypeTransformer? _instance;
}

class WithEnumsIntEnumEnum {
  /// Instantiate a new enum with the provided [value].
  const WithEnumsIntEnumEnum._(this.value);

  /// The underlying value of this enum member.
  final int value;

  @override
  String toString() => value.toString();

  int toJson() => value;

  static const number0 = WithEnumsIntEnumEnum._(0);
  static const number1 = WithEnumsIntEnumEnum._(1);
  static const number2 = WithEnumsIntEnumEnum._(2);

  /// List of all possible values in this [enum][WithEnumsIntEnumEnum].
  static const values = <WithEnumsIntEnumEnum>[
    number0,
    number1,
    number2,
  ];

  static WithEnumsIntEnumEnum? fromJson(dynamic value) => WithEnumsIntEnumEnumTypeTransformer().decode(value);

  static List<WithEnumsIntEnumEnum> listFromJson(
    dynamic json, {
    bool growable = false,
  }) {
    final result = <WithEnumsIntEnumEnum>[];
    if (json is List && json.isNotEmpty) {
      for (final row in json) {
        final value = WithEnumsIntEnumEnum.fromJson(row);
        if (value != null) {
          result.add(value);
        }
      }
    }
    return result.toList(growable: growable);
  }

  @override
  bool operator ==(Object other) => identical(this, other) || other is WithEnumsIntEnumEnum && other.value == value;

  @override
  int get hashCode => value.hashCode;
}

/// Transformation class that can [encode] an instance of [WithEnumsIntEnumEnum] to int,
/// and [decode] dynamic data back to [WithEnumsIntEnumEnum].
class WithEnumsIntEnumEnumTypeTransformer {
  factory WithEnumsIntEnumEnumTypeTransformer() => _instance ??= const WithEnumsIntEnumEnumTypeTransformer._();

  const WithEnumsIntEnumEnumTypeTransformer._();

  int encode(WithEnumsIntEnumEnum data) => data.value;

  /// Decodes a [dynamic value][data] to a WithEnumsIntEnumEnum.
  ///
  /// If [allowNull] is true and the [dynamic value][data] cannot be decoded successfully,
  /// then null is returned. However, if [allowNull] is false and the [dynamic value][data]
  /// cannot be decoded successfully, then an [UnimplementedError] is thrown.
  ///
  /// The [allowNull] is very handy when an API changes and a new enum value is added or removed,
  /// and users are still using an old app with the old code.
  WithEnumsIntEnumEnum? decode(dynamic data, {bool allowNull = true}) {
    if (data != null) {
      switch (data) {
        case 0:
          return WithEnumsIntEnumEnum.number0;
        case 1:
          return WithEnumsIntEnumEnum.number1;
        case 2:
          return WithEnumsIntEnumEnum.number2;
        default:
          if (!allowNull) {
            throw ArgumentError('Unknown enum value to decode: $data');
          }
      }
    }
    return null;
  }

  /// Singleton [WithEnumsIntEnumEnumTypeTransformer] instance.
  static WithEnumsIntEnumEnumTypeTransformer? _instance;
}