class AVAsset : NSObject, NSCopying, AVAsynchronousKeyValueLoading {
    class func assetWithURL(_ URL: NSURL!) -> AnyObject!
    var duration: CMTime { get }
    var preferredRate: Float { get }
    var preferredVolume: Float { get }
    var preferredTransform: CGAffineTransform { get }
    var naturalSize: CGSize { get }
}
extension AVAsset {
    var providesPreciseDurationAndTiming: Bool { get }
    func cancelLoading()
}
extension AVAsset {
    var referenceRestrictions: AVAssetReferenceRestrictions { get }
}
extension AVAsset {
    var tracks: [AnyObject]! { get }
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVAssetTrack!
    func tracksWithMediaType(_ mediaType: String!) -> [AnyObject]!
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String!) -> [AnyObject]!
    var trackGroups: [AnyObject]! { get }
}
extension AVAsset {
    var creationDate: AVMetadataItem! { get }
    var lyrics: String! { get }
    var commonMetadata: [AnyObject]! { get }
    var metadata: [AnyObject]! { get }
    var availableMetadataFormats: [AnyObject]! { get }
    func metadataForFormat(_ format: String!) -> [AnyObject]!
}
extension AVAsset {
    var availableChapterLocales: [AnyObject]! { get }
    func chapterMetadataGroupsWithTitleLocale(_ locale: NSLocale!, containingItemsWithCommonKeys commonKeys: [AnyObject]!) -> [AnyObject]!
    func chapterMetadataGroupsBestMatchingPreferredLanguages(_ preferredLanguages: [AnyObject]!) -> [AnyObject]!
}
extension AVAsset {
    var availableMediaCharacteristicsWithMediaSelectionOptions: [AnyObject]! { get }
    func mediaSelectionGroupForMediaCharacteristic(_ mediaCharacteristic: String!) -> AVMediaSelectionGroup!
}
extension AVAsset {
    var hasProtectedContent: Bool { get }
}
extension AVAsset {
    var playable: Bool { get }
    var exportable: Bool { get }
    var readable: Bool { get }
    var composable: Bool { get }
}
extension AVAsset {
    func unusedTrackID() -> CMPersistentTrackID
}

class AVAsset : NSObject, NSCopying, AVAsynchronousKeyValueLoading {
    convenience init(URL URL: NSURL)
    class func assetWithURL(_ URL: NSURL) -> Self
    var duration: CMTime { get }
    var preferredRate: Float { get }
    var preferredVolume: Float { get }
    var preferredTransform: CGAffineTransform { get }
    var naturalSize: CGSize { get }
}
extension AVAsset {
    var providesPreciseDurationAndTiming: Bool { get }
    func cancelLoading()
}
extension AVAsset {
    var referenceRestrictions: AVAssetReferenceRestrictions { get }
}
extension AVAsset {
    var tracks: [AVAssetTrack] { get }
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVAssetTrack?
    func tracksWithMediaType(_ mediaType: String) -> [AVAssetTrack]
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVAssetTrack]
    var trackGroups: [AVAssetTrackGroup] { get }
}
extension AVAsset {
    var creationDate: AVMetadataItem? { get }
    var lyrics: String? { get }
    var commonMetadata: [AVMetadataItem] { get }
    var metadata: [AVMetadataItem] { get }
    var availableMetadataFormats: [String] { get }
    func metadataForFormat(_ format: String) -> [AVMetadataItem]
}
extension AVAsset {
    var availableChapterLocales: [NSLocale] { get }
    func chapterMetadataGroupsWithTitleLocale(_ locale: NSLocale, containingItemsWithCommonKeys commonKeys: [String]?) -> [AVTimedMetadataGroup]
    func chapterMetadataGroupsBestMatchingPreferredLanguages(_ preferredLanguages: [String]) -> [AVTimedMetadataGroup]
}
extension AVAsset {
    var availableMediaCharacteristicsWithMediaSelectionOptions: [String] { get }
    func mediaSelectionGroupForMediaCharacteristic(_ mediaCharacteristic: String) -> AVMediaSelectionGroup?
    var preferredMediaSelection: AVMediaSelection { get }
}
extension AVAsset {
    var hasProtectedContent: Bool { get }
}
extension AVAsset {
    var canContainFragments: Bool { get }
    var containsFragments: Bool { get }
}
extension AVAsset {
    var playable: Bool { get }
    var exportable: Bool { get }
    var readable: Bool { get }
    var composable: Bool { get }
    var compatibleWithAirPlayVideo: Bool { get }
}
extension AVAsset {
    func unusedTrackID() -> CMPersistentTrackID
}

var availableChapterLocales: [AnyObject]! { get }

var availableChapterLocales: [NSLocale] { get }

var availableMediaCharacteristicsWithMediaSelectionOptions: [AnyObject]! { get }

var availableMediaCharacteristicsWithMediaSelectionOptions: [String] { get }

var availableMetadataFormats: [AnyObject]! { get }

var availableMetadataFormats: [String] { get }

func chapterMetadataGroupsBestMatchingPreferredLanguages(_ preferredLanguages: [AnyObject]!) -> [AnyObject]!

func chapterMetadataGroupsBestMatchingPreferredLanguages(_ preferredLanguages: [String]) -> [AVTimedMetadataGroup]

func chapterMetadataGroupsWithTitleLocale(_ locale: NSLocale!, containingItemsWithCommonKeys commonKeys: [AnyObject]!) -> [AnyObject]!

func chapterMetadataGroupsWithTitleLocale(_ locale: NSLocale, containingItemsWithCommonKeys commonKeys: [String]?) -> [AVTimedMetadataGroup]

var commonMetadata: [AnyObject]! { get }

var commonMetadata: [AVMetadataItem] { get }

var creationDate: AVMetadataItem! { get }

var creationDate: AVMetadataItem? { get }

class func assetWithURL(_ URL: NSURL!) -> AnyObject!

convenience init(URL URL: NSURL)

var lyrics: String! { get }

var lyrics: String? { get }

func mediaSelectionGroupForMediaCharacteristic(_ mediaCharacteristic: String!) -> AVMediaSelectionGroup!

func mediaSelectionGroupForMediaCharacteristic(_ mediaCharacteristic: String) -> AVMediaSelectionGroup?

var metadata: [AnyObject]! { get }

var metadata: [AVMetadataItem] { get }

func metadataForFormat(_ format: String!) -> [AnyObject]!

func metadataForFormat(_ format: String) -> [AVMetadataItem]

var trackGroups: [AnyObject]! { get }

var trackGroups: [AVAssetTrackGroup] { get }

var tracks: [AnyObject]! { get }

var tracks: [AVAssetTrack] { get }

func tracksWithMediaCharacteristic(_ mediaCharacteristic: String!) -> [AnyObject]!

func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVAssetTrack]

func tracksWithMediaType(_ mediaType: String!) -> [AnyObject]!

func tracksWithMediaType(_ mediaType: String) -> [AVAssetTrack]

func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVAssetTrack!

func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVAssetTrack?

class AVAssetExportSession : NSObject {
    class func allExportPresets() -> [AnyObject]!
    class func exportPresetsCompatibleWithAsset(_ asset: AVAsset!) -> [AnyObject]!
    class func determineCompatibilityOfExportPreset(_ presetName: String!, withAsset asset: AVAsset!, outputFileType outputFileType: String!, completionHandler handler: ((Bool) -> Void)!)
    init!(asset asset: AVAsset!, presetName presetName: String!) -> AVAssetExportSession
    class func exportSessionWithAsset(_ asset: AVAsset!, presetName presetName: String!) -> AVAssetExportSession!
    init!(asset asset: AVAsset!, presetName presetName: String!)
    var presetName: String! { get }
    var asset: AVAsset! { get }
    var supportedFileTypes: [AnyObject]! { get }
    var outputFileType: String!
    @NSCopying var outputURL: NSURL!
    var status: AVAssetExportSessionStatus { get }
    var error: NSError! { get }
    var progress: Float { get }
    var estimatedOutputFileLength: Int64 { get }
    var timeRange: CMTimeRange
    var metadata: [AnyObject]!
    var metadataItemFilter: AVMetadataItemFilter!
    var audioTimePitchAlgorithm: String!
    @NSCopying var audioMix: AVAudioMix!
    @NSCopying var videoComposition: AVVideoComposition!
    var customVideoCompositor: AVVideoCompositing! { get }
    var shouldOptimizeForNetworkUse: Bool
    var canPerformMultiplePassesOverSourceMediaData: Bool
    @NSCopying var directoryForTemporaryFiles: NSURL!
    func determineCompatibleFileTypesWithCompletionHandler(_ handler: (([AnyObject]!) -> Void)!)
    func exportAsynchronouslyWithCompletionHandler(_ handler: (() -> Void)!)
    func cancelExport()
}

class AVAssetExportSession : NSObject {
    convenience init()
    convenience init?(asset asset: AVAsset, presetName presetName: String)
    class func exportSessionWithAsset(_ asset: AVAsset, presetName presetName: String) -> Self?
    init?(asset asset: AVAsset, presetName presetName: String)
    var presetName: String { get }
    var asset: AVAsset { get }
    var outputFileType: String?
    @NSCopying var outputURL: NSURL?
    var shouldOptimizeForNetworkUse: Bool
    var status: AVAssetExportSessionStatus { get }
    var error: NSError? { get }
    func exportAsynchronouslyWithCompletionHandler(_ handler: () -> Void)
    var progress: Float { get }
    func cancelExport()
}
extension AVAssetExportSession {
    class func allExportPresets() -> [String]
    class func exportPresetsCompatibleWithAsset(_ asset: AVAsset) -> [String]
    class func determineCompatibilityOfExportPreset(_ presetName: String, withAsset asset: AVAsset, outputFileType outputFileType: String?, completionHandler handler: (Bool) -> Void)
}
extension AVAssetExportSession {
    var supportedFileTypes: [String] { get }
    func determineCompatibleFileTypesWithCompletionHandler(_ handler: ([String]) -> Void)
}
extension AVAssetExportSession {
    var timeRange: CMTimeRange
    var estimatedOutputFileLength: Int64 { get }
}
extension AVAssetExportSession {
    var metadata: [AVMetadataItem]?
    var metadataItemFilter: AVMetadataItemFilter?
}
extension AVAssetExportSession {
    var audioTimePitchAlgorithm: String
    @NSCopying var audioMix: AVAudioMix?
    @NSCopying var videoComposition: AVVideoComposition?
    var customVideoCompositor: AVVideoCompositing? { get }
}
extension AVAssetExportSession {
    var canPerformMultiplePassesOverSourceMediaData: Bool
    @NSCopying var directoryForTemporaryFiles: NSURL?
}

class func allExportPresets() -> [AnyObject]!

class func allExportPresets() -> [String]

var asset: AVAsset! { get }

var asset: AVAsset { get }

@NSCopying var audioMix: AVAudioMix!

@NSCopying var audioMix: AVAudioMix?

var audioTimePitchAlgorithm: String!

var audioTimePitchAlgorithm: String

var customVideoCompositor: AVVideoCompositing! { get }

var customVideoCompositor: AVVideoCompositing? { get }

class func determineCompatibilityOfExportPreset(_ presetName: String!, withAsset asset: AVAsset!, outputFileType outputFileType: String!, completionHandler handler: ((Bool) -> Void)!)

class func determineCompatibilityOfExportPreset(_ presetName: String, withAsset asset: AVAsset, outputFileType outputFileType: String?, completionHandler handler: (Bool) -> Void)

func determineCompatibleFileTypesWithCompletionHandler(_ handler: (([AnyObject]!) -> Void)!)

func determineCompatibleFileTypesWithCompletionHandler(_ handler: ([String]) -> Void)

@NSCopying var directoryForTemporaryFiles: NSURL!

@NSCopying var directoryForTemporaryFiles: NSURL?

var error: NSError! { get }

var error: NSError? { get }

func exportAsynchronouslyWithCompletionHandler(_ handler: (() -> Void)!)

func exportAsynchronouslyWithCompletionHandler(_ handler: () -> Void)

class func exportPresetsCompatibleWithAsset(_ asset: AVAsset!) -> [AnyObject]!

class func exportPresetsCompatibleWithAsset(_ asset: AVAsset) -> [String]

init!(asset asset: AVAsset!, presetName presetName: String!)

init?(asset asset: AVAsset, presetName presetName: String)

var metadata: [AnyObject]!

var metadata: [AVMetadataItem]?

var metadataItemFilter: AVMetadataItemFilter!

var metadataItemFilter: AVMetadataItemFilter?

var outputFileType: String!

var outputFileType: String?

@NSCopying var outputURL: NSURL!

@NSCopying var outputURL: NSURL?

var presetName: String! { get }

var presetName: String { get }

var supportedFileTypes: [AnyObject]! { get }

var supportedFileTypes: [String] { get }

@NSCopying var videoComposition: AVVideoComposition!

@NSCopying var videoComposition: AVVideoComposition?

class AVAssetImageGenerator : NSObject {
    var asset: AVAsset! { get }
    var appliesPreferredTrackTransform: Bool
    var maximumSize: CGSize
    var apertureMode: String!
    @NSCopying var videoComposition: AVVideoComposition!
    var customVideoCompositor: AVVideoCompositing! { get }
    var requestedTimeToleranceBefore: CMTime
    var requestedTimeToleranceAfter: CMTime
    init!(asset asset: AVAsset!) -> AVAssetImageGenerator
    class func assetImageGeneratorWithAsset(_ asset: AVAsset!) -> AVAssetImageGenerator!
    init!(asset asset: AVAsset!)
    func copyCGImageAtTime(_ requestedTime: CMTime, actualTime actualTime: UnsafeMutablePointer<CMTime>, error outError: NSErrorPointer) -> CGImage!
    func generateCGImagesAsynchronouslyForTimes(_ requestedTimes: [AnyObject]!, completionHandler handler: AVAssetImageGeneratorCompletionHandler!)
    func cancelAllCGImageGeneration()
}

class AVAssetImageGenerator : NSObject {
    convenience init()
    var asset: AVAsset { get }
    var appliesPreferredTrackTransform: Bool
    var maximumSize: CGSize
    var apertureMode: String?
    @NSCopying var videoComposition: AVVideoComposition?
    var customVideoCompositor: AVVideoCompositing? { get }
    var requestedTimeToleranceBefore: CMTime
    var requestedTimeToleranceAfter: CMTime
    convenience init(asset asset: AVAsset)
    class func assetImageGeneratorWithAsset(_ asset: AVAsset) -> Self
    init(asset asset: AVAsset)
    func copyCGImageAtTime(_ requestedTime: CMTime, actualTime actualTime: UnsafeMutablePointer<CMTime>) throws -> CGImage
    func generateCGImagesAsynchronouslyForTimes(_ requestedTimes: [NSValue], completionHandler handler: AVAssetImageGeneratorCompletionHandler)
    func cancelAllCGImageGeneration()
}

var apertureMode: String!

var apertureMode: String?

var asset: AVAsset! { get }

var asset: AVAsset { get }

func copyCGImageAtTime(_ requestedTime: CMTime, actualTime actualTime: UnsafeMutablePointer<CMTime>, error outError: NSErrorPointer) -> CGImage!

func copyCGImageAtTime(_ requestedTime: CMTime, actualTime actualTime: UnsafeMutablePointer<CMTime>) throws -> CGImage

var customVideoCompositor: AVVideoCompositing! { get }

var customVideoCompositor: AVVideoCompositing? { get }

func generateCGImagesAsynchronouslyForTimes(_ requestedTimes: [AnyObject]!, completionHandler handler: AVAssetImageGeneratorCompletionHandler!)

func generateCGImagesAsynchronouslyForTimes(_ requestedTimes: [NSValue], completionHandler handler: AVAssetImageGeneratorCompletionHandler)

init!(asset asset: AVAsset!)

init(asset asset: AVAsset)

@NSCopying var videoComposition: AVVideoComposition!

@NSCopying var videoComposition: AVVideoComposition?

class AVAssetReader : NSObject {
    convenience init!(asset asset: AVAsset!, error outError: NSErrorPointer)
    class func assetReaderWithAsset(_ asset: AVAsset!, error outError: NSErrorPointer) -> Self!
    init!(asset asset: AVAsset!, error outError: NSErrorPointer)
    var asset: AVAsset! { get }
    var status: AVAssetReaderStatus { get }
    var error: NSError! { get }
    var timeRange: CMTimeRange
    var outputs: [AnyObject]! { get }
    func canAddOutput(_ output: AVAssetReaderOutput!) -> Bool
    func addOutput(_ output: AVAssetReaderOutput!)
    func startReading() -> Bool
    func cancelReading()
}

class AVAssetReader : NSObject {
    convenience init()
    convenience init(asset asset: AVAsset) throws
    class func assetReaderWithAsset(_ asset: AVAsset) throws -> Self
    init(asset asset: AVAsset) throws
    var asset: AVAsset { get }
    var status: AVAssetReaderStatus { get }
    var error: NSError? { get }
    var timeRange: CMTimeRange
    var outputs: [AVAssetReaderOutput] { get }
    func canAddOutput(_ output: AVAssetReaderOutput) -> Bool
    func addOutput(_ output: AVAssetReaderOutput)
    func startReading() -> Bool
    func cancelReading()
}

func addOutput(_ output: AVAssetReaderOutput!)

func addOutput(_ output: AVAssetReaderOutput)

var asset: AVAsset! { get }

var asset: AVAsset { get }

func canAddOutput(_ output: AVAssetReaderOutput!) -> Bool

func canAddOutput(_ output: AVAssetReaderOutput) -> Bool

var error: NSError! { get }

var error: NSError? { get }

init!(asset asset: AVAsset!, error outError: NSErrorPointer)

init(asset asset: AVAsset) throws

var outputs: [AnyObject]! { get }

var outputs: [AVAssetReaderOutput] { get }

class AVAssetReaderAudioMixOutput : AVAssetReaderOutput {
    convenience init!(audioTracks audioTracks: [AnyObject]!, audioSettings audioSettings: [NSObject : AnyObject]!)
    class func assetReaderAudioMixOutputWithAudioTracks(_ audioTracks: [AnyObject]!, audioSettings audioSettings: [NSObject : AnyObject]!) -> Self!
    init!(audioTracks audioTracks: [AnyObject]!, audioSettings audioSettings: [NSObject : AnyObject]!)
    var audioTracks: [AnyObject]! { get }
    var audioSettings: [NSObject : AnyObject]! { get }
    @NSCopying var audioMix: AVAudioMix!
    var audioTimePitchAlgorithm: String!
}

class AVAssetReaderAudioMixOutput : AVAssetReaderOutput {
    convenience init()
    convenience init(audioTracks audioTracks: [AVAssetTrack], audioSettings audioSettings: [String : AnyObject]?)
    class func assetReaderAudioMixOutputWithAudioTracks(_ audioTracks: [AVAssetTrack], audioSettings audioSettings: [String : AnyObject]?) -> Self
    init(audioTracks audioTracks: [AVAssetTrack], audioSettings audioSettings: [String : AnyObject]?)
    var audioTracks: [AVAssetTrack] { get }
    var audioSettings: [String : AnyObject]? { get }
    @NSCopying var audioMix: AVAudioMix?
    var audioTimePitchAlgorithm: String
}

