// GENERATED CODE - DO NOT MODIFY BY HAND
// @dart=2.7

part of 'stream.dart';

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

const StreamFormatEnum _$streamFormatEnum_mPEG4 =
    const StreamFormatEnum._('mPEG4');
const StreamFormatEnum _$streamFormatEnum_v3GPP =
    const StreamFormatEnum._('v3GPP');
const StreamFormatEnum _$streamFormatEnum_WEBM =
    const StreamFormatEnum._('WEBM');
const StreamFormatEnum _$streamFormatEnum_m4A = const StreamFormatEnum._('m4A');
const StreamFormatEnum _$streamFormatEnum_WEBMA_OPUS =
    const StreamFormatEnum._('WEBMA_OPUS');

StreamFormatEnum _$streamFormatEnumValueOf(String name) {
  switch (name) {
    case 'mPEG4':
      return _$streamFormatEnum_mPEG4;
    case 'v3GPP':
      return _$streamFormatEnum_v3GPP;
    case 'WEBM':
      return _$streamFormatEnum_WEBM;
    case 'm4A':
      return _$streamFormatEnum_m4A;
    case 'WEBMA_OPUS':
      return _$streamFormatEnum_WEBMA_OPUS;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<StreamFormatEnum> _$streamFormatEnumValues =
    new BuiltSet<StreamFormatEnum>(const <StreamFormatEnum>[
  _$streamFormatEnum_mPEG4,
  _$streamFormatEnum_v3GPP,
  _$streamFormatEnum_WEBM,
  _$streamFormatEnum_m4A,
  _$streamFormatEnum_WEBMA_OPUS,
]);

Serializer<StreamFormatEnum> _$streamFormatEnumSerializer =
    new _$StreamFormatEnumSerializer();

class _$StreamFormatEnumSerializer
    implements PrimitiveSerializer<StreamFormatEnum> {
  static const Map<String, Object> _toWire = const <String, Object>{
    'mPEG4': 'MPEG_4',
    'v3GPP': 'v3GPP',
    'WEBM': 'WEBM',
    'm4A': 'M4A',
    'WEBMA_OPUS': 'WEBMA_OPUS',
  };
  static const Map<Object, String> _fromWire = const <Object, String>{
    'MPEG_4': 'mPEG4',
    'v3GPP': 'v3GPP',
    'WEBM': 'WEBM',
    'M4A': 'm4A',
    'WEBMA_OPUS': 'WEBMA_OPUS',
  };

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

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

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

class _$Stream extends Stream {
  @override
  final String url;
  @override
  final StreamFormatEnum format;
  @override
  final String quality;
  @override
  final String mimeType;
  @override
  final String codec;
  @override
  final bool videoOnly;
  @override
  final int bitrate;
  @override
  final int initStart;
  @override
  final int initEnd;
  @override
  final int indexStart;
  @override
  final int indexEnd;
  @override
  final int width;
  @override
  final int height;
  @override
  final int fps;

  factory _$Stream([void Function(StreamBuilder) updates]) =>
      (new StreamBuilder()..update(updates))._build();

  _$Stream._(
      {this.url,
      this.format,
      this.quality,
      this.mimeType,
      this.codec,
      this.videoOnly,
      this.bitrate,
      this.initStart,
      this.initEnd,
      this.indexStart,
      this.indexEnd,
      this.width,
      this.height,
      this.fps})
      : super._();

  @override
  Stream rebuild(void Function(StreamBuilder) updates) =>
      (toBuilder()..update(updates)).build();

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

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is Stream &&
        url == other.url &&
        format == other.format &&
        quality == other.quality &&
        mimeType == other.mimeType &&
        codec == other.codec &&
        videoOnly == other.videoOnly &&
        bitrate == other.bitrate &&
        initStart == other.initStart &&
        initEnd == other.initEnd &&
        indexStart == other.indexStart &&
        indexEnd == other.indexEnd &&
        width == other.width &&
        height == other.height &&
        fps == other.fps;
  }

  @override
  int get hashCode {
    var _$hash = 0;
    _$hash = $jc(_$hash, url.hashCode);
    _$hash = $jc(_$hash, format.hashCode);
    _$hash = $jc(_$hash, quality.hashCode);
    _$hash = $jc(_$hash, mimeType.hashCode);
    _$hash = $jc(_$hash, codec.hashCode);
    _$hash = $jc(_$hash, videoOnly.hashCode);
    _$hash = $jc(_$hash, bitrate.hashCode);
    _$hash = $jc(_$hash, initStart.hashCode);
    _$hash = $jc(_$hash, initEnd.hashCode);
    _$hash = $jc(_$hash, indexStart.hashCode);
    _$hash = $jc(_$hash, indexEnd.hashCode);
    _$hash = $jc(_$hash, width.hashCode);
    _$hash = $jc(_$hash, height.hashCode);
    _$hash = $jc(_$hash, fps.hashCode);
    _$hash = $jf(_$hash);
    return _$hash;
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(r'Stream')
          ..add('url', url)
          ..add('format', format)
          ..add('quality', quality)
          ..add('mimeType', mimeType)
          ..add('codec', codec)
          ..add('videoOnly', videoOnly)
          ..add('bitrate', bitrate)
          ..add('initStart', initStart)
          ..add('initEnd', initEnd)
          ..add('indexStart', indexStart)
          ..add('indexEnd', indexEnd)
          ..add('width', width)
          ..add('height', height)
          ..add('fps', fps))
        .toString();
  }
}

class StreamBuilder implements Builder<Stream, StreamBuilder> {
  _$Stream _$v;

  String _url;
  String get url => _$this._url;
  set url(String url) => _$this._url = url;

  StreamFormatEnum _format;
  StreamFormatEnum get format => _$this._format;
  set format(StreamFormatEnum format) => _$this._format = format;

  String _quality;
  String get quality => _$this._quality;
  set quality(String quality) => _$this._quality = quality;

  String _mimeType;
  String get mimeType => _$this._mimeType;
  set mimeType(String mimeType) => _$this._mimeType = mimeType;

  String _codec;
  String get codec => _$this._codec;
  set codec(String codec) => _$this._codec = codec;

  bool _videoOnly;
  bool get videoOnly => _$this._videoOnly;
  set videoOnly(bool videoOnly) => _$this._videoOnly = videoOnly;

  int _bitrate;
  int get bitrate => _$this._bitrate;
  set bitrate(int bitrate) => _$this._bitrate = bitrate;

  int _initStart;
  int get initStart => _$this._initStart;
  set initStart(int initStart) => _$this._initStart = initStart;

  int _initEnd;
  int get initEnd => _$this._initEnd;
  set initEnd(int initEnd) => _$this._initEnd = initEnd;

  int _indexStart;
  int get indexStart => _$this._indexStart;
  set indexStart(int indexStart) => _$this._indexStart = indexStart;

  int _indexEnd;
  int get indexEnd => _$this._indexEnd;
  set indexEnd(int indexEnd) => _$this._indexEnd = indexEnd;

  int _width;
  int get width => _$this._width;
  set width(int width) => _$this._width = width;

  int _height;
  int get height => _$this._height;
  set height(int height) => _$this._height = height;

  int _fps;
  int get fps => _$this._fps;
  set fps(int fps) => _$this._fps = fps;

  StreamBuilder() {
    Stream._initializeBuilder(this);
  }

  StreamBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _url = $v.url;
      _format = $v.format;
      _quality = $v.quality;
      _mimeType = $v.mimeType;
      _codec = $v.codec;
      _videoOnly = $v.videoOnly;
      _bitrate = $v.bitrate;
      _initStart = $v.initStart;
      _initEnd = $v.initEnd;
      _indexStart = $v.indexStart;
      _indexEnd = $v.indexEnd;
      _width = $v.width;
      _height = $v.height;
      _fps = $v.fps;
      _$v = null;
    }
    return this;
  }

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

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

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

  _$Stream _build() {
    final _$result = _$v ??
        new _$Stream._(
            url: url,
            format: format,
            quality: quality,
            mimeType: mimeType,
            codec: codec,
            videoOnly: videoOnly,
            bitrate: bitrate,
            initStart: initStart,
            initEnd: initEnd,
            indexStart: indexStart,
            indexEnd: indexEnd,
            width: width,
            height: height,
            fps: fps);
    replace(_$result);
    return _$result;
  }
}

// ignore_for_file: deprecated_member_use_from_same_package,type=lint