text: import Postbox
  
  public enum PeerMuteState: Equatable {
      case `default`
      case unmuted
      case muted(until: Int32)
      
      fileprivate static func decodeInline(_ decoder: PostboxDecoder) -> PeerMuteState {
          switch decoder.decodeInt32ForKey("m.v", orElse: 0) {
              case 0:
                  return .default
              case 1:
                  return .muted(until: decoder.decodeInt32ForKey("m.u", orElse: 0))
              case 2:
                  return .unmuted
              default:
                  return .default
          }
      }
      
      fileprivate func encodeInline(_ encoder: PostboxEncoder) {
          switch self {
              case .default:
                  encoder.encodeInt32(0, forKey: "m.v")
              case let .muted(until):
                  encoder.encodeInt32(1, forKey: "m.v")
                  encoder.encodeInt32(until, forKey: "m.u")
              case .unmuted:
                  encoder.encodeInt32(2, forKey: "m.v")
          }
      }
  }
  
  private enum PeerMessageSoundValue: Int32 {
      case none
      case bundledModern
      case bundledClassic
      case `default`
  }
  
  public enum PeerMessageSound: Equatable {
      case none
      case `default`
      case bundledModern(id: Int32)
      case bundledClassic(id: Int32)
      
      static func decodeInline(_ decoder: PostboxDecoder) -> PeerMessageSound {
          switch decoder.decodeInt32ForKey("s.v", orElse: 0) {
              case PeerMessageSoundValue.none.rawValue:
                  return .none
              case PeerMessageSoundValue.bundledModern.rawValue:
                  return .bundledModern(id: decoder.decodeInt32ForKey("s.i", orElse: 0))
              case PeerMessageSoundValue.bundledClassic.rawValue:
                  return .bundledClassic(id: decoder.decodeInt32ForKey("s.i", orElse: 0))
              case PeerMessageSoundValue.default.rawValue:
                  return .default
              default:
                  assertionFailure()
                  return .bundledModern(id: 0)
          }
      }
      
      func encodeInline(_ encoder: PostboxEncoder) {
          switch self {
              case .none:
                  encoder.encodeInt32(PeerMessageSoundValue.none.rawValue, forKey: "s.v")
              case let .bundledModern(id):
                  encoder.encodeInt32(PeerMessageSoundValue.bundledModern.rawValue, forKey: "s.v")
                  encoder.encodeInt32(id, forKey: "s.i")
              case let .bundledClassic(id):
                  encoder.encodeInt32(PeerMessageSoundValue.bundledClassic.rawValue, forKey: "s.v")
                  encoder.encodeInt32(id, forKey: "s.i")
              case .default:
                  encoder.encodeInt32(PeerMessageSoundValue.default.rawValue, forKey: "s.v")
          }
      }
      
      public static func ==(lhs: PeerMessageSound, rhs: PeerMessageSound) -> Bool {
          switch lhs {
              case .none:
                  if case .none = rhs {
                      return true
                  } else {
                      return false
                  }
              case let .bundledModern(id):
                  if case .bundledModern(id) = rhs {
                      return true
                  } else {
                      return false
                  }
              case let .bundledClassic(id):
                  if case .bundledClassic(id) = rhs {
                      return true
                  } else {
                      return false
                  }
              case .default:
                  if case .default = rhs {
                      return true
                  } else {
                      return false
                  }
          }
      }
  }
  
  public enum PeerNotificationDisplayPreviews {
      case `default`
      case show
      case hide
      
      static func decodeInline(_ decoder: PostboxDecoder) -> PeerNotificationDisplayPreviews {
          switch decoder.decodeInt32ForKey("p.v", orElse: 0) {
              case 0:
                  return .default
              case 1:
                  return .show
              case 2:
                  return .hide
              default:
                  assertionFailure()
                  return .default
          }
      }
      
      func encodeInline(_ encoder: PostboxEncoder) {
          switch self {
              case .default:
                  encoder.encodeInt32(0, forKey: "p.v")
              case .show:
                  encoder.encodeInt32(1, forKey: "p.v")
              case .hide:
                  encoder.encodeInt32(2, forKey: "p.v")
          }
      }
  }
  
  public final class TelegramPeerNotificationSettings: PeerNotificationSettings, Equatable {
      public let muteState: PeerMuteState
      public let messageSound: PeerMessageSound
      public let displayPreviews: PeerNotificationDisplayPreviews
      
      public static var defaultSettings: TelegramPeerNotificationSettings {
          return TelegramPeerNotificationSettings(muteState: .unmuted, messageSound: .default, displayPreviews: .default)
      }
      
      public func isRemovedFromTotalUnreadCount(`default`: Bool) -> Bool {
          switch self.muteState {
              case .unmuted:
                  return false
              case .muted:
                  return true
              case .default:
                  return `default`
          }
      }
      
      public var behavior: PeerNotificationSettingsBehavior {
          if case let .muted(untilTimestamp) = self.muteState, untilTimestamp < Int32.max {
              return .reset(atTimestamp: untilTimestamp, toValue: self.withUpdatedMuteState(.unmuted))
          } else {
              return .none
          }
      }
      
      public init(muteState: PeerMuteState, messageSound: PeerMessageSound, displayPreviews: PeerNotificationDisplayPreviews) {
          self.muteState = muteState
          self.messageSound = messageSound
          self.displayPreviews = displayPreviews
      }
      
      public init(decoder: PostboxDecoder) {
          self.muteState = PeerMuteState.decodeInline(decoder)
          self.messageSound = PeerMessageSound.decodeInline(decoder)
          self.displayPreviews = PeerNotificationDisplayPreviews.decodeInline(decoder)
      }
      
      public func encode(_ encoder: PostboxEncoder) {
          self.muteState.encodeInline(encoder)
          self.messageSound.encodeInline(encoder)
          self.displayPreviews.encodeInline(encoder)
      }
      
      public func isEqual(to: PeerNotificationSettings) -> Bool {
          if let to = to as? TelegramPeerNotificationSettings {
              return self == to
          } else {
              return false
          }
      }
      
      public func withUpdatedMuteState(_ muteState: PeerMuteState) -> TelegramPeerNotificationSettings {
          return TelegramPeerNotificationSettings(muteState: muteState, messageSound: self.messageSound, displayPreviews: self.displayPreviews)
      }
      
      public func withUpdatedMessageSound(_ messageSound: PeerMessageSound) -> TelegramPeerNotificationSettings {
          return TelegramPeerNotificationSettings(muteState: self.muteState, messageSound: messageSound, displayPreviews: self.displayPreviews)
      }
      
      public func withUpdatedDisplayPreviews(_ displayPreviews: PeerNotificationDisplayPreviews) -> TelegramPeerNotificationSettings {
          return TelegramPeerNotificationSettings(muteState: self.muteState, messageSound: self.messageSound, displayPreviews: displayPreviews)
      }
      
      public static func ==(lhs: TelegramPeerNotificationSettings, rhs: TelegramPeerNotificationSettings) -> Bool {
          return lhs.muteState == rhs.muteState && lhs.messageSound == rhs.messageSound && lhs.displayPreviews == rhs.displayPreviews
      }
  }
  