// coverage:ignore-file
// GENERATED CODE - DO NOT MODIFY BY HAND
// 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 'session.dart';

class SessionMapper extends ClassMapperBase<Session> {
  SessionMapper._();

  static SessionMapper? _instance;
  static SessionMapper ensureInitialized() {
    if (_instance == null) {
      MapperContainer.globals.use(_instance = SessionMapper._());
      _t$_R0Mapper.ensureInitialized();
      _t$_R1Mapper.ensureInitialized();
    }
    return _instance!;
  }

  @override
  final String id = 'Session';

  static String _$title(Session v) => v.title;
  static const Field<Session, String> _f$title = Field('title', _$title);
  static String _$id(Session v) => v.id;
  static const Field<Session, String> _f$id = Field('id', _$id);
  static String _$description(Session v) => v.description;
  static const Field<Session, String> _f$description = Field('description', _$description);
  static DateTime _$startsAt(Session v) => v.startsAt;
  static const Field<Session, DateTime> _f$startsAt = Field('startsAt', _$startsAt);
  static DateTime _$endsAt(Session v) => v.endsAt;
  static const Field<Session, DateTime> _f$endsAt = Field('endsAt', _$endsAt);
  static List<_t$_R0<String>> _$speakers(Session v) => v.speakers;
  static const Field<Session, List<_t$_R0<String>>> _f$speakers = Field('speakers', _$speakers);
  static String _$room(Session v) => v.room;
  static const Field<Session, String> _f$room = Field('room', _$room);
  static List<_t$_R1<List<_t$_R0<String>>, String>> _$categories(Session v) => v.categories;
  static const Field<Session, List<_t$_R1<List<_t$_R0<String>>, String>>> _f$categories =
      Field('categories', _$categories);

  @override
  final MappableFields<Session> fields = const {
    #title: _f$title,
    #id: _f$id,
    #description: _f$description,
    #startsAt: _f$startsAt,
    #endsAt: _f$endsAt,
    #speakers: _f$speakers,
    #room: _f$room,
    #categories: _f$categories,
  };

  static Session _instantiate(DecodingData data) {
    return Session(
        title: data.dec(_f$title),
        id: data.dec(_f$id),
        description: data.dec(_f$description),
        startsAt: data.dec(_f$startsAt),
        endsAt: data.dec(_f$endsAt),
        speakers: data.dec(_f$speakers),
        room: data.dec(_f$room),
        categories: data.dec(_f$categories));
  }

  @override
  final Function instantiate = _instantiate;

  static Session fromMap(Map<String, dynamic> map) {
    return ensureInitialized().decodeMap<Session>(map);
  }

  static Session fromJson(String json) {
    return ensureInitialized().decodeJson<Session>(json);
  }
}

mixin SessionMappable {
  String toJson() {
    return SessionMapper.ensureInitialized().encodeJson<Session>(this as Session);
  }

  Map<String, dynamic> toMap() {
    return SessionMapper.ensureInitialized().encodeMap<Session>(this as Session);
  }

  SessionCopyWith<Session, Session, Session> get copyWith =>
      _SessionCopyWithImpl(this as Session, $identity, $identity);
  @override
  String toString() {
    return SessionMapper.ensureInitialized().stringifyValue(this as Session);
  }

  @override
  bool operator ==(Object other) {
    return SessionMapper.ensureInitialized().equalsValue(this as Session, other);
  }

  @override
  int get hashCode {
    return SessionMapper.ensureInitialized().hashValue(this as Session);
  }
}

extension SessionValueCopy<$R, $Out> on ObjectCopyWith<$R, Session, $Out> {
  SessionCopyWith<$R, Session, $Out> get $asSession => $base.as((v, t, t2) => _SessionCopyWithImpl(v, t, t2));
}

abstract class SessionCopyWith<$R, $In extends Session, $Out> implements ClassCopyWith<$R, $In, $Out> {
  ListCopyWith<$R, _t$_R0<String>, ObjectCopyWith<$R, _t$_R0<String>, _t$_R0<String>>> get speakers;
  ListCopyWith<$R, _t$_R1<List<_t$_R0<String>>, String>,
      ObjectCopyWith<$R, _t$_R1<List<_t$_R0<String>>, String>, _t$_R1<List<_t$_R0<String>>, String>>> get categories;
  $R call(
      {String? title,
      String? id,
      String? description,
      DateTime? startsAt,
      DateTime? endsAt,
      List<_t$_R0<String>>? speakers,
      String? room,
      List<_t$_R1<List<_t$_R0<String>>, String>>? categories});
  SessionCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(Then<$Out2, $R2> t);
}

