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 }
    var compatibleWithSavedPhotosAlbum: 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 compatibleWithSavedPhotosAlbum: 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 maxDuration: CMTime { get }
    var estimatedOutputFileLength: Int64 { get }
    var timeRange: CMTimeRange
    var metadata: [AnyObject]!
    var metadataItemFilter: AVMetadataItemFilter!
    var fileLengthLimit: Int64
    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 maxDuration: CMTime { get }
    var estimatedOutputFileLength: Int64 { get }
    var fileLengthLimit: Int64
}
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]!
}

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]
}

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 }

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
    var channelAssignments: [AnyObject]!
}

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 channelAssignments: [NSNumber]?
}

var channelAssignments: [AnyObject]!

var channelAssignments: [NSNumber]?

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!)
    optional func audioPlayerBeginInterruption(_ player: AVAudioPlayer!)
    optional func audioPlayerEndInterruption(_ player: AVAudioPlayer!, withOptions flags: Int)
    optional func audioPlayerEndInterruption(_ player: AVAudioPlayer!, withFlags flags: Int)
    optional func audioPlayerEndInterruption(_ player: AVAudioPlayer!)
}

protocol AVAudioPlayerDelegate : NSObjectProtocol {
    optional func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool)
    optional func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer, error error: NSError?)
    optional func audioPlayerBeginInterruption(_ player: AVAudioPlayer)
    optional func audioPlayerEndInterruption(_ player: AVAudioPlayer, withOptions flags: Int)
    optional func audioPlayerEndInterruption(_ player: AVAudioPlayer, withFlags flags: Int)
    optional func audioPlayerEndInterruption(_ player: AVAudioPlayer)
}

optional func audioPlayerBeginInterruption(_ player: AVAudioPlayer!)

optional func audioPlayerBeginInterruption(_ player: AVAudioPlayer)

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)

optional func audioPlayerEndInterruption(_ player: AVAudioPlayer!, withOptions flags: Int)

optional func audioPlayerEndInterruption(_ player: AVAudioPlayer, withOptions flags: Int)

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
    var channelAssignments: [AnyObject]!
}

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
    var channelAssignments: [NSNumber]?
}

var channelAssignments: [AnyObject]!

var channelAssignments: [NSNumber]?

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!)
    optional func audioRecorderBeginInterruption(_ recorder: AVAudioRecorder!)
    optional func audioRecorderEndInterruption(_ recorder: AVAudioRecorder!, withOptions flags: Int)
    optional func audioRecorderEndInterruption(_ recorder: AVAudioRecorder!, withFlags flags: Int)
    optional func audioRecorderEndInterruption(_ recorder: AVAudioRecorder!)
}

protocol AVAudioRecorderDelegate : NSObjectProtocol {
    optional func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool)
    optional func audioRecorderEncodeErrorDidOccur(_ recorder: AVAudioRecorder, error error: NSError?)
    optional func audioRecorderBeginInterruption(_ recorder: AVAudioRecorder)
    optional func audioRecorderEndInterruption(_ recorder: AVAudioRecorder, withOptions flags: Int)
    optional func audioRecorderEndInterruption(_ recorder: AVAudioRecorder, withFlags flags: Int)
    optional func audioRecorderEndInterruption(_ recorder: AVAudioRecorder)
}

optional func audioRecorderBeginInterruption(_ recorder: AVAudioRecorder!)

optional func audioRecorderBeginInterruption(_ recorder: AVAudioRecorder)

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?)

optional func audioRecorderEndInterruption(_ recorder: AVAudioRecorder!, withOptions flags: Int)

optional func audioRecorderEndInterruption(_ recorder: AVAudioRecorder, withOptions flags: Int)

