// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'model.dart';

// **************************************************************************
// EnhancedEnumGenerator
// **************************************************************************

extension RoleFromStringExtension on Iterable<Role> {
  Role? fromString(String val) {
    final override = {
      'm.role.admin': Role.mRoleAdmin,
      'm.role.security': Role.mRoleSecurity,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension RoleEnhancedEnum on Role {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        Role.mRoleAdmin: 'm.role.admin',
        Role.mRoleSecurity: 'm.role.security',
      }[this]!;
  bool get isMRoleAdmin => this == Role.mRoleAdmin;
  bool get isMRoleSecurity => this == Role.mRoleSecurity;
  T when<T>({
    required T Function() mRoleAdmin,
    required T Function() mRoleSecurity,
  }) =>
      {
        Role.mRoleAdmin: mRoleAdmin,
        Role.mRoleSecurity: mRoleSecurity,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? mRoleAdmin,
    T? Function()? mRoleSecurity,
    required T Function() orElse,
  }) =>
      {
        Role.mRoleAdmin: mRoleAdmin,
        Role.mRoleSecurity: mRoleSecurity,
      }[this]
          ?.call() ??
      orElse();
}

extension MethodFromStringExtension on Iterable<Method> {
  Method? fromString(String val) {
    final override = {
      'crop': Method.crop,
      'scale': Method.scale,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension MethodEnhancedEnum on Method {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        Method.crop: 'crop',
        Method.scale: 'scale',
      }[this]!;
  bool get isCrop => this == Method.crop;
  bool get isScale => this == Method.scale;
  T when<T>({
    required T Function() crop,
    required T Function() scale,
  }) =>
      {
        Method.crop: crop,
        Method.scale: scale,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? crop,
    T? Function()? scale,
    required T Function() orElse,
  }) =>
      {
        Method.crop: crop,
        Method.scale: scale,
      }[this]
          ?.call() ??
      orElse();
}

extension DirectionFromStringExtension on Iterable<Direction> {
  Direction? fromString(String val) {
    final override = {
      'b': Direction.b,
      'f': Direction.f,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension DirectionEnhancedEnum on Direction {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        Direction.b: 'b',
        Direction.f: 'f',
      }[this]!;
  bool get isB => this == Direction.b;
  bool get isF => this == Direction.f;
  T when<T>({
    required T Function() b,
    required T Function() f,
  }) =>
      {
        Direction.b: b,
        Direction.f: f,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? b,
    T? Function()? f,
    required T Function() orElse,
  }) =>
      {
        Direction.b: b,
        Direction.f: f,
      }[this]
          ?.call() ??
      orElse();
}

extension IncludeFromStringExtension on Iterable<Include> {
  Include? fromString(String val) {
    final override = {
      'all': Include.all,
      'participated': Include.participated,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension IncludeEnhancedEnum on Include {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        Include.all: 'all',
        Include.participated: 'participated',
      }[this]!;
  bool get isAll => this == Include.all;
  bool get isParticipated => this == Include.participated;
  T when<T>({
    required T Function() all,
    required T Function() participated,
  }) =>
      {
        Include.all: all,
        Include.participated: participated,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? all,
    T? Function()? participated,
    required T Function() orElse,
  }) =>
      {
        Include.all: all,
        Include.participated: participated,
      }[this]
          ?.call() ??
      orElse();
}

extension ThirdPartyIdentifierMediumFromStringExtension
    on Iterable<ThirdPartyIdentifierMedium> {
  ThirdPartyIdentifierMedium? fromString(String val) {
    final override = {
      'email': ThirdPartyIdentifierMedium.email,
      'msisdn': ThirdPartyIdentifierMedium.msisdn,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension ThirdPartyIdentifierMediumEnhancedEnum on ThirdPartyIdentifierMedium {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        ThirdPartyIdentifierMedium.email: 'email',
        ThirdPartyIdentifierMedium.msisdn: 'msisdn',
      }[this]!;
  bool get isEmail => this == ThirdPartyIdentifierMedium.email;
  bool get isMsisdn => this == ThirdPartyIdentifierMedium.msisdn;
  T when<T>({
    required T Function() email,
    required T Function() msisdn,
  }) =>
      {
        ThirdPartyIdentifierMedium.email: email,
        ThirdPartyIdentifierMedium.msisdn: msisdn,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? email,
    T? Function()? msisdn,
    required T Function() orElse,
  }) =>
      {
        ThirdPartyIdentifierMedium.email: email,
        ThirdPartyIdentifierMedium.msisdn: msisdn,
      }[this]
          ?.call() ??
      orElse();
}

extension IdServerUnbindResultFromStringExtension
    on Iterable<IdServerUnbindResult> {
  IdServerUnbindResult? fromString(String val) {
    final override = {
      'no-support': IdServerUnbindResult.noSupport,
      'success': IdServerUnbindResult.success,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension IdServerUnbindResultEnhancedEnum on IdServerUnbindResult {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        IdServerUnbindResult.noSupport: 'no-support',
        IdServerUnbindResult.success: 'success',
      }[this]!;
  bool get isNoSupport => this == IdServerUnbindResult.noSupport;
  bool get isSuccess => this == IdServerUnbindResult.success;
  T when<T>({
    required T Function() noSupport,
    required T Function() success,
  }) =>
      {
        IdServerUnbindResult.noSupport: noSupport,
        IdServerUnbindResult.success: success,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? noSupport,
    T? Function()? success,
    required T Function() orElse,
  }) =>
      {
        IdServerUnbindResult.noSupport: noSupport,
        IdServerUnbindResult.success: success,
      }[this]
          ?.call() ??
      orElse();
}

extension RoomVersionAvailableFromStringExtension
    on Iterable<RoomVersionAvailable> {
  RoomVersionAvailable? fromString(String val) {
    final override = {
      'stable': RoomVersionAvailable.stable,
      'unstable': RoomVersionAvailable.unstable,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension RoomVersionAvailableEnhancedEnum on RoomVersionAvailable {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        RoomVersionAvailable.stable: 'stable',
        RoomVersionAvailable.unstable: 'unstable',
      }[this]!;
  bool get isStable => this == RoomVersionAvailable.stable;
  bool get isUnstable => this == RoomVersionAvailable.unstable;
  T when<T>({
    required T Function() stable,
    required T Function() unstable,
  }) =>
      {
        RoomVersionAvailable.stable: stable,
        RoomVersionAvailable.unstable: unstable,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? stable,
    T? Function()? unstable,
    required T Function() orElse,
  }) =>
      {
        RoomVersionAvailable.stable: stable,
        RoomVersionAvailable.unstable: unstable,
      }[this]
          ?.call() ??
      orElse();
}

extension CreateRoomPresetFromStringExtension on Iterable<CreateRoomPreset> {
  CreateRoomPreset? fromString(String val) {
    final override = {
      'private_chat': CreateRoomPreset.privateChat,
      'public_chat': CreateRoomPreset.publicChat,
      'trusted_private_chat': CreateRoomPreset.trustedPrivateChat,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension CreateRoomPresetEnhancedEnum on CreateRoomPreset {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        CreateRoomPreset.privateChat: 'private_chat',
        CreateRoomPreset.publicChat: 'public_chat',
        CreateRoomPreset.trustedPrivateChat: 'trusted_private_chat',
      }[this]!;
  bool get isPrivateChat => this == CreateRoomPreset.privateChat;
  bool get isPublicChat => this == CreateRoomPreset.publicChat;
  bool get isTrustedPrivateChat => this == CreateRoomPreset.trustedPrivateChat;
  T when<T>({
    required T Function() privateChat,
    required T Function() publicChat,
    required T Function() trustedPrivateChat,
  }) =>
      {
        CreateRoomPreset.privateChat: privateChat,
        CreateRoomPreset.publicChat: publicChat,
        CreateRoomPreset.trustedPrivateChat: trustedPrivateChat,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? privateChat,
    T? Function()? publicChat,
    T? Function()? trustedPrivateChat,
    required T Function() orElse,
  }) =>
      {
        CreateRoomPreset.privateChat: privateChat,
        CreateRoomPreset.publicChat: publicChat,
        CreateRoomPreset.trustedPrivateChat: trustedPrivateChat,
      }[this]
          ?.call() ??
      orElse();
}

extension VisibilityFromStringExtension on Iterable<Visibility> {
  Visibility? fromString(String val) {
    final override = {
      'private': Visibility.private,
      'public': Visibility.public,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension VisibilityEnhancedEnum on Visibility {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        Visibility.private: 'private',
        Visibility.public: 'public',
      }[this]!;
  bool get isPrivate => this == Visibility.private;
  bool get isPublic => this == Visibility.public;
  T when<T>({
    required T Function() private,
    required T Function() public,
  }) =>
      {
        Visibility.private: private,
        Visibility.public: public,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? private,
    T? Function()? public,
    required T Function() orElse,
  }) =>
      {
        Visibility.private: private,
        Visibility.public: public,
      }[this]
          ?.call() ??
      orElse();
}

extension PresenceTypeFromStringExtension on Iterable<PresenceType> {
  PresenceType? fromString(String val) {
    final override = {
      'offline': PresenceType.offline,
      'online': PresenceType.online,
      'unavailable': PresenceType.unavailable,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension PresenceTypeEnhancedEnum on PresenceType {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        PresenceType.offline: 'offline',
        PresenceType.online: 'online',
        PresenceType.unavailable: 'unavailable',
      }[this]!;
  bool get isOffline => this == PresenceType.offline;
  bool get isOnline => this == PresenceType.online;
  bool get isUnavailable => this == PresenceType.unavailable;
  T when<T>({
    required T Function() offline,
    required T Function() online,
    required T Function() unavailable,
  }) =>
      {
        PresenceType.offline: offline,
        PresenceType.online: online,
        PresenceType.unavailable: unavailable,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? offline,
    T? Function()? online,
    T? Function()? unavailable,
    required T Function() orElse,
  }) =>
      {
        PresenceType.offline: offline,
        PresenceType.online: online,
        PresenceType.unavailable: unavailable,
      }[this]
          ?.call() ??
      orElse();
}

extension PushRuleKindFromStringExtension on Iterable<PushRuleKind> {
  PushRuleKind? fromString(String val) {
    final override = {
      'content': PushRuleKind.content,
      'override': PushRuleKind.override,
      'room': PushRuleKind.room,
      'sender': PushRuleKind.sender,
      'underride': PushRuleKind.underride,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension PushRuleKindEnhancedEnum on PushRuleKind {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        PushRuleKind.content: 'content',
        PushRuleKind.override: 'override',
        PushRuleKind.room: 'room',
        PushRuleKind.sender: 'sender',
        PushRuleKind.underride: 'underride',
      }[this]!;
  bool get isContent => this == PushRuleKind.content;
  bool get isOverride => this == PushRuleKind.override;
  bool get isRoom => this == PushRuleKind.room;
  bool get isSender => this == PushRuleKind.sender;
  bool get isUnderride => this == PushRuleKind.underride;
  T when<T>({
    required T Function() content,
    required T Function() override,
    required T Function() room,
    required T Function() sender,
    required T Function() underride,
  }) =>
      {
        PushRuleKind.content: content,
        PushRuleKind.override: override,
        PushRuleKind.room: room,
        PushRuleKind.sender: sender,
        PushRuleKind.underride: underride,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? content,
    T? Function()? override,
    T? Function()? room,
    T? Function()? sender,
    T? Function()? underride,
    required T Function() orElse,
  }) =>
      {
        PushRuleKind.content: content,
        PushRuleKind.override: override,
        PushRuleKind.room: room,
        PushRuleKind.sender: sender,
        PushRuleKind.underride: underride,
      }[this]
          ?.call() ??
      orElse();
}

extension AccountKindFromStringExtension on Iterable<AccountKind> {
  AccountKind? fromString(String val) {
    final override = {
      'guest': AccountKind.guest,
      'user': AccountKind.user,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension AccountKindEnhancedEnum on AccountKind {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        AccountKind.guest: 'guest',
        AccountKind.user: 'user',
      }[this]!;
  bool get isGuest => this == AccountKind.guest;
  bool get isUser => this == AccountKind.user;
  T when<T>({
    required T Function() guest,
    required T Function() user,
  }) =>
      {
        AccountKind.guest: guest,
        AccountKind.user: user,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? guest,
    T? Function()? user,
    required T Function() orElse,
  }) =>
      {
        AccountKind.guest: guest,
        AccountKind.user: user,
      }[this]
          ?.call() ??
      orElse();
}

extension BackupAlgorithmFromStringExtension on Iterable<BackupAlgorithm> {
  BackupAlgorithm? fromString(String val) {
    final override = {
      'm.megolm_backup.v1.curve25519-aes-sha2':
          BackupAlgorithm.mMegolmBackupV1Curve25519AesSha2,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension BackupAlgorithmEnhancedEnum on BackupAlgorithm {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        BackupAlgorithm.mMegolmBackupV1Curve25519AesSha2:
            'm.megolm_backup.v1.curve25519-aes-sha2',
      }[this]!;
  bool get isMMegolmBackupV1Curve25519AesSha2 =>
      this == BackupAlgorithm.mMegolmBackupV1Curve25519AesSha2;
  T when<T>({
    required T Function() mMegolmBackupV1Curve25519AesSha2,
  }) =>
      {
        BackupAlgorithm.mMegolmBackupV1Curve25519AesSha2:
            mMegolmBackupV1Curve25519AesSha2,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? mMegolmBackupV1Curve25519AesSha2,
    required T Function() orElse,
  }) =>
      {
        BackupAlgorithm.mMegolmBackupV1Curve25519AesSha2:
            mMegolmBackupV1Curve25519AesSha2,
      }[this]
          ?.call() ??
      orElse();
}

extension MembershipFromStringExtension on Iterable<Membership> {
  Membership? fromString(String val) {
    final override = {
      'ban': Membership.ban,
      'invite': Membership.invite,
      'join': Membership.join,
      'knock': Membership.knock,
      'leave': Membership.leave,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension MembershipEnhancedEnum on Membership {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        Membership.ban: 'ban',
        Membership.invite: 'invite',
        Membership.join: 'join',
        Membership.knock: 'knock',
        Membership.leave: 'leave',
      }[this]!;
  bool get isBan => this == Membership.ban;
  bool get isInvite => this == Membership.invite;
  bool get isJoin => this == Membership.join;
  bool get isKnock => this == Membership.knock;
  bool get isLeave => this == Membership.leave;
  T when<T>({
    required T Function() ban,
    required T Function() invite,
    required T Function() join,
    required T Function() knock,
    required T Function() leave,
  }) =>
      {
        Membership.ban: ban,
        Membership.invite: invite,
        Membership.join: join,
        Membership.knock: knock,
        Membership.leave: leave,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? ban,
    T? Function()? invite,
    T? Function()? join,
    T? Function()? knock,
    T? Function()? leave,
    required T Function() orElse,
  }) =>
      {
        Membership.ban: ban,
        Membership.invite: invite,
        Membership.join: join,
        Membership.knock: knock,
        Membership.leave: leave,
      }[this]
          ?.call() ??
      orElse();
}

extension ReceiptTypeFromStringExtension on Iterable<ReceiptType> {
  ReceiptType? fromString(String val) {
    final override = {
      'm.fully_read': ReceiptType.mFullyRead,
      'm.read': ReceiptType.mRead,
      'm.read.private': ReceiptType.mReadPrivate,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension ReceiptTypeEnhancedEnum on ReceiptType {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        ReceiptType.mFullyRead: 'm.fully_read',
        ReceiptType.mRead: 'm.read',
        ReceiptType.mReadPrivate: 'm.read.private',
      }[this]!;
  bool get isMFullyRead => this == ReceiptType.mFullyRead;
  bool get isMRead => this == ReceiptType.mRead;
  bool get isMReadPrivate => this == ReceiptType.mReadPrivate;
  T when<T>({
    required T Function() mFullyRead,
    required T Function() mRead,
    required T Function() mReadPrivate,
  }) =>
      {
        ReceiptType.mFullyRead: mFullyRead,
        ReceiptType.mRead: mRead,
        ReceiptType.mReadPrivate: mReadPrivate,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? mFullyRead,
    T? Function()? mRead,
    T? Function()? mReadPrivate,
    required T Function() orElse,
  }) =>
      {
        ReceiptType.mFullyRead: mFullyRead,
        ReceiptType.mRead: mRead,
        ReceiptType.mReadPrivate: mReadPrivate,
      }[this]
          ?.call() ??
      orElse();
}

extension GroupKeyFromStringExtension on Iterable<GroupKey> {
  GroupKey? fromString(String val) {
    final override = {
      'room_id': GroupKey.roomId,
      'sender': GroupKey.sender,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension GroupKeyEnhancedEnum on GroupKey {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        GroupKey.roomId: 'room_id',
        GroupKey.sender: 'sender',
      }[this]!;
  bool get isRoomId => this == GroupKey.roomId;
  bool get isSender => this == GroupKey.sender;
  T when<T>({
    required T Function() roomId,
    required T Function() sender,
  }) =>
      {
        GroupKey.roomId: roomId,
        GroupKey.sender: sender,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? roomId,
    T? Function()? sender,
    required T Function() orElse,
  }) =>
      {
        GroupKey.roomId: roomId,
        GroupKey.sender: sender,
      }[this]
          ?.call() ??
      orElse();
}

extension KeyKindFromStringExtension on Iterable<KeyKind> {
  KeyKind? fromString(String val) {
    final override = {
      'content.body': KeyKind.contentBody,
      'content.name': KeyKind.contentName,
      'content.topic': KeyKind.contentTopic,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension KeyKindEnhancedEnum on KeyKind {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        KeyKind.contentBody: 'content.body',
        KeyKind.contentName: 'content.name',
        KeyKind.contentTopic: 'content.topic',
      }[this]!;
  bool get isContentBody => this == KeyKind.contentBody;
  bool get isContentName => this == KeyKind.contentName;
  bool get isContentTopic => this == KeyKind.contentTopic;
  T when<T>({
    required T Function() contentBody,
    required T Function() contentName,
    required T Function() contentTopic,
  }) =>
      {
        KeyKind.contentBody: contentBody,
        KeyKind.contentName: contentName,
        KeyKind.contentTopic: contentTopic,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? contentBody,
    T? Function()? contentName,
    T? Function()? contentTopic,
    required T Function() orElse,
  }) =>
      {
        KeyKind.contentBody: contentBody,
        KeyKind.contentName: contentName,
        KeyKind.contentTopic: contentTopic,
      }[this]
          ?.call() ??
      orElse();
}

extension SearchOrderFromStringExtension on Iterable<SearchOrder> {
  SearchOrder? fromString(String val) {
    final override = {
      'rank': SearchOrder.rank,
      'recent': SearchOrder.recent,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension SearchOrderEnhancedEnum on SearchOrder {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        SearchOrder.rank: 'rank',
        SearchOrder.recent: 'recent',
      }[this]!;
  bool get isRank => this == SearchOrder.rank;
  bool get isRecent => this == SearchOrder.recent;
  T when<T>({
    required T Function() rank,
    required T Function() recent,
  }) =>
      {
        SearchOrder.rank: rank,
        SearchOrder.recent: recent,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? rank,
    T? Function()? recent,
    required T Function() orElse,
  }) =>
      {
        SearchOrder.rank: rank,
        SearchOrder.recent: recent,
      }[this]
          ?.call() ??
      orElse();
}

extension EventFormatFromStringExtension on Iterable<EventFormat> {
  EventFormat? fromString(String val) {
    final override = {
      'client': EventFormat.client,
      'federation': EventFormat.federation,
    }[val];
// ignore: unnecessary_this
    return this.contains(override) ? override : null;
  }
}

extension EventFormatEnhancedEnum on EventFormat {
  @override
// ignore: override_on_non_overriding_member
  String get name => {
        EventFormat.client: 'client',
        EventFormat.federation: 'federation',
      }[this]!;
  bool get isClient => this == EventFormat.client;
  bool get isFederation => this == EventFormat.federation;
  T when<T>({
    required T Function() client,
    required T Function() federation,
  }) =>
      {
        EventFormat.client: client,
        EventFormat.federation: federation,
      }[this]!();
  T maybeWhen<T>({
    T? Function()? client,
    T? Function()? federation,
    required T Function() orElse,
  }) =>
      {
        EventFormat.client: client,
        EventFormat.federation: federation,
      }[this]
          ?.call() ??
      orElse();
}