class _SessionCopyWithImpl<$R, $Out> extends ClassCopyWithBase<$R, Session, $Out>
    implements SessionCopyWith<$R, Session, $Out> {
  _SessionCopyWithImpl(super.value, super.then, super.then2);

  @override
  late final ClassMapperBase<Session> $mapper = SessionMapper.ensureInitialized();
  @override
  ListCopyWith<$R, _t$_R0<String>, ObjectCopyWith<$R, _t$_R0<String>, _t$_R0<String>>> get speakers =>
      ListCopyWith($value.speakers, (v, t) => ObjectCopyWith(v, $identity, t), (v) => call(speakers: v));
  @override
  ListCopyWith<$R, _t$_R1<List<_t$_R0<String>>, String>,
          ObjectCopyWith<$R, _t$_R1<List<_t$_R0<String>>, String>, _t$_R1<List<_t$_R0<String>>, String>>>
      get categories =>
          ListCopyWith($value.categories, (v, t) => ObjectCopyWith(v, $identity, t), (v) => call(categories: v));
  @override
  $R call(
          {String? title,
          String? id,
          String? description,
          DateTime? startsAt,
          DateTime? endsAt,
          List<_t$_R0<String>>? speakers,
          String? room,
          List<_t$_R1<List<_t$_R0<String>>, String>>? categories}) =>
      $apply(FieldCopyWithData({
        if (title != null) #title: title,
        if (id != null) #id: id,
        if (description != null) #description: description,
        if (startsAt != null) #startsAt: startsAt,
        if (endsAt != null) #endsAt: endsAt,
        if (speakers != null) #speakers: speakers,
        if (room != null) #room: room,
        if (categories != null) #categories: categories
      }));
  @override
  Session $make(CopyWithData data) => Session(
      title: data.get(#title, or: $value.title),
      id: data.get(#id, or: $value.id),
      description: data.get(#description, or: $value.description),
      startsAt: data.get(#startsAt, or: $value.startsAt),
      endsAt: data.get(#endsAt, or: $value.endsAt),
      speakers: data.get(#speakers, or: $value.speakers),
      room: data.get(#room, or: $value.room),
      categories: data.get(#categories, or: $value.categories));

  @override
  SessionCopyWith<$R2, Session, $Out2> $chain<$R2, $Out2>(Then<$Out2, $R2> t) => _SessionCopyWithImpl($value, $cast, t);
}

typedef _t$_R1<A, B> = ({A categoryItems, B name});

class _t$_R1Mapper extends RecordMapperBase<_t$_R1> {
  static _t$_R1Mapper? _instance;
  _t$_R1Mapper._();

  static _t$_R1Mapper ensureInitialized() {
    if (_instance == null) {
      MapperContainer.globals.use(_instance = _t$_R1Mapper._());
      MapperBase.addType(<A, B>(f) => f<({A categoryItems, B name})>());
    }
    return _instance!;
  }

  static dynamic _$categoryItems(_t$_R1 v) => v.categoryItems;
  static dynamic _arg$categoryItems<A, B>(f) => f<A>();
  static const Field<_t$_R1, dynamic> _f$categoryItems =
      Field('categoryItems', _$categoryItems, arg: _arg$categoryItems);
  static dynamic _$name(_t$_R1 v) => v.name;
  static dynamic _arg$name<A, B>(f) => f<B>();
  static const Field<_t$_R1, dynamic> _f$name = Field('name', _$name, arg: _arg$name);

  @override
  final MappableFields<_t$_R1> fields = const {
    #categoryItems: _f$categoryItems,
    #name: _f$name,
  };

  @override
  Function get typeFactory => <A, B>(f) => f<_t$_R1<A, B>>();

  static _t$_R1<A, B> _instantiate<A, B>(DecodingData<_t$_R1> data) {
    return (categoryItems: data.dec(_f$categoryItems), name: data.dec(_f$name));
  }

  @override
  final Function instantiate = _instantiate;

  static _t$_R1<A, B> fromMap<A, B>(Map<String, dynamic> map) {
    return ensureInitialized().decodeMap<_t$_R1<A, B>>(map);
  }

  static _t$_R1<A, B> fromJson<A, B>(String json) {
    return ensureInitialized().decodeJson<_t$_R1<A, B>>(json);
  }
}

typedef _t$_R0<A> = ({A name});

class _t$_R0Mapper extends RecordMapperBase<_t$_R0> {
  static _t$_R0Mapper? _instance;
  _t$_R0Mapper._();

  static _t$_R0Mapper ensureInitialized() {
    if (_instance == null) {
      MapperContainer.globals.use(_instance = _t$_R0Mapper._());
      MapperBase.addType(<A>(f) => f<({A name})>());
    }
    return _instance!;
  }

  static dynamic _$name(_t$_R0 v) => v.name;
  static dynamic _arg$name<A>(f) => f<A>();
  static const Field<_t$_R0, dynamic> _f$name = Field('name', _$name, arg: _arg$name);

  @override
  final MappableFields<_t$_R0> fields = const {
    #name: _f$name,
  };

  @override
  Function get typeFactory => <A>(f) => f<_t$_R0<A>>();

  static _t$_R0<A> _instantiate<A>(DecodingData<_t$_R0> data) {
    return (name: data.dec(_f$name));
  }

  @override
  final Function instantiate = _instantiate;

  static _t$_R0<A> fromMap<A>(Map<String, dynamic> map) {
    return ensureInitialized().decodeMap<_t$_R0<A>>(map);
  }

  static _t$_R0<A> fromJson<A>(String json) {
    return ensureInitialized().decodeJson<_t$_R0<A>>(json);
  }
}