class AVAudioSession : NSObject {
    class func sharedInstance() -> AVAudioSession!
    func setActive(_ active: Bool, error outError: NSErrorPointer) -> Bool
    func setActive(_ active: Bool, withOptions options: AVAudioSessionSetActiveOptions, error outError: NSErrorPointer) -> Bool
    func setCategory(_ category: String!, error outError: NSErrorPointer) -> Bool
    func setCategory(_ category: String!, withOptions options: AVAudioSessionCategoryOptions, error outError: NSErrorPointer) -> Bool
    func recordPermission() -> AVAudioSessionRecordPermission
    func requestRecordPermission(_ response: PermissionBlock!)
    var category: String! { get }
    var categoryOptions: AVAudioSessionCategoryOptions { get }
    func setMode(_ mode: String!, error outError: NSErrorPointer) -> Bool
    var mode: String! { get }
    func overrideOutputAudioPort(_ portOverride: AVAudioSessionPortOverride, error outError: NSErrorPointer) -> Bool
    var otherAudioPlaying: Bool { get }
    var secondaryAudioShouldBeSilencedHint: Bool { get }
    var currentRoute: AVAudioSessionRouteDescription! { get }
    func setPreferredInput(_ inPort: AVAudioSessionPortDescription!, error outError: NSErrorPointer) -> Bool
    var preferredInput: AVAudioSessionPortDescription! { get }
    var availableInputs: [AnyObject]! { get }
}
extension AVAudioSession {
    func setPreferredSampleRate(_ sampleRate: Double, error outError: NSErrorPointer) -> Bool
    var preferredSampleRate: Double { get }
    func setPreferredIOBufferDuration(_ duration: NSTimeInterval, error outError: NSErrorPointer) -> Bool
    var preferredIOBufferDuration: NSTimeInterval { get }
    func setPreferredInputNumberOfChannels(_ count: Int, error outError: NSErrorPointer) -> Bool
    var preferredInputNumberOfChannels: Int { get }
    func setPreferredOutputNumberOfChannels(_ count: Int, error outError: NSErrorPointer) -> Bool
    var preferredOutputNumberOfChannels: Int { get }
    var maximumInputNumberOfChannels: Int { get }
    var maximumOutputNumberOfChannels: Int { get }
    func setInputGain(_ gain: Float, error outError: NSErrorPointer) -> Bool
    var inputGain: Float { get }
    var inputGainSettable: Bool { get }
    var inputAvailable: Bool { get }
    var inputDataSources: [AnyObject]! { get }
    var inputDataSource: AVAudioSessionDataSourceDescription! { get }
    func setInputDataSource(_ dataSource: AVAudioSessionDataSourceDescription!, error outError: NSErrorPointer) -> Bool
    var outputDataSources: [AnyObject]! { get }
    var outputDataSource: AVAudioSessionDataSourceDescription! { get }
    func setOutputDataSource(_ dataSource: AVAudioSessionDataSourceDescription!, error outError: NSErrorPointer) -> Bool
    var sampleRate: Double { get }
    var inputNumberOfChannels: Int { get }
    var outputNumberOfChannels: Int { get }
    var outputVolume: Float { get }
    var inputLatency: NSTimeInterval { get }
    var outputLatency: NSTimeInterval { get }
    var IOBufferDuration: NSTimeInterval { get }
}
extension AVAudioSession {
    unowned(unsafe) var delegate: AVAudioSessionDelegate!
    func setActive(_ active: Bool, withFlags flags: Int, error outError: NSErrorPointer) -> Bool
    var inputIsAvailable: Bool { get }
    var currentHardwareSampleRate: Double { get }
    var currentHardwareInputNumberOfChannels: Int { get }
    var currentHardwareOutputNumberOfChannels: Int { get }
    func setPreferredHardwareSampleRate(_ sampleRate: Double, error outError: NSErrorPointer) -> Bool
    var preferredHardwareSampleRate: Double { get }
}