@NSCopying var audioMix: AVAudioMix!

@NSCopying var audioMix: AVAudioMix?

var audioSettings: [NSObject : AnyObject]! { get }

var audioSettings: [String : AnyObject]? { get }

var audioTimePitchAlgorithm: String!

var audioTimePitchAlgorithm: String

var audioTracks: [AnyObject]! { get }

var audioTracks: [AVAssetTrack] { get }

init!(audioTracks audioTracks: [AnyObject]!, audioSettings audioSettings: [NSObject : AnyObject]!)

init(audioTracks audioTracks: [AVAssetTrack], audioSettings audioSettings: [String : AnyObject]?)

class AVAssetReaderOutput : NSObject {
    var mediaType: String! { get }
    var alwaysCopiesSampleData: Bool
    func copyNextSampleBuffer() -> CMSampleBuffer!
}
extension AVAssetReaderOutput {
    var supportsRandomAccess: Bool
    func resetForReadingTimeRanges(_ timeRanges: [AnyObject]!)
    func markConfigurationAsFinal()
}

class AVAssetReaderOutput : NSObject {
    var mediaType: String { get }
    var alwaysCopiesSampleData: Bool
    func copyNextSampleBuffer() -> CMSampleBuffer?
}
extension AVAssetReaderOutput {
    var supportsRandomAccess: Bool
    func resetForReadingTimeRanges(_ timeRanges: [NSValue])
    func markConfigurationAsFinal()
}

func copyNextSampleBuffer() -> CMSampleBuffer!

func copyNextSampleBuffer() -> CMSampleBuffer?

var mediaType: String! { get }

var mediaType: String { get }

func resetForReadingTimeRanges(_ timeRanges: [AnyObject]!)

func resetForReadingTimeRanges(_ timeRanges: [NSValue])

class AVAssetReaderOutputMetadataAdaptor : NSObject {
    convenience init!(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput!)
    class func assetReaderOutputMetadataAdaptorWithAssetReaderTrackOutput(_ trackOutput: AVAssetReaderTrackOutput!) -> Self!
    init!(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput!)
    var assetReaderTrackOutput: AVAssetReaderTrackOutput! { get }
    func nextTimedMetadataGroup() -> AVTimedMetadataGroup!
}

class AVAssetReaderOutputMetadataAdaptor : NSObject {
    convenience init()
    convenience init(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput)
    class func assetReaderOutputMetadataAdaptorWithAssetReaderTrackOutput(_ trackOutput: AVAssetReaderTrackOutput) -> Self
    init(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput)
    var assetReaderTrackOutput: AVAssetReaderTrackOutput { get }
    func nextTimedMetadataGroup() -> AVTimedMetadataGroup?
}

var assetReaderTrackOutput: AVAssetReaderTrackOutput! { get }

var assetReaderTrackOutput: AVAssetReaderTrackOutput { get }

init!(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput!)

init(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput)

func nextTimedMetadataGroup() -> AVTimedMetadataGroup!

func nextTimedMetadataGroup() -> AVTimedMetadataGroup?

class AVAssetReaderSampleReferenceOutput : AVAssetReaderOutput {
    init!(track track: AVAssetTrack!) -> AVAssetReaderSampleReferenceOutput
    class func assetReaderSampleReferenceOutputWithTrack(_ track: AVAssetTrack!) -> AVAssetReaderSampleReferenceOutput!
    init!(track track: AVAssetTrack!)
    var track: AVAssetTrack! { get }
}

class AVAssetReaderSampleReferenceOutput : AVAssetReaderOutput {
    convenience init()
    convenience init(track track: AVAssetTrack)
    class func assetReaderSampleReferenceOutputWithTrack(_ track: AVAssetTrack) -> Self
    init(track track: AVAssetTrack)
    var track: AVAssetTrack { get }
}

init!(track track: AVAssetTrack!)

init(track track: AVAssetTrack)

var track: AVAssetTrack! { get }

var track: AVAssetTrack { get }

class AVAssetReaderTrackOutput : AVAssetReaderOutput {
    convenience init!(track track: AVAssetTrack!, outputSettings outputSettings: [NSObject : AnyObject]!)
    class func assetReaderTrackOutputWithTrack(_ track: AVAssetTrack!, outputSettings outputSettings: [NSObject : AnyObject]!) -> Self!
    init!(track track: AVAssetTrack!, outputSettings outputSettings: [NSObject : AnyObject]!)
    var track: AVAssetTrack! { get }
    var outputSettings: [NSObject : AnyObject]! { get }
    var audioTimePitchAlgorithm: String!
}

class AVAssetReaderTrackOutput : AVAssetReaderOutput {
    convenience init()
    convenience init(track track: AVAssetTrack, outputSettings outputSettings: [String : AnyObject]?)
    class func assetReaderTrackOutputWithTrack(_ track: AVAssetTrack, outputSettings outputSettings: [String : AnyObject]?) -> Self
    init(track track: AVAssetTrack, outputSettings outputSettings: [String : AnyObject]?)
    var track: AVAssetTrack { get }
    var outputSettings: [String : AnyObject]? { get }
    var audioTimePitchAlgorithm: String
}

var audioTimePitchAlgorithm: String!

var audioTimePitchAlgorithm: String

init!(track track: AVAssetTrack!, outputSettings outputSettings: [NSObject : AnyObject]!)

init(track track: AVAssetTrack, outputSettings outputSettings: [String : AnyObject]?)

var outputSettings: [NSObject : AnyObject]! { get }

var outputSettings: [String : AnyObject]? { get }

var track: AVAssetTrack! { get }

var track: AVAssetTrack { get }

class AVAssetReaderVideoCompositionOutput : AVAssetReaderOutput {
    convenience init!(videoTracks videoTracks: [AnyObject]!, videoSettings videoSettings: [NSObject : AnyObject]!)
    class func assetReaderVideoCompositionOutputWithVideoTracks(_ videoTracks: [AnyObject]!, videoSettings videoSettings: [NSObject : AnyObject]!) -> Self!
    init!(videoTracks videoTracks: [AnyObject]!, videoSettings videoSettings: [NSObject : AnyObject]!)
    var videoTracks: [AnyObject]! { get }
    var videoSettings: [NSObject : AnyObject]! { get }
    @NSCopying var videoComposition: AVVideoComposition!
    var customVideoCompositor: AVVideoCompositing! { get }
}

class AVAssetReaderVideoCompositionOutput : AVAssetReaderOutput {
    convenience init()
    convenience init(videoTracks videoTracks: [AVAssetTrack], videoSettings videoSettings: [String : AnyObject]?)
    class func assetReaderVideoCompositionOutputWithVideoTracks(_ videoTracks: [AVAssetTrack], videoSettings videoSettings: [String : AnyObject]?) -> Self
    init(videoTracks videoTracks: [AVAssetTrack], videoSettings videoSettings: [String : AnyObject]?)
    var videoTracks: [AVAssetTrack] { get }
    var videoSettings: [String : AnyObject]? { get }
    @NSCopying var videoComposition: AVVideoComposition?
    var customVideoCompositor: AVVideoCompositing? { get }
}

var customVideoCompositor: AVVideoCompositing! { get }

var customVideoCompositor: AVVideoCompositing? { get }

init!(videoTracks videoTracks: [AnyObject]!, videoSettings videoSettings: [NSObject : AnyObject]!)

init(videoTracks videoTracks: [AVAssetTrack], videoSettings videoSettings: [String : AnyObject]?)

@NSCopying var videoComposition: AVVideoComposition!

@NSCopying var videoComposition: AVVideoComposition?

var videoSettings: [NSObject : AnyObject]! { get }

var videoSettings: [String : AnyObject]? { get }

var videoTracks: [AnyObject]! { get }

var videoTracks: [AVAssetTrack] { get }

struct AVAssetReferenceRestrictions : RawOptionSetType {
    init(_ rawValue: UInt)
    init(rawValue rawValue: UInt)
    static var RestrictionForbidNone: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidRemoteReferenceToLocal: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidLocalReferenceToRemote: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidCrossSiteReference: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidLocalReferenceToLocal: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidAll: AVAssetReferenceRestrictions { get }
}

struct AVAssetReferenceRestrictions : OptionSetType {
    init(rawValue rawValue: UInt)
    static var ForbidNone: AVAssetReferenceRestrictions { get }
    static var ForbidRemoteReferenceToLocal: AVAssetReferenceRestrictions { get }
    static var ForbidLocalReferenceToRemote: AVAssetReferenceRestrictions { get }
    static var ForbidCrossSiteReference: AVAssetReferenceRestrictions { get }
    static var ForbidLocalReferenceToLocal: AVAssetReferenceRestrictions { get }
    static var ForbidAll: AVAssetReferenceRestrictions { get }
}

static var RestrictionForbidAll: AVAssetReferenceRestrictions { get }

static var ForbidAll: AVAssetReferenceRestrictions { get }

static var RestrictionForbidCrossSiteReference: AVAssetReferenceRestrictions { get }

static var ForbidCrossSiteReference: AVAssetReferenceRestrictions { get }

static var RestrictionForbidLocalReferenceToLocal: AVAssetReferenceRestrictions { get }

static var ForbidLocalReferenceToLocal: AVAssetReferenceRestrictions { get }

static var RestrictionForbidLocalReferenceToRemote: AVAssetReferenceRestrictions { get }

static var ForbidLocalReferenceToRemote: AVAssetReferenceRestrictions { get }

static var RestrictionForbidNone: AVAssetReferenceRestrictions { get }

static var ForbidNone: AVAssetReferenceRestrictions { get }

static var RestrictionForbidRemoteReferenceToLocal: AVAssetReferenceRestrictions { get }

static var ForbidRemoteReferenceToLocal: AVAssetReferenceRestrictions { get }

class AVAssetResourceLoader : NSObject {
    func setDelegate(_ delegate: AVAssetResourceLoaderDelegate!, queue delegateQueue: dispatch_queue_t!)
    var delegate: AVAssetResourceLoaderDelegate! { get }
    var delegateQueue: dispatch_queue_t! { get }
}

class AVAssetResourceLoader : NSObject {
    init()
    func setDelegate(_ delegate: AVAssetResourceLoaderDelegate?, queue delegateQueue: dispatch_queue_t?)
    weak var delegate: AVAssetResourceLoaderDelegate? { get }
    var delegateQueue: dispatch_queue_t? { get }
}
extension AVAssetResourceLoader {
    var preloadsEligibleContentKeys: Bool
}

var delegate: AVAssetResourceLoaderDelegate! { get }

weak var delegate: AVAssetResourceLoaderDelegate? { get }

var delegateQueue: dispatch_queue_t! { get }

var delegateQueue: dispatch_queue_t? { get }

func setDelegate(_ delegate: AVAssetResourceLoaderDelegate!, queue delegateQueue: dispatch_queue_t!)

func setDelegate(_ delegate: AVAssetResourceLoaderDelegate?, queue delegateQueue: dispatch_queue_t?)

protocol AVAssetResourceLoaderDelegate : NSObjectProtocol {
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest!) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForRenewalOfRequestedResource renewalRequest: AVAssetResourceRenewalRequest!) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, didCancelLoadingRequest loadingRequest: AVAssetResourceLoadingRequest!)
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForResponseToAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge!) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, didCancelAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge!)
}

protocol AVAssetResourceLoaderDelegate : NSObjectProtocol {
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForRenewalOfRequestedResource renewalRequest: AVAssetResourceRenewalRequest) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancelLoadingRequest loadingRequest: AVAssetResourceLoadingRequest)
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForResponseToAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancelAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge)
}

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, didCancelAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge!)

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancelAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge)

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, didCancelLoadingRequest loadingRequest: AVAssetResourceLoadingRequest!)

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancelLoadingRequest loadingRequest: AVAssetResourceLoadingRequest)

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest!) -> Bool

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForRenewalOfRequestedResource renewalRequest: AVAssetResourceRenewalRequest!) -> Bool

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForRenewalOfRequestedResource renewalRequest: AVAssetResourceRenewalRequest) -> Bool

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForResponseToAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge!) -> Bool

optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForResponseToAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge) -> Bool

class AVAssetResourceLoadingContentInformationRequest : NSObject {
    var contentType: String!
    var contentLength: Int64
    var byteRangeAccessSupported: Bool
    @NSCopying var renewalDate: NSDate!
}

class AVAssetResourceLoadingContentInformationRequest : NSObject {
    init()
    var contentType: String?
    var contentLength: Int64
    var byteRangeAccessSupported: Bool
    @NSCopying var renewalDate: NSDate?
}

var contentType: String!

var contentType: String?

@NSCopying var renewalDate: NSDate!

@NSCopying var renewalDate: NSDate?

class AVAssetResourceLoadingDataRequest : NSObject {
    var requestedOffset: Int64 { get }
    var requestedLength: Int { get }
    var currentOffset: Int64 { get }
    func respondWithData(_ data: NSData!)
}

class AVAssetResourceLoadingDataRequest : NSObject {
    init()
    var requestedOffset: Int64 { get }
    var requestedLength: Int { get }
    var requestsAllDataToEndOfResource: Bool { get }
    var currentOffset: Int64 { get }
    func respondWithData(_ data: NSData)
}

func respondWithData(_ data: NSData!)

func respondWithData(_ data: NSData)

class AVAssetResourceLoadingRequest : NSObject {
    var request: NSURLRequest! { get }
    var finished: Bool { get }
    var cancelled: Bool { get }
    var contentInformationRequest: AVAssetResourceLoadingContentInformationRequest! { get }
    var dataRequest: AVAssetResourceLoadingDataRequest! { get }
    @NSCopying var response: NSURLResponse!
    @NSCopying var redirect: NSURLRequest!
    func finishLoading()
    func finishLoadingWithError(_ error: NSError!)
}
extension AVAssetResourceLoadingRequest {
    func streamingContentKeyRequestDataForApp(_ appIdentifier: NSData!, contentIdentifier contentIdentifier: NSData!, options options: [NSObject : AnyObject]!, error outError: NSErrorPointer) -> NSData!
}
extension AVAssetResourceLoadingRequest {
    func finishLoadingWithResponse(_ response: NSURLResponse!, data data: NSData!, redirect redirect: NSURLRequest!)
}

class AVAssetResourceLoadingRequest : NSObject {
    init()
    var request: NSURLRequest { get }
    var finished: Bool { get }
    var cancelled: Bool { get }
    var contentInformationRequest: AVAssetResourceLoadingContentInformationRequest? { get }
    var dataRequest: AVAssetResourceLoadingDataRequest? { get }
    @NSCopying var response: NSURLResponse?
    @NSCopying var redirect: NSURLRequest?
    func finishLoading()
    func finishLoadingWithError(_ error: NSError?)
}
extension AVAssetResourceLoadingRequest {
    func streamingContentKeyRequestDataForApp(_ appIdentifier: NSData, contentIdentifier contentIdentifier: NSData, options options: [String : AnyObject]?) throws -> NSData
    func persistentContentKeyFromKeyVendorResponse(_ keyVendorResponse: NSData, options options: [String : AnyObject]?, error outError: NSErrorPointer) -> NSData
}
extension AVAssetResourceLoadingRequest {
    func finishLoadingWithResponse(_ response: NSURLResponse?, data data: NSData?, redirect redirect: NSURLRequest?)
}

var contentInformationRequest: AVAssetResourceLoadingContentInformationRequest! { get }

var contentInformationRequest: AVAssetResourceLoadingContentInformationRequest? { get }

var dataRequest: AVAssetResourceLoadingDataRequest! { get }

var dataRequest: AVAssetResourceLoadingDataRequest? { get }

func finishLoadingWithError(_ error: NSError!)

func finishLoadingWithError(_ error: NSError?)

@NSCopying var redirect: NSURLRequest!

@NSCopying var redirect: NSURLRequest?

var request: NSURLRequest! { get }

var request: NSURLRequest { get }

@NSCopying var response: NSURLResponse!

@NSCopying var response: NSURLResponse?

func streamingContentKeyRequestDataForApp(_ appIdentifier: NSData!, contentIdentifier contentIdentifier: NSData!, options options: [NSObject : AnyObject]!, error outError: NSErrorPointer) -> NSData!

func streamingContentKeyRequestDataForApp(_ appIdentifier: NSData, contentIdentifier contentIdentifier: NSData, options options: [String : AnyObject]?) throws -> NSData

class AVAssetTrack : NSObject, NSCopying, AVAsynchronousKeyValueLoading {
    var asset: AVAsset! { get }
    var trackID: CMPersistentTrackID { get }
}
extension AVAssetTrack {
    var mediaType: String! { get }
    var formatDescriptions: [AnyObject]! { get }
    var playable: Bool { get }
    var enabled: Bool { get }
    var selfContained: Bool { get }
    var totalSampleDataLength: Int64 { get }
    func hasMediaCharacteristic(_ mediaCharacteristic: String!) -> Bool
}
extension AVAssetTrack {
    var timeRange: CMTimeRange { get }
    var naturalTimeScale: CMTimeScale { get }
    var estimatedDataRate: Float { get }
}
extension AVAssetTrack {
    var languageCode: String! { get }
    var extendedLanguageTag: String! { get }
}
extension AVAssetTrack {
    var naturalSize: CGSize { get }
    var preferredTransform: CGAffineTransform { get }
}
extension AVAssetTrack {
    var preferredVolume: Float { get }
}
extension AVAssetTrack {
    var nominalFrameRate: Float { get }
    var minFrameDuration: CMTime { get }
    var requiresFrameReordering: Bool { get }
}
extension AVAssetTrack {
    var segments: [AnyObject]! { get }
    func segmentForTrackTime(_ trackTime: CMTime) -> AVAssetTrackSegment!
    func samplePresentationTimeForTrackTime(_ trackTime: CMTime) -> CMTime
}
extension AVAssetTrack {
    var commonMetadata: [AnyObject]! { get }
    var metadata: [AnyObject]! { get }
    var availableMetadataFormats: [AnyObject]! { get }
    func metadataForFormat(_ format: String!) -> [AnyObject]!
}
extension AVAssetTrack {
    var availableTrackAssociationTypes: [AnyObject]! { get }
    func associatedTracksOfType(_ trackAssociationType: String!) -> [AnyObject]!
}
extension AVAssetTrack {
    var canProvideSampleCursors: Bool { get }
    func makeSampleCursorWithPresentationTimeStamp(_ presentationTimeStamp: CMTime) -> AVSampleCursor!
    func makeSampleCursorAtFirstSampleInDecodeOrder() -> AVSampleCursor!
    func makeSampleCursorAtLastSampleInDecodeOrder() -> AVSampleCursor!
}

