// swift-interface-format-version: 1.0
// swift-compiler-version: Apple Swift version 5.9.2 (swiftlang-5.9.2.2.56 clang-1500.1.0.2.5)
// swift-module-flags: -target arm64-apple-ios13.0 -enable-objc-interop -enable-library-evolution -swift-version 5 -enforce-exclusivity=checked -O -module-name NutPlayer
// swift-module-flags-ignorable: -enable-bare-slash-regex
import AVFoundation
import AVKit
import Combine
import CoreFoundation
import CoreGraphics
import DeveloperToolsSupport
import Foundation
import MediaPlayer
import Swift
import SwiftUI
import UIKit
import _Concurrency
import _StringProcessing
import _SwiftConcurrencyShims
public typealias AnyCancellable = Combine.AnyCancellable
extension Swift.Array {
  public subscript(safe index: Swift.Array<Element>.Index) -> Element? {
    get
  }
}
extension Swift.Array where Element : Swift.Hashable {
  public func distinct() -> Swift.Array<Element>
}
extension Swift.Array where Element == NutPlayer.Constraint {
  public var forCurrentDevice: CoreFoundation.CGFloat {
    get
  }
}
extension Combine.CurrentValueSubject where Output : Swift.Equatable {
  final public func bind(to other: Combine.CurrentValueSubject<Output, Failure>) -> NutPlayer.AnyCancellable
}
public typealias Bind<Output> = Combine.CurrentValueSubject<Output, Swift.Never>
extension CoreFoundation.CGSize : Swift.Comparable {
  public static func < (lhs: CoreFoundation.CGSize, rhs: CoreFoundation.CGSize) -> Swift.Bool
  public static func <= (lhs: CoreFoundation.CGSize, rhs: CoreFoundation.CGSize) -> Swift.Bool
}
public struct CommonPlayerContent : NutPlayer.PlayerContent {
  public let subtitles: [any NutPlayer.PlayerSubtitleRecord]
  public let content: NutPlayer.ContentType
  public let statistics: [any NutPlayer.PlayerStatisticRecord]
  public init(content: NutPlayer.ContentType, statistics: [any NutPlayer.PlayerStatisticRecord] = [], subtitles: [any NutPlayer.PlayerSubtitleRecord] = [])
}
public struct CommonProvider : NutPlayer.Provider {
  public init(content: any NutPlayer.PlayerContent)
  public func retrieveContent(_ completion: @escaping NutPlayer.CommonProvider.Completion)
}
final public class ConsoleLogDestination : NutPlayer.LogDestination {
  final public let format: Swift.String
  final public let limitOutputLevel: NutPlayer.LogLevel
  public init(format: Swift.String, limitOutputLevel: NutPlayer.LogLevel = .trace)
  final public func process(_ message: Swift.String, level: NutPlayer.LogLevel)
  @objc deinit
}
public enum Constraint : Swift.Equatable {
  case iPhoneSE(CoreFoundation.CGFloat)
  case iPhoneX(CoreFoundation.CGFloat)
  case iPod(CoreFoundation.CGFloat)
  case iPadSM(CoreFoundation.CGFloat)
  case iPadL(CoreFoundation.CGFloat)
  case appleTV(CoreFoundation.CGFloat)
  public static func == (a: NutPlayer.Constraint, b: NutPlayer.Constraint) -> Swift.Bool
}
@_hasMissingDesignatedInitializers final public class ContentPlayer : NutPlayer.TechDelegate {
  public typealias SeekCompletion = (Swift.Bool) -> Swift.Void
  weak final public var delegate: (any NutPlayer.ContentPlayerDelegate)?
  final public let layer: QuartzCore.CALayer
  final public var pipController: any NutPlayer.PlayerPictureInPictureController {
    get
    set
  }
  final public var currentQuality: NutPlayer.ContentQuality? {
    get
    set
  }
  final public var qualities: [NutPlayer.ContentQuality] {
    get
  }
  final public var state: NutPlayer.PlayerState {
    get
  }
  final public var volume: Swift.Float {
    get
    set
  }
  final public var playbackRate: NutPlayer.PlayerPlaybackRate {
    get
    set
  }
  final public var duration: Foundation.TimeInterval {
    get
  }
  final public var time: Foundation.TimeInterval {
    get
  }
  @NutPlayer.ValueSubject final public var cache: NutPlayer.Value<Foundation.TimeInterval> {
    get
  }
  final public func play()
  final public func pause()
  final public func stop()
  final public func seek(to time: Foundation.TimeInterval, completion: NutPlayer.ContentPlayer.SeekCompletion? = nil)
  final public func end()
  final public func didChange(state: NutPlayer.TechState)
  final public func didChange(time: Foundation.TimeInterval)
  final public func didChange(volume: Swift.Float)
  final public func didChange(playbackType: NutPlayer.TechPlayableType)
  final public func didChange(quality: any NutPlayer.TechQuality)
  final public func didChange(qualities: [any NutPlayer.TechQuality])
  @objc deinit
}
public protocol ContentPlayerDelegate : AnyObject {
  func requireSwitchContent(from player: NutPlayer.ContentPlayer)
  func didChange(state: NutPlayer.PlayerState, from player: NutPlayer.ContentPlayer)
  func didChange(time: Foundation.TimeInterval, from player: NutPlayer.ContentPlayer)
  func didChange(volume: Swift.Float, from player: NutPlayer.ContentPlayer)
  func didChange(quality: NutPlayer.ContentQuality, from player: NutPlayer.ContentPlayer)
  func didChange(qualities: [NutPlayer.ContentQuality], from player: NutPlayer.ContentPlayer)
}
public struct ContentQuality : NutPlayer.PlayerQualityRecord, Swift.Equatable {
  public var id: Swift.String {
    get
  }
  public var resolution: CoreFoundation.CGSize {
    get
  }
  public var bandwidth: Swift.Int {
    get
  }
  public static func == (lhs: NutPlayer.ContentQuality, rhs: NutPlayer.ContentQuality) -> Swift.Bool
}
public struct CustomizableAreaSettings {
  public init(isFullscreenSwitcherEnabled: Swift.Bool, isPipSwitcherEnabled: Swift.Bool, isSettingsSwitcherEnabled: Swift.Bool)
}
final public class DefaultQualityTitleMapper : NutPlayer.QualityTitleMapper {
  public init(policy: NutPlayer.VideoQualityTitleFormat = .common)
  final public func map(quality: any NutPlayer.PlayerQualityRecord) -> Swift.String?
  final public func map(quality: NutPlayer.VideoQuality) -> Swift.String?
  @objc deinit
}
public enum Either<T, U> {
  case firstType(T)
  case secondType(U)
  public func unwrap() -> Any
  public func map<V>(firstTypeTransform: (T) -> V, secondTypeTransform: (U) -> V) -> V
}
extension NutPlayer.Either : Swift.Decodable where T : Swift.Decodable, U : Swift.Decodable {
  public init(from decoder: any Swift.Decoder) throws
}
@objc @_hasMissingDesignatedInitializers @_Concurrency.MainActor(unsafe) final public class ErrorView : UIKit.UIView {
  @_Concurrency.MainActor(unsafe) public init(title: Swift.String? = nil)
  @_Concurrency.MainActor(unsafe) final public func updateView(with title: Swift.String)
  @objc deinit
}
public struct Event<Output> : Combine.Publisher {
  public typealias Output = Output
  public typealias Failure = Swift.Never
  public init<P>(_ publisher: P) where Output == P.Output, P : Combine.Publisher, P.Failure == Swift.Never
  public func receive<S>(subscriber: S) where Output == S.Input, S : Combine.Subscriber, S.Failure == Swift.Never
}
@propertyWrapper public class EventSubject<Output> : Combine.Subject {
  public typealias Output = Output
  public typealias Failure = Swift.Never
  final public let wrappedValue: NutPlayer.Event<Output>
  public init()
  public func send(_ value: Output)
  public func send(completion: Combine.Subscribers.Completion<NutPlayer.EventSubject<Output>.Failure>)
  public func send(subscription: any Combine.Subscription)
  public func receive<S>(subscriber: S) where Output == S.Input, S : Combine.Subscriber, S.Failure == Swift.Never
  @objc deinit
}
public protocol BusEventRepresentable {
  typealias EventName = Swift.String
}
public protocol EventTransmittable : AnyObject {
  typealias EventName = Swift.String
  typealias NamedCompletion = () -> Swift.Void
  typealias HashableCompletion = ([Swift.AnyHashable : Any]) -> Swift.Void
  typealias RawDataCompletion = (Foundation.Data) -> Swift.Void
  typealias SingleArgumentCompletion = (Any) -> Swift.Void
  func send<E>(_ event: E) where E : NutPlayer.BusEventRepresentable
  @discardableResult
  func receive<E>(_ eventType: E.Type, perform action: @escaping (E) -> Swift.Void) -> NutPlayer.AnyCancellable where E : NutPlayer.BusEventRepresentable
  @discardableResult
  func receive<E, S>(_ eventType: E.Type, performOn scheduler: S, action: @escaping (E) -> Swift.Void) -> NutPlayer.AnyCancellable where E : NutPlayer.BusEventRepresentable, S : Combine.Scheduler
}
extension NutPlayer.EventTransmittable {
  public func send(_ name: Self.EventName)
  @discardableResult
  public func receive(_ name: Self.EventName, perform action: @escaping Self.NamedCompletion) -> NutPlayer.AnyCancellable
  @discardableResult
  public func receive<S>(_ name: Self.EventName, performOn scheduler: S, action: @escaping Self.NamedCompletion) -> NutPlayer.AnyCancellable where S : Combine.Scheduler
}
extension NutPlayer.EventTransmittable {
  public func send(_ name: Self.EventName, params: [Swift.AnyHashable : Any])
  @discardableResult
  public func receive(_ name: Self.EventName, perform action: @escaping Self.HashableCompletion) -> NutPlayer.AnyCancellable
  @discardableResult
  public func receive<S>(_ name: Self.EventName, performOn scheduler: S, action: @escaping Self.HashableCompletion) -> NutPlayer.AnyCancellable where S : Combine.Scheduler
}
extension NutPlayer.EventTransmittable {
  public func send(_ name: Self.EventName, data: Foundation.Data)
  public func send(data: Foundation.Data)
  @discardableResult
  public func receive(_ name: Self.EventName = "COMMON", perform action: @escaping Self.RawDataCompletion) -> NutPlayer.AnyCancellable
  @discardableResult
  public func receive<S>(_ name: Self.EventName = "COMMON", performOn scheduler: S, action: @escaping Self.RawDataCompletion) -> NutPlayer.AnyCancellable where S : Combine.Scheduler
}
extension NutPlayer.EventTransmittable {
  public func send(_ name: Self.EventName, argument: Any)
  @discardableResult
  public func receive(_ name: Self.EventName = "COMMON", perform action: @escaping Self.SingleArgumentCompletion) -> NutPlayer.AnyCancellable
  @discardableResult
  public func receive<S>(_ name: Self.EventName = "COMMON", performOn scheduler: S, action: @escaping Self.SingleArgumentCompletion) -> NutPlayer.AnyCancellable where S : Combine.Scheduler
}
final public class FileLogDestination : NutPlayer.LogDestination {
  final public let format: Swift.String
  final public let limitOutputLevel: NutPlayer.LogLevel
  public init(format: Swift.String, limitOutputLevel: NutPlayer.LogLevel = .info)
  @objc deinit
  final public func process(_ message: Swift.String, level: NutPlayer.LogLevel)
}
public enum HlsError : Swift.Error {
  case unowned
  case emptyUrl
  case incorrectUrl
  case incorrectManifestData
  case emptyQualities
  case assetNotLoaded
  case assetNotPlayable
  case assetMetadata(_: (any Swift.Error)? = nil)
  case emptyResponseData
  case http(code: Swift.Int? = nil, description: Swift.String? = nil)
  case timeout
  case network(any Swift.Error)
  case unknown(_: (any Swift.Error)? = nil)
  case parsingFailed(_: (any Swift.Error)? = nil)
}
extension Swift.Int {
  public func leadingZero() -> Swift.String
}
public protocol LogDestination : AnyObject {
  var format: Swift.String { get }
  var limitOutputLevel: NutPlayer.LogLevel { get }
  func localize(_ message: Swift.String, params: [Swift.String]) -> Swift.String
  func process(_ message: Swift.String, level: NutPlayer.LogLevel)
}
extension NutPlayer.LogDestination {
  public func localize(_ message: Swift.String, params: [Swift.String]) -> Swift.String
}
public enum LogLevel {
  case none
  case fatal
  case assert
  case error
  case warning
  case info
  case debug
  case trace
  public static func == (a: NutPlayer.LogLevel, b: NutPlayer.LogLevel) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public let log: NutPlayer.Logger
final public class Logger {
  public typealias ParamsClosure = () -> [Swift.String]
  public typealias MessageClosure = () -> Swift.String
  final public let module: Swift.String
  public init(module: Swift.String)
  final public func addDestination(_ destination: any NutPlayer.LogDestination)
  final public func removeDestination(_ destination: any NutPlayer.LogDestination)
  final public func waitUntilAllOperationsAreFinished()
  final public func fatal(_ msg: @autoclosure @escaping NutPlayer.Logger.MessageClosure, _ params: @autoclosure @escaping NutPlayer.Logger.ParamsClosure = [], path: Swift.StaticString = #file, line: Swift.UInt = #line, fun: Swift.StaticString = #function) -> Swift.Never
  final public func assert(_ msg: @autoclosure @escaping NutPlayer.Logger.MessageClosure, _ params: @autoclosure @escaping NutPlayer.Logger.ParamsClosure = [], path: Swift.StaticString = #file, line: Swift.UInt = #line, fun: Swift.StaticString = #function)
  final public func assert(_ condition: Swift.Bool, _ msg: @autoclosure @escaping NutPlayer.Logger.MessageClosure, _ params: @autoclosure @escaping NutPlayer.Logger.ParamsClosure = [], path: Swift.StaticString = #file, line: Swift.UInt = #line, fun: Swift.StaticString = #function)
  final public func error(_ msg: @autoclosure @escaping NutPlayer.Logger.MessageClosure, _ params: @autoclosure @escaping NutPlayer.Logger.ParamsClosure = [], path: Swift.StaticString = #file, line: Swift.UInt = #line, fun: Swift.StaticString = #function)
  final public func warning(_ msg: @autoclosure @escaping NutPlayer.Logger.MessageClosure, _ params: @autoclosure @escaping NutPlayer.Logger.ParamsClosure = [], path: Swift.StaticString = #file, line: Swift.UInt = #line, fun: Swift.StaticString = #function, args: any Swift.CustomStringConvertible...)
  final public func info(_ msg: @autoclosure @escaping NutPlayer.Logger.MessageClosure, _ params: @autoclosure @escaping NutPlayer.Logger.ParamsClosure = [], path: Swift.StaticString = #file, line: Swift.UInt = #line, fun: Swift.StaticString = #function)
  final public func debug(_ msg: @autoclosure @escaping NutPlayer.Logger.MessageClosure, _ params: @autoclosure @escaping NutPlayer.Logger.ParamsClosure = [], path: Swift.StaticString = #file, line: Swift.UInt = #line, fun: Swift.StaticString = #function)
  final public func trace(_ msg: @autoclosure @escaping NutPlayer.Logger.MessageClosure, _ params: @autoclosure @escaping NutPlayer.Logger.ParamsClosure = [], path: Swift.StaticString = #file, line: Swift.UInt = #line, fun: Swift.StaticString = #function)
  final public func other(_ level: NutPlayer.LogLevel, _ msgClosure: @autoclosure @escaping NutPlayer.Logger.MessageClosure, _ params: @autoclosure @escaping NutPlayer.Logger.ParamsClosure, path: Swift.StaticString = #file, line: Swift.UInt = #line, fun: Swift.StaticString = #function)
  @objc deinit
}
public protocol M3U8BufferedReader {
  func close()
  func readLine() -> Swift.String?
}
public enum M3U8Error : Swift.Error, Swift.CustomStringConvertible {
  case emptyMasterplaylist
  case emptyMediaplaylist
  case streamInfError(line: Swift.String)
  case iFrameStreamError(line: Swift.String)
  case mediaError(line: Swift.String)
  case versionError(line: Swift.String)
  case targetDurationError(line: Swift.String)
  case mediaSequenceError(line: Swift.String)
  case segmentInfoError(line: Swift.String)
  case byterangeError(line: Swift.String)
  case discontinuityError(line: Swift.String)
  public var description: Swift.String {
    get
  }
}
open class M3U8FileBufferedReader : NutPlayer.M3U8BufferedReader {
  public init(path: Swift.String)
  open func close()
  open func readLine() -> Swift.String?
  @objc deinit
}
open class M3U8ManifestBuilder {
  public init()
  open func parse(_ url: Foundation.URL, onMediaPlaylist: ((_ playlist: NutPlayer.M3U8MediaPlaylist) -> Swift.Void)? = nil, onMediaSegment: ((_ segment: NutPlayer.M3U8MediaSegment) -> Swift.Void)? = nil) -> NutPlayer.M3U8MasterPlaylist
  open func parseMasterPlaylistFromString(_ string: Swift.String, onMediaPlaylist: ((_ playlist: NutPlayer.M3U8MediaPlaylist) -> Swift.Void)? = nil) -> NutPlayer.M3U8MasterPlaylist
  open func parseMasterPlaylistFromFile(_ path: Swift.String, onMediaPlaylist: ((_ playlist: NutPlayer.M3U8MediaPlaylist) -> Swift.Void)? = nil) -> NutPlayer.M3U8MasterPlaylist
  open func parseMasterPlaylistFromURL(_ url: Foundation.URL, onMediaPlaylist: ((_ playlist: NutPlayer.M3U8MediaPlaylist) -> Swift.Void)? = nil) -> NutPlayer.M3U8MasterPlaylist
  open func parseMediaPlaylistFromString(_ string: Swift.String, mediaPlaylist: NutPlayer.M3U8MediaPlaylist = M3U8MediaPlaylist(), onMediaSegment: ((_ segment: NutPlayer.M3U8MediaSegment) -> Swift.Void)? = nil) -> NutPlayer.M3U8MediaPlaylist
  open func parseMediaPlaylistFromFile(_ path: Swift.String, mediaPlaylist: NutPlayer.M3U8MediaPlaylist = M3U8MediaPlaylist(), onMediaSegment: ((_ segment: NutPlayer.M3U8MediaSegment) -> Swift.Void)? = nil) -> NutPlayer.M3U8MediaPlaylist
  @discardableResult
  open func parseMediaPlaylistFromURL(_ url: Foundation.URL, mediaPlaylist: NutPlayer.M3U8MediaPlaylist = M3U8MediaPlaylist(), onMediaSegment: ((_ segment: NutPlayer.M3U8MediaSegment) -> Swift.Void)? = nil) -> NutPlayer.M3U8MediaPlaylist
  open func transformManifestWith(baseUrl: Swift.String, from string: Swift.String) -> Foundation.Data?
  @objc deinit
}
open class M3U8MasterPlaylist {
  open var path: Swift.String?
  public var mediaTypes: [NutPlayer.M3U8MediaType] {
    get
  }
  public var iframes: [NutPlayer.M3U8MediaIFrame] {
    get
  }
  public var playlists: [NutPlayer.M3U8MediaPlaylist] {
    get
  }
  public var errors: [NutPlayer.M3U8Error] {
    get
  }
  public var isEmpty: Swift.Bool {
    get
  }
  public init()
  open func addPlaylist(_ playlist: NutPlayer.M3U8MediaPlaylist)
  open func getPlaylist(_ index: Swift.Int) -> NutPlayer.M3U8MediaPlaylist?
  open func getPlaylistCount() -> Swift.Int
  open func addIFrame(_ iframe: NutPlayer.M3U8MediaIFrame)
  open func addMediaType(_ type: NutPlayer.M3U8MediaType)
  @objc deinit
}
@_hasMissingDesignatedInitializers public class M3U8MediaIFrame {
  final public let averageBandwidth: Swift.Int
  final public let bandwidth: Swift.Int
  final public let codecs: Swift.String
  final public let resolution: CoreFoundation.CGSize
  final public let urlPath: Swift.String?
  @objc deinit
}
open class M3U8MediaPlaylist {
  open var programId: Swift.Int
  open var bandwidth: Swift.Int?
  open var resolution: CoreFoundation.CGSize
  open var path: Swift.String?
  open var version: Swift.Int?
  open var targetDuration: Swift.Int?
  open var mediaSequence: Swift.Int?
  open var codecs: Swift.String?
  open var frameRate: Swift.Float?
  open var errors: [NutPlayer.M3U8Error]
  open var isEmpty: Swift.Bool {
    get
  }
  public init()
  open func addSegment(_ segment: NutPlayer.M3U8MediaSegment)
  open func getSegment(_ index: Swift.Int) -> NutPlayer.M3U8MediaSegment?
  open func getSegmentCount() -> Swift.Int
  open func duration() -> Swift.Float
  @objc deinit
}
open class M3U8MediaSegment {
  open var duration: Swift.Float?
  open var sequence: Swift.Int
  open var subrangeLength: Swift.Int?
  open var subrangeStart: Swift.Int?
  open var title: Swift.String?
  open var discontinuity: Swift.Bool
  open var path: Swift.String?
  public init()
  open func getMediaPlaylist() -> NutPlayer.M3U8MediaPlaylist?
  @objc deinit
}
public enum M3U8MediaType {
  case audio(groupID: Swift.String, language: Swift.String, name: Swift.String, autoselect: Swift.Bool, byDefault: Swift.Bool, uri: Swift.String)
  case subtitles(groupID: Swift.String, language: Swift.String, name: Swift.String, autoselect: Swift.Bool, byDefault: Swift.Bool, forced: Swift.Bool, uri: Swift.String)
}
@_hasMissingDesignatedInitializers open class M3U8ReaderBuilder {
  @objc deinit
}
open class M3U8StringBufferedReader : NutPlayer.M3U8BufferedReader {
  public init(string: Swift.String)
  open func close()
  open func readLine() -> Swift.String?
  @objc deinit
}
open class M3U8URLBufferedReader : NutPlayer.M3U8BufferedReader {
  public init(uri: Foundation.URL)
  open func close()
  open func readLine() -> Swift.String?
  @objc deinit
}
extension Foundation.URL {
  public func URLByReplacingLastPathComponent(_ pathComponent: Swift.String) -> Foundation.URL?
}
final public class NutActivityIndicatorPlugin : NutPlayer.PlayerPlugin, NutPlayer.ViewablePlayerPlugin {
  final public var view: UIKit.UIView {
    get
  }
  public init(player: any NutPlayer.Player, eventBus: any NutPlayer.EventTransmittable, settings: (any NutPlayer.PlayerPluginSettings)?)
  @objc deinit
}
final public class NutBlackoutPlugin : NutPlayer.PlayerPlugin, NutPlayer.ViewablePlayerPlugin {
  public init(player: any NutPlayer.Player, eventBus: any NutPlayer.EventTransmittable, settings: (any NutPlayer.PlayerPluginSettings)?)
  final public var view: UIKit.UIView
  @objc deinit
}
final public class NutCache<Key, Value> where Key : Swift.Hashable {
  final public func insert(_ value: Value, forKey key: Key)
  final public func value(forKey key: Key) -> Value?
  final public func removeValue(forKey key: Key)
  final public subscript(key: Key) -> Value? {
    get
    set
  }
  public init()
  @objc deinit
}
public struct NutContent : NutPlayer.PlayerContent {
  public let content: NutPlayer.ContentType
  public let statistics: [any NutPlayer.PlayerStatisticRecord]
  public var subtitles: [any NutPlayer.PlayerSubtitleRecord]
}
public enum NutContentUIType {
  case standard
  case loop
  case live
  public static func == (a: NutPlayer.NutContentUIType, b: NutPlayer.NutContentUIType) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
final public class NutEventBus : NutPlayer.EventTransmittable {
  final public let id: Swift.String
  public init(id: Swift.String = UUID().uuidString)
  final public func send<E>(_ event: E) where E : NutPlayer.BusEventRepresentable
  @discardableResult
  final public func receive<E>(_ eventType: E.Type, perform action: @escaping (E) -> Swift.Void) -> NutPlayer.AnyCancellable where E : NutPlayer.BusEventRepresentable
  @discardableResult
  final public func receive<E, S>(_ eventType: E.Type, performOn scheduler: S, action: @escaping (E) -> Swift.Void) -> NutPlayer.AnyCancellable where E : NutPlayer.BusEventRepresentable, S : Combine.Scheduler
  @objc deinit
}
final public class NutHlsTech : NutPlayer.Tech {
  public typealias LoadCompletion = (NutPlayer.NutHlsTech, NutPlayer.HlsError?) -> Swift.Void
  public typealias QualityPresets = (resolution: CoreFoundation.CGSize, bandwidth: Swift.Int)
  final public var pipController: (any NutPlayer.TechPipController)? {
    get
    set
  }
  final public let layer: QuartzCore.CALayer
  final public var state: NutPlayer.TechState {
    get
  }
  final public var duration: Swift.Double
  final public var currentTime: Foundation.TimeInterval {
    get
  }
  @NutPlayer.ValueSubject final public var cache: NutPlayer.Value<Foundation.TimeInterval> {
    get
  }
  final public var volume: Swift.Float {
    get
    set
  }
  final public var playbackRate: NutPlayer.TechPlaybackRate {
    get
    set
  }
  final public var qualities: [any NutPlayer.TechQuality] {
    get
  }
  final public var quality: (any NutPlayer.TechQuality)? {
    get
  }
  weak final public var delegate: (any NutPlayer.TechDelegate)?
  public init()
  @objc deinit
  final public func load(with url: Foundation.URL, reduceStalling: Swift.Bool, timeouts: NutPlayer.TechTimeouts, quality: NutPlayer.NutHlsTech.QualityPresets? = nil, completion: NutPlayer.NutHlsTech.LoadCompletion? = nil)
  final public func play(context: NutPlayer.TechPlayingContext? = nil)
  final public func pause()
  final public func seek(to time: Foundation.TimeInterval, completion: NutPlayer.NutHlsTech.SeekCompletion? = nil)
  final public func stop()
  final public func end()
  @discardableResult
  final public func select(quality: any NutPlayer.TechQuality) -> NutPlayer.TechError?
}
@objc @_hasMissingDesignatedInitializers @_Concurrency.MainActor(unsafe) final public class NutLoaderView : UIKit.UIActivityIndicatorView {
  @_Concurrency.MainActor(unsafe) @objc dynamic public init()
  @_Concurrency.MainActor(unsafe) @objc override final public func layoutSubviews()
  @objc deinit
}
final public class NutLocalization {
  public enum BundleLevel {
    case app
    case package
    public static func == (a: NutPlayer.NutLocalization.BundleLevel, b: NutPlayer.NutLocalization.BundleLevel) -> Swift.Bool
    public func hash(into hasher: inout Swift.Hasher)
    public var hashValue: Swift.Int {
      get
    }
  }
  public init(from level: NutPlayer.NutLocalization.BundleLevel = .app)
  final public subscript(identity: Swift.String) -> Swift.String {
    get
  }
  @objc deinit
}
final public class NutMP4LoopTech : NutPlayer.Tech, NutPlayer.TechViewable, NutPlayer.TechLoadable {
  final public let pipController: (any NutPlayer.TechPipController)?
  final public let layer: QuartzCore.CALayer
  final public var state: NutPlayer.TechState {
    get
    set
  }
  final public var duration: Swift.Double
  final public var currentTime: Foundation.TimeInterval {
    get
  }
  @NutPlayer.ValueSubject final public var cache: NutPlayer.Value<Foundation.TimeInterval> {
    get
  }
  final public var volume: Swift.Float {
    get
    set
  }
  final public var playbackRate: NutPlayer.TechPlaybackRate {
    get
    set
  }
  weak final public var delegate: (any NutPlayer.TechDelegate)?
  public init()
  @objc deinit
  final public func load(with url: Foundation.URL)
  final public func play(context: NutPlayer.TechPlayingContext? = nil)
  final public func pause()
  final public func stop()
  final public func seek(to time: Foundation.TimeInterval, completion: NutPlayer.NutMP4LoopTech.SeekCompletion? = nil)
  final public func end()
}
final public class NutMP4Tech : NutPlayer.Tech, NutPlayer.TechViewable, NutPlayer.TechLoadable {
  final public var pipController: (any NutPlayer.TechPipController)? {
    get
    set
  }
  final public var layer: QuartzCore.CALayer {
    get
  }
  final public var state: NutPlayer.TechState {
    get
    set
  }
  final public var duration: Swift.Double
  final public var currentTime: Foundation.TimeInterval {
    get
  }
  @NutPlayer.ValueSubject final public var cache: NutPlayer.Value<Foundation.TimeInterval> {
    get
  }
  final public var volume: Swift.Float {
    get
    set
  }
  final public var playbackRate: NutPlayer.TechPlaybackRate {
    get
    set
  }
  weak final public var delegate: (any NutPlayer.TechDelegate)?
  public init()
  @objc deinit
  final public func load(with url: Foundation.URL)
  final public func play(context: NutPlayer.TechPlayingContext? = nil)
  final public func pause()
  final public func seek(to time: Foundation.TimeInterval, completion: NutPlayer.NutMP4Tech.SeekCompletion? = nil)
  final public func stop()
  final public func end()
}
public enum NutPlaybackButtonType {
  case play
  case pause
  case restart
  public static func == (a: NutPlayer.NutPlaybackButtonType, b: NutPlayer.NutPlaybackButtonType) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
@_hasMissingDesignatedInitializers final public class NutPlayer : NutPlayer.Player {
  @NutPlayer.ValueSubject final public var pipController: NutPlayer.Value<(any NutPlayer.PlayerPictureInPictureController)?> {
    get
  }
  @NutPlayer.ValueSubject final public var state: NutPlayer.Value<NutPlayer.PlayerState> {
    get
  }
  @NutPlayer.ValueSubject final public var volume: NutPlayer.Value<Swift.Float> {
    get
  }
  @NutPlayer.ValueSubject final public var currentTime: NutPlayer.Value<Foundation.TimeInterval> {
    get
  }
  @NutPlayer.ValueSubject final public var duration: NutPlayer.Value<Foundation.TimeInterval> {
    get
  }
  @NutPlayer.ValueSubject final public var cache: NutPlayer.Value<Foundation.TimeInterval> {
    get
  }
  @NutPlayer.ValueSubject final public var currentQuality: NutPlayer.Value<(any NutPlayer.PlayerQualityRecord)?> {
    get
  }
  @NutPlayer.ValueSubject final public var qualities: NutPlayer.Value<[any NutPlayer.PlayerQualityRecord]> {
    get
  }
  @NutPlayer.ValueSubject final public var content: NutPlayer.Value<(any NutPlayer.PlayerContent)?> {
    get
  }
  final public var menu: [any NutPlayer.PlayerSettingsRecord] {
    get
  }
  final public var plugins: [any NutPlayer.PlayerPlugin] {
    get
  }
  public init(settings: NutPlayer.NutPlayerSettings = NutPlayerSettings())
  final public func load(content: NutPlayer.ContentType)
  final public func load(provider: any NutPlayer.Provider, timeouts: NutPlayer.PlayerTimeouts = PlayerTimeouts(playlist: 5_000, track: 3_000), autoplay: Swift.Bool = false, position: Foundation.TimeInterval = 0.0, quality: NutPlayer.QualityPresets? = nil)
  final public func play()
  final public func pause()
  final public func stop()
  final public func seek(time: Foundation.TimeInterval)
  final public func end()
  final public func change(rate: NutPlayer.PlayerPlaybackRate)
  final public func change(volume: Swift.Float)
  final public func select(quality: any NutPlayer.PlayerQualityRecord)
  @objc deinit
}
final public class NutPlayerErrorPlugin : NutPlayer.ViewablePlayerPlugin {
  public init(player: any NutPlayer.Player, eventBus: any NutPlayer.EventTransmittable, settings: (any NutPlayer.PlayerPluginSettings)?)
  final public var view: UIKit.UIView {
    get
  }
  @objc deinit
}
public enum ContentPlayerFactoryError : Swift.Error {
  case unsupported(urlPath: Swift.String)
  case unrecognized(type: NutPlayer.ContentType)
}
public protocol ContentPlayerFactory {
  typealias TimeInterval = Swift.Double
  typealias QualityPresets = (resolution: CoreFoundation.CGSize, bandwidth: Swift.Int)
  static func contentPlayer(with content: NutPlayer.ContentType, playerTimeouts: NutPlayer.PlayerTimeouts, from position: Self.TimeInterval, autostart: Swift.Bool, quality: Self.QualityPresets?) -> Swift.Result<NutPlayer.ContentPlayer, NutPlayer.ContentPlayerFactoryError>
}
public protocol AdvertisementPlayerFactory {
}
public enum NutPlayerFactory : NutPlayer.ContentPlayerFactory, NutPlayer.AdvertisementPlayerFactory {
  public static func contentPlayer(with content: NutPlayer.ContentType, playerTimeouts: NutPlayer.PlayerTimeouts, from position: Foundation.TimeInterval, autostart: Swift.Bool, quality: NutPlayer.QualityPresets? = nil) -> Swift.Result<NutPlayer.ContentPlayer, NutPlayer.ContentPlayerFactoryError>
}
public struct NutPlayerSettings {
  public let isPipAvailable: Swift.Bool
  public init(isPipAvailable: Swift.Bool = true)
}
@objc final public class NutPlayerSkinPlugin : ObjectiveC.NSObject, NutPlayer.ViewablePlayerPlugin, NutPlayer.NutPlayerSkinViewDelegate {
  public struct Settings : NutPlayer.PlayerPluginSettings {
    public typealias VoidCallback = () -> Swift.Void
    public typealias BoolCallback = (_ onEnter: Swift.Bool) -> Swift.Void
    public let onSettings: NutPlayer.NutPlayerSkinPlugin.Settings.VoidCallback?
    public let onPip: NutPlayer.NutPlayerSkinPlugin.Settings.BoolCallback?
    public let onFullscreen: NutPlayer.NutPlayerSkinPlugin.Settings.BoolCallback?
    public init(onSettings: NutPlayer.NutPlayerSkinPlugin.Settings.VoidCallback? = nil, onPip: NutPlayer.NutPlayerSkinPlugin.Settings.BoolCallback? = nil, onFullscreen: NutPlayer.NutPlayerSkinPlugin.Settings.BoolCallback? = nil)
  }
  final public let view: UIKit.UIView
  final public func changeGeometry(portrait: Swift.Bool)
  public init(player: any NutPlayer.Player, eventBus: any NutPlayer.EventTransmittable, settings: (any NutPlayer.PlayerPluginSettings)?)
  final public func playbackButtonPressed(_ type: NutPlayer.NutPlaybackButtonType)
  final public func seekButtonPressed(_ type: NutPlayer.NutSeekButtonType)
  final public func viewModeChanged(to mode: NutPlayer.NutViewMode)
  final public func timelineDidChange(state: NutPlayer.NutSliderState)
  final public func settingsTapped()
  final public func volumeChanged(value: Swift.Float)
  @objc deinit
}
public enum NutPlayerSkinState {
  case idle
  case ready
  case loading
  case playing
  case seeking
  case paused
  case completed
  public static func == (a: NutPlayer.NutPlayerSkinState, b: NutPlayer.NutPlayerSkinState) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public struct NutPlayerSkinTimeModel {
  public init(position: Foundation.TimeInterval, duration: Foundation.TimeInterval)
}
@objc @_hasMissingDesignatedInitializers @_Concurrency.MainActor(unsafe) final public class NutPlayerSkinView : UIKit.UIView {
  @_Concurrency.MainActor(unsafe) weak final public var delegate: (any NutPlayer.NutPlayerSkinViewDelegate)?
  @NutPlayer.ValueSubject @_Concurrency.MainActor(unsafe) final public var areMainElementsVisible: NutPlayer.Value<Swift.Bool> {
    get
  }
  @NutPlayer.ValueSubject @_Concurrency.MainActor(unsafe) final public var timelineTopMargin: NutPlayer.Value<CoreFoundation.CGFloat> {
    get
  }
  @_Concurrency.MainActor(unsafe) public init(viewModel: NutPlayer.NutPlayerSkinViewModel, settings: NutPlayer.CustomizableAreaSettings)
  @_Concurrency.MainActor(unsafe) @objc override final public func layoutSubviews()
  @_Concurrency.MainActor(unsafe) final public func changePlaybackButton(with state: NutPlayer.NutPlayerSkinState)
  @_Concurrency.MainActor(unsafe) final public func changeSeekBack(enabled: Swift.Bool)
  @_Concurrency.MainActor(unsafe) final public func changeSeekForward(enabled: Swift.Bool)
  @_Concurrency.MainActor(unsafe) final public func changeTime(_ time: Foundation.TimeInterval)
  @_Concurrency.MainActor(unsafe) final public func changeBuffer(_ buffer: Foundation.TimeInterval)
  @_Concurrency.MainActor(unsafe) final public func changeFullscreen(_ isFullscreen: Swift.Bool)
  @_Concurrency.MainActor(unsafe) final public func changeValue(type: NutPlayer.NutVerticalSliderType, value: Swift.Float)
  @_Concurrency.MainActor(unsafe) final public func hide()
  @_Concurrency.MainActor(unsafe) final public func show()
  @_Concurrency.MainActor(unsafe) @objc override final public func traitCollectionDidChange(_ previousTraitCollection: UIKit.UITraitCollection?)
  @objc deinit
}
public protocol NutPlayerSkinViewDelegate : AnyObject {
  func playbackButtonPressed(_ type: NutPlayer.NutPlaybackButtonType)
  func seekButtonPressed(_ type: NutPlayer.NutSeekButtonType)
  func settingsTapped()
  func viewModeChanged(to mode: NutPlayer.NutViewMode)
  func volumeChanged(value: Swift.Float)
  func timelineDidChange(state: NutPlayer.NutSliderState)
}
public struct NutPlayerSkinViewModel {
  public let viewMode: NutPlayer.NutViewMode
  public let volume: Swift.Float
  public let state: NutPlayer.NutPlayerSkinState
  public let contentType: NutPlayer.NutContentUIType
  public let time: NutPlayer.NutPlayerSkinTimeModel?
  public init(viewMode: NutPlayer.NutViewMode, volume: Swift.Float, state: NutPlayer.NutPlayerSkinState, contentType: NutPlayer.NutContentUIType, time: NutPlayer.NutPlayerSkinTimeModel?)
}
@objc @_hasMissingDesignatedInitializers @_Concurrency.MainActor(unsafe) final public class NutPlayerView : UIKit.UIView {
  @_Concurrency.MainActor(unsafe) @objc override final public func addSubview(_ view: UIKit.UIView)
  @_Concurrency.MainActor(unsafe) @objc override final public func insertSubview(_ view: UIKit.UIView, at index: Swift.Int)
  @_Concurrency.MainActor(unsafe) @objc override final public func insertSubview(_ view: UIKit.UIView, aboveSubview siblingSubview: UIKit.UIView)
  @_Concurrency.MainActor(unsafe) @objc override final public func insertSubview(_ view: UIKit.UIView, belowSubview siblingSubview: UIKit.UIView)
  @_Concurrency.MainActor(unsafe) @objc override final public func layoutSubviews()
  @_Concurrency.MainActor(unsafe) @objc override final public func traitCollectionDidChange(_ previousTraitCollection: UIKit.UITraitCollection?)
  @objc deinit
}
final public class NutPlayerViewBuilder {
  public struct PluginRecord : Swift.Comparable {
    public enum Priority {
      case system
      case userInitiated
      case ui(level: Swift.Int = 500)
    }
    public init(plugin: any NutPlayer.PlayerPlugin.Type, priority: NutPlayer.NutPlayerViewBuilder.PluginRecord.Priority = .ui(), settings: (any NutPlayer.PlayerPluginSettings)? = nil)
    public static func < (lhs: NutPlayer.NutPlayerViewBuilder.PluginRecord, rhs: NutPlayer.NutPlayerViewBuilder.PluginRecord) -> Swift.Bool
    public static func == (lhs: NutPlayer.NutPlayerViewBuilder.PluginRecord, rhs: NutPlayer.NutPlayerViewBuilder.PluginRecord) -> Swift.Bool
  }
  public init()
  @discardableResult
  final public func clearPlugins() -> NutPlayer.NutPlayerViewBuilder
  @discardableResult
  final public func attach(plugins: [NutPlayer.NutPlayerViewBuilder.PluginRecord]) -> NutPlayer.NutPlayerViewBuilder
  @discardableResult
  final public func defaultSkin(_ value: Swift.Bool = true) -> NutPlayer.NutPlayerViewBuilder
  @discardableResult
  final public func defaultSkin(settings: NutPlayer.NutPlayerSkinPlugin.Settings) -> NutPlayer.NutPlayerViewBuilder
  final public func build(with player: NutPlayer.NutPlayer) -> NutPlayer.NutPlayerView
  @objc deinit
}
public struct NutProvider : NutPlayer.Provider {
  public init(hash: Swift.String, configuration: Foundation.URLSessionConfiguration? = nil)
  public func retrieveContent(_ completion: @escaping NutPlayer.NutProvider.Completion)
}
final public class NutQualityPlugin : NutPlayer.SettingsPlayerPlugin, NutPlayer.QualityTitleMapper {
  public struct Settings : NutPlayer.PlayerPluginSettings {
    public let mapper: any NutPlayer.QualityTitleMapper
    public init(mapper: any NutPlayer.QualityTitleMapper)
  }
  public struct PluginSettingsRecord : NutPlayer.PlayerSettingsRecord {
    public let quality: (any NutPlayer.PlayerQualityRecord)?
    public let id: Swift.String
    public let index: Swift.Int
    public let isActive: Swift.Bool
    public let group: Swift.String
    public let title: Swift.String
    public let element: NutPlayer.PlayerSettingsElementRecord
  }
  public init(player: any NutPlayer.Player, eventBus: any NutPlayer.EventTransmittable, settings: (any NutPlayer.PlayerPluginSettings)?)
  final public var menu: [any NutPlayer.PlayerSettingsRecord] {
    get
  }
  final public func map(quality: any NutPlayer.PlayerQualityRecord) -> Swift.String?
  @objc deinit
}
public enum NutSeekButtonType {
  case back
  case forward
  public static func == (a: NutPlayer.NutSeekButtonType, b: NutPlayer.NutSeekButtonType) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public enum NutSliderState {
  case started
  case updating(value: Swift.Float)
  case finished(value: Swift.Float)
}
final public class NutStatisticsPlugin : NutPlayer.PlayerPlugin {
  public init(player: any NutPlayer.Player, eventBus: any NutPlayer.EventTransmittable, settings: (any NutPlayer.PlayerPluginSettings)?)
  @objc deinit
}
final public class NutSubtitlePlugin : NutPlayer.PlayerPlugin, NutPlayer.SettingsPlayerPlugin, NutPlayer.ViewablePlayerPlugin {
  public init(player: any NutPlayer.Player, eventBus: any NutPlayer.EventTransmittable, settings: (any NutPlayer.PlayerPluginSettings)?)
  final public var menu: [any NutPlayer.PlayerSettingsRecord]
  final public var view: UIKit.UIView
  @objc deinit
}
public enum NutVerticalSliderType {
  case volume
  case brightness
  public static func == (a: NutPlayer.NutVerticalSliderType, b: NutPlayer.NutVerticalSliderType) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public enum NutViewMode {
  case normal
  case fullscreen
  case pip
  public static func == (a: NutPlayer.NutViewMode, b: NutPlayer.NutViewMode) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
precedencegroup MonadicPrecedence {
  associativity: left
  higherThan: BitwiseShiftPrecedence
}
infix operator >>- : MonadicPrecedence
@discardableResult
@inline(__always) public func >>- <T, U>(a: T?, f: (T) throws -> U?) rethrows -> U?
precedencegroup FunctionApplicationPrecedenceLeft {
  associativity: left
  lowerThan: AssignmentPrecedence
}
infix operator >>> : FunctionApplicationPrecedenceLeft
@inline(__always) public func >>> <T, U>(x: T, f: (T) throws -> U) rethrows -> U
precedencegroup FunctionApplicationPrecedenceRight {
  associativity: right
  lowerThan: AssignmentPrecedence
}
infix operator <<< : FunctionApplicationPrecedenceRight
@inline(__always) public func <<< <T, U>(f: (T) throws -> U, x: T) rethrows -> U
infix operator +/- : DefaultPrecedence
@inline(__always) public func +/- <T>(lhs: T, rhs: T) -> Swift.ClosedRange<T> where T : Swift.Comparable, T : Swift.Numeric
extension Swift.Optional {
  public var isExist: Swift.Bool {
    get
  }
  public func orCreate(_ creation: @autoclosure () -> Wrapped) -> Wrapped
  public func orTypedCreate<Element>(_ creation: @autoclosure () -> Element) -> Element where Wrapped == Element.RawValue, Element : Swift.RawRepresentable
}
public typealias QualityPresets = (resolution: CoreFoundation.CGSize, bandwidth: Swift.Int)
public protocol Player : AnyObject {
  typealias TimeInterval = Swift.Double
  var state: NutPlayer.Value<NutPlayer.PlayerState> { get }
  var volume: NutPlayer.Value<Swift.Float> { get }
  var currentTime: NutPlayer.Value<Self.TimeInterval> { get }
  var content: NutPlayer.Value<(any NutPlayer.PlayerContent)?> { get }
  var duration: NutPlayer.Value<Self.TimeInterval> { get }
  var cache: NutPlayer.Value<Self.TimeInterval> { get }
  var currentQuality: NutPlayer.Value<(any NutPlayer.PlayerQualityRecord)?> { get }
  var qualities: NutPlayer.Value<[any NutPlayer.PlayerQualityRecord]> { get }
  func select(quality: any NutPlayer.PlayerQualityRecord)
  func play()
  func pause()
  func stop()
  func seek(time: Self.TimeInterval)
  func end()
  func change(rate: NutPlayer.PlayerPlaybackRate)
  func change(volume: Swift.Float)
}
public protocol PlayerContent {
  var content: NutPlayer.ContentType { get }
  var statistics: [any NutPlayer.PlayerStatisticRecord] { get }
  var subtitles: [any NutPlayer.PlayerSubtitleRecord] { get }
}
public enum ContentType {
  case auto(url: Foundation.URL)
  case hls(url: Foundation.URL, reduceStalling: Swift.Bool = true)
  case dash(url: Foundation.URL)
  case mp4(url: Foundation.URL, loop: Swift.Bool = false)
  case raw(data: Foundation.Data)
}
public enum HTTPMethod : Swift.String {
  case get
  case post
  public init?(rawValue: Swift.String)
  public typealias RawValue = Swift.String
  public var rawValue: Swift.String {
    get
  }
}
public enum SubtitleType : Swift.String {
  case SRT
  public init?(rawValue: Swift.String)
  public typealias RawValue = Swift.String
  public var rawValue: Swift.String {
    get
  }
}
public protocol PlayerStatisticRecord {
  var name: Swift.String { get }
  var urlTemplate: Swift.String { get }
  var start: Foundation.TimeInterval { get }
  var delay: Foundation.TimeInterval { get }
  var count: Swift.Int { get }
  var method: NutPlayer.HTTPMethod { get }
  var body: Swift.String? { get }
}
public protocol PlayerSubtitleRecord {
  var title: Swift.String { get }
  var type: NutPlayer.SubtitleType { get }
  var url: Swift.String { get }
  var language: Swift.String { get }
}
public enum PlayerError : Swift.Error {
  case loop
  case provider(any Swift.Error)
  case other(any Swift.Error)
  case unsupported(urlPath: Swift.String)
  case unrecognized(type: NutPlayer.ContentType)
}
public protocol PlayerPictureInPictureController {
  var isPossible: NutPlayer.Value<Swift.Bool> { get }
  var isActive: NutPlayer.Value<Swift.Bool> { get }
  var isSuspended: NutPlayer.Value<Swift.Bool> { get }
  func start()
  func stop()
}
public enum PlayerPlaybackRate : Swift.Float, Swift.CaseIterable {
  case speed0x25
  case speed0x5
  case speed0x75
  case normal
  case speed1x25
  case speed1x5
  case speed1x75
  case speed2x
  public init(title: Swift.String)
  public var title: Swift.String {
    get
  }
  public init?(rawValue: Swift.Float)
  public typealias AllCases = [NutPlayer.PlayerPlaybackRate]
  public typealias RawValue = Swift.Float
  public static var allCases: [NutPlayer.PlayerPlaybackRate] {
    get
  }
  public var rawValue: Swift.Float {
    get
  }
}
public protocol PlayerPluginSettings {
}
public protocol PlayerPlugin {
  init(player: any NutPlayer.Player, eventBus: any NutPlayer.EventTransmittable, settings: (any NutPlayer.PlayerPluginSettings)?)
}
public protocol ViewablePlayerPlugin : NutPlayer.PlayerPlugin {
  var view: UIKit.UIView { get }
  func changeGeometry(portrait: Swift.Bool)
}
public protocol SettingsPlayerPlugin : NutPlayer.PlayerPlugin {
  var menu: [any NutPlayer.PlayerSettingsRecord] { get }
}
extension NutPlayer.ViewablePlayerPlugin {
  public func changeGeometry(portrait: Swift.Bool)
}
public protocol PlayerQualityRecord {
  typealias Identity = Swift.String
  var id: Self.Identity { get }
  var resolution: CoreFoundation.CGSize { get }
  var bandwidth: Swift.Int { get }
}
public enum PlayerSettingsElementRecord {
  public typealias ActionHandler = (any NutPlayer.PlayerSettingsRecord) -> Swift.Void
  case action(NutPlayer.PlayerSettingsElementRecord.ActionHandler)
  case separator
  case submenu([any NutPlayer.PlayerSettingsRecord])
}
public protocol PlayerSettingsRecord {
  typealias Identity = Swift.String
  var id: Self.Identity { get }
  var index: Swift.Int { get }
  var isActive: Swift.Bool { get }
  var group: Swift.String { get }
  var title: Swift.String { get }
  var element: NutPlayer.PlayerSettingsElementRecord { get }
}
public enum PlayerState : Swift.Equatable {
  case idle
  case content(any NutPlayer.PlayerContent)
  case loading
  case ready(position: Foundation.TimeInterval, duration: Foundation.TimeInterval?)
  case buffering
  case playing
  case paused(byUI: Swift.Bool = false)
  case completed
  case seeking(Foundation.TimeInterval)
  case error(NutPlayer.PlayerError)
  case uninitialized
  public var isError: Swift.Bool {
    get
  }
  public static func == (lhs: NutPlayer.PlayerState, rhs: NutPlayer.PlayerState) -> Swift.Bool
}
public struct PlayerTimeouts {
  public let playlist: Foundation.TimeInterval
  public let track: Foundation.TimeInterval
  public init(playlist: Foundation.TimeInterval, track: Foundation.TimeInterval)
}
public enum ProviderError : Swift.Error {
  case noPlayable
  case native(error: any Swift.Error)
  case noMime
  case unsupported
  case wrongUrl(url: Swift.String)
  case data
  case casting(any Swift.Decodable.Type)
  case unknown
}
public protocol Provider {
  typealias Completion = (Swift.Result<any NutPlayer.PlayerContent, NutPlayer.ProviderError>) -> Swift.Void
  typealias FilesCompletion = ([Swift.String]) -> Swift.Void
  func retrieveContent(_ completion: @escaping Self.Completion)
}
public protocol QualityTitleMapper {
  func map(quality: any NutPlayer.PlayerQualityRecord) -> Swift.String?
}
final public class Ref<T> where T : AnyObject {
  final public var value: T
  public init(_ value: T)
  @objc deinit
}
final public class OptionalRef<T> where T : AnyObject {
  final public var value: T?
  public init(_ value: T? = nil)
  @objc deinit
}
extension Swift.Sequence {
  public func all(where predicate: (Self.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Swift.String {
  public func createAttributedString(fontFamily: Swift.String, fontSize: CoreFoundation.CGFloat, alignment: UIKit.NSTextAlignment, color: UIKit.UIColor) -> Foundation.NSAttributedString
}
extension Swift.String {
  public func replace(_ pattern: Swift.String, replacement: Swift.String) throws -> Swift.String
  public func substring(using range: Foundation.NSRange) -> Swift.String?
  @inlinable public func contains<T>(anyOf sequence: T) -> Swift.Bool where T : Swift.Sequence, T.Element : Swift.StringProtocol {
        sequence.contains(where: { self.contains($0) })
    }
  public var isURI: Swift.Bool {
    get
  }
}
public protocol Tech : AnyObject {
  typealias TimeInterval = Swift.Double
  typealias SeekCompletion = (Swift.Bool) -> Swift.Void
  var pipController: (any NutPlayer.TechPipController)? { get }
  var state: NutPlayer.TechState { get }
  var duration: Self.TimeInterval { get }
  var currentTime: Self.TimeInterval { get }
  var cache: NutPlayer.Value<Self.TimeInterval> { get }
  var volume: Swift.Float { get set }
  var playbackRate: NutPlayer.TechPlaybackRate { get set }
  var delegate: (any NutPlayer.TechDelegate)? { get set }
  var quality: (any NutPlayer.TechQuality)? { get }
  var qualities: [any NutPlayer.TechQuality] { get }
  func play(context: NutPlayer.TechPlayingContext?)
  func pause()
  func stop()
  func seek(to time: Self.TimeInterval, completion: Self.SeekCompletion?)
  func end()
  @discardableResult
  func select(quality: any NutPlayer.TechQuality) -> NutPlayer.TechError?
}
extension NutPlayer.Tech {
  public var quality: (any NutPlayer.TechQuality)? {
    get
  }
  public var qualities: [any NutPlayer.TechQuality] {
    get
  }
  @discardableResult
  public func select(quality: any NutPlayer.TechQuality) -> NutPlayer.TechError?
}
@objc @_inheritsConvenienceInitializers final public class TechAVPlayer : AVFoundation.AVPlayer {
  @objc override final public func seek(to time: CoreMedia.CMTime)
  @objc override final public func seek(to time: CoreMedia.CMTime, completionHandler: @escaping (Swift.Bool) -> Swift.Void)
  @objc override dynamic public init(url URL: Foundation.URL)
  @objc override dynamic public init(playerItem item: AVFoundation.AVPlayerItem?)
  @objc override dynamic public init()
  @objc deinit
}
public protocol TechDelegate : AnyObject {
  func didChange(state: NutPlayer.TechState)
  func didChange(time: Foundation.TimeInterval)
  func didChange(playbackType: NutPlayer.TechPlayableType)
  func didChange(volume: Swift.Float)
  func didChange(quality: any NutPlayer.TechQuality)
  func didChange(qualities: [any NutPlayer.TechQuality])
}
public enum TechError : Swift.Error {
  case playlistEmpty
  case qualityNotExists
  case allQualitiesEndedWithError
  case assetStatus(any Swift.Error)
  case loopDuration
}
public protocol TechLoadable {
  func load(with url: Foundation.URL)
}
public protocol TechPipController {
  var isPossible: NutPlayer.Value<Swift.Bool> { get }
  var isActive: NutPlayer.Value<Swift.Bool> { get }
  var isSuspended: NutPlayer.Value<Swift.Bool> { get }
  func start()
  func stop()
}
@_hasMissingDesignatedInitializers final public class TechPipControllerImpl : NutPlayer.TechPipController {
  public static func create(using playerLayer: AVFoundation.AVPlayerLayer) -> (any NutPlayer.TechPipController)?
  @objc deinit
  final public let isPossible: NutPlayer.Value<Swift.Bool>
  final public let isActive: NutPlayer.Value<Swift.Bool>
  final public let isSuspended: NutPlayer.Value<Swift.Bool>
  final public func start()
  final public func stop()
}
public enum TechPlayableType {
  case vod
  case raw
  case live
  case drm
  case unknown
  public static func == (a: NutPlayer.TechPlayableType, b: NutPlayer.TechPlayableType) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public enum TechPlaybackRate : Swift.RawRepresentable {
  case rate0x25
  case rate0x50
  case rate0x75
  case normal
  case rate1x25
  case rate1x50
  case rate1x75
  case rate2x
  case custom(rate: Swift.Float)
  public init?(rawValue: Swift.Float)
  public var rawValue: Swift.Float {
    get
  }
  public typealias RawValue = Swift.Float
}
public protocol TechQuality {
  typealias Identify = Swift.String
  var id: Self.Identify { get }
  var resolution: CoreFoundation.CGSize { get }
  var bandwidth: Swift.Int { get }
}
public struct CommonTechQuality : NutPlayer.TechQuality {
  public let id: Swift.String
  public let resolution: CoreFoundation.CGSize
  public let bandwidth: Swift.Int
  public static func create() -> any NutPlayer.TechQuality
}
public enum TechState : Swift.Equatable {
  case uninitialized
  case idle
  case loading(quality: any NutPlayer.TechQuality)
  case ready(duration: Foundation.TimeInterval? = nil)
  case buffering
  case playing
  case paused
  case completed
  case seeking(Foundation.TimeInterval)
  case error(NutPlayer.TechError)
  public var isError: Swift.Bool {
    get
  }
  public static func == (lhs: NutPlayer.TechState, rhs: NutPlayer.TechState) -> Swift.Bool
}
public enum TechPlayingContext {
  case didBecomeActive
  public static func == (a: NutPlayer.TechPlayingContext, b: NutPlayer.TechPlayingContext) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public struct TechTimeouts {
  public let playlist: Foundation.TimeInterval
  public let track: Foundation.TimeInterval
  public init(playlist: Foundation.TimeInterval, track: Foundation.TimeInterval)
}
public protocol TechViewable {
  var layer: QuartzCore.CALayer { get }
}
extension Swift.Double {
  public func secondsToHoursMinutesSeconds(withFormattingBasedOn time: Foundation.TimeInterval) -> Swift.String
}
extension Swift.Double {
  public func handleSeekTime(using duration: Foundation.TimeInterval, canOverflow: Swift.Bool = false) -> Foundation.TimeInterval
}
extension UIKit.UIButton {
  @_Concurrency.MainActor(unsafe) public func setImage(name: Swift.String = "", in bundle: Foundation.Bundle = .main, width: CoreFoundation.CGFloat = 0.0)
}
public enum DeviceType {
  case ipadS
  case ipadM
  case ipadL
  case iphone
  case iphoneSE
  case ipod
  case appleTV
  case unknown
  public static func == (a: NutPlayer.DeviceType, b: NutPlayer.DeviceType) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
extension UIKit.UIDevice {
  @_Concurrency.MainActor(unsafe) public var isIphoneFamily: Swift.Bool {
    get
  }
  @_Concurrency.MainActor(unsafe) public var type: NutPlayer.DeviceType {
    get
  }
  @_Concurrency.MainActor(unsafe) public var model: UIKit.UIDevice.Model {
    get
  }
  public enum Model : Swift.String {
    case simulator, iPod3, iPod4, iPod5, iPod6, iPod7, iPad4, iPadAir, iPadAir2, iPadAir3, iPadAir4, iPadAir5, iPad5, iPad6, iPad7, iPad8, iPad9, iPad10, iPadMini, iPadMini2, iPadMini3, iPadMini4, iPadMini5, iPadMini6, iPadPro9_7, iPadPro10_5, iPadPro11, iPadPro2_11, iPadPro3_11, iPadPro4_11, iPadPro12_9, iPadPro2_12_9, iPadPro3_12_9, iPadPro4_12_9, iPadPro5_12_9, iPadPro6_12_9, iPhone6, iPhone6Plus, iPhone6S, iPhone6SPlus, iPhoneSE, iPhone7, iPhone7Plus, iPhone8, iPhone8Plus, iPhoneX, iPhoneXS, iPhoneXSMax, iPhoneXR, iPhone11, iPhone11Pro, iPhone11ProMax, iPhoneSE2, iPhone12Mini, iPhone12, iPhone12Pro, iPhone12ProMax, iPhone13Mini, iPhone13, iPhone13Pro, iPhone13ProMax, iPhone14, iPhone14Plus, iPhone14Pro, iPhone14ProMax, iPhoneSE3, iPhone15, iPhone15Plus, iPhone15Pro, iPhone15ProMax, appleTV1, appleTV2, appleTV3, appleTV4, appleTV4K, appleTV24K, unrecognized
    public init?(rawValue: Swift.String)
    public typealias RawValue = Swift.String
    public var rawValue: Swift.String {
      get
    }
  }
}
extension UIKit.UIImage {
  public func resizedImage(with newWidth: CoreFoundation.CGFloat) -> UIKit.UIImage
}
@dynamicMemberLookup public struct Value<Output> : Combine.Publisher {
  public typealias Output = Output
  public typealias Failure = Swift.Never
  public var value: Output {
    get
  }
  public var current: Output {
    get
  }
  public init<P>(_ publisher: P) where Output == P.Output, P : Combine.Publisher, P.Failure == Swift.Never
  public init(const: Output)
  public func callAsFunction() -> Output
  public func receive<S>(subscriber: S) where Output == S.Input, S : Combine.Subscriber, S.Failure == Swift.Never
  public subscript<T>(dynamicMember keyPath: Swift.KeyPath<Output, T>) -> T {
    get
  }
  public subscript<T>(dynamicMember keyPath: Swift.KeyPath<Output, T?>) -> T? {
    get
  }
}
@dynamicMemberLookup public struct OptValue<Item> : Combine.Publisher {
  public typealias Output = Swift.Optional<Item>
  public typealias Failure = Swift.Never
  public var value: Item? {
    get
  }
  public var v: Item? {
    get
  }
  public init<P>(_ publisher: P) where P : Combine.Publisher, P.Failure == Swift.Never, P.Output == Item?
  public init(const: NutPlayer.OptValue<Item>.Output)
  public func callAsFunction() -> Item?
  public func receive<S>(subscriber: S) where S : Combine.Subscriber, S.Failure == Swift.Never, S.Input == Item?
  public subscript<T>(dynamicMember keyPath: Swift.KeyPath<Item, T>) -> T? {
    get
  }
  public subscript<T>(dynamicMember keyPath: Swift.KeyPath<Item, T?>) -> T? {
    get
  }
}
@propertyWrapper public class ValueSubject<TOutput> : Combine.Subject {
  public typealias Output = TOutput
  public typealias Failure = Swift.Never
  public var value: NutPlayer.ValueSubject<TOutput>.Output {
    get
  }
  final public let wrappedValue: NutPlayer.Value<NutPlayer.ValueSubject<TOutput>.Output>
  public init(initial: NutPlayer.ValueSubject<TOutput>.Output)
  public func send(_ value: NutPlayer.ValueSubject<TOutput>.Output)
  public func send(_ value: NutPlayer.ValueSubject<TOutput>.Output) where TOutput : Swift.Equatable
  public func sendWithoutCompare(_ value: NutPlayer.ValueSubject<TOutput>.Output)
  public func send(_ update: (_ prevValue: NutPlayer.ValueSubject<TOutput>.Output) -> NutPlayer.ValueSubject<TOutput>.Output)
  public func send(_ update: (_ prevValue: NutPlayer.ValueSubject<TOutput>.Output) -> NutPlayer.ValueSubject<TOutput>.Output) where TOutput : Swift.Equatable
  public func send(completion: Combine.Subscribers.Completion<NutPlayer.ValueSubject<TOutput>.Failure>)
  public func send(subscription: any Combine.Subscription)
  public func receive<S>(subscriber: S) where TOutput == S.Input, S : Combine.Subscriber, S.Failure == Swift.Never
  @objc deinit
}
@propertyWrapper public class OptValueSubject<Item> : Combine.Subject {
  public typealias Output = Swift.Optional<Item>
  public typealias Failure = Swift.Never
  public var value: Item? {
    get
  }
  final public let wrappedValue: NutPlayer.OptValue<Item>
  public init(initial: NutPlayer.OptValueSubject<Item>.Output)
  public func send(_ value: NutPlayer.OptValueSubject<Item>.Output)
  public func send(_ value: NutPlayer.OptValueSubject<Item>.Output) where Item : Swift.Equatable
  public func sendWithoutCompare(_ value: NutPlayer.OptValueSubject<Item>.Output)
  public func send(_ update: (_ prevValue: NutPlayer.OptValueSubject<Item>.Output) -> NutPlayer.OptValueSubject<Item>.Output)
  public func send(_ update: (_ prevValue: NutPlayer.OptValueSubject<Item>.Output) -> NutPlayer.OptValueSubject<Item>.Output) where Item : Swift.Equatable
  public func send(completion: Combine.Subscribers.Completion<NutPlayer.OptValueSubject<Item>.Failure>)
  public func send(subscription: any Combine.Subscription)
  public func receive<S>(subscriber: S) where S : Combine.Subscriber, S.Failure == Swift.Never, S.Input == Item?
  @objc deinit
}
public func == <Output>(lhs: NutPlayer.Value<Output>, rhs: Output) -> Swift.Bool where Output : Swift.Equatable
public func != <Output>(lhs: NutPlayer.Value<Output>, rhs: Output) -> Swift.Bool where Output : Swift.Equatable
public func == <Output>(lhs: Output, rhs: NutPlayer.Value<Output>) -> Swift.Bool where Output : Swift.Equatable
public func != <Output>(lhs: Output, rhs: NutPlayer.Value<Output>) -> Swift.Bool where Output : Swift.Equatable
public func == <Output>(lhs: NutPlayer.OptValue<Output>, rhs: Output) -> Swift.Bool where Output : Swift.Equatable
public func != <Output>(lhs: NutPlayer.OptValue<Output>, rhs: Output) -> Swift.Bool where Output : Swift.Equatable
public func == <Output>(lhs: Output, rhs: NutPlayer.OptValue<Output>) -> Swift.Bool where Output : Swift.Equatable
public func != <Output>(lhs: Output, rhs: NutPlayer.OptValue<Output>) -> Swift.Bool where Output : Swift.Equatable
public enum VideoQuality : Swift.String, Swift.CaseIterable {
  case unknown
  case auto
  case ultraHD4k
  case ultraHD1440
  case fullHD
  case HD
  case SD
  case SDlow
  case LD
  case LDlow
  public var resolution: CoreFoundation.CGSize {
    get
  }
  public var bandwidth: Swift.Int {
    get
  }
  public init?(rawValue: Swift.String)
  public typealias AllCases = [NutPlayer.VideoQuality]
  public typealias RawValue = Swift.String
  public static var allCases: [NutPlayer.VideoQuality] {
    get
  }
  public var rawValue: Swift.String {
    get
  }
}
public enum VideoQualityTitleFormat : Swift.CaseIterable {
  case common
  case rus
  case eng
  case resolution
  public init(rawValue: Swift.Int)
  public func createTitle(from quality: NutPlayer.VideoQuality) -> Swift.String
  public static func == (a: NutPlayer.VideoQualityTitleFormat, b: NutPlayer.VideoQualityTitleFormat) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public typealias AllCases = [NutPlayer.VideoQualityTitleFormat]
  public static var allCases: [NutPlayer.VideoQualityTitleFormat] {
    get
  }
  public var hashValue: Swift.Int {
    get
  }
}
final public class XcodeLogDestination : NutPlayer.LogDestination {
  final public let format: Swift.String
  final public let limitOutputLevel: NutPlayer.LogLevel
  public init(format: Swift.String, limitOutputLevel: NutPlayer.LogLevel = .trace)
  final public func process(_ message: Swift.String, level: NutPlayer.LogLevel)
  @objc deinit
}
extension NutPlayer.LogLevel : Swift.Equatable {}
extension NutPlayer.LogLevel : Swift.Hashable {}
extension NutPlayer.NutContentUIType : Swift.Equatable {}
extension NutPlayer.NutContentUIType : Swift.Hashable {}
extension NutPlayer.NutLocalization.BundleLevel : Swift.Equatable {}
extension NutPlayer.NutLocalization.BundleLevel : Swift.Hashable {}
extension NutPlayer.NutPlaybackButtonType : Swift.Equatable {}
extension NutPlayer.NutPlaybackButtonType : Swift.Hashable {}
extension NutPlayer.NutPlayerSkinState : Swift.Equatable {}
extension NutPlayer.NutPlayerSkinState : Swift.Hashable {}
extension NutPlayer.NutSeekButtonType : Swift.Equatable {}
extension NutPlayer.NutSeekButtonType : Swift.Hashable {}
extension NutPlayer.NutVerticalSliderType : Swift.Equatable {}
extension NutPlayer.NutVerticalSliderType : Swift.Hashable {}
extension NutPlayer.NutViewMode : Swift.Equatable {}
extension NutPlayer.NutViewMode : Swift.Hashable {}
extension NutPlayer.HTTPMethod : Swift.Equatable {}
extension NutPlayer.HTTPMethod : Swift.Hashable {}
extension NutPlayer.HTTPMethod : Swift.RawRepresentable {}
extension NutPlayer.SubtitleType : Swift.Equatable {}
extension NutPlayer.SubtitleType : Swift.Hashable {}
extension NutPlayer.SubtitleType : Swift.RawRepresentable {}
extension NutPlayer.PlayerPlaybackRate : Swift.Equatable {}
extension NutPlayer.PlayerPlaybackRate : Swift.Hashable {}
extension NutPlayer.PlayerPlaybackRate : Swift.RawRepresentable {}
extension NutPlayer.TechPlayableType : Swift.Equatable {}
extension NutPlayer.TechPlayableType : Swift.Hashable {}
extension NutPlayer.TechPlayingContext : Swift.Equatable {}
extension NutPlayer.TechPlayingContext : Swift.Hashable {}
extension NutPlayer.DeviceType : Swift.Equatable {}
extension NutPlayer.DeviceType : Swift.Hashable {}
extension UIKit.UIDevice.Model : Swift.Equatable {}
extension UIKit.UIDevice.Model : Swift.Hashable {}
extension UIKit.UIDevice.Model : Swift.RawRepresentable {}
extension NutPlayer.VideoQuality : Swift.Equatable {}
extension NutPlayer.VideoQuality : Swift.Hashable {}
extension NutPlayer.VideoQuality : Swift.RawRepresentable {}
extension NutPlayer.VideoQualityTitleFormat : Swift.Equatable {}
extension NutPlayer.VideoQualityTitleFormat : Swift.Hashable {}