class AVAudioSession : NSObject {
    class func sharedInstance() -> AVAudioSession
    func setActive(_ active: Bool) throws
    func setActive(_ active: Bool, withOptions options: AVAudioSessionSetActiveOptions) throws
    var availableCategories: [String] { get }
    func setCategory(_ category: String) throws
    func setCategory(_ category: String, withOptions options: AVAudioSessionCategoryOptions) throws
    var category: String { get }
    func recordPermission() -> AVAudioSessionRecordPermission
    func requestRecordPermission(_ response: PermissionBlock)
    var categoryOptions: AVAudioSessionCategoryOptions { get }
    var availableModes: [String] { get }
    func setMode(_ mode: String) throws
    var mode: String { get }
    func overrideOutputAudioPort(_ portOverride: AVAudioSessionPortOverride) throws
    var otherAudioPlaying: Bool { get }
    var secondaryAudioShouldBeSilencedHint: Bool { get }
    var currentRoute: AVAudioSessionRouteDescription { get }
    func setPreferredInput(_ inPort: AVAudioSessionPortDescription?) throws
    var preferredInput: AVAudioSessionPortDescription? { get }
    var availableInputs: [AVAudioSessionPortDescription]? { get }
}
extension AVAudioSession {
    func setPreferredSampleRate(_ sampleRate: Double) throws
    var preferredSampleRate: Double { get }
    func setPreferredIOBufferDuration(_ duration: NSTimeInterval) throws
    var preferredIOBufferDuration: NSTimeInterval { get }
    func setPreferredInputNumberOfChannels(_ count: Int) throws
    var preferredInputNumberOfChannels: Int { get }
    func setPreferredOutputNumberOfChannels(_ count: Int) throws
    var preferredOutputNumberOfChannels: Int { get }
    var maximumInputNumberOfChannels: Int { get }
    var maximumOutputNumberOfChannels: Int { get }
    func setInputGain(_ gain: Float) throws
    var inputGain: Float { get }
    var inputGainSettable: Bool { get }
    var inputAvailable: Bool { get }
    var inputDataSources: [AVAudioSessionDataSourceDescription]? { get }
    var inputDataSource: AVAudioSessionDataSourceDescription? { get }
    func setInputDataSource(_ dataSource: AVAudioSessionDataSourceDescription?) throws
    var outputDataSources: [AVAudioSessionDataSourceDescription]? { get }
    var outputDataSource: AVAudioSessionDataSourceDescription? { get }
    func setOutputDataSource(_ dataSource: AVAudioSessionDataSourceDescription?) throws
    var sampleRate: Double { get }
    var inputNumberOfChannels: Int { get }
    var outputNumberOfChannels: Int { get }
    var outputVolume: Float { get }
    var inputLatency: NSTimeInterval { get }
    var outputLatency: NSTimeInterval { get }
    var IOBufferDuration: NSTimeInterval { get }
}
extension AVAudioSession {
    unowned(unsafe) var delegate: AVAudioSessionDelegate?
    func setActive(_ active: Bool, withFlags flags: Int) throws
    var inputIsAvailable: Bool { get }
    var currentHardwareSampleRate: Double { get }
    var currentHardwareInputNumberOfChannels: Int { get }
    var currentHardwareOutputNumberOfChannels: Int { get }
    func setPreferredHardwareSampleRate(_ sampleRate: Double) throws
    var preferredHardwareSampleRate: Double { get }
}

var availableInputs: [AnyObject]! { get }

var availableInputs: [AVAudioSessionPortDescription]? { get }

var category: String! { get }

var category: String { get }

var currentRoute: AVAudioSessionRouteDescription! { get }

var currentRoute: AVAudioSessionRouteDescription { get }

var inputDataSource: AVAudioSessionDataSourceDescription! { get }

var inputDataSource: AVAudioSessionDataSourceDescription? { get }

var inputDataSources: [AnyObject]! { get }

var inputDataSources: [AVAudioSessionDataSourceDescription]? { get }

var mode: String! { get }

var mode: String { get }

var outputDataSource: AVAudioSessionDataSourceDescription! { get }

var outputDataSource: AVAudioSessionDataSourceDescription? { get }

var outputDataSources: [AnyObject]! { get }

var outputDataSources: [AVAudioSessionDataSourceDescription]? { get }

func overrideOutputAudioPort(_ portOverride: AVAudioSessionPortOverride, error outError: NSErrorPointer) -> Bool

func overrideOutputAudioPort(_ portOverride: AVAudioSessionPortOverride) throws

var preferredInput: AVAudioSessionPortDescription! { get }

var preferredInput: AVAudioSessionPortDescription? { get }

func requestRecordPermission(_ response: PermissionBlock!)