class AVAssetTrack : NSObject, NSCopying, AVAsynchronousKeyValueLoading {
    init()
    weak var asset: AVAsset? { get }
    var trackID: CMPersistentTrackID { get }
}
extension AVAssetTrack {
    var mediaType: String { get }
    var formatDescriptions: [AnyObject] { get }
    var playable: Bool { get }
    var enabled: Bool { get }
    var selfContained: Bool { get }
    var totalSampleDataLength: Int64 { get }
    func hasMediaCharacteristic(_ mediaCharacteristic: String) -> Bool
}
extension AVAssetTrack {
    var timeRange: CMTimeRange { get }
    var naturalTimeScale: CMTimeScale { get }
    var estimatedDataRate: Float { get }
}
extension AVAssetTrack {
    var languageCode: String { get }
    var extendedLanguageTag: String { get }
}
extension AVAssetTrack {
    var naturalSize: CGSize { get }
    var preferredTransform: CGAffineTransform { get }
}
extension AVAssetTrack {
    var preferredVolume: Float { get }
}
extension AVAssetTrack {
    var nominalFrameRate: Float { get }
    var minFrameDuration: CMTime { get }
    var requiresFrameReordering: Bool { get }
}
extension AVAssetTrack {
    var segments: [AVAssetTrackSegment] { get }
    func segmentForTrackTime(_ trackTime: CMTime) -> AVAssetTrackSegment?
    func samplePresentationTimeForTrackTime(_ trackTime: CMTime) -> CMTime
}
extension AVAssetTrack {
    var commonMetadata: [AVMetadataItem] { get }
    var metadata: [AVMetadataItem] { get }
    var availableMetadataFormats: [String] { get }
    func metadataForFormat(_ format: String) -> [AVMetadataItem]
}
extension AVAssetTrack {
    var availableTrackAssociationTypes: [String] { get }
    func associatedTracksOfType(_ trackAssociationType: String) -> [AVAssetTrack]
}
extension AVAssetTrack {
    var canProvideSampleCursors: Bool { get }
    func makeSampleCursorWithPresentationTimeStamp(_ presentationTimeStamp: CMTime) -> AVSampleCursor?
    func makeSampleCursorAtFirstSampleInDecodeOrder() -> AVSampleCursor?
    func makeSampleCursorAtLastSampleInDecodeOrder() -> AVSampleCursor?
}

var asset: AVAsset! { get }

weak var asset: AVAsset? { get }

func associatedTracksOfType(_ trackAssociationType: String!) -> [AnyObject]!

func associatedTracksOfType(_ trackAssociationType: String) -> [AVAssetTrack]

var availableMetadataFormats: [AnyObject]! { get }

var availableMetadataFormats: [String] { get }

var availableTrackAssociationTypes: [AnyObject]! { get }

var availableTrackAssociationTypes: [String] { get }

var commonMetadata: [AnyObject]! { get }

var commonMetadata: [AVMetadataItem] { get }

var extendedLanguageTag: String! { get }

var extendedLanguageTag: String { get }

var formatDescriptions: [AnyObject]! { get }

var formatDescriptions: [AnyObject] { get }

func hasMediaCharacteristic(_ mediaCharacteristic: String!) -> Bool

func hasMediaCharacteristic(_ mediaCharacteristic: String) -> Bool

var languageCode: String! { get }

var languageCode: String { get }

func makeSampleCursorAtFirstSampleInDecodeOrder() -> AVSampleCursor!

func makeSampleCursorAtFirstSampleInDecodeOrder() -> AVSampleCursor?

func makeSampleCursorAtLastSampleInDecodeOrder() -> AVSampleCursor!

func makeSampleCursorAtLastSampleInDecodeOrder() -> AVSampleCursor?

func makeSampleCursorWithPresentationTimeStamp(_ presentationTimeStamp: CMTime) -> AVSampleCursor!

func makeSampleCursorWithPresentationTimeStamp(_ presentationTimeStamp: CMTime) -> AVSampleCursor?

var mediaType: String! { get }

var mediaType: String { get }

var metadata: [AnyObject]! { get }

var metadata: [AVMetadataItem] { get }

func metadataForFormat(_ format: String!) -> [AnyObject]!

func metadataForFormat(_ format: String) -> [AVMetadataItem]

func segmentForTrackTime(_ trackTime: CMTime) -> AVAssetTrackSegment!

func segmentForTrackTime(_ trackTime: CMTime) -> AVAssetTrackSegment?

var segments: [AnyObject]! { get }

var segments: [AVAssetTrackSegment] { get }

class AVAssetTrackGroup : NSObject, NSCopying {
    var trackIDs: [AnyObject]! { get }
}

class AVAssetTrackGroup : NSObject, NSCopying {
    var trackIDs: [NSNumber] { get }
}

var trackIDs: [AnyObject]! { get }

var trackIDs: [NSNumber] { get }

class AVAssetTrackSegment : NSObject {
    var timeMapping: CMTimeMapping { get }
    var empty: Bool { get }
}

class AVAssetTrackSegment : NSObject {
    init()
    var timeMapping: CMTimeMapping { get }
    var empty: Bool { get }
}

class AVAssetWriter : NSObject {
    convenience init!(URL outputURL: NSURL!, fileType outputFileType: String!, error outError: NSErrorPointer)
    class func assetWriterWithURL(_ outputURL: NSURL!, fileType outputFileType: String!, error outError: NSErrorPointer) -> Self!
    init!(URL outputURL: NSURL!, fileType outputFileType: String!, error outError: NSErrorPointer)
    @NSCopying var outputURL: NSURL! { get }
    var outputFileType: String! { get }
    var availableMediaTypes: [AnyObject]! { get }
    var status: AVAssetWriterStatus { get }
    var error: NSError! { get }
    var metadata: [AnyObject]!
    var shouldOptimizeForNetworkUse: Bool
    @NSCopying var directoryForTemporaryFiles: NSURL!
    var inputs: [AnyObject]! { get }
    func canApplyOutputSettings(_ outputSettings: [NSObject : AnyObject]!, forMediaType mediaType: String!) -> Bool
    func canAddInput(_ input: AVAssetWriterInput!) -> Bool
    func addInput(_ input: AVAssetWriterInput!)
    func startWriting() -> Bool
    func startSessionAtSourceTime(_ startTime: CMTime)
    func endSessionAtSourceTime(_ endTime: CMTime)
    func cancelWriting()
    func finishWriting() -> Bool
    func finishWritingWithCompletionHandler(_ handler: (() -> Void)!)
}
extension AVAssetWriter {
    var movieFragmentInterval: CMTime
    var movieTimeScale: CMTimeScale
}
extension AVAssetWriter {
    func canAddInputGroup(_ inputGroup: AVAssetWriterInputGroup!) -> Bool
    func addInputGroup(_ inputGroup: AVAssetWriterInputGroup!)
    var inputGroups: [AnyObject]! { get }
}

class AVAssetWriter : NSObject {
    convenience init()
    convenience init(URL outputURL: NSURL, fileType outputFileType: String) throws
    class func assetWriterWithURL(_ outputURL: NSURL, fileType outputFileType: String) throws -> Self
    init(URL outputURL: NSURL, fileType outputFileType: String) throws
    @NSCopying var outputURL: NSURL { get }
    var outputFileType: String { get }
    var availableMediaTypes: [String] { get }
    var status: AVAssetWriterStatus { get }
    var error: NSError? { get }
    var metadata: [AVMetadataItem]
    var shouldOptimizeForNetworkUse: Bool
    @NSCopying var directoryForTemporaryFiles: NSURL?
    var inputs: [AVAssetWriterInput] { get }
    func canApplyOutputSettings(_ outputSettings: [String : AnyObject]?, forMediaType mediaType: String) -> Bool
    func canAddInput(_ input: AVAssetWriterInput) -> Bool
    func addInput(_ input: AVAssetWriterInput)
    func startWriting() -> Bool
    func startSessionAtSourceTime(_ startTime: CMTime)
    func endSessionAtSourceTime(_ endTime: CMTime)
    func cancelWriting()
    func finishWriting() -> Bool
    func finishWritingWithCompletionHandler(_ handler: () -> Void)
}
extension AVAssetWriter {
    var movieFragmentInterval: CMTime
    var overallDurationHint: CMTime
    var movieTimeScale: CMTimeScale
}
extension AVAssetWriter {
    func canAddInputGroup(_ inputGroup: AVAssetWriterInputGroup) -> Bool
    func addInputGroup(_ inputGroup: AVAssetWriterInputGroup)
    var inputGroups: [AVAssetWriterInputGroup] { get }
}

func addInput(_ input: AVAssetWriterInput!)

func addInput(_ input: AVAssetWriterInput)

func addInputGroup(_ inputGroup: AVAssetWriterInputGroup!)

func addInputGroup(_ inputGroup: AVAssetWriterInputGroup)

var availableMediaTypes: [AnyObject]! { get }

var availableMediaTypes: [String] { get }

func canAddInput(_ input: AVAssetWriterInput!) -> Bool

func canAddInput(_ input: AVAssetWriterInput) -> Bool

func canAddInputGroup(_ inputGroup: AVAssetWriterInputGroup!) -> Bool

func canAddInputGroup(_ inputGroup: AVAssetWriterInputGroup) -> Bool

func canApplyOutputSettings(_ outputSettings: [NSObject : AnyObject]!, forMediaType mediaType: String!) -> Bool

func canApplyOutputSettings(_ outputSettings: [String : AnyObject]?, forMediaType mediaType: String) -> Bool

@NSCopying var directoryForTemporaryFiles: NSURL!

@NSCopying var directoryForTemporaryFiles: NSURL?

var error: NSError! { get }

var error: NSError? { get }

func finishWritingWithCompletionHandler(_ handler: (() -> Void)!)

func finishWritingWithCompletionHandler(_ handler: () -> Void)

init!(URL outputURL: NSURL!, fileType outputFileType: String!, error outError: NSErrorPointer)

init(URL outputURL: NSURL, fileType outputFileType: String) throws

var inputGroups: [AnyObject]! { get }

var inputGroups: [AVAssetWriterInputGroup] { get }

var inputs: [AnyObject]! { get }

var inputs: [AVAssetWriterInput] { get }

var metadata: [AnyObject]!

var metadata: [AVMetadataItem]

var outputFileType: String! { get }

var outputFileType: String { get }

@NSCopying var outputURL: NSURL! { get }

@NSCopying var outputURL: NSURL { get }

class AVAssetWriterInput : NSObject {
    init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!) -> AVAssetWriterInput
    class func assetWriterInputWithMediaType(_ mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!) -> AVAssetWriterInput!
    init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!, sourceFormatHint sourceFormatHint: CMFormatDescription!) -> AVAssetWriterInput
    class func assetWriterInputWithMediaType(_ mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!, sourceFormatHint sourceFormatHint: CMFormatDescription!) -> AVAssetWriterInput!
    init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!)
    init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!, sourceFormatHint sourceFormatHint: CMFormatDescription!)
    var mediaType: String! { get }
    var outputSettings: [NSObject : AnyObject]! { get }
    var sourceFormatHint: CMFormatDescription! { get }
    var metadata: [AnyObject]!
    var readyForMoreMediaData: Bool { get }
    var expectsMediaDataInRealTime: Bool
    func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t!, usingBlock block: (() -> Void)!)
    func appendSampleBuffer(_ sampleBuffer: CMSampleBuffer!) -> Bool
    func markAsFinished()
}
extension AVAssetWriterInput {
    var languageCode: String!
    var extendedLanguageTag: String!
}
extension AVAssetWriterInput {
    var naturalSize: CGSize
    var transform: CGAffineTransform
}
extension AVAssetWriterInput {
    var preferredVolume: Float
}
extension AVAssetWriterInput {
    var marksOutputTrackAsEnabled: Bool
    var mediaTimeScale: CMTimeScale
    var preferredMediaChunkDuration: CMTime
    var preferredMediaChunkAlignment: Int
    @NSCopying var sampleReferenceBaseURL: NSURL!
}
extension AVAssetWriterInput {
    func canAddTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput!, type trackAssociationType: String!) -> Bool
    func addTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput!, type trackAssociationType: String!)
}
extension AVAssetWriterInput {
    var performsMultiPassEncodingIfSupported: Bool
    var canPerformMultiplePasses: Bool { get }
    var currentPassDescription: AVAssetWriterInputPassDescription! { get }
    func respondToEachPassDescriptionOnQueue(_ queue: dispatch_queue_t!, usingBlock block: dispatch_block_t!)
    func markCurrentPassAsFinished()
}

class AVAssetWriterInput : NSObject {
    convenience init()
    convenience init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?)
    class func assetWriterInputWithMediaType(_ mediaType: String, outputSettings outputSettings: [String : AnyObject]?) -> Self
    convenience init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?, sourceFormatHint sourceFormatHint: CMFormatDescription?)
    class func assetWriterInputWithMediaType(_ mediaType: String, outputSettings outputSettings: [String : AnyObject]?, sourceFormatHint sourceFormatHint: CMFormatDescription?) -> Self
    convenience init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?)
    init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?, sourceFormatHint sourceFormatHint: CMFormatDescription?)
    var mediaType: String { get }
    var outputSettings: [String : AnyObject]? { get }
    var sourceFormatHint: CMFormatDescription? { get }
    var metadata: [AVMetadataItem]
    var readyForMoreMediaData: Bool { get }
    var expectsMediaDataInRealTime: Bool
    func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t, usingBlock block: () -> Void)
    func appendSampleBuffer(_ sampleBuffer: CMSampleBuffer) -> Bool
    func markAsFinished()
}
extension AVAssetWriterInput {
    var languageCode: String?
    var extendedLanguageTag: String?
}
extension AVAssetWriterInput {
    var naturalSize: CGSize
    var transform: CGAffineTransform
}
extension AVAssetWriterInput {
    var preferredVolume: Float
}
extension AVAssetWriterInput {
    var marksOutputTrackAsEnabled: Bool
    var mediaTimeScale: CMTimeScale
    var preferredMediaChunkDuration: CMTime
    var preferredMediaChunkAlignment: Int
    @NSCopying var sampleReferenceBaseURL: NSURL?
}
extension AVAssetWriterInput {
    func canAddTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput, type trackAssociationType: String) -> Bool
    func addTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput, type trackAssociationType: String)
}
extension AVAssetWriterInput {
    var performsMultiPassEncodingIfSupported: Bool
    var canPerformMultiplePasses: Bool { get }
    var currentPassDescription: AVAssetWriterInputPassDescription? { get }
    func respondToEachPassDescriptionOnQueue(_ queue: dispatch_queue_t, usingBlock block: dispatch_block_t)
    func markCurrentPassAsFinished()
}

func addTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput!, type trackAssociationType: String!)

func addTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput, type trackAssociationType: String)

func appendSampleBuffer(_ sampleBuffer: CMSampleBuffer!) -> Bool

func appendSampleBuffer(_ sampleBuffer: CMSampleBuffer) -> Bool

func canAddTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput!, type trackAssociationType: String!) -> Bool

func canAddTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput, type trackAssociationType: String) -> Bool

var currentPassDescription: AVAssetWriterInputPassDescription! { get }

var currentPassDescription: AVAssetWriterInputPassDescription? { get }

var extendedLanguageTag: String!

var extendedLanguageTag: String?

init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!)

convenience init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?)

init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!, sourceFormatHint sourceFormatHint: CMFormatDescription!)

init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?, sourceFormatHint sourceFormatHint: CMFormatDescription?)

var languageCode: String!

var languageCode: String?

var mediaType: String! { get }

var mediaType: String { get }

var metadata: [AnyObject]!

var metadata: [AVMetadataItem]

var outputSettings: [NSObject : AnyObject]! { get }

var outputSettings: [String : AnyObject]? { get }

func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t!, usingBlock block: (() -> Void)!)

func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t, usingBlock block: () -> Void)

func respondToEachPassDescriptionOnQueue(_ queue: dispatch_queue_t!, usingBlock block: dispatch_block_t!)

func respondToEachPassDescriptionOnQueue(_ queue: dispatch_queue_t, usingBlock block: dispatch_block_t)

@NSCopying var sampleReferenceBaseURL: NSURL!

@NSCopying var sampleReferenceBaseURL: NSURL?

var sourceFormatHint: CMFormatDescription! { get }

var sourceFormatHint: CMFormatDescription? { get }

class AVAssetWriterInputGroup : AVMediaSelectionGroup {
    init!(inputs inputs: [AnyObject]!, defaultInput defaultInput: AVAssetWriterInput!) -> AVAssetWriterInputGroup
    class func assetWriterInputGroupWithInputs(_ inputs: [AnyObject]!, defaultInput defaultInput: AVAssetWriterInput!) -> AVAssetWriterInputGroup!
    init!(inputs inputs: [AnyObject]!, defaultInput defaultInput: AVAssetWriterInput!)
    var inputs: [AnyObject]! { get }
    var defaultInput: AVAssetWriterInput! { get }
}

class AVAssetWriterInputGroup : AVMediaSelectionGroup {
    convenience init()
    convenience init(inputs inputs: [AVAssetWriterInput], defaultInput defaultInput: AVAssetWriterInput?)
    class func assetWriterInputGroupWithInputs(_ inputs: [AVAssetWriterInput], defaultInput defaultInput: AVAssetWriterInput?) -> Self
    init(inputs inputs: [AVAssetWriterInput], defaultInput defaultInput: AVAssetWriterInput?)
    var inputs: [AVAssetWriterInput] { get }
    var defaultInput: AVAssetWriterInput? { get }
}

var defaultInput: AVAssetWriterInput! { get }

var defaultInput: AVAssetWriterInput? { get }

init!(inputs inputs: [AnyObject]!, defaultInput defaultInput: AVAssetWriterInput!)

init(inputs inputs: [AVAssetWriterInput], defaultInput defaultInput: AVAssetWriterInput?)

var inputs: [AnyObject]! { get }

var inputs: [AVAssetWriterInput] { get }

class AVAssetWriterInputMetadataAdaptor : NSObject {
    convenience init!(assetWriterInput input: AVAssetWriterInput!)
    class func assetWriterInputMetadataAdaptorWithAssetWriterInput(_ input: AVAssetWriterInput!) -> Self!
    init!(assetWriterInput input: AVAssetWriterInput!)
    var assetWriterInput: AVAssetWriterInput! { get }
    func appendTimedMetadataGroup(_ timedMetadataGroup: AVTimedMetadataGroup!) -> Bool
}

class AVAssetWriterInputMetadataAdaptor : NSObject {
    convenience init()
    convenience init(assetWriterInput input: AVAssetWriterInput)
    class func assetWriterInputMetadataAdaptorWithAssetWriterInput(_ input: AVAssetWriterInput) -> Self
    init(assetWriterInput input: AVAssetWriterInput)
    var assetWriterInput: AVAssetWriterInput { get }
    func appendTimedMetadataGroup(_ timedMetadataGroup: AVTimedMetadataGroup) -> Bool
}

func appendTimedMetadataGroup(_ timedMetadataGroup: AVTimedMetadataGroup!) -> Bool

func appendTimedMetadataGroup(_ timedMetadataGroup: AVTimedMetadataGroup) -> Bool

