// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'column_condition_compat.dart';

// **************************************************************************
// BuiltValueGenerator
// **************************************************************************

const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_eq =
    const ColumnConditionCompatOperator_Enum._('eq');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_ne =
    const ColumnConditionCompatOperator_Enum._('ne');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_gt =
    const ColumnConditionCompatOperator_Enum._('gt');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_lt =
    const ColumnConditionCompatOperator_Enum._('lt');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_ge =
    const ColumnConditionCompatOperator_Enum._('ge');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_le =
    const ColumnConditionCompatOperator_Enum._('le');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_contains =
    const ColumnConditionCompatOperator_Enum._('contains');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_notContains =
    const ColumnConditionCompatOperator_Enum._('notContains');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_startsWith =
    const ColumnConditionCompatOperator_Enum._('startsWith');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_notStartsWith =
    const ColumnConditionCompatOperator_Enum._('notStartsWith');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_endsWith =
    const ColumnConditionCompatOperator_Enum._('endsWith');
const ColumnConditionCompatOperator_Enum
    _$columnConditionCompatOperatorEnum_notEndsWith =
    const ColumnConditionCompatOperator_Enum._('notEndsWith');

ColumnConditionCompatOperator_Enum _$columnConditionCompatOperatorEnumValueOf(
    String name) {
  switch (name) {
    case 'eq':
      return _$columnConditionCompatOperatorEnum_eq;
    case 'ne':
      return _$columnConditionCompatOperatorEnum_ne;
    case 'gt':
      return _$columnConditionCompatOperatorEnum_gt;
    case 'lt':
      return _$columnConditionCompatOperatorEnum_lt;
    case 'ge':
      return _$columnConditionCompatOperatorEnum_ge;
    case 'le':
      return _$columnConditionCompatOperatorEnum_le;
    case 'contains':
      return _$columnConditionCompatOperatorEnum_contains;
    case 'notContains':
      return _$columnConditionCompatOperatorEnum_notContains;
    case 'startsWith':
      return _$columnConditionCompatOperatorEnum_startsWith;
    case 'notStartsWith':
      return _$columnConditionCompatOperatorEnum_notStartsWith;
    case 'endsWith':
      return _$columnConditionCompatOperatorEnum_endsWith;
    case 'notEndsWith':
      return _$columnConditionCompatOperatorEnum_notEndsWith;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<ColumnConditionCompatOperator_Enum>
    _$columnConditionCompatOperatorEnumValues = new BuiltSet<
        ColumnConditionCompatOperator_Enum>(const <ColumnConditionCompatOperator_Enum>[
  _$columnConditionCompatOperatorEnum_eq,
  _$columnConditionCompatOperatorEnum_ne,
  _$columnConditionCompatOperatorEnum_gt,
  _$columnConditionCompatOperatorEnum_lt,
  _$columnConditionCompatOperatorEnum_ge,
  _$columnConditionCompatOperatorEnum_le,
  _$columnConditionCompatOperatorEnum_contains,
  _$columnConditionCompatOperatorEnum_notContains,
  _$columnConditionCompatOperatorEnum_startsWith,
  _$columnConditionCompatOperatorEnum_notStartsWith,
  _$columnConditionCompatOperatorEnum_endsWith,
  _$columnConditionCompatOperatorEnum_notEndsWith,
]);

Serializer<ColumnConditionCompatOperator_Enum>
    _$columnConditionCompatOperatorEnumSerializer =
    new _$ColumnConditionCompatOperator_EnumSerializer();

class _$ColumnConditionCompatOperator_EnumSerializer
    implements PrimitiveSerializer<ColumnConditionCompatOperator_Enum> {
  static const Map<String, Object> _toWire = const <String, Object>{
    'eq': 'eq',
    'ne': 'ne',
    'gt': 'gt',
    'lt': 'lt',
    'ge': 'ge',
    'le': 'le',
    'contains': 'contains',
    'notContains': 'not_contains',
    'startsWith': 'starts_with',
    'notStartsWith': 'not_starts_with',
    'endsWith': 'ends_with',
    'notEndsWith': 'not_ends_with',
  };
  static const Map<Object, String> _fromWire = const <Object, String>{
    'eq': 'eq',
    'ne': 'ne',
    'gt': 'gt',
    'lt': 'lt',
    'ge': 'ge',
    'le': 'le',
    'contains': 'contains',
    'not_contains': 'notContains',
    'starts_with': 'startsWith',
    'not_starts_with': 'notStartsWith',
    'ends_with': 'endsWith',
    'not_ends_with': 'notEndsWith',
  };

  @override
  final Iterable<Type> types = const <Type>[ColumnConditionCompatOperator_Enum];
  @override
  final String wireName = 'ColumnConditionCompatOperator_Enum';

  @override
  Object serialize(
          Serializers serializers, ColumnConditionCompatOperator_Enum object,
          {FullType specifiedType = FullType.unspecified}) =>
      _toWire[object.name] ?? object.name;

  @override
  ColumnConditionCompatOperator_Enum deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      ColumnConditionCompatOperator_Enum.valueOf(
          _fromWire[serialized] ?? (serialized is String ? serialized : ''));
}

class _$ColumnConditionCompat extends ColumnConditionCompat {
  @override
  final String column;
  @override
  final ColumnConditionCompatOperator_Enum operator_;
  @override
  final JsonObject? value;

  factory _$ColumnConditionCompat(
          [void Function(ColumnConditionCompatBuilder)? updates]) =>
      (new ColumnConditionCompatBuilder()..update(updates))._build();

  _$ColumnConditionCompat._(
      {required this.column, required this.operator_, this.value})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        column, r'ColumnConditionCompat', 'column');
    BuiltValueNullFieldError.checkNotNull(
        operator_, r'ColumnConditionCompat', 'operator_');
  }

  @override
  ColumnConditionCompat rebuild(
          void Function(ColumnConditionCompatBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  ColumnConditionCompatBuilder toBuilder() =>
      new ColumnConditionCompatBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is ColumnConditionCompat &&
        column == other.column &&
        operator_ == other.operator_ &&
        value == other.value;
  }

  @override
  int get hashCode {
    var _$hash = 0;
    _$hash = $jc(_$hash, column.hashCode);
    _$hash = $jc(_$hash, operator_.hashCode);
    _$hash = $jc(_$hash, value.hashCode);
    _$hash = $jf(_$hash);
    return _$hash;
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(r'ColumnConditionCompat')
          ..add('column', column)
          ..add('operator_', operator_)
          ..add('value', value))
        .toString();
  }
}