func requestRecordPermission(_ response: PermissionBlock)

func setActive(_ active: Bool, error outError: NSErrorPointer) -> Bool

func setActive(_ active: Bool) throws

func setActive(_ active: Bool, withOptions options: AVAudioSessionSetActiveOptions, error outError: NSErrorPointer) -> Bool

func setActive(_ active: Bool, withOptions options: AVAudioSessionSetActiveOptions) throws

func setCategory(_ category: String!, error outError: NSErrorPointer) -> Bool

func setCategory(_ category: String) throws

func setCategory(_ category: String!, withOptions options: AVAudioSessionCategoryOptions, error outError: NSErrorPointer) -> Bool

func setCategory(_ category: String, withOptions options: AVAudioSessionCategoryOptions) throws

func setInputDataSource(_ dataSource: AVAudioSessionDataSourceDescription!, error outError: NSErrorPointer) -> Bool

func setInputDataSource(_ dataSource: AVAudioSessionDataSourceDescription?) throws

func setInputGain(_ gain: Float, error outError: NSErrorPointer) -> Bool

func setInputGain(_ gain: Float) throws

func setMode(_ mode: String!, error outError: NSErrorPointer) -> Bool

func setMode(_ mode: String) throws

func setOutputDataSource(_ dataSource: AVAudioSessionDataSourceDescription!, error outError: NSErrorPointer) -> Bool

func setOutputDataSource(_ dataSource: AVAudioSessionDataSourceDescription?) throws

func setPreferredInput(_ inPort: AVAudioSessionPortDescription!, error outError: NSErrorPointer) -> Bool

func setPreferredInput(_ inPort: AVAudioSessionPortDescription?) throws

func setPreferredInputNumberOfChannels(_ count: Int, error outError: NSErrorPointer) -> Bool

func setPreferredInputNumberOfChannels(_ count: Int) throws

func setPreferredIOBufferDuration(_ duration: NSTimeInterval, error outError: NSErrorPointer) -> Bool

func setPreferredIOBufferDuration(_ duration: NSTimeInterval) throws

func setPreferredOutputNumberOfChannels(_ count: Int, error outError: NSErrorPointer) -> Bool

func setPreferredOutputNumberOfChannels(_ count: Int) throws

func setPreferredSampleRate(_ sampleRate: Double, error outError: NSErrorPointer) -> Bool

func setPreferredSampleRate(_ sampleRate: Double) throws

class func sharedInstance() -> AVAudioSession!

class func sharedInstance() -> AVAudioSession

struct AVAudioSessionCategoryOptions : RawOptionSetType {
    init(_ rawValue: UInt)
    init(rawValue rawValue: UInt)
    static var MixWithOthers: AVAudioSessionCategoryOptions { get }
    static var DuckOthers: AVAudioSessionCategoryOptions { get }
    static var AllowBluetooth: AVAudioSessionCategoryOptions { get }
    static var DefaultToSpeaker: AVAudioSessionCategoryOptions { get }
}

struct AVAudioSessionCategoryOptions : OptionSetType {
    init(rawValue rawValue: UInt)
    static var MixWithOthers: AVAudioSessionCategoryOptions { get }
    static var DuckOthers: AVAudioSessionCategoryOptions { get }
    static var AllowBluetooth: AVAudioSessionCategoryOptions { get }
    static var DefaultToSpeaker: AVAudioSessionCategoryOptions { get }
    static var InterruptSpokenAudioAndMixWithOthers: AVAudioSessionCategoryOptions { get }
}

class AVAudioSessionChannelDescription : NSObject {
    var channelName: String! { get }
    var owningPortUID: String! { get }
    var channelNumber: Int { get }
    var channelLabel: AudioChannelLabel { get }
}

class AVAudioSessionChannelDescription : NSObject {
    var channelName: String { get }
    var owningPortUID: String { get }
    var channelNumber: Int { get }
    var channelLabel: AudioChannelLabel { get }
}

var channelName: String! { get }

var channelName: String { get }

var owningPortUID: String! { get }

var owningPortUID: String { get }