var assetWriterInput: AVAssetWriterInput! { get }

var assetWriterInput: AVAssetWriterInput { get }

init!(assetWriterInput input: AVAssetWriterInput!)

init(assetWriterInput input: AVAssetWriterInput)

class AVAssetWriterInputPassDescription : NSObject {
    var sourceTimeRanges: [AnyObject]! { get }
}

class AVAssetWriterInputPassDescription : NSObject {
    init()
    var sourceTimeRanges: [NSValue] { get }
}

var sourceTimeRanges: [AnyObject]! { get }

var sourceTimeRanges: [NSValue] { get }

class AVAssetWriterInputPixelBufferAdaptor : NSObject {
    convenience init!(assetWriterInput input: AVAssetWriterInput!, sourcePixelBufferAttributes sourcePixelBufferAttributes: [NSObject : AnyObject]!)
    class func assetWriterInputPixelBufferAdaptorWithAssetWriterInput(_ input: AVAssetWriterInput!, sourcePixelBufferAttributes sourcePixelBufferAttributes: [NSObject : AnyObject]!) -> Self!
    init!(assetWriterInput input: AVAssetWriterInput!, sourcePixelBufferAttributes sourcePixelBufferAttributes: [NSObject : AnyObject]!)
    var assetWriterInput: AVAssetWriterInput! { get }
    var sourcePixelBufferAttributes: [NSObject : AnyObject]! { get }
    var pixelBufferPool: CVPixelBufferPool! { get }
    func appendPixelBuffer(_ pixelBuffer: CVPixelBuffer!, withPresentationTime presentationTime: CMTime) -> Bool
}

class AVAssetWriterInputPixelBufferAdaptor : NSObject {
    convenience init()
    convenience init(assetWriterInput input: AVAssetWriterInput, sourcePixelBufferAttributes sourcePixelBufferAttributes: [String : AnyObject]?)
    class func assetWriterInputPixelBufferAdaptorWithAssetWriterInput(_ input: AVAssetWriterInput, sourcePixelBufferAttributes sourcePixelBufferAttributes: [String : AnyObject]?) -> Self
    init(assetWriterInput input: AVAssetWriterInput, sourcePixelBufferAttributes sourcePixelBufferAttributes: [String : AnyObject]?)
    var assetWriterInput: AVAssetWriterInput { get }
    var sourcePixelBufferAttributes: [String : AnyObject]? { get }
    var pixelBufferPool: CVPixelBufferPool? { get }
    func appendPixelBuffer(_ pixelBuffer: CVPixelBuffer, withPresentationTime presentationTime: CMTime) -> Bool
}

func appendPixelBuffer(_ pixelBuffer: CVPixelBuffer!, withPresentationTime presentationTime: CMTime) -> Bool

func appendPixelBuffer(_ pixelBuffer: CVPixelBuffer, withPresentationTime presentationTime: CMTime) -> Bool

var assetWriterInput: AVAssetWriterInput! { get }

var assetWriterInput: AVAssetWriterInput { get }

init!(assetWriterInput input: AVAssetWriterInput!, sourcePixelBufferAttributes sourcePixelBufferAttributes: [NSObject : AnyObject]!)

init(assetWriterInput input: AVAssetWriterInput, sourcePixelBufferAttributes sourcePixelBufferAttributes: [String : AnyObject]?)

var pixelBufferPool: CVPixelBufferPool! { get }

var pixelBufferPool: CVPixelBufferPool? { get }

var sourcePixelBufferAttributes: [NSObject : AnyObject]! { get }

var sourcePixelBufferAttributes: [String : AnyObject]? { get }

protocol AVAsynchronousKeyValueLoading {
    func statusOfValueForKey(_ key: String!, error outError: NSErrorPointer) -> AVKeyValueStatus
    func loadValuesAsynchronouslyForKeys(_ keys: [AnyObject]!, completionHandler handler: (() -> Void)!)
}

protocol AVAsynchronousKeyValueLoading {
    func statusOfValueForKey(_ key: String, error outError: NSErrorPointer) -> AVKeyValueStatus
    func loadValuesAsynchronouslyForKeys(_ keys: [String], completionHandler handler: (() -> Void)?)
}

func loadValuesAsynchronouslyForKeys(_ keys: [AnyObject]!, completionHandler handler: (() -> Void)!)

func loadValuesAsynchronouslyForKeys(_ keys: [String], completionHandler handler: (() -> Void)?)

func statusOfValueForKey(_ key: String!, error outError: NSErrorPointer) -> AVKeyValueStatus

func statusOfValueForKey(_ key: String, error outError: NSErrorPointer) -> AVKeyValueStatus

class AVAsynchronousVideoCompositionRequest : NSObject, NSCopying {
    var renderContext: AVVideoCompositionRenderContext! { get }
    var compositionTime: CMTime { get }
    var sourceTrackIDs: [AnyObject]! { get }
    var videoCompositionInstruction: AVVideoCompositionInstructionProtocol! { get }
    func sourceFrameByTrackID(_ trackID: CMPersistentTrackID) -> Unmanaged<CVPixelBuffer>!
    func finishWithComposedVideoFrame(_ composedVideoFrame: CVPixelBuffer!)
    func finishWithError(_ error: NSError!)
    func finishCancelledRequest()
}

class AVAsynchronousVideoCompositionRequest : NSObject, NSCopying {
    var renderContext: AVVideoCompositionRenderContext { get }
    var compositionTime: CMTime { get }
    var sourceTrackIDs: [NSNumber] { get }
    var videoCompositionInstruction: AVVideoCompositionInstructionProtocol { get }
    func sourceFrameByTrackID(_ trackID: CMPersistentTrackID) -> CVPixelBuffer?
    func finishWithComposedVideoFrame(_ composedVideoFrame: CVPixelBuffer)
    func finishWithError(_ error: NSError)
    func finishCancelledRequest()
}

func finishWithComposedVideoFrame(_ composedVideoFrame: CVPixelBuffer!)

func finishWithComposedVideoFrame(_ composedVideoFrame: CVPixelBuffer)

func finishWithError(_ error: NSError!)

func finishWithError(_ error: NSError)

var renderContext: AVVideoCompositionRenderContext! { get }

var renderContext: AVVideoCompositionRenderContext { get }

func sourceFrameByTrackID(_ trackID: CMPersistentTrackID) -> Unmanaged<CVPixelBuffer>!

func sourceFrameByTrackID(_ trackID: CMPersistentTrackID) -> CVPixelBuffer?

var sourceTrackIDs: [AnyObject]! { get }

var sourceTrackIDs: [NSNumber] { get }

var videoCompositionInstruction: AVVideoCompositionInstructionProtocol! { get }

var videoCompositionInstruction: AVVideoCompositionInstructionProtocol { get }

class AVAudioBuffer : NSObject, NSCopying, NSMutableCopying {
    var format: AVAudioFormat! { get }
    var audioBufferList: UnsafePointer<AudioBufferList> { get }
    var mutableAudioBufferList: UnsafeMutablePointer<AudioBufferList> { get }
}

class AVAudioBuffer : NSObject, NSCopying, NSMutableCopying {
    var format: AVAudioFormat { get }
    var audioBufferList: UnsafePointer<AudioBufferList> { get }
    var mutableAudioBufferList: UnsafeMutablePointer<AudioBufferList> { get }
}

var format: AVAudioFormat! { get }

var format: AVAudioFormat { get }

class AVAudioChannelLayout : NSObject {
    init!(layoutTag layoutTag: AudioChannelLayoutTag)
    init!(layout layout: UnsafePointer<AudioChannelLayout>)
    func isEqual(_ object: AnyObject!) -> Bool
    class func layoutWithLayoutTag(_ layoutTag: AudioChannelLayoutTag) -> Self!
    class func layoutWithLayout(_ layout: UnsafePointer<AudioChannelLayout>) -> Self!
    var layoutTag: AudioChannelLayoutTag { get }
    var layout: UnsafePointer<AudioChannelLayout> { get }
    var channelCount: AVAudioChannelCount { get }
}

class AVAudioChannelLayout : NSObject, NSSecureCoding, NSCoding {
    convenience init(layoutTag layoutTag: AudioChannelLayoutTag)
    init(layout layout: UnsafePointer<AudioChannelLayout>)
    func isEqual(_ object: AnyObject) -> Bool
    class func layoutWithLayoutTag(_ layoutTag: AudioChannelLayoutTag) -> Self
    class func layoutWithLayout(_ layout: UnsafePointer<AudioChannelLayout>) -> Self
    var layoutTag: AudioChannelLayoutTag { get }
    var layout: UnsafePointer<AudioChannelLayout> { get }
    var channelCount: AVAudioChannelCount { get }
}

init!(layout layout: UnsafePointer<AudioChannelLayout>)

init(layout layout: UnsafePointer<AudioChannelLayout>)

init!(layoutTag layoutTag: AudioChannelLayoutTag)

convenience init(layoutTag layoutTag: AudioChannelLayoutTag)

func isEqual(_ object: AnyObject!) -> Bool

func isEqual(_ object: AnyObject) -> Bool

class AVAudioEngine : NSObject {
    init!()
    func attachNode(_ node: AVAudioNode!)
    func detachNode(_ node: AVAudioNode!)
    func connect(_ node1: AVAudioNode!, to node2: AVAudioNode!, fromBus bus1: AVAudioNodeBus, toBus bus2: AVAudioNodeBus, format format: AVAudioFormat!)
    func connect(_ node1: AVAudioNode!, to node2: AVAudioNode!, format format: AVAudioFormat!)
    func disconnectNodeInput(_ node: AVAudioNode!, bus bus: AVAudioNodeBus)
    func disconnectNodeInput(_ node: AVAudioNode!)
    func disconnectNodeOutput(_ node: AVAudioNode!, bus bus: AVAudioNodeBus)
    func disconnectNodeOutput(_ node: AVAudioNode!)
    func prepare()
    func startAndReturnError(_ outError: NSErrorPointer) -> Bool
    func pause()
    func reset()
    func stop()
    var musicSequence: MusicSequence
    var outputNode: AVAudioOutputNode! { get }
    var inputNode: AVAudioInputNode! { get }
    var mainMixerNode: AVAudioMixerNode! { get }
    var running: Bool { get }
}

class AVAudioEngine : NSObject {
    init()
    func attachNode(_ node: AVAudioNode)
    func detachNode(_ node: AVAudioNode)
    func connect(_ node1: AVAudioNode, to node2: AVAudioNode, fromBus bus1: AVAudioNodeBus, toBus bus2: AVAudioNodeBus, format format: AVAudioFormat?)
    func connect(_ node1: AVAudioNode, to node2: AVAudioNode, format format: AVAudioFormat?)
    func connect(_ sourceNode: AVAudioNode, toConnectionPoints destNodes: [AVAudioConnectionPoint], fromBus sourceBus: AVAudioNodeBus, format format: AVAudioFormat?)
    func disconnectNodeInput(_ node: AVAudioNode, bus bus: AVAudioNodeBus)
    func disconnectNodeInput(_ node: AVAudioNode)
    func disconnectNodeOutput(_ node: AVAudioNode, bus bus: AVAudioNodeBus)
    func disconnectNodeOutput(_ node: AVAudioNode)
    func prepare()
    func start() throws
    func pause()
    func reset()
    func stop()
    func inputConnectionPointForNode(_ node: AVAudioNode, inputBus bus: AVAudioNodeBus) -> AVAudioConnectionPoint?
    func outputConnectionPointsForNode(_ node: AVAudioNode, outputBus bus: AVAudioNodeBus) -> [AVAudioConnectionPoint]
    var musicSequence: MusicSequence
    var outputNode: AVAudioOutputNode { get }
    var inputNode: AVAudioInputNode? { get }
    var mainMixerNode: AVAudioMixerNode { get }
    var running: Bool { get }
}

func attachNode(_ node: AVAudioNode!)

func attachNode(_ node: AVAudioNode)

func connect(_ node1: AVAudioNode!, to node2: AVAudioNode!, format format: AVAudioFormat!)

func connect(_ node1: AVAudioNode, to node2: AVAudioNode, format format: AVAudioFormat?)

func connect(_ node1: AVAudioNode!, to node2: AVAudioNode!, fromBus bus1: AVAudioNodeBus, toBus bus2: AVAudioNodeBus, format format: AVAudioFormat!)

func connect(_ node1: AVAudioNode, to node2: AVAudioNode, fromBus bus1: AVAudioNodeBus, toBus bus2: AVAudioNodeBus, format format: AVAudioFormat?)

func detachNode(_ node: AVAudioNode!)

func detachNode(_ node: AVAudioNode)

func disconnectNodeInput(_ node: AVAudioNode!)

func disconnectNodeInput(_ node: AVAudioNode)

func disconnectNodeInput(_ node: AVAudioNode!, bus bus: AVAudioNodeBus)

func disconnectNodeInput(_ node: AVAudioNode, bus bus: AVAudioNodeBus)

func disconnectNodeOutput(_ node: AVAudioNode!)

func disconnectNodeOutput(_ node: AVAudioNode)

func disconnectNodeOutput(_ node: AVAudioNode!, bus bus: AVAudioNodeBus)

func disconnectNodeOutput(_ node: AVAudioNode, bus bus: AVAudioNodeBus)

init!()

init()

var inputNode: AVAudioInputNode! { get }

var inputNode: AVAudioInputNode? { get }

var mainMixerNode: AVAudioMixerNode! { get }

var mainMixerNode: AVAudioMixerNode { get }

var outputNode: AVAudioOutputNode! { get }

var outputNode: AVAudioOutputNode { get }

func startAndReturnError(_ outError: NSErrorPointer) -> Bool

func start() throws

class AVAudioEnvironmentNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    var outputVolume: Float
    var nextAvailableInputBus: AVAudioNodeBus { get }
    var listenerPosition: AVAudio3DPoint
    var listenerVectorOrientation: AVAudio3DVectorOrientation
    var listenerAngularOrientation: AVAudio3DAngularOrientation
    var distanceAttenuationParameters: AVAudioEnvironmentDistanceAttenuationParameters! { get }
    var reverbParameters: AVAudioEnvironmentReverbParameters! { get }
    func applicableRenderingAlgorithms() -> [AnyObject]!
}

class AVAudioEnvironmentNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    var outputVolume: Float
    var nextAvailableInputBus: AVAudioNodeBus { get }
    var listenerPosition: AVAudio3DPoint
    var listenerVectorOrientation: AVAudio3DVectorOrientation
    var listenerAngularOrientation: AVAudio3DAngularOrientation
    var distanceAttenuationParameters: AVAudioEnvironmentDistanceAttenuationParameters { get }
    var reverbParameters: AVAudioEnvironmentReverbParameters { get }
    var applicableRenderingAlgorithms: [NSNumber] { get }
}

var distanceAttenuationParameters: AVAudioEnvironmentDistanceAttenuationParameters! { get }

var distanceAttenuationParameters: AVAudioEnvironmentDistanceAttenuationParameters { get }

var reverbParameters: AVAudioEnvironmentReverbParameters! { get }

var reverbParameters: AVAudioEnvironmentReverbParameters { get }

class AVAudioEnvironmentReverbParameters : NSObject {
    var enable: Bool
    var level: Float
    var filterParameters: AVAudioUnitEQFilterParameters! { get }
    func loadFactoryReverbPreset(_ preset: AVAudioUnitReverbPreset)
}

class AVAudioEnvironmentReverbParameters : NSObject {
    var enable: Bool
    var level: Float
    var filterParameters: AVAudioUnitEQFilterParameters { get }
    func loadFactoryReverbPreset(_ preset: AVAudioUnitReverbPreset)
}

var filterParameters: AVAudioUnitEQFilterParameters! { get }

var filterParameters: AVAudioUnitEQFilterParameters { get }

class AVAudioFile : NSObject {
    init!(forReading fileURL: NSURL!, error outError: NSErrorPointer)
    init!(forReading fileURL: NSURL!, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool, error outError: NSErrorPointer)
    init!(forWriting fileURL: NSURL!, settings settings: [NSObject : AnyObject]!, error outError: NSErrorPointer)
    init!(forWriting fileURL: NSURL!, settings settings: [NSObject : AnyObject]!, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool, error outError: NSErrorPointer)
    func readIntoBuffer(_ buffer: AVAudioPCMBuffer!, error outError: NSErrorPointer) -> Bool
    func readIntoBuffer(_ buffer: AVAudioPCMBuffer!, frameCount frames: AVAudioFrameCount, error outError: NSErrorPointer) -> Bool
    func writeFromBuffer(_ buffer: AVAudioPCMBuffer!, error outError: NSErrorPointer) -> Bool
    var url: NSURL! { get }
    var fileFormat: AVAudioFormat! { get }
    var processingFormat: AVAudioFormat! { get }
    var length: AVAudioFramePosition { get }
    var framePosition: AVAudioFramePosition
}

class AVAudioFile : NSObject {
    init(forReading fileURL: NSURL) throws
    init(forReading fileURL: NSURL, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool) throws
    init(forWriting fileURL: NSURL, settings settings: [String : AnyObject]) throws
    init(forWriting fileURL: NSURL, settings settings: [String : AnyObject], commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool) throws
    func readIntoBuffer(_ buffer: AVAudioPCMBuffer) throws
    func readIntoBuffer(_ buffer: AVAudioPCMBuffer, frameCount frames: AVAudioFrameCount) throws
    func writeFromBuffer(_ buffer: AVAudioPCMBuffer) throws
    var url: NSURL { get }
    var fileFormat: AVAudioFormat { get }
    var processingFormat: AVAudioFormat { get }
    var length: AVAudioFramePosition { get }
    var framePosition: AVAudioFramePosition
}

var fileFormat: AVAudioFormat! { get }

var fileFormat: AVAudioFormat { get }

init!(forReading fileURL: NSURL!, error outError: NSErrorPointer)

init(forReading fileURL: NSURL) throws

init!(forReading fileURL: NSURL!, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool, error outError: NSErrorPointer)

init(forReading fileURL: NSURL, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool) throws

init!(forWriting fileURL: NSURL!, settings settings: [NSObject : AnyObject]!, error outError: NSErrorPointer)

init(forWriting fileURL: NSURL, settings settings: [String : AnyObject]) throws

init!(forWriting fileURL: NSURL!, settings settings: [NSObject : AnyObject]!, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool, error outError: NSErrorPointer)

init(forWriting fileURL: NSURL, settings settings: [String : AnyObject], commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool) throws

var processingFormat: AVAudioFormat! { get }

var processingFormat: AVAudioFormat { get }

func readIntoBuffer(_ buffer: AVAudioPCMBuffer!, error outError: NSErrorPointer) -> Bool

func readIntoBuffer(_ buffer: AVAudioPCMBuffer) throws

func readIntoBuffer(_ buffer: AVAudioPCMBuffer!, frameCount frames: AVAudioFrameCount, error outError: NSErrorPointer) -> Bool

func readIntoBuffer(_ buffer: AVAudioPCMBuffer, frameCount frames: AVAudioFrameCount) throws