class ColumnConditionCompatBuilder
    implements Builder<ColumnConditionCompat, ColumnConditionCompatBuilder> {
  _$ColumnConditionCompat? _$v;

  String? _column;
  String? get column => _$this._column;
  set column(String? column) => _$this._column = column;

  ColumnConditionCompatOperator_Enum? _operator_;
  ColumnConditionCompatOperator_Enum? get operator_ => _$this._operator_;
  set operator_(ColumnConditionCompatOperator_Enum? operator_) =>
      _$this._operator_ = operator_;

  JsonObject? _value;
  JsonObject? get value => _$this._value;
  set value(JsonObject? value) => _$this._value = value;

  ColumnConditionCompatBuilder() {
    ColumnConditionCompat._defaults(this);
  }

  ColumnConditionCompatBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _column = $v.column;
      _operator_ = $v.operator_;
      _value = $v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(ColumnConditionCompat other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$ColumnConditionCompat;
  }

  @override
  void update(void Function(ColumnConditionCompatBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  ColumnConditionCompat build() => _build();

  _$ColumnConditionCompat _build() {
    final _$result = _$v ??
        new _$ColumnConditionCompat._(
            column: BuiltValueNullFieldError.checkNotNull(
                column, r'ColumnConditionCompat', 'column'),
            operator_: BuiltValueNullFieldError.checkNotNull(
                operator_, r'ColumnConditionCompat', 'operator_'),
            value: value);
    replace(_$result);
    return _$result;
  }
}

// ignore_for_file: deprecated_member_use_from_same_package,type=lint