class AVAudioSessionDataSourceDescription : NSObject {
    var dataSourceID: NSNumber! { get }
    var dataSourceName: String! { get }
    var location: String! { get }
    var orientation: String! { get }
    var supportedPolarPatterns: [AnyObject]! { get }
    var selectedPolarPattern: String! { get }
    var preferredPolarPattern: String! { get }
    func setPreferredPolarPattern(_ pattern: String!, error outError: NSErrorPointer) -> Bool
}

class AVAudioSessionDataSourceDescription : NSObject {
    var dataSourceID: NSNumber { get }
    var dataSourceName: String { get }
    var location: String? { get }
    var orientation: String? { get }
    var supportedPolarPatterns: [String]? { get }
    var selectedPolarPattern: String? { get }
    var preferredPolarPattern: String? { get }
    func setPreferredPolarPattern(_ pattern: String?) throws
}

var dataSourceID: NSNumber! { get }

var dataSourceID: NSNumber { get }

var dataSourceName: String! { get }

var dataSourceName: String { get }

var location: String! { get }

var location: String? { get }

var orientation: String! { get }

var orientation: String? { get }

var preferredPolarPattern: String! { get }

var preferredPolarPattern: String? { get }

var selectedPolarPattern: String! { get }

var selectedPolarPattern: String? { get }

func setPreferredPolarPattern(_ pattern: String!, error outError: NSErrorPointer) -> Bool

func setPreferredPolarPattern(_ pattern: String?) throws

var supportedPolarPatterns: [AnyObject]! { get }

var supportedPolarPatterns: [String]? { get }

enum AVAudioSessionErrorCode : Int {
    case CodeNone
    case CodeMediaServicesFailed
    case CodeIsBusy
    case CodeIncompatibleCategory
    case CodeCannotInterruptOthers
    case CodeMissingEntitlement
    case CodeSiriIsRecording
    case CodeCannotStartPlaying
    case CodeCannotStartRecording
    case CodeBadParam
    case InsufficientPriority
    case CodeUnspecified
}

enum AVAudioSessionErrorCode : Int {
    case CodeNone
    case CodeMediaServicesFailed
    case CodeIsBusy
    case CodeIncompatibleCategory
    case CodeCannotInterruptOthers
    case CodeMissingEntitlement
    case CodeSiriIsRecording
    case CodeCannotStartPlaying
    case CodeCannotStartRecording
    case CodeBadParam
    case InsufficientPriority
    case CodeResourceNotAvailable
    case CodeUnspecified
}

struct AVAudioSessionInterruptionOptions : RawOptionSetType {
    init(_ rawValue: UInt)
    init(rawValue rawValue: UInt)
    static var OptionShouldResume: AVAudioSessionInterruptionOptions { get }
}

struct AVAudioSessionInterruptionOptions : OptionSetType {
    init(rawValue rawValue: UInt)
    static var ShouldResume: AVAudioSessionInterruptionOptions { get }
}

static var OptionShouldResume: AVAudioSessionInterruptionOptions { get }

static var ShouldResume: AVAudioSessionInterruptionOptions { get }

class AVAudioSessionPortDescription : NSObject {
    var portType: String! { get }
    var portName: String! { get }
    var UID: String! { get }
    var channels: [AnyObject]! { get }
    var dataSources: [AnyObject]! { get }
    var selectedDataSource: AVAudioSessionDataSourceDescription! { get }
    var preferredDataSource: AVAudioSessionDataSourceDescription! { get }
    func setPreferredDataSource(_ dataSource: AVAudioSessionDataSourceDescription!, error outError: NSErrorPointer) -> Bool
}

class AVAudioSessionPortDescription : NSObject {
    var portType: String { get }
    var portName: String { get }
    var UID: String { get }
    var channels: [AVAudioSessionChannelDescription]? { get }
    var dataSources: [AVAudioSessionDataSourceDescription]? { get }
    var selectedDataSource: AVAudioSessionDataSourceDescription? { get }
    var preferredDataSource: AVAudioSessionDataSourceDescription? { get }
    func setPreferredDataSource(_ dataSource: AVAudioSessionDataSourceDescription?) throws
}