var url: NSURL! { get }

var url: NSURL { get }

func writeFromBuffer(_ buffer: AVAudioPCMBuffer!, error outError: NSErrorPointer) -> Bool

func writeFromBuffer(_ buffer: AVAudioPCMBuffer) throws

class AVAudioFormat : NSObject {
    init!(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>)
    init!(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>, channelLayout layout: AVAudioChannelLayout!)
    init!(standardFormatWithSampleRate sampleRate: Double, channels channels: AVAudioChannelCount)
    init!(standardFormatWithSampleRate sampleRate: Double, channelLayout layout: AVAudioChannelLayout!)
    init!(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, channels channels: AVAudioChannelCount, interleaved interleaved: Bool)
    init!(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, interleaved interleaved: Bool, channelLayout layout: AVAudioChannelLayout!)
    init!(settings settings: [NSObject : AnyObject]!)
    func isEqual(_ object: AnyObject!) -> Bool
    var standard: Bool { get }
    var commonFormat: AVAudioCommonFormat { get }
    var channelCount: AVAudioChannelCount { get }
    var sampleRate: Double { get }
    var interleaved: Bool { get }
    var streamDescription: UnsafePointer<AudioStreamBasicDescription> { get }
    var channelLayout: AVAudioChannelLayout! { get }
    var settings: [NSObject : AnyObject]! { get }
}

class AVAudioFormat : NSObject, NSSecureCoding, NSCoding {
    init(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>)
    init(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>, channelLayout layout: AVAudioChannelLayout?)
    init(standardFormatWithSampleRate sampleRate: Double, channels channels: AVAudioChannelCount)
    init(standardFormatWithSampleRate sampleRate: Double, channelLayout layout: AVAudioChannelLayout)
    init(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, channels channels: AVAudioChannelCount, interleaved interleaved: Bool)
    init(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, interleaved interleaved: Bool, channelLayout layout: AVAudioChannelLayout)
    init(settings settings: [String : AnyObject])
    init(CMAudioFormatDescription formatDescription: CMAudioFormatDescription)
    func isEqual(_ object: AnyObject) -> Bool
    var standard: Bool { get }
    var commonFormat: AVAudioCommonFormat { get }
    var channelCount: AVAudioChannelCount { get }
    var sampleRate: Double { get }
    var interleaved: Bool { get }
    var streamDescription: UnsafePointer<AudioStreamBasicDescription> { get }
    var channelLayout: AVAudioChannelLayout? { get }
    var settings: [String : AnyObject] { get }
    var formatDescription: CMAudioFormatDescription { get }
}

var channelLayout: AVAudioChannelLayout! { get }

var channelLayout: AVAudioChannelLayout? { get }

init!(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, channels channels: AVAudioChannelCount, interleaved interleaved: Bool)

init(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, channels channels: AVAudioChannelCount, interleaved interleaved: Bool)

init!(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, interleaved interleaved: Bool, channelLayout layout: AVAudioChannelLayout!)

init(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, interleaved interleaved: Bool, channelLayout layout: AVAudioChannelLayout)

init!(settings settings: [NSObject : AnyObject]!)

init(settings settings: [String : AnyObject])

init!(standardFormatWithSampleRate sampleRate: Double, channelLayout layout: AVAudioChannelLayout!)

init(standardFormatWithSampleRate sampleRate: Double, channelLayout layout: AVAudioChannelLayout)

init!(standardFormatWithSampleRate sampleRate: Double, channels channels: AVAudioChannelCount)

init(standardFormatWithSampleRate sampleRate: Double, channels channels: AVAudioChannelCount)

init!(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>)

init(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>)

init!(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>, channelLayout layout: AVAudioChannelLayout!)

init(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>, channelLayout layout: AVAudioChannelLayout?)

func isEqual(_ object: AnyObject!) -> Bool

func isEqual(_ object: AnyObject) -> Bool

var settings: [NSObject : AnyObject]! { get }

var settings: [String : AnyObject] { get }

class AVAudioInputNode : AVAudioIONode, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
}

class AVAudioInputNode : AVAudioIONode, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
}

class AVAudioMix : NSObject, NSCopying, NSMutableCopying {
    var inputParameters: [AnyObject]! { get }
}

class AVAudioMix : NSObject, NSCopying, NSMutableCopying {
    var inputParameters: [AVAudioMixInputParameters] { get }
}

var inputParameters: [AnyObject]! { get }

var inputParameters: [AVAudioMixInputParameters] { get }

class AVAudioMixerNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    var outputVolume: Float
    var nextAvailableInputBus: AVAudioNodeBus { get }
}

class AVAudioMixerNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    var outputVolume: Float
    var nextAvailableInputBus: AVAudioNodeBus { get }
}

protocol AVAudioMixing : AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    var volume: Float { get set }
}

protocol AVAudioMixing : AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    func destinationForMixer(_ mixer: AVAudioNode, bus bus: AVAudioNodeBus) -> AVAudioMixingDestination?
    var volume: Float { get set }
}

class AVAudioMixInputParameters : NSObject, NSCopying, NSMutableCopying {
    var trackID: CMPersistentTrackID { get }
    var audioTimePitchAlgorithm: String! { get }
    var audioTapProcessor: MTAudioProcessingTap! { get }
    func getVolumeRampForTime(_ time: CMTime, startVolume startVolume: UnsafeMutablePointer<Float>, endVolume endVolume: UnsafeMutablePointer<Float>, timeRange timeRange: UnsafeMutablePointer<CMTimeRange>) -> Bool
}

class AVAudioMixInputParameters : NSObject, NSCopying, NSMutableCopying {
    var trackID: CMPersistentTrackID { get }
    var audioTimePitchAlgorithm: String? { get }
    var audioTapProcessor: MTAudioProcessingTap? { get }
    func getVolumeRampForTime(_ time: CMTime, startVolume startVolume: UnsafeMutablePointer<Float>, endVolume endVolume: UnsafeMutablePointer<Float>, timeRange timeRange: UnsafeMutablePointer<CMTimeRange>) -> Bool
}

var audioTapProcessor: MTAudioProcessingTap! { get }

var audioTapProcessor: MTAudioProcessingTap? { get }

var audioTimePitchAlgorithm: String! { get }

var audioTimePitchAlgorithm: String? { get }

class AVAudioNode : NSObject {
    func reset()
    func inputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat!
    func outputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat!
    func nameForInputBus(_ bus: AVAudioNodeBus) -> String!
    func nameForOutputBus(_ bus: AVAudioNodeBus) -> String!
    func installTapOnBus(_ bus: AVAudioNodeBus, bufferSize bufferSize: AVAudioFrameCount, format format: AVAudioFormat!, block tapBlock: AVAudioNodeTapBlock!)
    func removeTapOnBus(_ bus: AVAudioNodeBus)
    var engine: AVAudioEngine! { get }
    var numberOfInputs: Int { get }
    var numberOfOutputs: Int { get }
    var lastRenderTime: AVAudioTime! { get }
}

class AVAudioNode : NSObject {
    func reset()
    func inputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat
    func outputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat
    func nameForInputBus(_ bus: AVAudioNodeBus) -> String
    func nameForOutputBus(_ bus: AVAudioNodeBus) -> String
    func installTapOnBus(_ bus: AVAudioNodeBus, bufferSize bufferSize: AVAudioFrameCount, format format: AVAudioFormat?, block tapBlock: AVAudioNodeTapBlock)
    func removeTapOnBus(_ bus: AVAudioNodeBus)
    var engine: AVAudioEngine? { get }
    var numberOfInputs: Int { get }
    var numberOfOutputs: Int { get }
    var lastRenderTime: AVAudioTime? { get }
}

var engine: AVAudioEngine! { get }

var engine: AVAudioEngine? { get }

func inputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat!

func inputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat

func installTapOnBus(_ bus: AVAudioNodeBus, bufferSize bufferSize: AVAudioFrameCount, format format: AVAudioFormat!, block tapBlock: AVAudioNodeTapBlock!)

func installTapOnBus(_ bus: AVAudioNodeBus, bufferSize bufferSize: AVAudioFrameCount, format format: AVAudioFormat?, block tapBlock: AVAudioNodeTapBlock)

var lastRenderTime: AVAudioTime! { get }

var lastRenderTime: AVAudioTime? { get }

func nameForInputBus(_ bus: AVAudioNodeBus) -> String!

func nameForInputBus(_ bus: AVAudioNodeBus) -> String

func nameForOutputBus(_ bus: AVAudioNodeBus) -> String!

func nameForOutputBus(_ bus: AVAudioNodeBus) -> String

func outputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat!

func outputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat

class AVAudioPCMBuffer : AVAudioBuffer {
    init!(PCMFormat format: AVAudioFormat!, frameCapacity frameCapacity: AVAudioFrameCount)
    var frameCapacity: AVAudioFrameCount { get }
    var frameLength: AVAudioFrameCount
    var stride: Int { get }
    var floatChannelData: UnsafePointer<UnsafeMutablePointer<Float>> { get }
    var int16ChannelData: UnsafePointer<UnsafeMutablePointer<Int16>> { get }
    var int32ChannelData: UnsafePointer<UnsafeMutablePointer<Int32>> { get }
}

class AVAudioPCMBuffer : AVAudioBuffer {
    init(PCMFormat format: AVAudioFormat, frameCapacity frameCapacity: AVAudioFrameCount)
    var frameCapacity: AVAudioFrameCount { get }
    var frameLength: AVAudioFrameCount
    var stride: Int { get }
    var floatChannelData: UnsafePointer<UnsafeMutablePointer<Float>> { get }
    var int16ChannelData: UnsafePointer<UnsafeMutablePointer<Int16>> { get }
    var int32ChannelData: UnsafePointer<UnsafeMutablePointer<Int32>> { get }
}

init!(PCMFormat format: AVAudioFormat!, frameCapacity frameCapacity: AVAudioFrameCount)

init(PCMFormat format: AVAudioFormat, frameCapacity frameCapacity: AVAudioFrameCount)

class AVAudioPlayer : NSObject {
    init!(contentsOfURL url: NSURL!, error outError: NSErrorPointer)
    init!(data data: NSData!, error outError: NSErrorPointer)
    init!(contentsOfURL url: NSURL!, fileTypeHint utiString: String!, error outError: NSErrorPointer)
    init!(data data: NSData!, fileTypeHint utiString: String!, error outError: NSErrorPointer)
    func prepareToPlay() -> Bool
    func play() -> Bool
    func playAtTime(_ time: NSTimeInterval) -> Bool
    func pause()
    func stop()
    var playing: Bool { get }
    var numberOfChannels: Int { get }
    var duration: NSTimeInterval { get }
    unowned(unsafe) var delegate: AVAudioPlayerDelegate!
    var url: NSURL! { get }
    var data: NSData! { get }
    var pan: Float
    var volume: Float
    var enableRate: Bool
    var rate: Float
    var currentTime: NSTimeInterval
    var deviceCurrentTime: NSTimeInterval { get }
    var numberOfLoops: Int
    var settings: [NSObject : AnyObject]! { get }
    var meteringEnabled: Bool
    func updateMeters()
    func peakPowerForChannel(_ channelNumber: Int) -> Float
    func averagePowerForChannel(_ channelNumber: Int) -> Float
}

class AVAudioPlayer : NSObject {
    init(contentsOfURL url: NSURL) throws
    init(data data: NSData) throws
    init(contentsOfURL url: NSURL, fileTypeHint utiString: String?) throws
    init(data data: NSData, fileTypeHint utiString: String?) throws
    func prepareToPlay() -> Bool
    func play() -> Bool
    func playAtTime(_ time: NSTimeInterval) -> Bool
    func pause()
    func stop()
    var playing: Bool { get }
    var numberOfChannels: Int { get }
    var duration: NSTimeInterval { get }
    unowned(unsafe) var delegate: AVAudioPlayerDelegate?
    var url: NSURL? { get }
    var data: NSData? { get }
    var pan: Float
    var volume: Float
    var enableRate: Bool
    var rate: Float
    var currentTime: NSTimeInterval
    var deviceCurrentTime: NSTimeInterval { get }
    var numberOfLoops: Int
    var settings: [String : AnyObject] { get }
    var meteringEnabled: Bool
    func updateMeters()
    func peakPowerForChannel(_ channelNumber: Int) -> Float
    func averagePowerForChannel(_ channelNumber: Int) -> Float
}

var data: NSData! { get }

var data: NSData? { get }

unowned(unsafe) var delegate: AVAudioPlayerDelegate!

unowned(unsafe) var delegate: AVAudioPlayerDelegate?

init!(contentsOfURL url: NSURL!, error outError: NSErrorPointer)

init(contentsOfURL url: NSURL) throws

init!(contentsOfURL url: NSURL!, fileTypeHint utiString: String!, error outError: NSErrorPointer)

init(contentsOfURL url: NSURL, fileTypeHint utiString: String?) throws

init!(data data: NSData!, error outError: NSErrorPointer)

init(data data: NSData) throws

init!(data data: NSData!, fileTypeHint utiString: String!, error outError: NSErrorPointer)

init(data data: NSData, fileTypeHint utiString: String?) throws

var settings: [NSObject : AnyObject]! { get }

var settings: [String : AnyObject] { get }

var url: NSURL! { get }

var url: NSURL? { get }

protocol AVAudioPlayerDelegate : NSObjectProtocol {
    optional func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer!, successfully flag: Bool)
    optional func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer!, error error: NSError!)
}

protocol AVAudioPlayerDelegate : NSObjectProtocol {
    optional func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool)
    optional func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer, error error: NSError?)
}

optional func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer!, error error: NSError!)

optional func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer, error error: NSError?)

optional func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer!, successfully flag: Bool)

optional func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool)

class AVAudioPlayerNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    func scheduleBuffer(_ buffer: AVAudioPCMBuffer!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
    func scheduleBuffer(_ buffer: AVAudioPCMBuffer!, atTime when: AVAudioTime!, options options: AVAudioPlayerNodeBufferOptions, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
    func scheduleFile(_ file: AVAudioFile!, atTime when: AVAudioTime!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
    func scheduleSegment(_ file: AVAudioFile!, startingFrame startFrame: AVAudioFramePosition, frameCount numberFrames: AVAudioFrameCount, atTime when: AVAudioTime!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
    func stop()
    func prepareWithFrameCount(_ frameCount: AVAudioFrameCount)
    func play()
    func playAtTime(_ when: AVAudioTime!)
    func pause()
    func nodeTimeForPlayerTime(_ playerTime: AVAudioTime!) -> AVAudioTime!
    func playerTimeForNodeTime(_ nodeTime: AVAudioTime!) -> AVAudioTime!
    var playing: Bool { get }
}

class AVAudioPlayerNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    func scheduleBuffer(_ buffer: AVAudioPCMBuffer, completionHandler completionHandler: AVAudioNodeCompletionHandler?)
    func scheduleBuffer(_ buffer: AVAudioPCMBuffer, atTime when: AVAudioTime?, options options: AVAudioPlayerNodeBufferOptions, completionHandler completionHandler: AVAudioNodeCompletionHandler?)
    func scheduleFile(_ file: AVAudioFile, atTime when: AVAudioTime?, completionHandler completionHandler: AVAudioNodeCompletionHandler?)
    func scheduleSegment(_ file: AVAudioFile, startingFrame startFrame: AVAudioFramePosition, frameCount numberFrames: AVAudioFrameCount, atTime when: AVAudioTime?, completionHandler completionHandler: AVAudioNodeCompletionHandler?)
    func stop()
    func prepareWithFrameCount(_ frameCount: AVAudioFrameCount)
    func play()
    func playAtTime(_ when: AVAudioTime?)
    func pause()
    func nodeTimeForPlayerTime(_ playerTime: AVAudioTime) -> AVAudioTime?
    func playerTimeForNodeTime(_ nodeTime: AVAudioTime) -> AVAudioTime?
    var playing: Bool { get }
}

func nodeTimeForPlayerTime(_ playerTime: AVAudioTime!) -> AVAudioTime!

func nodeTimeForPlayerTime(_ playerTime: AVAudioTime) -> AVAudioTime?

func playAtTime(_ when: AVAudioTime!)

func playAtTime(_ when: AVAudioTime?)

func playerTimeForNodeTime(_ nodeTime: AVAudioTime!) -> AVAudioTime!

func playerTimeForNodeTime(_ nodeTime: AVAudioTime) -> AVAudioTime?

func scheduleBuffer(_ buffer: AVAudioPCMBuffer!, atTime when: AVAudioTime!, options options: AVAudioPlayerNodeBufferOptions, completionHandler completionHandler: AVAudioNodeCompletionHandler!)

func scheduleBuffer(_ buffer: AVAudioPCMBuffer, atTime when: AVAudioTime?, options options: AVAudioPlayerNodeBufferOptions, completionHandler completionHandler: AVAudioNodeCompletionHandler?)

func scheduleBuffer(_ buffer: AVAudioPCMBuffer!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)

func scheduleBuffer(_ buffer: AVAudioPCMBuffer, completionHandler completionHandler: AVAudioNodeCompletionHandler?)

func scheduleFile(_ file: AVAudioFile!, atTime when: AVAudioTime!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)

func scheduleFile(_ file: AVAudioFile, atTime when: AVAudioTime?, completionHandler completionHandler: AVAudioNodeCompletionHandler?)

func scheduleSegment(_ file: AVAudioFile!, startingFrame startFrame: AVAudioFramePosition, frameCount numberFrames: AVAudioFrameCount, atTime when: AVAudioTime!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)

func scheduleSegment(_ file: AVAudioFile, startingFrame startFrame: AVAudioFramePosition, frameCount numberFrames: AVAudioFrameCount, atTime when: AVAudioTime?, completionHandler completionHandler: AVAudioNodeCompletionHandler?)

struct AVAudioPlayerNodeBufferOptions : RawOptionSetType {
    init(_ rawValue: UInt)
    init(rawValue rawValue: UInt)
    static var Loops: AVAudioPlayerNodeBufferOptions { get }
    static var Interrupts: AVAudioPlayerNodeBufferOptions { get }
    static var InterruptsAtLoop: AVAudioPlayerNodeBufferOptions { get }
}

struct AVAudioPlayerNodeBufferOptions : OptionSetType {
    init(rawValue rawValue: UInt)
    static var Loops: AVAudioPlayerNodeBufferOptions { get }
    static var Interrupts: AVAudioPlayerNodeBufferOptions { get }
    static var InterruptsAtLoop: AVAudioPlayerNodeBufferOptions { get }
}

class AVAudioRecorder : NSObject {
    init!(URL url: NSURL!, settings settings: [NSObject : AnyObject]!, error outError: NSErrorPointer)
    func prepareToRecord() -> Bool
    func record() -> Bool
    func recordAtTime(_ time: NSTimeInterval) -> Bool
    func recordForDuration(_ duration: NSTimeInterval) -> Bool
    func recordAtTime(_ time: NSTimeInterval, forDuration duration: NSTimeInterval) -> Bool
    func pause()
    func stop()
    func deleteRecording() -> Bool
    var recording: Bool { get }
    var url: NSURL! { get }
    var settings: [NSObject : AnyObject]! { get }
    unowned(unsafe) var delegate: AVAudioRecorderDelegate!
    var currentTime: NSTimeInterval { get }
    var deviceCurrentTime: NSTimeInterval { get }
    var meteringEnabled: Bool
    func updateMeters()
    func peakPowerForChannel(_ channelNumber: Int) -> Float
    func averagePowerForChannel(_ channelNumber: Int) -> Float
}

class AVAudioRecorder : NSObject {
    init(URL url: NSURL, settings settings: [String : AnyObject]) throws
    func prepareToRecord() -> Bool
    func record() -> Bool
    func recordAtTime(_ time: NSTimeInterval) -> Bool
    func recordForDuration(_ duration: NSTimeInterval) -> Bool
    func recordAtTime(_ time: NSTimeInterval, forDuration duration: NSTimeInterval) -> Bool
    func pause()
    func stop()
    func deleteRecording() -> Bool
    var recording: Bool { get }
    var url: NSURL { get }
    var settings: [String : AnyObject] { get }
    unowned(unsafe) var delegate: AVAudioRecorderDelegate?
    var currentTime: NSTimeInterval { get }
    var deviceCurrentTime: NSTimeInterval { get }
    var meteringEnabled: Bool
    func updateMeters()
    func peakPowerForChannel(_ channelNumber: Int) -> Float
    func averagePowerForChannel(_ channelNumber: Int) -> Float
}

unowned(unsafe) var delegate: AVAudioRecorderDelegate!

unowned(unsafe) var delegate: AVAudioRecorderDelegate?

init!(URL url: NSURL!, settings settings: [NSObject : AnyObject]!, error outError: NSErrorPointer)

init(URL url: NSURL, settings settings: [String : AnyObject]) throws

var settings: [NSObject : AnyObject]! { get }

var settings: [String : AnyObject] { get }

var url: NSURL! { get }

var url: NSURL { get }

protocol AVAudioRecorderDelegate : NSObjectProtocol {
    optional func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder!, successfully flag: Bool)
    optional func audioRecorderEncodeErrorDidOccur(_ recorder: AVAudioRecorder!, error error: NSError!)
}

protocol AVAudioRecorderDelegate : NSObjectProtocol {
    optional func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool)
    optional func audioRecorderEncodeErrorDidOccur(_ recorder: AVAudioRecorder, error error: NSError?)
}