var channels: [AnyObject]! { get }

var channels: [AVAudioSessionChannelDescription]? { get }

var dataSources: [AnyObject]! { get }

var dataSources: [AVAudioSessionDataSourceDescription]? { get }

var portName: String! { get }

var portName: String { get }

var portType: String! { get }

var portType: String { get }

var preferredDataSource: AVAudioSessionDataSourceDescription! { get }

var preferredDataSource: AVAudioSessionDataSourceDescription? { get }

var selectedDataSource: AVAudioSessionDataSourceDescription! { get }

var selectedDataSource: AVAudioSessionDataSourceDescription? { get }

func setPreferredDataSource(_ dataSource: AVAudioSessionDataSourceDescription!, error outError: NSErrorPointer) -> Bool

func setPreferredDataSource(_ dataSource: AVAudioSessionDataSourceDescription?) throws

var UID: String! { get }

var UID: String { get }

struct AVAudioSessionRecordPermission : RawOptionSetType {
    init(_ rawValue: UInt)
    init(rawValue rawValue: UInt)
    static var Undetermined: AVAudioSessionRecordPermission { get }
    static var Denied: AVAudioSessionRecordPermission { get }
    static var Granted: AVAudioSessionRecordPermission { get }
}

struct AVAudioSessionRecordPermission : OptionSetType {
    init(rawValue rawValue: UInt)
    static var Undetermined: AVAudioSessionRecordPermission { get }
    static var Denied: AVAudioSessionRecordPermission { get }
    static var Granted: AVAudioSessionRecordPermission { get }
}

class AVAudioSessionRouteDescription : NSObject {
    var inputs: [AnyObject]! { get }
    var outputs: [AnyObject]! { get }
}

class AVAudioSessionRouteDescription : NSObject {
    var inputs: [AVAudioSessionPortDescription] { get }
    var outputs: [AVAudioSessionPortDescription] { get }
}

var inputs: [AnyObject]! { get }

var inputs: [AVAudioSessionPortDescription] { get }

var outputs: [AnyObject]! { get }

var outputs: [AVAudioSessionPortDescription] { get }

struct AVAudioSessionSetActiveOptions : RawOptionSetType {
    init(_ rawValue: UInt)
    init(rawValue rawValue: UInt)
    static var OptionNotifyOthersOnDeactivation: AVAudioSessionSetActiveOptions { get }
}

struct AVAudioSessionSetActiveOptions : OptionSetType {
    init(rawValue rawValue: UInt)
    static var NotifyOthersOnDeactivation: AVAudioSessionSetActiveOptions { get }
}

static var OptionNotifyOthersOnDeactivation: AVAudioSessionSetActiveOptions { get }

static var NotifyOthersOnDeactivation: AVAudioSessionSetActiveOptions { 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 }
}

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 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 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 supportsVideoMinFrameDuration: Bool { get }
    var videoMinFrameDuration: CMTime
    var supportsVideoMaxFrameDuration: Bool { get }
    var videoMaxFrameDuration: CMTime
    var videoMaxScaleAndCropFactor: CGFloat { get }
    var videoScaleAndCropFactor: CGFloat
    var preferredVideoStabilizationMode: AVCaptureVideoStabilizationMode
    var activeVideoStabilizationMode: AVCaptureVideoStabilizationMode { get }
    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 supportsVideoMinFrameDuration: Bool { get }
    var videoMinFrameDuration: CMTime
    var supportsVideoMaxFrameDuration: Bool { get }
    var videoMaxFrameDuration: CMTime
    var videoMaxScaleAndCropFactor: CGFloat { get }
    var videoScaleAndCropFactor: CGFloat
    var preferredVideoStabilizationMode: AVCaptureVideoStabilizationMode
    var activeVideoStabilizationMode: AVCaptureVideoStabilizationMode { get }
    var supportsVideoStabilization: Bool { get }
    var videoStabilizationEnabled: Bool { get }
    var enablesVideoStabilizationWhenAvailable: Bool
}

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 }
    func hasMediaType(_ mediaType: String!) -> Bool
    func lockForConfiguration(_ outError: NSErrorPointer) -> Bool
    func unlockForConfiguration()
    func supportsAVCaptureSessionPreset(_ preset: String!) -> Bool
    var connected: Bool { get }
    var formats: [AnyObject]! { get }
    var activeFormat: AVCaptureDeviceFormat!
    var activeVideoMinFrameDuration: CMTime
    var activeVideoMaxFrameDuration: CMTime
}
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 }
    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 automaticallyAdjustsVideoHDREnabled: Bool
    var videoHDREnabled: Bool
}

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 }
    func hasMediaType(_ mediaType: String!) -> Bool
    func lockForConfiguration() throws
    func unlockForConfiguration()
    func supportsAVCaptureSessionPreset(_ preset: String!) -> Bool
    var connected: Bool { get }
    var formats: [AnyObject]! { get }
    var activeFormat: AVCaptureDeviceFormat!
    var activeVideoMinFrameDuration: CMTime
    var activeVideoMaxFrameDuration: CMTime
}
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 automaticallyAdjustsVideoHDREnabled: Bool
    var videoHDREnabled: Bool
}

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