optional func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder!, successfully flag: Bool)

optional func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool)

optional func audioRecorderEncodeErrorDidOccur(_ recorder: AVAudioRecorder!, error error: NSError!)

optional func audioRecorderEncodeErrorDidOccur(_ recorder: AVAudioRecorder, error error: NSError?)

class AVAudioTime : NSObject {
    init!(audioTimeStamp ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double)
    init!(hostTime hostTime: UInt64)
    init!(sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
    init!(hostTime hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
    class func timeWithAudioTimeStamp(_ ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double) -> Self!
    class func timeWithHostTime(_ hostTime: UInt64) -> Self!
    class func timeWithSampleTime(_ sampleTime: AVAudioFramePosition, atRate sampleRate: Double) -> Self!
    class func timeWithHostTime(_ hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double) -> Self!
    class func hostTimeForSeconds(_ seconds: NSTimeInterval) -> UInt64
    class func secondsForHostTime(_ hostTime: UInt64) -> NSTimeInterval
    func extrapolateTimeFromAnchor(_ anchorTime: AVAudioTime!) -> AVAudioTime!
    var hostTimeValid: Bool { get }
    var hostTime: UInt64 { get }
    var sampleTimeValid: Bool { get }
    var sampleTime: AVAudioFramePosition { get }
    var sampleRate: Double { get }
    var audioTimeStamp: AudioTimeStamp { get }
}

class AVAudioTime : NSObject {
    init(audioTimeStamp ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double)
    init(hostTime hostTime: UInt64)
    init(sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
    init(hostTime hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
    class func timeWithAudioTimeStamp(_ ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double) -> Self
    class func timeWithHostTime(_ hostTime: UInt64) -> Self
    class func timeWithSampleTime(_ sampleTime: AVAudioFramePosition, atRate sampleRate: Double) -> Self
    class func timeWithHostTime(_ hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double) -> Self
    class func hostTimeForSeconds(_ seconds: NSTimeInterval) -> UInt64
    class func secondsForHostTime(_ hostTime: UInt64) -> NSTimeInterval
    func extrapolateTimeFromAnchor(_ anchorTime: AVAudioTime) -> AVAudioTime
    var hostTimeValid: Bool { get }
    var hostTime: UInt64 { get }
    var sampleTimeValid: Bool { get }
    var sampleTime: AVAudioFramePosition { get }
    var sampleRate: Double { get }
    var audioTimeStamp: AudioTimeStamp { get }
}

func extrapolateTimeFromAnchor(_ anchorTime: AVAudioTime!) -> AVAudioTime!

func extrapolateTimeFromAnchor(_ anchorTime: AVAudioTime) -> AVAudioTime

init!(audioTimeStamp ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double)

init(audioTimeStamp ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double)

init!(hostTime hostTime: UInt64)

init(hostTime hostTime: UInt64)

init!(hostTime hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)

init(hostTime hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)

init!(sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)

init(sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)

class AVAudioUnit : AVAudioNode {
    func loadAudioUnitPresetAtURL(_ url: NSURL!, error error: NSErrorPointer) -> Bool
    var audioComponentDescription: AudioComponentDescription { get }
    var audioUnit: AudioUnit { get }
    var name: String! { get }
    var manufacturerName: String! { get }
    var version: Int { get }
}

class AVAudioUnit : AVAudioNode {
    class func instantiateWithComponentDescription(_ audioComponentDescription: AudioComponentDescription, options options: AudioComponentInstantiationOptions, completionHandler completionHandler: (AVAudioUnit?, NSError?) -> Void)
    func loadAudioUnitPresetAtURL(_ url: NSURL) throws
    var audioComponentDescription: AudioComponentDescription { get }
    var audioUnit: AudioUnit { get }
    var AUAudioUnit: AUAudioUnit { get }
    var name: String { get }
    var manufacturerName: String { get }
    var version: Int { get }
}

func loadAudioUnitPresetAtURL(_ url: NSURL!, error error: NSErrorPointer) -> Bool

func loadAudioUnitPresetAtURL(_ url: NSURL) throws

var manufacturerName: String! { get }

var manufacturerName: String { get }

var name: String! { get }

var name: String { get }

class AVAudioUnitComponent : NSObject {
    var name: String! { get }
    var typeName: String! { get }
    var localizedTypeName: String! { get }
    var manufacturerName: String! { get }
    var version: Int { get }
    var versionString: String! { get }
    var iconURL: NSURL! { get }
    var componentURL: NSURL! { get }
    var availableArchitectures: [AnyObject]! { get }
    var hasCustomView: Bool { get }
    var passesAUVal: Bool { get }
    var sandboxSafe: Bool { get }
    var hasMIDIInput: Bool { get }
    var hasMIDIOutput: Bool { get }
    var audioComponent: AudioComponent { get }
    var configurationDictionary: [NSObject : AnyObject]! { get }
    var userTagNames: [AnyObject]!
    var allTagNames: [AnyObject]! { get }
    var audioComponentDescription: AudioComponentDescription { get }
    func supportsNumberInputChannels(_ numInputChannels: Int, outputChannels numOutputChannels: Int) -> Bool
}

class AVAudioUnitComponent : NSObject {
    var name: String { get }
    var typeName: String { get }
    var localizedTypeName: String { get }
    var manufacturerName: String { get }
    var version: Int { get }
    var versionString: String { get }
    var componentURL: NSURL? { get }
    var availableArchitectures: [NSNumber] { get }
    var sandboxSafe: Bool { get }
    var hasMIDIInput: Bool { get }
    var hasMIDIOutput: Bool { get }
    var audioComponent: AudioComponent { get }
    var userTagNames: [String]
    var allTagNames: [String] { get }
    var audioComponentDescription: AudioComponentDescription { get }
    var iconURL: NSURL? { get }
    var icon: NSImage? { get }
    var passesAUVal: Bool { get }
    var hasCustomView: Bool { get }
    var configurationDictionary: [String : AnyObject] { get }
    func supportsNumberInputChannels(_ numInputChannels: Int, outputChannels numOutputChannels: Int) -> Bool
}

var allTagNames: [AnyObject]! { get }

var allTagNames: [String] { get }

var availableArchitectures: [AnyObject]! { get }

var availableArchitectures: [NSNumber] { get }

var componentURL: NSURL! { get }

var componentURL: NSURL? { get }

var configurationDictionary: [NSObject : AnyObject]! { get }

var configurationDictionary: [String : AnyObject] { get }

var iconURL: NSURL! { get }

var iconURL: NSURL? { get }

var localizedTypeName: String! { get }

var localizedTypeName: String { get }

var manufacturerName: String! { get }

var manufacturerName: String { get }

var name: String! { get }

var name: String { get }

var typeName: String! { get }

var typeName: String { get }

var userTagNames: [AnyObject]!

var userTagNames: [String]

var versionString: String! { get }

var versionString: String { get }

class AVAudioUnitComponentManager : NSObject {
    var tagNames: [AnyObject]! { get }
    var standardLocalizedTagNames: [AnyObject]! { get }
    class func sharedAudioUnitComponentManager() -> Self!
    func componentsMatchingPredicate(_ predicate: NSPredicate!) -> [AnyObject]!
    func componentsPassingTest(_ testHandler: ((AVAudioUnitComponent!, UnsafeMutablePointer<ObjCBool>) -> Bool)!) -> [AnyObject]!
    func componentsMatchingDescription(_ desc: AudioComponentDescription) -> [AnyObject]!
}

class AVAudioUnitComponentManager : NSObject {
    var tagNames: [String] { get }
    var standardLocalizedTagNames: [String] { get }
    class func sharedAudioUnitComponentManager() -> Self
    func componentsMatchingPredicate(_ predicate: NSPredicate) -> [AVAudioUnitComponent]
    func componentsPassingTest(_ testHandler: (AVAudioUnitComponent, UnsafeMutablePointer<ObjCBool>) -> Bool) -> [AVAudioUnitComponent]
    func componentsMatchingDescription(_ desc: AudioComponentDescription) -> [AVAudioUnitComponent]
}

func componentsMatchingDescription(_ desc: AudioComponentDescription) -> [AnyObject]!

func componentsMatchingDescription(_ desc: AudioComponentDescription) -> [AVAudioUnitComponent]

func componentsMatchingPredicate(_ predicate: NSPredicate!) -> [AnyObject]!

func componentsMatchingPredicate(_ predicate: NSPredicate) -> [AVAudioUnitComponent]

func componentsPassingTest(_ testHandler: ((AVAudioUnitComponent!, UnsafeMutablePointer<ObjCBool>) -> Bool)!) -> [AnyObject]!

func componentsPassingTest(_ testHandler: (AVAudioUnitComponent, UnsafeMutablePointer<ObjCBool>) -> Bool) -> [AVAudioUnitComponent]

class func sharedAudioUnitComponentManager() -> Self!

class func sharedAudioUnitComponentManager() -> Self

var standardLocalizedTagNames: [AnyObject]! { get }

var standardLocalizedTagNames: [String] { get }

var tagNames: [AnyObject]! { get }

var tagNames: [String] { get }

class AVAudioUnitEffect : AVAudioUnit {
    init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}

class AVAudioUnitEffect : AVAudioUnit {
    init(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}

init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)

init(audioComponentDescription audioComponentDescription: AudioComponentDescription)

class AVAudioUnitEQ : AVAudioUnitEffect {
    init!(numberOfBands numberOfBands: Int)
    var bands: [AnyObject]! { get }
    var globalGain: Float
}

class AVAudioUnitEQ : AVAudioUnitEffect {
    init(numberOfBands numberOfBands: Int)
    var bands: [AVAudioUnitEQFilterParameters] { get }
    var globalGain: Float
}

var bands: [AnyObject]! { get }

var bands: [AVAudioUnitEQFilterParameters] { get }

init!(numberOfBands numberOfBands: Int)

init(numberOfBands numberOfBands: Int)

class AVAudioUnitGenerator : AVAudioUnit, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}

class AVAudioUnitGenerator : AVAudioUnit, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    init(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}

init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)

init(audioComponentDescription audioComponentDescription: AudioComponentDescription)

class AVAudioUnitMIDIInstrument : AVAudioUnit {
    init!(audioComponentDescription description: AudioComponentDescription)
    func startNote(_ note: UInt8, withVelocity velocity: UInt8, onChannel channel: UInt8)
    func stopNote(_ note: UInt8, onChannel channel: UInt8)
    func sendController(_ controller: UInt8, withValue value: UInt8, onChannel channel: UInt8)
    func sendPitchBend(_ pitchbend: UInt16, onChannel channel: UInt8)
    func sendPressure(_ pressure: UInt8, onChannel channel: UInt8)
    func sendPressureForKey(_ key: UInt8, withValue value: UInt8, onChannel channel: UInt8)
    func sendProgramChange(_ program: UInt8, onChannel channel: UInt8)
    func sendProgramChange(_ program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8, onChannel channel: UInt8)
    func sendMIDIEvent(_ midiStatus: UInt8, data1 data1: UInt8, data2 data2: UInt8)
    func sendMIDIEvent(_ midiStatus: UInt8, data1 data1: UInt8)
    func sendMIDISysExEvent(_ midiData: NSData!)
}

class AVAudioUnitMIDIInstrument : AVAudioUnit, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    init(audioComponentDescription description: AudioComponentDescription)
    func startNote(_ note: UInt8, withVelocity velocity: UInt8, onChannel channel: UInt8)
    func stopNote(_ note: UInt8, onChannel channel: UInt8)
    func sendController(_ controller: UInt8, withValue value: UInt8, onChannel channel: UInt8)
    func sendPitchBend(_ pitchbend: UInt16, onChannel channel: UInt8)
    func sendPressure(_ pressure: UInt8, onChannel channel: UInt8)
    func sendPressureForKey(_ key: UInt8, withValue value: UInt8, onChannel channel: UInt8)
    func sendProgramChange(_ program: UInt8, onChannel channel: UInt8)
    func sendProgramChange(_ program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8, onChannel channel: UInt8)
    func sendMIDIEvent(_ midiStatus: UInt8, data1 data1: UInt8, data2 data2: UInt8)
    func sendMIDIEvent(_ midiStatus: UInt8, data1 data1: UInt8)
    func sendMIDISysExEvent(_ midiData: NSData)
}

init!(audioComponentDescription description: AudioComponentDescription)

init(audioComponentDescription description: AudioComponentDescription)

func sendMIDISysExEvent(_ midiData: NSData!)

func sendMIDISysExEvent(_ midiData: NSData)

class AVAudioUnitSampler : AVAudioUnitMIDIInstrument {
    func loadSoundBankInstrumentAtURL(_ bankURL: NSURL!, program program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8, error outError: NSErrorPointer) -> Bool
    func loadInstrumentAtURL(_ instrumentURL: NSURL!, error outError: NSErrorPointer) -> Bool
    func loadAudioFilesAtURLs(_ audioFiles: [AnyObject]!, error outError: NSErrorPointer) -> Bool
    var stereoPan: Float
    var masterGain: Float
    var globalTuning: Float
}

class AVAudioUnitSampler : AVAudioUnitMIDIInstrument {
    func loadSoundBankInstrumentAtURL(_ bankURL: NSURL, program program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8) throws
    func loadInstrumentAtURL(_ instrumentURL: NSURL) throws
    func loadAudioFilesAtURLs(_ audioFiles: [NSURL]) throws
    var stereoPan: Float
    var masterGain: Float
    var globalTuning: Float
}

func loadAudioFilesAtURLs(_ audioFiles: [AnyObject]!, error outError: NSErrorPointer) -> Bool

func loadAudioFilesAtURLs(_ audioFiles: [NSURL]) throws

func loadInstrumentAtURL(_ instrumentURL: NSURL!, error outError: NSErrorPointer) -> Bool

func loadInstrumentAtURL(_ instrumentURL: NSURL) throws

func loadSoundBankInstrumentAtURL(_ bankURL: NSURL!, program program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8, error outError: NSErrorPointer) -> Bool

func loadSoundBankInstrumentAtURL(_ bankURL: NSURL, program program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8) throws

class AVAudioUnitTimeEffect : AVAudioUnit {
    init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}

class AVAudioUnitTimeEffect : AVAudioUnit {
    init(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}

init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)

init(audioComponentDescription audioComponentDescription: AudioComponentDescription)

class AVCaptureAudioDataOutput : AVCaptureOutput {
    func setSampleBufferDelegate(_ sampleBufferDelegate: AVCaptureAudioDataOutputSampleBufferDelegate!, queue sampleBufferCallbackQueue: dispatch_queue_t!)
    var sampleBufferDelegate: AVCaptureAudioDataOutputSampleBufferDelegate! { get }
    var sampleBufferCallbackQueue: dispatch_queue_t! { get }
    var audioSettings: [NSObject : AnyObject]!
}

class AVCaptureAudioDataOutput : AVCaptureOutput {
    func setSampleBufferDelegate(_ sampleBufferDelegate: AVCaptureAudioDataOutputSampleBufferDelegate!, queue sampleBufferCallbackQueue: dispatch_queue_t!)
    var sampleBufferDelegate: AVCaptureAudioDataOutputSampleBufferDelegate! { get }
    var sampleBufferCallbackQueue: dispatch_queue_t! { get }
    var audioSettings: [NSObject : AnyObject]!
    func recommendedAudioSettingsForAssetWriterWithOutputFileType(_ outputFileType: String!) -> [NSObject : AnyObject]!
}

class AVCaptureConnection : NSObject {
    init!(inputPorts ports: [AnyObject]!, output output: AVCaptureOutput!) -> AVCaptureConnection
    class func connectionWithInputPorts(_ ports: [AnyObject]!, output output: AVCaptureOutput!) -> AVCaptureConnection!
    init!(inputPort port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!) -> AVCaptureConnection
    class func connectionWithInputPort(_ port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!) -> AVCaptureConnection!
    init!(inputPorts ports: [AnyObject]!, output output: AVCaptureOutput!)
    init!(inputPort port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!)
    var inputPorts: [AnyObject]! { get }
    var output: AVCaptureOutput! { get }
    var videoPreviewLayer: AVCaptureVideoPreviewLayer! { get }
    var enabled: Bool
    var active: Bool { get }
    var audioChannels: [AnyObject]! { get }
    var supportsVideoMirroring: Bool { get }
    var videoMirrored: Bool
    var automaticallyAdjustsVideoMirroring: Bool
    var supportsVideoOrientation: Bool { get }
    var videoOrientation: AVCaptureVideoOrientation
    var supportsVideoFieldMode: Bool { get }
    var videoFieldMode: AVVideoFieldMode
    var supportsVideoMinFrameDuration: Bool { get }
    var videoMinFrameDuration: CMTime
    var supportsVideoMaxFrameDuration: Bool { get }
    var videoMaxFrameDuration: CMTime
    var videoMaxScaleAndCropFactor: CGFloat { get }
    var videoScaleAndCropFactor: CGFloat
    var supportsVideoStabilization: Bool { get }
    var videoStabilizationEnabled: Bool { get }
    var enablesVideoStabilizationWhenAvailable: Bool
}

class AVCaptureConnection : NSObject {
    convenience init!(inputPorts ports: [AnyObject]!, output output: AVCaptureOutput!)
    class func connectionWithInputPorts(_ ports: [AnyObject]!, output output: AVCaptureOutput!) -> Self!
    convenience init!(inputPort port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!)
    class func connectionWithInputPort(_ port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!) -> Self!
    init!(inputPorts ports: [AnyObject]!, output output: AVCaptureOutput!)
    init!(inputPort port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!)
    var inputPorts: [AnyObject]! { get }
    var output: AVCaptureOutput! { get }
    var videoPreviewLayer: AVCaptureVideoPreviewLayer! { get }
    var enabled: Bool
    var active: Bool { get }
    var audioChannels: [AnyObject]! { get }
    var supportsVideoMirroring: Bool { get }
    var videoMirrored: Bool
    var automaticallyAdjustsVideoMirroring: Bool
    var supportsVideoOrientation: Bool { get }
    var videoOrientation: AVCaptureVideoOrientation
    var supportsVideoFieldMode: Bool { get }
    var videoFieldMode: AVVideoFieldMode
    var supportsVideoMinFrameDuration: Bool { get }
    var videoMinFrameDuration: CMTime
    var supportsVideoMaxFrameDuration: Bool { get }
    var videoMaxFrameDuration: CMTime
}

class AVCaptureDevice : NSObject {
    class func devices() -> [AnyObject]!
    class func devicesWithMediaType(_ mediaType: String!) -> [AnyObject]!
    class func defaultDeviceWithMediaType(_ mediaType: String!) -> AVCaptureDevice!
    init!(uniqueID deviceUniqueID: String!) -> AVCaptureDevice
    class func deviceWithUniqueID(_ deviceUniqueID: String!) -> AVCaptureDevice!
    var uniqueID: String! { get }
    var modelID: String! { get }
    var localizedName: String! { get }
    var manufacturer: String! { get }
    var transportType: Int32 { get }
    func hasMediaType(_ mediaType: String!) -> Bool
    func lockForConfiguration(_ outError: NSErrorPointer) -> Bool
    func unlockForConfiguration()
    func supportsAVCaptureSessionPreset(_ preset: String!) -> Bool
    var connected: Bool { get }
    var inUseByAnotherApplication: Bool { get }
    var suspended: Bool { get }
    var linkedDevices: [AnyObject]! { get }
    var formats: [AnyObject]! { get }
    var activeFormat: AVCaptureDeviceFormat!
    var activeVideoMinFrameDuration: CMTime
    var activeVideoMaxFrameDuration: CMTime
    var inputSources: [AnyObject]! { get }
    var activeInputSource: AVCaptureDeviceInputSource!
}
extension AVCaptureDevice {
    var position: AVCaptureDevicePosition { get }
}
extension AVCaptureDevice {
    var hasFlash: Bool { get }
    var flashAvailable: Bool { get }
    var flashActive: Bool { get }
    func isFlashModeSupported(_ flashMode: AVCaptureFlashMode) -> Bool
    var flashMode: AVCaptureFlashMode
}
extension AVCaptureDevice {
    var hasTorch: Bool { get }
    var torchAvailable: Bool { get }
    var torchActive: Bool { get }
    var torchLevel: Float { get }
    func isTorchModeSupported(_ torchMode: AVCaptureTorchMode) -> Bool
    var torchMode: AVCaptureTorchMode
    func setTorchModeOnWithLevel(_ torchLevel: Float, error outError: NSErrorPointer) -> Bool
}
extension AVCaptureDevice {
    func isFocusModeSupported(_ focusMode: AVCaptureFocusMode) -> Bool
    var focusMode: AVCaptureFocusMode
    var focusPointOfInterestSupported: Bool { get }
    var focusPointOfInterest: CGPoint
    var adjustingFocus: Bool { get }
}
extension AVCaptureDevice {
    func isExposureModeSupported(_ exposureMode: AVCaptureExposureMode) -> Bool
    var exposureMode: AVCaptureExposureMode
    var exposurePointOfInterestSupported: Bool { get }
    var exposurePointOfInterest: CGPoint
    var adjustingExposure: Bool { get }
}
extension AVCaptureDevice {
    func isWhiteBalanceModeSupported(_ whiteBalanceMode: AVCaptureWhiteBalanceMode) -> Bool
    var whiteBalanceMode: AVCaptureWhiteBalanceMode
    var adjustingWhiteBalance: Bool { get }
}
extension AVCaptureDevice {
    var subjectAreaChangeMonitoringEnabled: Bool
}
extension AVCaptureDevice {
    var lowLightBoostSupported: Bool { get }
    var lowLightBoostEnabled: Bool { get }
    var automaticallyEnablesLowLightBoostWhenAvailable: Bool
}
extension AVCaptureDevice {
    var transportControlsSupported: Bool { get }
    var transportControlsPlaybackMode: AVCaptureDeviceTransportControlsPlaybackMode { get }
    var transportControlsSpeed: AVCaptureDeviceTransportControlsSpeed { get }
    func setTransportControlsPlaybackMode(_ mode: AVCaptureDeviceTransportControlsPlaybackMode, speed speed: AVCaptureDeviceTransportControlsSpeed)
}

class AVCaptureDevice : NSObject {
    class func devices() -> [AnyObject]!
    class func devicesWithMediaType(_ mediaType: String!) -> [AnyObject]!
    class func defaultDeviceWithMediaType(_ mediaType: String!) -> AVCaptureDevice!
     init!(uniqueID deviceUniqueID: String!)
    class func deviceWithUniqueID(_ deviceUniqueID: String!) -> AVCaptureDevice!
    var uniqueID: String! { get }
    var modelID: String! { get }
    var localizedName: String! { get }
    var manufacturer: String! { get }
    var transportType: Int32 { get }
    func hasMediaType(_ mediaType: String!) -> Bool
    func lockForConfiguration() throws
    func unlockForConfiguration()
    func supportsAVCaptureSessionPreset(_ preset: String!) -> Bool
    var connected: Bool { get }
    var inUseByAnotherApplication: Bool { get }
    var suspended: Bool { get }
    var linkedDevices: [AnyObject]! { get }
    var formats: [AnyObject]! { get }
    var activeFormat: AVCaptureDeviceFormat!
    var activeVideoMinFrameDuration: CMTime
    var activeVideoMaxFrameDuration: CMTime
    var inputSources: [AnyObject]! { get }
    var activeInputSource: AVCaptureDeviceInputSource!
}
extension AVCaptureDevice {
    var position: AVCaptureDevicePosition { get }
}
extension AVCaptureDevice {
    var hasFlash: Bool { get }
    var flashAvailable: Bool { get }
    var flashActive: Bool { get }
    func isFlashModeSupported(_ flashMode: AVCaptureFlashMode) -> Bool
    var flashMode: AVCaptureFlashMode
}
extension AVCaptureDevice {
    var hasTorch: Bool { get }
    var torchAvailable: Bool { get }
    var torchActive: Bool { get }
    var torchLevel: Float { get }
    func isTorchModeSupported(_ torchMode: AVCaptureTorchMode) -> Bool
    var torchMode: AVCaptureTorchMode
    func setTorchModeOnWithLevel(_ torchLevel: Float) throws
}
extension AVCaptureDevice {
    func isFocusModeSupported(_ focusMode: AVCaptureFocusMode) -> Bool
    var focusMode: AVCaptureFocusMode
    var focusPointOfInterestSupported: Bool { get }
    var focusPointOfInterest: CGPoint
    var adjustingFocus: Bool { get }
    var autoFocusRangeRestrictionSupported: Bool { get }
    var autoFocusRangeRestriction: AVCaptureAutoFocusRangeRestriction
    var smoothAutoFocusSupported: Bool { get }
    var smoothAutoFocusEnabled: Bool
    var lensPosition: Float { get }
    func setFocusModeLockedWithLensPosition(_ lensPosition: Float, completionHandler handler: ((CMTime) -> Void)!)
}
extension AVCaptureDevice {
    func isExposureModeSupported(_ exposureMode: AVCaptureExposureMode) -> Bool
    var exposureMode: AVCaptureExposureMode
    var exposurePointOfInterestSupported: Bool { get }
    var exposurePointOfInterest: CGPoint
    var adjustingExposure: Bool { get }
    var lensAperture: Float { get }
    var exposureDuration: CMTime { get }
    var ISO: Float { get }
    func setExposureModeCustomWithDuration(_ duration: CMTime, ISO ISO: Float, completionHandler handler: ((CMTime) -> Void)!)
    var exposureTargetOffset: Float { get }
    var exposureTargetBias: Float { get }
    var minExposureTargetBias: Float { get }
    var maxExposureTargetBias: Float { get }
    func setExposureTargetBias(_ bias: Float, completionHandler handler: ((CMTime) -> Void)!)
}
extension AVCaptureDevice {
    func isWhiteBalanceModeSupported(_ whiteBalanceMode: AVCaptureWhiteBalanceMode) -> Bool
    var whiteBalanceMode: AVCaptureWhiteBalanceMode
    var adjustingWhiteBalance: Bool { get }
    var deviceWhiteBalanceGains: AVCaptureWhiteBalanceGains { get }
    var grayWorldDeviceWhiteBalanceGains: AVCaptureWhiteBalanceGains { get }
    var maxWhiteBalanceGain: Float { get }
    func setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains(_ whiteBalanceGains: AVCaptureWhiteBalanceGains, completionHandler handler: ((CMTime) -> Void)!)
    func chromaticityValuesForDeviceWhiteBalanceGains(_ whiteBalanceGains: AVCaptureWhiteBalanceGains) -> AVCaptureWhiteBalanceChromaticityValues
    func deviceWhiteBalanceGainsForChromaticityValues(_ chromaticityValues: AVCaptureWhiteBalanceChromaticityValues) -> AVCaptureWhiteBalanceGains
    func temperatureAndTintValuesForDeviceWhiteBalanceGains(_ whiteBalanceGains: AVCaptureWhiteBalanceGains) -> AVCaptureWhiteBalanceTemperatureAndTintValues
    func deviceWhiteBalanceGainsForTemperatureAndTintValues(_ tempAndTintValues: AVCaptureWhiteBalanceTemperatureAndTintValues) -> AVCaptureWhiteBalanceGains
}
extension AVCaptureDevice {
    var subjectAreaChangeMonitoringEnabled: Bool
}
extension AVCaptureDevice {
    var lowLightBoostSupported: Bool { get }
    var lowLightBoostEnabled: Bool { get }
    var automaticallyEnablesLowLightBoostWhenAvailable: Bool
}
extension AVCaptureDevice {
    var videoZoomFactor: CGFloat
    func rampToVideoZoomFactor(_ factor: CGFloat, withRate rate: Float)
    var rampingVideoZoom: Bool { get }
    func cancelVideoZoomRamp()
}
extension AVCaptureDevice {
    class func authorizationStatusForMediaType(_ mediaType: String!) -> AVAuthorizationStatus
    class func requestAccessForMediaType(_ mediaType: String!, completionHandler handler: ((Bool) -> Void)!)
}
extension AVCaptureDevice {
    var transportControlsSupported: Bool { get }
    var transportControlsPlaybackMode: AVCaptureDeviceTransportControlsPlaybackMode { get }
    var transportControlsSpeed: AVCaptureDeviceTransportControlsSpeed { get }
    func setTransportControlsPlaybackMode(_ mode: AVCaptureDeviceTransportControlsPlaybackMode, speed speed: AVCaptureDeviceTransportControlsSpeed)
}
extension AVCaptureDevice {
    var automaticallyAdjustsVideoHDREnabled: Bool
    var videoHDREnabled: Bool
}

init!(uniqueID deviceUniqueID: String!) -> AVCaptureDevice

init!(uniqueID deviceUniqueID: String!)

func lockForConfiguration(_ outError: NSErrorPointer) -> Bool

func lockForConfiguration() throws

class AVCaptureDeviceInput : AVCaptureInput {
    class func deviceInputWithDevice(_ device: AVCaptureDevice!, error outError: NSErrorPointer) -> AnyObject!
    init!(device device: AVCaptureDevice!, error outError: NSErrorPointer)
    var device: AVCaptureDevice! { get }
}

class AVCaptureDeviceInput : AVCaptureInput {
    convenience init(device device: AVCaptureDevice!) throws
    class func deviceInputWithDevice(_ device: AVCaptureDevice!) throws -> Self
    init(device device: AVCaptureDevice!) throws
    var device: AVCaptureDevice! { get }
}

init!(device device: AVCaptureDevice!, error outError: NSErrorPointer)

init(device device: AVCaptureDevice!) throws

enum AVCaptureExposureMode : Int {
    case Locked
    case AutoExpose
    case ContinuousAutoExposure
}

enum AVCaptureExposureMode : Int {
    case Locked
    case AutoExpose
    case ContinuousAutoExposure
    case Custom
}

class AVCaptureOutput : NSObject {
    var connections: [AnyObject]! { get }
    func connectionWithMediaType(_ mediaType: String!) -> AVCaptureConnection!
    func transformedMetadataObjectForMetadataObject(_ metadataObject: AVMetadataObject!, connection connection: AVCaptureConnection!) -> AVMetadataObject!
}

class AVCaptureOutput : NSObject {
    var connections: [AnyObject]! { get }
    func connectionWithMediaType(_ mediaType: String!) -> AVCaptureConnection!
    func transformedMetadataObjectForMetadataObject(_ metadataObject: AVMetadataObject!, connection connection: AVCaptureConnection!) -> AVMetadataObject!
    func metadataOutputRectOfInterestForRect(_ rectInOutputCoordinates: CGRect) -> CGRect
    func rectForMetadataOutputRectOfInterest(_ rectInMetadataOutputCoordinates: CGRect) -> CGRect
}

class AVCaptureVideoDataOutput : AVCaptureOutput {
    func setSampleBufferDelegate(_ sampleBufferDelegate: AVCaptureVideoDataOutputSampleBufferDelegate!, queue sampleBufferCallbackQueue: dispatch_queue_t!)
    var sampleBufferDelegate: AVCaptureVideoDataOutputSampleBufferDelegate! { get }
    var sampleBufferCallbackQueue: dispatch_queue_t! { get }
    var videoSettings: [NSObject : AnyObject]!
    var availableVideoCVPixelFormatTypes: [AnyObject]! { get }
    var availableVideoCodecTypes: [AnyObject]! { get }
    var minFrameDuration: CMTime
    var alwaysDiscardsLateVideoFrames: Bool
}

class AVCaptureVideoDataOutput : AVCaptureOutput {
    func setSampleBufferDelegate(_ sampleBufferDelegate: AVCaptureVideoDataOutputSampleBufferDelegate!, queue sampleBufferCallbackQueue: dispatch_queue_t!)
    var sampleBufferDelegate: AVCaptureVideoDataOutputSampleBufferDelegate! { get }
    var sampleBufferCallbackQueue: dispatch_queue_t! { get }
    var videoSettings: [NSObject : AnyObject]!
    func recommendedVideoSettingsForAssetWriterWithOutputFileType(_ outputFileType: String!) -> [NSObject : AnyObject]!
    var availableVideoCVPixelFormatTypes: [AnyObject]! { get }
    var availableVideoCodecTypes: [AnyObject]! { get }
    var minFrameDuration: CMTime
    var alwaysDiscardsLateVideoFrames: Bool
}

class AVCaptureVideoPreviewLayer : CALayer {
    class func layerWithSession(_ session: AVCaptureSession!) -> AnyObject!
    init!(session session: AVCaptureSession!)
    class func layerWithSessionWithNoConnection(_ session: AVCaptureSession!) -> AnyObject!
    init!(sessionWithNoConnection session: AVCaptureSession!)
    var session: AVCaptureSession!
    func setSessionWithNoConnection(_ session: AVCaptureSession!)
    var connection: AVCaptureConnection! { get }
    var videoGravity: String!
    func captureDevicePointOfInterestForPoint(_ pointInLayer: CGPoint) -> CGPoint
    func pointForCaptureDevicePointOfInterest(_ captureDevicePointOfInterest: CGPoint) -> CGPoint
    func transformedMetadataObjectForMetadataObject(_ metadataObject: AVMetadataObject!) -> AVMetadataObject!
}

class AVCaptureVideoPreviewLayer : CALayer {
    convenience init!(session session: AVCaptureSession!)
    class func layerWithSession(_ session: AVCaptureSession!) -> Self!
    init!(session session: AVCaptureSession!)
    convenience init!(sessionWithNoConnection session: AVCaptureSession!)
    class func layerWithSessionWithNoConnection(_ session: AVCaptureSession!) -> Self!
    init!(sessionWithNoConnection session: AVCaptureSession!)
    var session: AVCaptureSession!
    func setSessionWithNoConnection(_ session: AVCaptureSession!)
    var connection: AVCaptureConnection! { get }
    var videoGravity: String!
    func captureDevicePointOfInterestForPoint(_ pointInLayer: CGPoint) -> CGPoint
    func pointForCaptureDevicePointOfInterest(_ captureDevicePointOfInterest: CGPoint) -> CGPoint
    func metadataOutputRectOfInterestForRect(_ rectInLayerCoordinates: CGRect) -> CGRect
    func rectForMetadataOutputRectOfInterest(_ rectInMetadataOutputCoordinates: CGRect) -> CGRect
    func transformedMetadataObjectForMetadataObject(_ metadataObject: AVMetadataObject!) -> AVMetadataObject!
}

class AVComposition : AVAsset, NSMutableCopying {
    var tracks: [AnyObject]! { get }
    var naturalSize: CGSize { get }
}

class AVComposition : AVAsset, NSMutableCopying {
    var tracks: [AVCompositionTrack] { get }
    var naturalSize: CGSize { get }
    var URLAssetInitializationOptions: [String : AnyObject] { get }
}
extension AVComposition {
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVCompositionTrack?
    func tracksWithMediaType(_ mediaType: String) -> [AVCompositionTrack]
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVCompositionTrack]
}

var tracks: [AnyObject]! { get }

var tracks: [AVCompositionTrack] { get }

class AVCompositionTrack : AVAssetTrack {
    var segments: [AnyObject]! { get }
}

class AVCompositionTrack : AVAssetTrack {
    var segments: [AVCompositionTrackSegment] { get }
}

var segments: [AnyObject]! { get }

var segments: [AVCompositionTrackSegment] { get }

class AVCompositionTrackSegment : AVAssetTrackSegment {
    init!(URL URL: NSURL!, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange) -> AVCompositionTrackSegment
    class func compositionTrackSegmentWithURL(_ URL: NSURL!, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange) -> AVCompositionTrackSegment!
    init!(timeRange timeRange: CMTimeRange) -> AVCompositionTrackSegment
    class func compositionTrackSegmentWithTimeRange(_ timeRange: CMTimeRange) -> AVCompositionTrackSegment!
    init!(URL URL: NSURL!, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)
    init!(timeRange timeRange: CMTimeRange)
    var empty: Bool { get }
    var sourceURL: NSURL! { get }
    var sourceTrackID: CMPersistentTrackID { get }
}

class AVCompositionTrackSegment : AVAssetTrackSegment {
    convenience init(URL URL: NSURL, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)
    class func compositionTrackSegmentWithURL(_ URL: NSURL, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange) -> Self
    convenience init(timeRange timeRange: CMTimeRange)
    class func compositionTrackSegmentWithTimeRange(_ timeRange: CMTimeRange) -> Self
    init(URL URL: NSURL, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)
    init(timeRange timeRange: CMTimeRange)
    var empty: Bool { get }
    var sourceURL: NSURL? { get }
    var sourceTrackID: CMPersistentTrackID { get }
}