init!(uniqueID deviceUniqueID: String!)

func lockForConfiguration(_ outError: NSErrorPointer) -> Bool

func lockForConfiguration() throws

func setTorchModeOnWithLevel(_ torchLevel: Float, error outError: NSErrorPointer) -> Bool

func setTorchModeOnWithLevel(_ torchLevel: Float) 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

class AVCaptureMovieFileOutput : AVCaptureFileOutput {
    var movieFragmentInterval: CMTime
    var metadata: [AnyObject]!
}

class AVCaptureMovieFileOutput : AVCaptureFileOutput {
    var movieFragmentInterval: CMTime
    var metadata: [AnyObject]!
    func recordsVideoOrientationAndMirroringChangesAsMetadataTrackForConnection(_ connection: AVCaptureConnection!) -> Bool
    func setRecordsVideoOrientationAndMirroringChanges(_ doRecordChanges: Bool, asMetadataTrackForConnection connection: AVCaptureConnection!)
}

class AVCaptureStillImageOutput : AVCaptureOutput {
    var outputSettings: [NSObject : AnyObject]!
    var availableImageDataCVPixelFormatTypes: [AnyObject]! { get }
    var availableImageDataCodecTypes: [AnyObject]! { get }
    var stillImageStabilizationSupported: Bool { get }
    var automaticallyEnablesStillImageStabilizationWhenAvailable: Bool
    var stillImageStabilizationActive: Bool { get }
    var highResolutionStillImageOutputEnabled: Bool
    var capturingStillImage: Bool { get }
    func captureStillImageAsynchronouslyFromConnection(_ connection: AVCaptureConnection!, completionHandler handler: ((CMSampleBuffer!, NSError!) -> Void)!)
    class func jpegStillImageNSDataRepresentation(_ jpegSampleBuffer: CMSampleBuffer!) -> NSData!
}
extension AVCaptureStillImageOutput {
    var maxBracketedCaptureStillImageCount: Int { get }
    func prepareToCaptureStillImageBracketFromConnection(_ connection: AVCaptureConnection!, withSettingsArray settings: [AnyObject]!, completionHandler handler: ((Bool, NSError!) -> Void)!)
    func captureStillImageBracketAsynchronouslyFromConnection(_ connection: AVCaptureConnection!, withSettingsArray settings: [AnyObject]!, completionHandler handler: ((CMSampleBuffer!, AVCaptureBracketedStillImageSettings!, NSError!) -> Void)!)
}

class AVCaptureStillImageOutput : AVCaptureOutput {
    var outputSettings: [NSObject : AnyObject]!
    var availableImageDataCVPixelFormatTypes: [AnyObject]! { get }
    var availableImageDataCodecTypes: [AnyObject]! { get }
    var stillImageStabilizationSupported: Bool { get }
    var automaticallyEnablesStillImageStabilizationWhenAvailable: Bool
    var stillImageStabilizationActive: Bool { get }
    var highResolutionStillImageOutputEnabled: Bool
    var capturingStillImage: Bool { get }
    func captureStillImageAsynchronouslyFromConnection(_ connection: AVCaptureConnection!, completionHandler handler: ((CMSampleBuffer!, NSError!) -> Void)!)
    class func jpegStillImageNSDataRepresentation(_ jpegSampleBuffer: CMSampleBuffer!) -> NSData!
}
extension AVCaptureStillImageOutput {
    var maxBracketedCaptureStillImageCount: Int { get }
    var lensStabilizationDuringBracketedCaptureSupported: Bool { get }
    var lensStabilizationDuringBracketedCaptureEnabled: Bool
    func prepareToCaptureStillImageBracketFromConnection(_ connection: AVCaptureConnection!, withSettingsArray settings: [AnyObject]!, completionHandler handler: ((Bool, NSError!) -> Void)!)
    func captureStillImageBracketAsynchronouslyFromConnection(_ connection: AVCaptureConnection!, withSettingsArray settings: [AnyObject]!, completionHandler handler: ((CMSampleBuffer!, AVCaptureBracketedStillImageSettings!, NSError!) -> Void)!)
}

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 metadataOutputRectOfInterestForRect(_ rectInLayerCoordinates: CGRect) -> CGRect
    func rectForMetadataOutputRectOfInterest(_ rectInMetadataOutputCoordinates: CGRect) -> CGRect
    func transformedMetadataObjectForMetadataObject(_ metadataObject: AVMetadataObject!) -> AVMetadataObject!
    var orientationSupported: Bool { get }
    var orientation: AVCaptureVideoOrientation
    var mirroringSupported: Bool { get }
    var automaticallyAdjustsMirroring: Bool
    var mirrored: Bool
}

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!
    var orientationSupported: Bool { get }
    var orientation: AVCaptureVideoOrientation
    var mirroringSupported: Bool { get }
    var automaticallyAdjustsMirroring: Bool
    var mirrored: Bool
}

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 SessionWasInterrupted
    case MediaServicesWereReset
    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 DeviceIsNotAvailableInBackground
    case OperationNotSupportedForAsset
    case DecoderTemporarilyUnavailable
    case EncoderTemporarilyUnavailable
    case InvalidVideoComposition
    case ReferenceForbiddenByReferencePolicy
    case InvalidOutputURLPathExtension
    case ScreenCaptureFailed
    case DisplayWasDisabled
    case TorchLevelUnavailable
    case OperationInterrupted
    case IncompatibleAsset
    case FailedToLoadMediaData
    case ServerIncorrectlyConfigured
    case ApplicationIsNotAuthorizedToUseDevice
    case FailedToParse
    case FileTypeDoesNotSupportSampleReferences
    case UndecodableMediaData
    case AirPlayControllerRequiresInternet
    case AirPlayReceiverRequiresInternet
}

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 SessionWasInterrupted
    case MediaServicesWereReset
    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 DeviceIsNotAvailableInBackground
    case OperationNotSupportedForAsset
    case DecoderTemporarilyUnavailable
    case EncoderTemporarilyUnavailable
    case InvalidVideoComposition
    case ReferenceForbiddenByReferencePolicy
    case InvalidOutputURLPathExtension
    case ScreenCaptureFailed
    case DisplayWasDisabled
    case TorchLevelUnavailable
    case OperationInterrupted
    case IncompatibleAsset
    case FailedToLoadMediaData
    case ServerIncorrectlyConfigured
    case ApplicationIsNotAuthorizedToUseDevice
    case FailedToParse
    case FileTypeDoesNotSupportSampleReferences
    case UndecodableMediaData
    case AirPlayControllerRequiresInternet
    case AirPlayReceiverRequiresInternet
    case VideoCompositorFailed
    case RecordingAlreadyInProgress
}
extension AVError : Hashable, Equatable, __BridgedNSError, ErrorType, RawRepresentable, _ObjectiveCBridgeableErrorType, _BridgedNSError {
}
extension AVError : Hashable, Equatable, __BridgedNSError, ErrorType, RawRepresentable, _ObjectiveCBridgeableErrorType, _BridgedNSError {
}