init!(timeRange timeRange: CMTimeRange)

init(timeRange timeRange: CMTimeRange)

init!(URL URL: NSURL!, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)

init(URL URL: NSURL, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)

var sourceURL: NSURL! { get }

var sourceURL: NSURL? { get }

enum AVError : Int {
    case Unknown
    case OutOfMemory
    case SessionNotRunning
    case DeviceAlreadyUsedByAnotherSession
    case NoDataCaptured
    case SessionConfigurationChanged
    case DiskFull
    case DeviceWasDisconnected
    case MediaChanged
    case MaximumDurationReached
    case MaximumFileSizeReached
    case MediaDiscontinuity
    case MaximumNumberOfSamplesForFileFormatReached
    case DeviceNotConnected
    case DeviceInUseByAnotherApplication
    case DeviceLockedForConfigurationByAnotherProcess
    case ExportFailed
    case DecodeFailed
    case InvalidSourceMedia
    case FileAlreadyExists
    case CompositionTrackSegmentsNotContiguous
    case InvalidCompositionTrackSegmentDuration
    case InvalidCompositionTrackSegmentSourceStartTime
    case InvalidCompositionTrackSegmentSourceDuration
    case FileFormatNotRecognized
    case FileFailedToParse
    case MaximumStillImageCaptureRequestsExceeded
    case ContentIsProtected
    case NoImageAtTime
    case DecoderNotFound
    case EncoderNotFound
    case ContentIsNotAuthorized
    case ApplicationIsNotAuthorized
    case OperationNotSupportedForAsset
    case DecoderTemporarilyUnavailable
    case EncoderTemporarilyUnavailable
    case InvalidVideoComposition
    case ReferenceForbiddenByReferencePolicy
    case InvalidOutputURLPathExtension
    case ScreenCaptureFailed
    case DisplayWasDisabled
    case TorchLevelUnavailable
    case IncompatibleAsset
    case FailedToLoadMediaData
    case ServerIncorrectlyConfigured
    case ApplicationIsNotAuthorizedToUseDevice
    case FailedToParse
    case FileTypeDoesNotSupportSampleReferences
    case UndecodableMediaData
}

enum AVError : Int {
    case Unknown
    case OutOfMemory
    case SessionNotRunning
    case DeviceAlreadyUsedByAnotherSession
    case NoDataCaptured
    case SessionConfigurationChanged
    case DiskFull
    case DeviceWasDisconnected
    case MediaChanged
    case MaximumDurationReached
    case MaximumFileSizeReached
    case MediaDiscontinuity
    case MaximumNumberOfSamplesForFileFormatReached
    case DeviceNotConnected
    case DeviceInUseByAnotherApplication
    case DeviceLockedForConfigurationByAnotherProcess
    case ExportFailed
    case DecodeFailed
    case InvalidSourceMedia
    case FileAlreadyExists
    case CompositionTrackSegmentsNotContiguous
    case InvalidCompositionTrackSegmentDuration
    case InvalidCompositionTrackSegmentSourceStartTime
    case InvalidCompositionTrackSegmentSourceDuration
    case FileFormatNotRecognized
    case FileFailedToParse
    case MaximumStillImageCaptureRequestsExceeded
    case ContentIsProtected
    case NoImageAtTime
    case DecoderNotFound
    case EncoderNotFound
    case ContentIsNotAuthorized
    case ApplicationIsNotAuthorized
    case OperationNotSupportedForAsset
    case DecoderTemporarilyUnavailable
    case EncoderTemporarilyUnavailable
    case InvalidVideoComposition
    case ReferenceForbiddenByReferencePolicy
    case InvalidOutputURLPathExtension
    case ScreenCaptureFailed
    case DisplayWasDisabled
    case TorchLevelUnavailable
    case IncompatibleAsset
    case FailedToLoadMediaData
    case ServerIncorrectlyConfigured
    case ApplicationIsNotAuthorizedToUseDevice
    case FailedToParse
    case FileTypeDoesNotSupportSampleReferences
    case UndecodableMediaData
    case AirPlayControllerRequiresInternet
    case AirPlayReceiverRequiresInternet
    case VideoCompositorFailed
}
extension AVError : Hashable, Equatable, __BridgedNSError, ErrorType, RawRepresentable, _ObjectiveCBridgeableErrorType, _BridgedNSError {
}
extension AVError : Hashable, Equatable, __BridgedNSError, ErrorType, RawRepresentable, _ObjectiveCBridgeableErrorType, _BridgedNSError {
}

class AVFragmentedMovie : AVMovie {
    var tracks: [AnyObject]! { get }
}

class AVFragmentedMovie : AVMovie, AVFragmentMinding {
    var tracks: [AVFragmentedMovieTrack] { get }
}
extension AVFragmentedMovie {
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVFragmentedMovieTrack?
    func tracksWithMediaType(_ mediaType: String) -> [AVFragmentedMovieTrack]
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVFragmentedMovieTrack]
}

var tracks: [AnyObject]! { get }

var tracks: [AVFragmentedMovieTrack] { get }

class AVFragmentedMovieMinder : NSObject {
    convenience init!(movie movie: AVFragmentedMovie!, mindingInterval mindingInterval: NSTimeInterval)
    class func fragmentedMovieMinderWithMovie(_ movie: AVFragmentedMovie!, mindingInterval mindingInterval: NSTimeInterval) -> Self!
    init!(movie movie: AVFragmentedMovie!, mindingInterval mindingInterval: NSTimeInterval)
    var mindingInterval: NSTimeInterval
    var movies: [AnyObject]! { get }
    func addFragmentedMovie(_ movie: AVFragmentedMovie!)
    func removeFragmentedMovie(_ movie: AVFragmentedMovie!)
}

class AVFragmentedMovieMinder : AVFragmentedAssetMinder {
    convenience init(movie movie: AVFragmentedMovie, mindingInterval mindingInterval: NSTimeInterval)
    class func fragmentedMovieMinderWithMovie(_ movie: AVFragmentedMovie, mindingInterval mindingInterval: NSTimeInterval) -> Self
    init(movie movie: AVFragmentedMovie, mindingInterval mindingInterval: NSTimeInterval)
    var mindingInterval: NSTimeInterval
    var movies: [AVFragmentedMovie] { get }
    func addFragmentedMovie(_ movie: AVFragmentedMovie)
    func removeFragmentedMovie(_ movie: AVFragmentedMovie)
}

func addFragmentedMovie(_ movie: AVFragmentedMovie!)

func addFragmentedMovie(_ movie: AVFragmentedMovie)

init!(movie movie: AVFragmentedMovie!, mindingInterval mindingInterval: NSTimeInterval)

init(movie movie: AVFragmentedMovie, mindingInterval mindingInterval: NSTimeInterval)

var movies: [AnyObject]! { get }

var movies: [AVFragmentedMovie] { get }

func removeFragmentedMovie(_ movie: AVFragmentedMovie!)

func removeFragmentedMovie(_ movie: AVFragmentedMovie)

class AVMediaSelectionGroup : NSObject, NSCopying {
    var options: [AnyObject]! { get }
    var defaultOption: AVMediaSelectionOption! { get }
    var allowsEmptySelection: Bool { get }
    func mediaSelectionOptionWithPropertyList(_ plist: AnyObject!) -> AVMediaSelectionOption!
}
extension AVMediaSelectionGroup {
    class func playableMediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!) -> [AnyObject]!
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [AnyObject]!) -> [AnyObject]!
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withLocale locale: NSLocale!) -> [AnyObject]!
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withMediaCharacteristics mediaCharacteristics: [AnyObject]!) -> [AnyObject]!
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withoutMediaCharacteristics mediaCharacteristics: [AnyObject]!) -> [AnyObject]!
}

class AVMediaSelectionGroup : NSObject, NSCopying {
    var options: [AVMediaSelectionOption] { get }
    var defaultOption: AVMediaSelectionOption? { get }
    var allowsEmptySelection: Bool { get }
    func mediaSelectionOptionWithPropertyList(_ plist: AnyObject) -> AVMediaSelectionOption?
}
extension AVMediaSelectionGroup {
    class func playableMediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption]) -> [AVMediaSelectionOption]
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [String]) -> [AVMediaSelectionOption]
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withLocale locale: NSLocale) -> [AVMediaSelectionOption]
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withMediaCharacteristics mediaCharacteristics: [String]) -> [AVMediaSelectionOption]
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withoutMediaCharacteristics mediaCharacteristics: [String]) -> [AVMediaSelectionOption]
}

var defaultOption: AVMediaSelectionOption! { get }

var defaultOption: AVMediaSelectionOption? { get }

class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [AnyObject]!) -> [AnyObject]!

class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [String]) -> [AVMediaSelectionOption]

class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withLocale locale: NSLocale!) -> [AnyObject]!

class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withLocale locale: NSLocale) -> [AVMediaSelectionOption]

class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withMediaCharacteristics mediaCharacteristics: [AnyObject]!) -> [AnyObject]!

class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withMediaCharacteristics mediaCharacteristics: [String]) -> [AVMediaSelectionOption]

class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withoutMediaCharacteristics mediaCharacteristics: [AnyObject]!) -> [AnyObject]!

class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withoutMediaCharacteristics mediaCharacteristics: [String]) -> [AVMediaSelectionOption]

func mediaSelectionOptionWithPropertyList(_ plist: AnyObject!) -> AVMediaSelectionOption!

func mediaSelectionOptionWithPropertyList(_ plist: AnyObject) -> AVMediaSelectionOption?

var options: [AnyObject]! { get }

var options: [AVMediaSelectionOption] { get }

class func playableMediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!) -> [AnyObject]!

class func playableMediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption]) -> [AVMediaSelectionOption]

class AVMediaSelectionOption : NSObject, NSCopying {
    var mediaType: String! { get }
    var mediaSubTypes: [AnyObject]! { get }
    func hasMediaCharacteristic(_ mediaCharacteristic: String!) -> Bool
    var playable: Bool { get }
    var extendedLanguageTag: String! { get }
    var locale: NSLocale! { get }
    var commonMetadata: [AnyObject]! { get }
    var availableMetadataFormats: [AnyObject]! { get }
    func metadataForFormat(_ format: String!) -> [AnyObject]!
    func associatedMediaSelectionOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup!) -> AVMediaSelectionOption!
    func propertyList() -> AnyObject!
    func displayNameWithLocale(_ locale: NSLocale!) -> String!
    var displayName: String! { get }
}

class AVMediaSelectionOption : NSObject, NSCopying {
    var mediaType: String { get }
    var mediaSubTypes: [NSNumber] { get }
    func hasMediaCharacteristic(_ mediaCharacteristic: String) -> Bool
    var playable: Bool { get }
    var extendedLanguageTag: String? { get }
    var locale: NSLocale? { get }
    var commonMetadata: [AVMetadataItem] { get }
    var availableMetadataFormats: [String] { get }
    func metadataForFormat(_ format: String) -> [AVMetadataItem]
    func associatedMediaSelectionOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup) -> AVMediaSelectionOption?
    func propertyList() -> AnyObject
    func displayNameWithLocale(_ locale: NSLocale) -> String
    var displayName: String { get }
}

func associatedMediaSelectionOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup!) -> AVMediaSelectionOption!

func associatedMediaSelectionOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup) -> AVMediaSelectionOption?

var availableMetadataFormats: [AnyObject]! { get }

var availableMetadataFormats: [String] { get }

var commonMetadata: [AnyObject]! { get }

var commonMetadata: [AVMetadataItem] { get }

var displayName: String! { get }

var displayName: String { get }

func displayNameWithLocale(_ locale: NSLocale!) -> String!

func displayNameWithLocale(_ locale: NSLocale) -> String

var extendedLanguageTag: String! { get }

var extendedLanguageTag: String? { get }

func hasMediaCharacteristic(_ mediaCharacteristic: String!) -> Bool

func hasMediaCharacteristic(_ mediaCharacteristic: String) -> Bool

var locale: NSLocale! { get }

var locale: NSLocale? { get }

var mediaSubTypes: [AnyObject]! { get }

var mediaSubTypes: [NSNumber] { get }

var mediaType: String! { get }

var mediaType: String { get }

func metadataForFormat(_ format: String!) -> [AnyObject]!

func metadataForFormat(_ format: String) -> [AVMetadataItem]

func propertyList() -> AnyObject!

func propertyList() -> AnyObject

class AVMetadataItem : NSObject, AVAsynchronousKeyValueLoading, NSCopying, NSMutableCopying {
    var identifier: String! { get }
    var extendedLanguageTag: String! { get }
    @NSCopying var locale: NSLocale! { get }
    var time: CMTime { get }
    var duration: CMTime { get }
    var dataType: String! { get }
    @NSCopying var value: protocol<NSCopying, NSObjectProtocol>! { get }
    var extraAttributes: [NSObject : AnyObject]! { get }
}
extension AVMetadataItem {
    var stringValue: String! { get }
    var numberValue: NSNumber! { get }
    var dateValue: NSDate! { get }
    var dataValue: NSData! { get }
}
extension AVMetadataItem {
    func statusOfValueForKey(_ key: String!, error outError: NSErrorPointer) -> AVKeyValueStatus
    func loadValuesAsynchronouslyForKeys(_ keys: [AnyObject]!, completionHandler handler: (() -> Void)!)
}
extension AVMetadataItem {
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [AnyObject]!) -> [AnyObject]!
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredByIdentifier identifier: String!) -> [AnyObject]!
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredByMetadataItemFilter metadataItemFilter: AVMetadataItemFilter!) -> [AnyObject]!
}
extension AVMetadataItem {
    class func identifierForKey(_ key: AnyObject!, keySpace keySpace: String!) -> String!
    class func keySpaceForIdentifier(_ identifier: String!) -> String!
    class func keyForIdentifier(_ identifier: String!) -> AnyObject!
    @NSCopying var key: protocol<NSCopying, NSObjectProtocol>! { get }
    var commonKey: String! { get }
    var keySpace: String! { get }
}
extension AVMetadataItem {
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, withLocale locale: NSLocale!) -> [AnyObject]!
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, withKey key: AnyObject!, keySpace keySpace: String!) -> [AnyObject]!
}

class AVMetadataItem : NSObject, AVAsynchronousKeyValueLoading, NSCopying, NSMutableCopying {
    var identifier: String? { get }
    var extendedLanguageTag: String? { get }
    @NSCopying var locale: NSLocale? { get }
    var time: CMTime { get }
    var duration: CMTime { get }
    var dataType: String? { get }
    @NSCopying var value: protocol<NSCopying, NSObjectProtocol>? { get }
    var extraAttributes: [String : AnyObject]? { get }
}
extension AVMetadataItem {
    @NSCopying var startDate: NSDate? { get }
}
extension AVMetadataItem {
    var stringValue: String? { get }
    var numberValue: NSNumber? { get }
    var dateValue: NSDate? { get }
    var dataValue: NSData? { get }
}
extension AVMetadataItem {
    func statusOfValueForKey(_ key: String, error outError: NSErrorPointer) -> AVKeyValueStatus
    func loadValuesAsynchronouslyForKeys(_ keys: [String], completionHandler handler: (() -> Void)?)
}
extension AVMetadataItem {
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [String]) -> [AVMetadataItem]
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], filteredByIdentifier identifier: String) -> [AVMetadataItem]
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], filteredByMetadataItemFilter metadataItemFilter: AVMetadataItemFilter) -> [AVMetadataItem]
}
extension AVMetadataItem {
    class func identifierForKey(_ key: AnyObject, keySpace keySpace: String) -> String?
    class func keySpaceForIdentifier(_ identifier: String) -> String?
    class func keyForIdentifier(_ identifier: String) -> AnyObject?
    @NSCopying var key: protocol<NSCopying, NSObjectProtocol>? { get }
    var commonKey: String? { get }
    var keySpace: String? { get }
}
extension AVMetadataItem {
     init(propertiesOfMetadataItem metadataItem: AVMetadataItem, valueLoadingHandler handler: (AVMetadataItemValueRequest) -> Void)
    class func metadataItemWithPropertiesOfMetadataItem(_ metadataItem: AVMetadataItem, valueLoadingHandler handler: (AVMetadataItemValueRequest) -> Void) -> AVMetadataItem
}
extension AVMetadataItem {
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], withLocale locale: NSLocale) -> [AVMetadataItem]
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], withKey key: AnyObject?, keySpace keySpace: String?) -> [AVMetadataItem]
}

var commonKey: String! { get }

var commonKey: String? { get }

var dataType: String! { get }

var dataType: String? { get }

var dataValue: NSData! { get }

var dataValue: NSData? { get }

var dateValue: NSDate! { get }

var dateValue: NSDate? { get }

var extendedLanguageTag: String! { get }

var extendedLanguageTag: String? { get }

var extraAttributes: [NSObject : AnyObject]! { get }

var extraAttributes: [String : AnyObject]? { get }

var identifier: String! { get }

var identifier: String? { get }

class func identifierForKey(_ key: AnyObject!, keySpace keySpace: String!) -> String!

class func identifierForKey(_ key: AnyObject, keySpace keySpace: String) -> String?

@NSCopying var key: protocol<NSCopying, NSObjectProtocol>! { get }

@NSCopying var key: protocol<NSCopying, NSObjectProtocol>? { get }

class func keyForIdentifier(_ identifier: String!) -> AnyObject!

class func keyForIdentifier(_ identifier: String) -> AnyObject?

var keySpace: String! { get }

var keySpace: String? { get }

class func keySpaceForIdentifier(_ identifier: String!) -> String!

class func keySpaceForIdentifier(_ identifier: String) -> String?

func loadValuesAsynchronouslyForKeys(_ keys: [AnyObject]!, completionHandler handler: (() -> Void)!)

func loadValuesAsynchronouslyForKeys(_ keys: [String], completionHandler handler: (() -> Void)?)

@NSCopying var locale: NSLocale! { get }

@NSCopying var locale: NSLocale? { get }

class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [AnyObject]!) -> [AnyObject]!