struct AudioBalanceFade {
    var mLeftRightBalance: Float32
    var mBackFrontFade: Float32
    var mType: UInt32
    var mChannelLayout: UnsafePointer<AudioChannelLayout>
    init()
    init(mLeftRightBalance mLeftRightBalance: Float32, mBackFrontFade mBackFrontFade: Float32, mType mType: UInt32, mChannelLayout mChannelLayout: UnsafePointer<AudioChannelLayout>)
}

struct AudioBalanceFade {
    var mLeftRightBalance: Float32
    var mBackFrontFade: Float32
    var mType: AudioBalanceFadeType
    var mChannelLayout: UnsafePointer<AudioChannelLayout>
}

var mType: UInt32

var mType: AudioBalanceFadeType

struct AudioBytePacketTranslation {
    var mByte: Int64
    var mPacket: Int64
    var mByteOffsetInPacket: UInt32
    var mFlags: UInt32
    init()
    init(mByte mByte: Int64, mPacket mPacket: Int64, mByteOffsetInPacket mByteOffsetInPacket: UInt32, mFlags mFlags: UInt32)
}

struct AudioBytePacketTranslation {
    var mByte: Int64
    var mPacket: Int64
    var mByteOffsetInPacket: UInt32
    var mFlags: AudioBytePacketTranslationFlags
    init()
    init(mByte mByte: Int64, mPacket mPacket: Int64, mByteOffsetInPacket mByteOffsetInPacket: UInt32, mFlags mFlags: AudioBytePacketTranslationFlags)
}

var mFlags: UInt32

var mFlags: AudioBytePacketTranslationFlags

struct AudioFileMarker {
    var mFramePosition: Float64
    var mName: Unmanaged<CFString>!
    var mMarkerID: Int32
    var mSMPTETime: AudioFile_SMPTE_Time
    var mType: UInt32
    var mReserved: UInt16
    var mChannel: UInt16
    init()
    init(mFramePosition mFramePosition: Float64, mName mName: Unmanaged<CFString>!, mMarkerID mMarkerID: Int32, mSMPTETime mSMPTETime: AudioFile_SMPTE_Time, mType mType: UInt32, mReserved mReserved: UInt16, mChannel mChannel: UInt16)
}

struct AudioFileMarker {
    var mFramePosition: Float64
    var mName: Unmanaged<CFString>?
    var mMarkerID: Int32
    var mSMPTETime: AudioFile_SMPTE_Time
    var mType: UInt32
    var mReserved: UInt16
    var mChannel: UInt16
    init()
    init(mFramePosition mFramePosition: Float64, mName mName: Unmanaged<CFString>?, mMarkerID mMarkerID: Int32, mSMPTETime mSMPTETime: AudioFile_SMPTE_Time, mType mType: UInt32, mReserved mReserved: UInt16, mChannel mChannel: UInt16)
}

var mName: Unmanaged<CFString>!

var mName: Unmanaged<CFString>?

struct AudioFileRegion {
    var mRegionID: UInt32
    var mName: Unmanaged<CFString>!
    var mFlags: UInt32
    var mNumberMarkers: UInt32
    var mMarkers: (AudioFileMarker)
    init()
    init(mRegionID mRegionID: UInt32, mName mName: Unmanaged<CFString>!, mFlags mFlags: UInt32, mNumberMarkers mNumberMarkers: UInt32, mMarkers mMarkers: (AudioFileMarker))
}

struct AudioFileRegion {
    var mRegionID: UInt32
    var mName: Unmanaged<CFString>
    var mFlags: AudioFileRegionFlags
    var mNumberMarkers: UInt32
    var mMarkers: (AudioFileMarker)
}

var mFlags: UInt32

var mFlags: AudioFileRegionFlags

var mName: Unmanaged<CFString>!

var mName: Unmanaged<CFString>

struct AudioFormatInfo {
    var mASBD: AudioStreamBasicDescription
    var mMagicCookie: UnsafePointer<Void>
    var mMagicCookieSize: UInt32
    init()
    init(mASBD mASBD: AudioStreamBasicDescription, mMagicCookie mMagicCookie: UnsafePointer<Void>, mMagicCookieSize mMagicCookieSize: UInt32)
}

struct AudioFormatInfo {
    var mASBD: AudioStreamBasicDescription
    var mMagicCookie: UnsafePointer<Void>
    var mMagicCookieSize: UInt32
}

struct AudioPanningInfo {
    var mPanningMode: UInt32
    var mCoordinateFlags: UInt32
    var mCoordinates: (Float32, Float32, Float32)
    var mGainScale: Float32
    var mOutputChannelMap: UnsafePointer<AudioChannelLayout>
    init()
    init(mPanningMode mPanningMode: UInt32, mCoordinateFlags mCoordinateFlags: UInt32, mCoordinates mCoordinates: (Float32, Float32, Float32), mGainScale mGainScale: Float32, mOutputChannelMap mOutputChannelMap: UnsafePointer<AudioChannelLayout>)
}

struct AudioPanningInfo {
    var mPanningMode: AudioPanningMode
    var mCoordinateFlags: UInt32
    var mCoordinates: (Float32, Float32, Float32)
    var mGainScale: Float32
    var mOutputChannelMap: UnsafePointer<AudioChannelLayout>
}

var mPanningMode: UInt32

var mPanningMode: AudioPanningMode

struct AudioQueueBuffer {
    var mAudioDataBytesCapacity: UInt32
    var mAudioData: UnsafeMutablePointer<Void>
    var mAudioDataByteSize: UInt32
    var mUserData: UnsafeMutablePointer<Void>
    var mPacketDescriptionCapacity: UInt32
    var mPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>
    var mPacketDescriptionCount: UInt32
    init()
    init(mAudioDataBytesCapacity mAudioDataBytesCapacity: UInt32, mAudioData mAudioData: UnsafeMutablePointer<Void>, mAudioDataByteSize mAudioDataByteSize: UInt32, mUserData mUserData: UnsafeMutablePointer<Void>, mPacketDescriptionCapacity mPacketDescriptionCapacity: UInt32, mPacketDescriptions mPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>, mPacketDescriptionCount mPacketDescriptionCount: UInt32)
}

struct AudioQueueBuffer {
    var mAudioDataBytesCapacity: UInt32
    var mAudioData: UnsafeMutablePointer<Void>
    var mAudioDataByteSize: UInt32
    var mUserData: UnsafeMutablePointer<Void>
    var mPacketDescriptionCapacity: UInt32
    var mPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>
    var mPacketDescriptionCount: UInt32
}

struct AUPresetEvent {
    var scope: AudioUnitScope
    var element: AudioUnitElement
    var preset: Unmanaged<CFPropertyList>!
    init()
    init(scope scope: AudioUnitScope, element element: AudioUnitElement, preset preset: Unmanaged<CFPropertyList>!)
}

struct AUPresetEvent {
    var scope: AudioUnitScope
    var element: AudioUnitElement
    var preset: Unmanaged<CFPropertyList>
}

var preset: Unmanaged<CFPropertyList>!

var preset: Unmanaged<CFPropertyList>

struct CAFAudioDescription {
    var mSampleRate: Float64
    var mFormatID: UInt32
    var mFormatFlags: UInt32
    var mBytesPerPacket: UInt32
    var mFramesPerPacket: UInt32
    var mChannelsPerFrame: UInt32
    var mBitsPerChannel: UInt32
    init()
    init(mSampleRate mSampleRate: Float64, mFormatID mFormatID: UInt32, mFormatFlags mFormatFlags: UInt32, mBytesPerPacket mBytesPerPacket: UInt32, mFramesPerPacket mFramesPerPacket: UInt32, mChannelsPerFrame mChannelsPerFrame: UInt32, mBitsPerChannel mBitsPerChannel: UInt32)
}

struct CAFAudioDescription {
    var mSampleRate: Float64
    var mFormatID: UInt32
    var mFormatFlags: CAFFormatFlags
    var mBytesPerPacket: UInt32
    var mFramesPerPacket: UInt32
    var mChannelsPerFrame: UInt32
    var mBitsPerChannel: UInt32
    init()
    init(mSampleRate mSampleRate: Float64, mFormatID mFormatID: UInt32, mFormatFlags mFormatFlags: CAFFormatFlags, mBytesPerPacket mBytesPerPacket: UInt32, mFramesPerPacket mFramesPerPacket: UInt32, mChannelsPerFrame mChannelsPerFrame: UInt32, mBitsPerChannel mBitsPerChannel: UInt32)
}

var mFormatFlags: UInt32

var mFormatFlags: CAFFormatFlags

struct CAFRegion {
    var mRegionID: UInt32
    var mFlags: UInt32
    var mNumberMarkers: UInt32
    var mMarkers: (CAFMarker)
    init()
    init(mRegionID mRegionID: UInt32, mFlags mFlags: UInt32, mNumberMarkers mNumberMarkers: UInt32, mMarkers mMarkers: (CAFMarker))
}

struct CAFRegion {
    var mRegionID: UInt32
    var mFlags: CAFRegionFlags
    var mNumberMarkers: UInt32
    var mMarkers: (CAFMarker)
    init()
    init(mRegionID mRegionID: UInt32, mFlags mFlags: CAFRegionFlags, mNumberMarkers mNumberMarkers: UInt32, mMarkers mMarkers: (CAFMarker))
}

var mFlags: UInt32

var mFlags: CAFRegionFlags

struct ExtendedAudioFormatInfo {
    var mASBD: AudioStreamBasicDescription
    var mMagicCookie: UnsafePointer<Void>
    var mMagicCookieSize: UInt32
    var mClassDescription: AudioClassDescription
    init()
    init(mASBD mASBD: AudioStreamBasicDescription, mMagicCookie mMagicCookie: UnsafePointer<Void>, mMagicCookieSize mMagicCookieSize: UInt32, mClassDescription mClassDescription: AudioClassDescription)
}

struct ExtendedAudioFormatInfo {
    var mASBD: AudioStreamBasicDescription
    var mMagicCookie: UnsafePointer<Void>
    var mMagicCookieSize: UInt32
    var mClassDescription: AudioClassDescription
}

typealias AudioConverterComplexInputDataProc = CFunctionPointer<((AudioConverterRef, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<AudioBufferList>, UnsafeMutablePointer<UnsafeMutablePointer<AudioStreamPacketDescription>>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioConverterComplexInputDataProc = (AudioConverterRef, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<AudioBufferList>, UnsafeMutablePointer<UnsafeMutablePointer<AudioStreamPacketDescription>>, UnsafeMutablePointer<Void>) -> OSStatus

func AudioConverterGetPropertyInfo(_ inAudioConverter: AudioConverterRef, _ inPropertyID: AudioConverterPropertyID, _ outSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<Boolean>) -> OSStatus

func AudioConverterGetPropertyInfo(_ inAudioConverter: AudioConverterRef, _ inPropertyID: AudioConverterPropertyID, _ outSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

typealias AudioConverterInputDataProc = CFunctionPointer<((AudioConverterRef, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<UnsafeMutablePointer<Void>>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioConverterInputDataProc = (AudioConverterRef, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<UnsafeMutablePointer<Void>>, UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFile_GetSizeProc = CFunctionPointer<((UnsafeMutablePointer<Void>) -> Int64)>

typealias AudioFile_GetSizeProc = (UnsafeMutablePointer<Void>) -> Int64

typealias AudioFile_ReadProc = CFunctionPointer<((UnsafeMutablePointer<Void>, Int64, UInt32, UnsafeMutablePointer<Void>, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias AudioFile_ReadProc = (UnsafeMutablePointer<Void>, Int64, UInt32, UnsafeMutablePointer<Void>, UnsafeMutablePointer<UInt32>) -> OSStatus

typealias AudioFile_SetSizeProc = CFunctionPointer<((UnsafeMutablePointer<Void>, Int64) -> OSStatus)>

typealias AudioFile_SetSizeProc = (UnsafeMutablePointer<Void>, Int64) -> OSStatus

typealias AudioFile_WriteProc = CFunctionPointer<((UnsafeMutablePointer<Void>, Int64, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias AudioFile_WriteProc = (UnsafeMutablePointer<Void>, Int64, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<UInt32>) -> OSStatus

typealias AudioFileComponentCloseProc = CFunctionPointer<((UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioFileComponentCloseProc = (UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFileComponentCountUserDataProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias AudioFileComponentCountUserDataProc = (UnsafeMutablePointer<Void>, UInt32, UnsafeMutablePointer<UInt32>) -> OSStatus

func AudioFileComponentCreateURL(_ inComponent: AudioFileComponent, _ inFileRef: CFURL!, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: UInt32) -> OSStatus

func AudioFileComponentCreateURL(_ inComponent: AudioFileComponent, _ inFileRef: CFURL, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: UInt32) -> OSStatus

typealias AudioFileComponentCreateURLProc = CFunctionPointer<((UnsafeMutablePointer<Void>, CFURL!, UnsafePointer<AudioStreamBasicDescription>, UInt32) -> OSStatus)>

typealias AudioFileComponentCreateURLProc = (UnsafeMutablePointer<Void>, CFURL, UnsafePointer<AudioStreamBasicDescription>, UInt32) -> OSStatus

func AudioFileComponentExtensionIsThisFormat(_ inComponent: AudioFileComponent, _ inExtension: CFString!, _ outResult: UnsafeMutablePointer<UInt32>) -> OSStatus

func AudioFileComponentExtensionIsThisFormat(_ inComponent: AudioFileComponent, _ inExtension: CFString, _ outResult: UnsafeMutablePointer<UInt32>) -> OSStatus

typealias AudioFileComponentExtensionIsThisFormatProc = CFunctionPointer<((UnsafeMutablePointer<Void>, CFString!, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias AudioFileComponentExtensionIsThisFormatProc = (UnsafeMutablePointer<Void>, CFString, UnsafeMutablePointer<UInt32>) -> OSStatus

typealias AudioFileComponentFileDataIsThisFormatProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias AudioFileComponentFileDataIsThisFormatProc = (UnsafeMutablePointer<Void>, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<UInt32>) -> OSStatus

typealias AudioFileComponentGetGlobalInfoProc = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioFileComponentGetGlobalInfoProc = (UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFileComponentGetGlobalInfoSizeProc = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias AudioFileComponentGetGlobalInfoSizeProc = (UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<UInt32>) -> OSStatus

typealias AudioFileComponentGetPropertyInfoProc = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias AudioFileComponentGetPropertyInfoProc = (UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<UInt32>) -> OSStatus

typealias AudioFileComponentGetPropertyProc = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioFileComponentGetPropertyProc = (UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFileComponentGetUserDataProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioFileComponentGetUserDataProc = (UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFileComponentGetUserDataSizeProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias AudioFileComponentGetUserDataSizeProc = (UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafeMutablePointer<UInt32>) -> OSStatus

typealias AudioFileComponentInitializeWithCallbacksProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, AudioFile_ReadProc, AudioFile_WriteProc, AudioFile_GetSizeProc, AudioFile_SetSizeProc, UInt32, UnsafePointer<AudioStreamBasicDescription>, UInt32) -> OSStatus)>

typealias AudioFileComponentInitializeWithCallbacksProc = (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, AudioFile_ReadProc, AudioFile_WriteProc, AudioFile_GetSizeProc, AudioFile_SetSizeProc, UInt32, UnsafePointer<AudioStreamBasicDescription>, UInt32) -> OSStatus

func AudioFileComponentOpenURL(_ inComponent: AudioFileComponent, _ inFileRef: CFURL!, _ inPermissions: Int8, _ inFileDescriptor: Int32) -> OSStatus

func AudioFileComponentOpenURL(_ inComponent: AudioFileComponent, _ inFileRef: CFURL, _ inPermissions: Int8, _ inFileDescriptor: Int32) -> OSStatus

typealias AudioFileComponentOpenURLProc = CFunctionPointer<((UnsafeMutablePointer<Void>, CFURL!, Int8, Int32) -> OSStatus)>

typealias AudioFileComponentOpenURLProc = (UnsafeMutablePointer<Void>, CFURL, Int8, Int32) -> OSStatus

typealias AudioFileComponentOpenWithCallbacksProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, AudioFile_ReadProc, AudioFile_WriteProc, AudioFile_GetSizeProc, AudioFile_SetSizeProc) -> OSStatus)>

typealias AudioFileComponentOpenWithCallbacksProc = (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, AudioFile_ReadProc, AudioFile_WriteProc, AudioFile_GetSizeProc, AudioFile_SetSizeProc) -> OSStatus

typealias AudioFileComponentOptimizeProc = CFunctionPointer<((UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioFileComponentOptimizeProc = (UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileComponentReadBytes(_ inComponent: AudioFileComponent, _ inUseCache: Boolean, _ inStartingByte: Int64, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileComponentReadBytes(_ inComponent: AudioFileComponent, _ inUseCache: Bool, _ inStartingByte: Int64, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFileComponentReadBytesProc = CFunctionPointer<((UnsafeMutablePointer<Void>, Boolean, Int64, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioFileComponentReadBytesProc = (UnsafeMutablePointer<Void>, DarwinBoolean, Int64, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileComponentReadPacketData(_ inComponent: AudioFileComponent, _ inUseCache: Boolean, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ outPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileComponentReadPacketData(_ inComponent: AudioFileComponent, _ inUseCache: Bool, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ outPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFileComponentReadPacketDataProc = CFunctionPointer<((UnsafeMutablePointer<Void>, Boolean, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<AudioStreamPacketDescription>, Int64, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioFileComponentReadPacketDataProc = (UnsafeMutablePointer<Void>, DarwinBoolean, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<AudioStreamPacketDescription>, Int64, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileComponentReadPackets(_ inComponent: AudioFileComponent, _ inUseCache: Boolean, _ outNumBytes: UnsafeMutablePointer<UInt32>, _ outPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileComponentReadPackets(_ inComponent: AudioFileComponent, _ inUseCache: Bool, _ outNumBytes: UnsafeMutablePointer<UInt32>, _ outPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFileComponentReadPacketsProc = CFunctionPointer<((UnsafeMutablePointer<Void>, Boolean, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<AudioStreamPacketDescription>, Int64, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias AudioFileComponentReadPacketsProc = (UnsafeMutablePointer<Void>, DarwinBoolean, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<AudioStreamPacketDescription>, Int64, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFileComponentRemoveUserDataProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UInt32) -> OSStatus)>

typealias AudioFileComponentRemoveUserDataProc = (UnsafeMutablePointer<Void>, UInt32, UInt32) -> OSStatus

typealias AudioFileComponentSetPropertyProc = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UInt32, UnsafePointer<Void>) -> OSStatus)>

typealias AudioFileComponentSetPropertyProc = (UnsafeMutablePointer<Void>, AudioFileComponentPropertyID, UInt32, UnsafePointer<Void>) -> OSStatus

typealias AudioFileComponentSetUserDataProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UInt32, UInt32, UnsafePointer<Void>) -> OSStatus)>

typealias AudioFileComponentSetUserDataProc = (UnsafeMutablePointer<Void>, UInt32, UInt32, UInt32, UnsafePointer<Void>) -> OSStatus

func AudioFileComponentWriteBytes(_ inComponent: AudioFileComponent, _ inUseCache: Boolean, _ inStartingByte: Int64, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ inBuffer: UnsafePointer<Void>) -> OSStatus

func AudioFileComponentWriteBytes(_ inComponent: AudioFileComponent, _ inUseCache: Bool, _ inStartingByte: Int64, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ inBuffer: UnsafePointer<Void>) -> OSStatus

typealias AudioFileComponentWriteBytesProc = CFunctionPointer<((UnsafeMutablePointer<Void>, Boolean, Int64, UnsafeMutablePointer<UInt32>, UnsafePointer<Void>) -> OSStatus)>

typealias AudioFileComponentWriteBytesProc = (UnsafeMutablePointer<Void>, DarwinBoolean, Int64, UnsafeMutablePointer<UInt32>, UnsafePointer<Void>) -> OSStatus

func AudioFileComponentWritePackets(_ inComponent: AudioFileComponent, _ inUseCache: Boolean, _ inNumBytes: UInt32, _ inPacketDescriptions: UnsafePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ inBuffer: UnsafePointer<Void>) -> OSStatus

func AudioFileComponentWritePackets(_ inComponent: AudioFileComponent, _ inUseCache: Bool, _ inNumBytes: UInt32, _ inPacketDescriptions: UnsafePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ inBuffer: UnsafePointer<Void>) -> OSStatus

typealias AudioFileComponentWritePacketsProc = CFunctionPointer<((UnsafeMutablePointer<Void>, Boolean, UInt32, UnsafePointer<AudioStreamPacketDescription>, Int64, UnsafeMutablePointer<UInt32>, UnsafePointer<Void>) -> OSStatus)>

typealias AudioFileComponentWritePacketsProc = (UnsafeMutablePointer<Void>, DarwinBoolean, UInt32, UnsafePointer<AudioStreamPacketDescription>, Int64, UnsafeMutablePointer<UInt32>, UnsafePointer<Void>) -> OSStatus

func AudioFileCreateWithURL(_ inFileRef: CFURL!, _ inFileType: AudioFileTypeID, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: UInt32, _ outAudioFile: UnsafeMutablePointer<AudioFileID>) -> OSStatus

func AudioFileCreateWithURL(_ inFileRef: CFURL, _ inFileType: AudioFileTypeID, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: AudioFileFlags, _ outAudioFile: UnsafeMutablePointer<AudioFileID>) -> OSStatus

func AudioFileInitializeWithCallbacks(_ inClientData: UnsafeMutablePointer<Void>, _ inReadFunc: AudioFile_ReadProc, _ inWriteFunc: AudioFile_WriteProc, _ inGetSizeFunc: AudioFile_GetSizeProc, _ inSetSizeFunc: AudioFile_SetSizeProc, _ inFileType: AudioFileTypeID, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: UInt32, _ outAudioFile: UnsafeMutablePointer<AudioFileID>) -> OSStatus

func AudioFileInitializeWithCallbacks(_ inClientData: UnsafeMutablePointer<Void>, _ inReadFunc: AudioFile_ReadProc, _ inWriteFunc: AudioFile_WriteProc, _ inGetSizeFunc: AudioFile_GetSizeProc, _ inSetSizeFunc: AudioFile_SetSizeProc, _ inFileType: AudioFileTypeID, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: AudioFileFlags, _ outAudioFile: UnsafeMutablePointer<AudioFileID>) -> OSStatus

func AudioFileOpenURL(_ inFileRef: CFURL!, _ inPermissions: Int8, _ inFileTypeHint: AudioFileTypeID, _ outAudioFile: UnsafeMutablePointer<AudioFileID>) -> OSStatus

func AudioFileOpenURL(_ inFileRef: CFURL, _ inPermissions: AudioFilePermissions, _ inFileTypeHint: AudioFileTypeID, _ outAudioFile: UnsafeMutablePointer<AudioFileID>) -> OSStatus

func AudioFileOpenWithCallbacks(_ inClientData: UnsafeMutablePointer<Void>, _ inReadFunc: AudioFile_ReadProc, _ inWriteFunc: AudioFile_WriteProc, _ inGetSizeFunc: AudioFile_GetSizeProc, _ inSetSizeFunc: AudioFile_SetSizeProc, _ inFileTypeHint: AudioFileTypeID, _ outAudioFile: UnsafeMutablePointer<AudioFileID>) -> OSStatus

func AudioFileOpenWithCallbacks(_ inClientData: UnsafeMutablePointer<Void>, _ inReadFunc: AudioFile_ReadProc, _ inWriteFunc: AudioFile_WriteProc?, _ inGetSizeFunc: AudioFile_GetSizeProc, _ inSetSizeFunc: AudioFile_SetSizeProc?, _ inFileTypeHint: AudioFileTypeID, _ outAudioFile: UnsafeMutablePointer<AudioFileID>) -> OSStatus

func AudioFileReadBytes(_ inAudioFile: AudioFileID, _ inUseCache: Boolean, _ inStartingByte: Int64, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileReadBytes(_ inAudioFile: AudioFileID, _ inUseCache: Bool, _ inStartingByte: Int64, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileReadPacketData(_ inAudioFile: AudioFileID, _ inUseCache: Boolean, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ outPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileReadPacketData(_ inAudioFile: AudioFileID, _ inUseCache: Bool, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ outPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileReadPackets(_ inAudioFile: AudioFileID, _ inUseCache: Boolean, _ outNumBytes: UnsafeMutablePointer<UInt32>, _ outPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

func AudioFileReadPackets(_ inAudioFile: AudioFileID, _ inUseCache: Bool, _ outNumBytes: UnsafeMutablePointer<UInt32>, _ outPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ outBuffer: UnsafeMutablePointer<Void>) -> OSStatus

typealias AudioFileStream_PacketsProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<AudioStreamPacketDescription>) -> Void)>

typealias AudioFileStream_PacketsProc = (UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafePointer<Void>, UnsafeMutablePointer<AudioStreamPacketDescription>) -> Void

typealias AudioFileStream_PropertyListenerProc = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioFileStreamID, AudioFileStreamPropertyID, UnsafeMutablePointer<UInt32>) -> Void)>

typealias AudioFileStream_PropertyListenerProc = (UnsafeMutablePointer<Void>, AudioFileStreamID, AudioFileStreamPropertyID, UnsafeMutablePointer<AudioFileStreamPropertyFlags>) -> Void

func AudioFileStreamGetPropertyInfo(_ inAudioFileStream: AudioFileStreamID, _ inPropertyID: AudioFileStreamPropertyID, _ outPropertyDataSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<Boolean>) -> OSStatus

func AudioFileStreamGetPropertyInfo(_ inAudioFileStream: AudioFileStreamID, _ inPropertyID: AudioFileStreamPropertyID, _ outPropertyDataSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

func AudioFileStreamParseBytes(_ inAudioFileStream: AudioFileStreamID, _ inDataByteSize: UInt32, _ inData: UnsafePointer<Void>, _ inFlags: UInt32) -> OSStatus

func AudioFileStreamParseBytes(_ inAudioFileStream: AudioFileStreamID, _ inDataByteSize: UInt32, _ inData: UnsafePointer<Void>, _ inFlags: AudioFileStreamParseFlags) -> OSStatus

func AudioFileStreamSeek(_ inAudioFileStream: AudioFileStreamID, _ inPacketOffset: Int64, _ outDataByteOffset: UnsafeMutablePointer<Int64>, _ ioFlags: UnsafeMutablePointer<UInt32>) -> OSStatus

func AudioFileStreamSeek(_ inAudioFileStream: AudioFileStreamID, _ inPacketOffset: Int64, _ outDataByteOffset: UnsafeMutablePointer<Int64>, _ ioFlags: UnsafeMutablePointer<AudioFileStreamSeekFlags>) -> OSStatus

func AudioFileWriteBytes(_ inAudioFile: AudioFileID, _ inUseCache: Boolean, _ inStartingByte: Int64, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ inBuffer: UnsafePointer<Void>) -> OSStatus

func AudioFileWriteBytes(_ inAudioFile: AudioFileID, _ inUseCache: Bool, _ inStartingByte: Int64, _ ioNumBytes: UnsafeMutablePointer<UInt32>, _ inBuffer: UnsafePointer<Void>) -> OSStatus

func AudioFileWritePackets(_ inAudioFile: AudioFileID, _ inUseCache: Boolean, _ inNumBytes: UInt32, _ inPacketDescriptions: UnsafePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ inBuffer: UnsafePointer<Void>) -> OSStatus

func AudioFileWritePackets(_ inAudioFile: AudioFileID, _ inUseCache: Bool, _ inNumBytes: UInt32, _ inPacketDescriptions: UnsafePointer<AudioStreamPacketDescription>, _ inStartingPacket: Int64, _ ioNumPackets: UnsafeMutablePointer<UInt32>, _ inBuffer: UnsafePointer<Void>) -> OSStatus

func AudioHardwareServiceHasProperty(_ inObjectID: AudioObjectID, _ inAddress: UnsafePointer<AudioObjectPropertyAddress>) -> Boolean

func AudioHardwareServiceHasProperty(_ inObjectID: AudioObjectID, _ inAddress: UnsafePointer<AudioObjectPropertyAddress>) -> Bool

func AudioHardwareServiceIsPropertySettable(_ inObjectID: AudioObjectID, _ inAddress: UnsafePointer<AudioObjectPropertyAddress>, _ outIsSettable: UnsafeMutablePointer<Boolean>) -> OSStatus

func AudioHardwareServiceIsPropertySettable(_ inObjectID: AudioObjectID, _ inAddress: UnsafePointer<AudioObjectPropertyAddress>, _ outIsSettable: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

func AudioQueueDispose(_ inAQ: AudioQueueRef, _ inImmediate: Boolean) -> OSStatus

func AudioQueueDispose(_ inAQ: AudioQueueRef, _ inImmediate: Bool) -> OSStatus

func AudioQueueGetCurrentTime(_ inAQ: AudioQueueRef, _ inTimeline: AudioQueueTimelineRef, _ outTimeStamp: UnsafeMutablePointer<AudioTimeStamp>, _ outTimelineDiscontinuity: UnsafeMutablePointer<Boolean>) -> OSStatus

func AudioQueueGetCurrentTime(_ inAQ: AudioQueueRef, _ inTimeline: AudioQueueTimelineRef, _ outTimeStamp: UnsafeMutablePointer<AudioTimeStamp>, _ outTimelineDiscontinuity: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

typealias AudioQueueInputCallback = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioQueueRef, AudioQueueBufferRef, UnsafePointer<AudioTimeStamp>, UInt32, UnsafePointer<AudioStreamPacketDescription>) -> Void)>

typealias AudioQueueInputCallback = (UnsafeMutablePointer<Void>, AudioQueueRef, AudioQueueBufferRef, UnsafePointer<AudioTimeStamp>, UInt32, UnsafePointer<AudioStreamPacketDescription>) -> Void

func AudioQueueNewInput(_ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inCallbackProc: AudioQueueInputCallback, _ inUserData: UnsafeMutablePointer<Void>, _ inCallbackRunLoop: CFRunLoop!, _ inCallbackRunLoopMode: CFString!, _ inFlags: UInt32, _ outAQ: UnsafeMutablePointer<AudioQueueRef>) -> OSStatus

func AudioQueueNewInput(_ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inCallbackProc: AudioQueueInputCallback, _ inUserData: UnsafeMutablePointer<Void>, _ inCallbackRunLoop: CFRunLoop?, _ inCallbackRunLoopMode: CFString?, _ inFlags: UInt32, _ outAQ: UnsafeMutablePointer<AudioQueueRef>) -> OSStatus

func AudioQueueNewInputWithDispatchQueue(_ outAQ: UnsafeMutablePointer<AudioQueueRef>, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: UInt32, _ inCallbackDispatchQueue: dispatch_queue_t!, _ inCallbackBlock: AudioQueueInputCallbackBlock!) -> OSStatus

func AudioQueueNewInputWithDispatchQueue(_ outAQ: UnsafeMutablePointer<AudioQueueRef>, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: UInt32, _ inCallbackDispatchQueue: dispatch_queue_t, _ inCallbackBlock: AudioQueueInputCallbackBlock) -> OSStatus

func AudioQueueNewOutput(_ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inCallbackProc: AudioQueueOutputCallback, _ inUserData: UnsafeMutablePointer<Void>, _ inCallbackRunLoop: CFRunLoop!, _ inCallbackRunLoopMode: CFString!, _ inFlags: UInt32, _ outAQ: UnsafeMutablePointer<AudioQueueRef>) -> OSStatus

func AudioQueueNewOutput(_ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inCallbackProc: AudioQueueOutputCallback, _ inUserData: UnsafeMutablePointer<Void>, _ inCallbackRunLoop: CFRunLoop?, _ inCallbackRunLoopMode: CFString?, _ inFlags: UInt32, _ outAQ: UnsafeMutablePointer<AudioQueueRef>) -> OSStatus

func AudioQueueNewOutputWithDispatchQueue(_ outAQ: UnsafeMutablePointer<AudioQueueRef>, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: UInt32, _ inCallbackDispatchQueue: dispatch_queue_t!, _ inCallbackBlock: AudioQueueOutputCallbackBlock!) -> OSStatus

func AudioQueueNewOutputWithDispatchQueue(_ outAQ: UnsafeMutablePointer<AudioQueueRef>, _ inFormat: UnsafePointer<AudioStreamBasicDescription>, _ inFlags: UInt32, _ inCallbackDispatchQueue: dispatch_queue_t, _ inCallbackBlock: AudioQueueOutputCallbackBlock) -> OSStatus

typealias AudioQueueOutputCallback = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioQueueRef, AudioQueueBufferRef) -> Void)>

typealias AudioQueueOutputCallback = (UnsafeMutablePointer<Void>, AudioQueueRef, AudioQueueBufferRef) -> Void

typealias AudioQueueProcessingTapCallback = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioQueueProcessingTapRef, UInt32, UnsafeMutablePointer<AudioTimeStamp>, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<AudioBufferList>) -> Void)>

typealias AudioQueueProcessingTapCallback = (UnsafeMutablePointer<Void>, AudioQueueProcessingTapRef, UInt32, UnsafeMutablePointer<AudioTimeStamp>, UnsafeMutablePointer<AudioQueueProcessingTapFlags>, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<AudioBufferList>) -> Void

func AudioQueueProcessingTapGetSourceAudio(_ inAQTap: AudioQueueProcessingTapRef, _ inNumberFrames: UInt32, _ ioTimeStamp: UnsafeMutablePointer<AudioTimeStamp>, _ outFlags: UnsafeMutablePointer<UInt32>, _ outNumberFrames: UnsafeMutablePointer<UInt32>, _ ioData: UnsafeMutablePointer<AudioBufferList>) -> OSStatus

func AudioQueueProcessingTapGetSourceAudio(_ inAQTap: AudioQueueProcessingTapRef, _ inNumberFrames: UInt32, _ ioTimeStamp: UnsafeMutablePointer<AudioTimeStamp>, _ outFlags: UnsafeMutablePointer<AudioQueueProcessingTapFlags>, _ outNumberFrames: UnsafeMutablePointer<UInt32>, _ ioData: UnsafeMutablePointer<AudioBufferList>) -> OSStatus

func AudioQueueProcessingTapNew(_ inAQ: AudioQueueRef, _ inCallback: AudioQueueProcessingTapCallback, _ inClientData: UnsafeMutablePointer<Void>, _ inFlags: UInt32, _ outMaxFrames: UnsafeMutablePointer<UInt32>, _ outProcessingFormat: UnsafeMutablePointer<AudioStreamBasicDescription>, _ outAQTap: UnsafeMutablePointer<AudioQueueProcessingTapRef>) -> OSStatus

func AudioQueueProcessingTapNew(_ inAQ: AudioQueueRef, _ inCallback: AudioQueueProcessingTapCallback, _ inClientData: UnsafeMutablePointer<Void>, _ inFlags: AudioQueueProcessingTapFlags, _ outMaxFrames: UnsafeMutablePointer<UInt32>, _ outProcessingFormat: UnsafeMutablePointer<AudioStreamBasicDescription>, _ outAQTap: UnsafeMutablePointer<AudioQueueProcessingTapRef>) -> OSStatus

typealias AudioQueuePropertyListenerProc = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioQueueRef, AudioQueuePropertyID) -> Void)>

typealias AudioQueuePropertyListenerProc = (UnsafeMutablePointer<Void>, AudioQueueRef, AudioQueuePropertyID) -> Void

func AudioQueueStop(_ inAQ: AudioQueueRef, _ inImmediate: Boolean) -> OSStatus

func AudioQueueStop(_ inAQ: AudioQueueRef, _ inImmediate: Bool) -> OSStatus

func AudioServicesAddSystemSoundCompletion(_ inSystemSoundID: SystemSoundID, _ inRunLoop: CFRunLoop!, _ inRunLoopMode: CFString!, _ inCompletionRoutine: AudioServicesSystemSoundCompletionProc, _ inClientData: UnsafeMutablePointer<Void>) -> OSStatus

func AudioServicesAddSystemSoundCompletion(_ inSystemSoundID: SystemSoundID, _ inRunLoop: CFRunLoop?, _ inRunLoopMode: CFString?, _ inCompletionRoutine: AudioServicesSystemSoundCompletionProc, _ inClientData: UnsafeMutablePointer<Void>) -> OSStatus

func AudioServicesCreateSystemSoundID(_ inFileURL: CFURL!, _ outSystemSoundID: UnsafeMutablePointer<SystemSoundID>) -> OSStatus

func AudioServicesCreateSystemSoundID(_ inFileURL: CFURL, _ outSystemSoundID: UnsafeMutablePointer<SystemSoundID>) -> OSStatus

func AudioServicesGetPropertyInfo(_ inPropertyID: AudioServicesPropertyID, _ inSpecifierSize: UInt32, _ inSpecifier: UnsafePointer<Void>, _ outPropertyDataSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<Boolean>) -> OSStatus

func AudioServicesGetPropertyInfo(_ inPropertyID: AudioServicesPropertyID, _ inSpecifierSize: UInt32, _ inSpecifier: UnsafePointer<Void>, _ outPropertyDataSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

typealias AudioServicesSystemSoundCompletionProc = CFunctionPointer<((SystemSoundID, UnsafeMutablePointer<Void>) -> Void)>

typealias AudioServicesSystemSoundCompletionProc = (SystemSoundID, UnsafeMutablePointer<Void>) -> Void

func AUEventListenerCreate(_ inProc: AUEventListenerProc, _ inUserData: UnsafeMutablePointer<Void>, _ inRunLoop: CFRunLoop!, _ inRunLoopMode: CFString!, _ inNotificationInterval: Float32, _ inValueChangeGranularity: Float32, _ outListener: UnsafeMutablePointer<AUEventListenerRef>) -> OSStatus

func AUEventListenerCreate(_ inProc: AUEventListenerProc, _ inUserData: UnsafeMutablePointer<Void>, _ inRunLoop: CFRunLoop?, _ inRunLoopMode: CFString?, _ inNotificationInterval: Float32, _ inValueChangeGranularity: Float32, _ outListener: UnsafeMutablePointer<AUEventListenerRef>) -> OSStatus

func AUEventListenerCreateWithDispatchQueue(_ outListener: UnsafeMutablePointer<AUEventListenerRef>, _ inNotificationInterval: Float32, _ inValueChangeGranularity: Float32, _ inDispatchQueue: dispatch_queue_t!, _ inBlock: AUEventListenerBlock!) -> OSStatus

func AUEventListenerCreateWithDispatchQueue(_ outListener: UnsafeMutablePointer<AUEventListenerRef>, _ inNotificationInterval: Float32, _ inValueChangeGranularity: Float32, _ inDispatchQueue: dispatch_queue_t, _ inBlock: AUEventListenerBlock) -> OSStatus

typealias AUEventListenerProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, UnsafePointer<AudioUnitEvent>, UInt64, AudioUnitParameterValue) -> Void)>

typealias AUEventListenerProc = (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, UnsafePointer<AudioUnitEvent>, UInt64, AudioUnitParameterValue) -> Void

func AUGraphIsInitialized(_ inGraph: AUGraph, _ outIsInitialized: UnsafeMutablePointer<Boolean>) -> OSStatus

func AUGraphIsInitialized(_ inGraph: AUGraph, _ outIsInitialized: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

func AUGraphIsNodeSubGraph(_ inGraph: AUGraph, _ inNode: AUNode, _ outFlag: UnsafeMutablePointer<Boolean>) -> OSStatus

func AUGraphIsNodeSubGraph(_ inGraph: AUGraph, _ inNode: AUNode, _ outFlag: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

func AUGraphIsOpen(_ inGraph: AUGraph, _ outIsOpen: UnsafeMutablePointer<Boolean>) -> OSStatus

func AUGraphIsOpen(_ inGraph: AUGraph, _ outIsOpen: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

func AUGraphIsRunning(_ inGraph: AUGraph, _ outIsRunning: UnsafeMutablePointer<Boolean>) -> OSStatus

func AUGraphIsRunning(_ inGraph: AUGraph, _ outIsRunning: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

func AUGraphUpdate(_ inGraph: AUGraph, _ outIsUpdated: UnsafeMutablePointer<Boolean>) -> OSStatus

func AUGraphUpdate(_ inGraph: AUGraph, _ outIsUpdated: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

func AUListenerCreate(_ inProc: AUParameterListenerProc, _ inUserData: UnsafeMutablePointer<Void>, _ inRunLoop: CFRunLoop!, _ inRunLoopMode: CFString!, _ inNotificationInterval: Float32, _ outListener: UnsafeMutablePointer<AUParameterListenerRef>) -> OSStatus

func AUListenerCreate(_ inProc: AUParameterListenerProc, _ inUserData: UnsafeMutablePointer<Void>, _ inRunLoop: CFRunLoop?, _ inRunLoopMode: CFString?, _ inNotificationInterval: Float32, _ outListener: UnsafeMutablePointer<AUParameterListenerRef>) -> OSStatus

func AUListenerCreateWithDispatchQueue(_ outListener: UnsafeMutablePointer<AUParameterListenerRef>, _ inNotificationInterval: Float32, _ inDispatchQueue: dispatch_queue_t!, _ inBlock: AUParameterListenerBlock!) -> OSStatus

func AUListenerCreateWithDispatchQueue(_ outListener: UnsafeMutablePointer<AUParameterListenerRef>, _ inNotificationInterval: Float32, _ inDispatchQueue: dispatch_queue_t, _ inBlock: AUParameterListenerBlock) -> OSStatus

typealias AUParameterListenerProc = CFunctionPointer<((UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, UnsafePointer<AudioUnitParameter>, AudioUnitParameterValue) -> Void)>

typealias AUParameterListenerProc = (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, UnsafePointer<AudioUnitParameter>, AudioUnitParameterValue) -> Void

func CAClockGetPropertyInfo(_ inCAClock: CAClockRef, _ inPropertyID: CAClockPropertyID, _ outSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<Boolean>) -> OSStatus

func CAClockGetPropertyInfo(_ inCAClock: CAClockRef, _ inPropertyID: CAClockPropertyID, _ outSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

typealias CAClockListenerProc = CFunctionPointer<((UnsafeMutablePointer<Void>, CAClockMessage, UnsafePointer<Void>) -> Void)>

typealias CAClockListenerProc = (UnsafeMutablePointer<Void>, CAClockMessage, UnsafePointer<Void>) -> Void

typealias CAClockSMPTEFormat = UInt32

typealias CAClockSMPTEFormat = SMPTETimeType

func CopyInstrumentInfoFromSoundBank(_ inURL: CFURL!, _ outInstrumentInfo: UnsafeMutablePointer<Unmanaged<CFArray>?>) -> OSStatus

func CopyInstrumentInfoFromSoundBank(_ inURL: CFURL, _ outInstrumentInfo: UnsafeMutablePointer<Unmanaged<CFArray>?>) -> OSStatus

func CopyNameFromSoundBank(_ inURL: CFURL!, _ outName: UnsafeMutablePointer<Unmanaged<CFString>?>) -> OSStatus

func CopyNameFromSoundBank(_ inURL: CFURL, _ outName: UnsafeMutablePointer<Unmanaged<CFString>?>) -> OSStatus

typealias CountUserDataFDF = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias CountUserDataFDF = (UnsafeMutablePointer<Void>, UInt32, UnsafeMutablePointer<UInt32>) -> OSStatus

func ExtAudioFileCreateWithURL(_ inURL: CFURL!, _ inFileType: AudioFileTypeID, _ inStreamDesc: UnsafePointer<AudioStreamBasicDescription>, _ inChannelLayout: UnsafePointer<AudioChannelLayout>, _ inFlags: UInt32, _ outExtAudioFile: UnsafeMutablePointer<ExtAudioFileRef>) -> OSStatus

func ExtAudioFileCreateWithURL(_ inURL: CFURL, _ inFileType: AudioFileTypeID, _ inStreamDesc: UnsafePointer<AudioStreamBasicDescription>, _ inChannelLayout: UnsafePointer<AudioChannelLayout>, _ inFlags: UInt32, _ outExtAudioFile: UnsafeMutablePointer<ExtAudioFileRef>) -> OSStatus

func ExtAudioFileGetPropertyInfo(_ inExtAudioFile: ExtAudioFileRef, _ inPropertyID: ExtAudioFilePropertyID, _ outSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<Boolean>) -> OSStatus

func ExtAudioFileGetPropertyInfo(_ inExtAudioFile: ExtAudioFileRef, _ inPropertyID: ExtAudioFilePropertyID, _ outSize: UnsafeMutablePointer<UInt32>, _ outWritable: UnsafeMutablePointer<DarwinBoolean>) -> OSStatus

func ExtAudioFileOpenURL(_ inURL: CFURL!, _ outExtAudioFile: UnsafeMutablePointer<ExtAudioFileRef>) -> OSStatus

func ExtAudioFileOpenURL(_ inURL: CFURL, _ outExtAudioFile: UnsafeMutablePointer<ExtAudioFileRef>) -> OSStatus

func ExtAudioFileWrapAudioFileID(_ inFileID: AudioFileID, _ inForWriting: Boolean, _ outExtAudioFile: UnsafeMutablePointer<ExtAudioFileRef>) -> OSStatus

func ExtAudioFileWrapAudioFileID(_ inFileID: AudioFileID, _ inForWriting: Bool, _ outExtAudioFile: UnsafeMutablePointer<ExtAudioFileRef>) -> OSStatus

typealias GetPropertyFDF = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioFilePropertyID, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias GetPropertyFDF = (UnsafeMutablePointer<Void>, AudioFilePropertyID, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus

typealias GetPropertyInfoFDF = CFunctionPointer<((UnsafeMutablePointer<Void>, AudioFilePropertyID, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias GetPropertyInfoFDF = (UnsafeMutablePointer<Void>, AudioFilePropertyID, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<UInt32>) -> OSStatus

typealias GetUserDataFDF = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus)>

typealias GetUserDataFDF = (UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafeMutablePointer<UInt32>, UnsafeMutablePointer<Void>) -> OSStatus

typealias GetUserDataSizeFDF = CFunctionPointer<((UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafeMutablePointer<UInt32>) -> OSStatus)>

typealias GetUserDataSizeFDF = (UnsafeMutablePointer<Void>, UInt32, UInt32, UnsafeMutablePointer<UInt32>) -> OSStatus

var kAudioConverterApplicableEncodeBitRates: Int { get }

var kAudioConverterApplicableEncodeBitRates: AudioConverterPropertyID { get }

var kAudioConverterApplicableEncodeSampleRates: Int { get }

var kAudioConverterApplicableEncodeSampleRates: AudioConverterPropertyID { get }

var kAudioConverterAvailableEncodeBitRates: Int { get }

var kAudioConverterAvailableEncodeBitRates: AudioConverterPropertyID { get }

var kAudioConverterAvailableEncodeChannelLayoutTags: Int { get }

var kAudioConverterAvailableEncodeChannelLayoutTags: AudioConverterPropertyID { get }

var kAudioConverterAvailableEncodeSampleRates: Int { get }

var kAudioConverterAvailableEncodeSampleRates: AudioConverterPropertyID { get }

var kAudioConverterChannelMap: Int { get }

var kAudioConverterChannelMap: AudioConverterPropertyID { get }

var kAudioConverterCodecQuality: Int { get }

var kAudioConverterCodecQuality: AudioConverterPropertyID { get }

var kAudioConverterCompressionMagicCookie: Int { get }

var kAudioConverterCompressionMagicCookie: AudioConverterPropertyID { get }

var kAudioConverterCurrentInputStreamDescription: Int { get }

var kAudioConverterCurrentInputStreamDescription: AudioConverterPropertyID { get }

var kAudioConverterCurrentOutputStreamDescription: Int { get }

var kAudioConverterCurrentOutputStreamDescription: AudioConverterPropertyID { get }

var kAudioConverterDecompressionMagicCookie: Int { get }

var kAudioConverterDecompressionMagicCookie: AudioConverterPropertyID { get }

var kAudioConverterEncodeAdjustableSampleRate: Int { get }

var kAudioConverterEncodeAdjustableSampleRate: AudioConverterPropertyID { get }

var kAudioConverterEncodeBitRate: Int { get }

var kAudioConverterEncodeBitRate: AudioConverterPropertyID { get }

var kAudioConverterErr_BadPropertySizeError: Int { get }

var kAudioConverterErr_BadPropertySizeError: OSStatus { get }

var kAudioConverterErr_FormatNotSupported: Int { get }

var kAudioConverterErr_FormatNotSupported: OSStatus { get }

var kAudioConverterErr_InputSampleRateOutOfRange: Int { get }

var kAudioConverterErr_InputSampleRateOutOfRange: OSStatus { get }

var kAudioConverterErr_InvalidInputSize: Int { get }

var kAudioConverterErr_InvalidInputSize: OSStatus { get }

var kAudioConverterErr_InvalidOutputSize: Int { get }

var kAudioConverterErr_InvalidOutputSize: OSStatus { get }

var kAudioConverterErr_OperationNotSupported: Int { get }

var kAudioConverterErr_OperationNotSupported: OSStatus { get }

var kAudioConverterErr_OutputSampleRateOutOfRange: Int { get }

var kAudioConverterErr_OutputSampleRateOutOfRange: OSStatus { get }

var kAudioConverterErr_PropertyNotSupported: Int { get }

var kAudioConverterErr_PropertyNotSupported: OSStatus { get }

var kAudioConverterErr_RequiresPacketDescriptionsError: Int { get }

var kAudioConverterErr_RequiresPacketDescriptionsError: OSStatus { get }

var kAudioConverterErr_UnspecifiedError: Int { get }

var kAudioConverterErr_UnspecifiedError: OSStatus { get }

var kAudioConverterInputChannelLayout: Int { get }

var kAudioConverterInputChannelLayout: AudioConverterPropertyID { get }

var kAudioConverterOutputChannelLayout: Int { get }

var kAudioConverterOutputChannelLayout: AudioConverterPropertyID { get }

var kAudioConverterPrimeInfo: Int { get }

var kAudioConverterPrimeInfo: AudioConverterPropertyID { get }

var kAudioConverterPrimeMethod: Int { get }

var kAudioConverterPrimeMethod: AudioConverterPropertyID { get }

var kAudioConverterPropertyBitDepthHint: Int { get }

var kAudioConverterPropertyBitDepthHint: AudioConverterPropertyID { get }

var kAudioConverterPropertyCalculateInputBufferSize: Int { get }

var kAudioConverterPropertyCalculateInputBufferSize: AudioConverterPropertyID { get }

var kAudioConverterPropertyCalculateOutputBufferSize: Int { get }

var kAudioConverterPropertyCalculateOutputBufferSize: AudioConverterPropertyID { get }

var kAudioConverterPropertyDitherBitDepth: Int { get }

var kAudioConverterPropertyDitherBitDepth: AudioConverterPropertyID { get }

var kAudioConverterPropertyDithering: Int { get }

var kAudioConverterPropertyDithering: AudioConverterPropertyID { get }

var kAudioConverterPropertyFormatList: Int { get }

var kAudioConverterPropertyFormatList: AudioConverterPropertyID { get }

var kAudioConverterPropertyInputCodecParameters: Int { get }

var kAudioConverterPropertyInputCodecParameters: AudioConverterPropertyID { get }

var kAudioConverterPropertyMaximumInputBufferSize: Int { get }

var kAudioConverterPropertyMaximumInputBufferSize: AudioConverterPropertyID { get }

var kAudioConverterPropertyMaximumInputPacketSize: Int { get }

var kAudioConverterPropertyMaximumInputPacketSize: AudioConverterPropertyID { get }

var kAudioConverterPropertyMaximumOutputPacketSize: Int { get }

var kAudioConverterPropertyMaximumOutputPacketSize: AudioConverterPropertyID { get }

var kAudioConverterPropertyMinimumInputBufferSize: Int { get }

var kAudioConverterPropertyMinimumInputBufferSize: AudioConverterPropertyID { get }

var kAudioConverterPropertyMinimumOutputBufferSize: Int { get }

var kAudioConverterPropertyMinimumOutputBufferSize: AudioConverterPropertyID { get }

var kAudioConverterPropertyOutputCodecParameters: Int { get }

var kAudioConverterPropertyOutputCodecParameters: AudioConverterPropertyID { get }

var kAudioConverterPropertySettings: Int { get }

var kAudioConverterPropertySettings: AudioConverterPropertyID { get }

var kAudioConverterQuality_High: Int { get }

var kAudioConverterQuality_High: UInt32 { get }

var kAudioConverterQuality_Low: Int { get }

var kAudioConverterQuality_Low: UInt32 { get }

var kAudioConverterQuality_Max: Int { get }

var kAudioConverterQuality_Max: UInt32 { get }

var kAudioConverterQuality_Medium: Int { get }

var kAudioConverterQuality_Medium: UInt32 { get }

var kAudioConverterQuality_Min: Int { get }

var kAudioConverterQuality_Min: UInt32 { get }

var kAudioConverterSampleRateConverterAlgorithm: Int { get }

var kAudioConverterSampleRateConverterAlgorithm: AudioConverterPropertyID { get }

var kAudioConverterSampleRateConverterComplexity: Int { get }

var kAudioConverterSampleRateConverterComplexity: AudioConverterPropertyID { get }

var kAudioConverterSampleRateConverterComplexity_Linear: Int { get }

var kAudioConverterSampleRateConverterComplexity_Linear: UInt32 { get }

var kAudioConverterSampleRateConverterComplexity_Mastering: Int { get }

var kAudioConverterSampleRateConverterComplexity_Mastering: UInt32 { get }

var kAudioConverterSampleRateConverterComplexity_Normal: Int { get }

var kAudioConverterSampleRateConverterComplexity_Normal: UInt32 { get }

var kAudioConverterSampleRateConverterInitialPhase: Int { get }

var kAudioConverterSampleRateConverterInitialPhase: AudioConverterPropertyID { get }

var kAudioConverterSampleRateConverterQuality: Int { get }

var kAudioConverterSampleRateConverterQuality: AudioConverterPropertyID { get }

var kAudioFile3GP2Type: Int { get }

var kAudioFile3GP2Type: AudioFileTypeID { get }

var kAudioFile3GPType: Int { get }

var kAudioFile3GPType: AudioFileTypeID { get }

var kAudioFileAAC_ADTSType: Int { get }

var kAudioFileAAC_ADTSType: AudioFileTypeID { get }

var kAudioFileAC3Type: Int { get }

var kAudioFileAC3Type: AudioFileTypeID { get }

var kAudioFileAIFCType: Int { get }

var kAudioFileAIFCType: AudioFileTypeID { get }

var kAudioFileAIFFType: Int { get }

var kAudioFileAIFFType: AudioFileTypeID { get }

var kAudioFileAMRType: Int { get }

var kAudioFileAMRType: AudioFileTypeID { get }

var kAudioFileBadPropertySizeError: Int { get }

var kAudioFileBadPropertySizeError: OSStatus { get }

var kAudioFileCAFType: Int { get }

var kAudioFileCAFType: AudioFileTypeID { get }

var kAudioFileComponent_AvailableFormatIDs: Int { get }

var kAudioFileComponent_AvailableFormatIDs: AudioFilePropertyID { get }

var kAudioFileComponent_AvailableStreamDescriptionsForFormat: Int { get }

var kAudioFileComponent_AvailableStreamDescriptionsForFormat: AudioFilePropertyID { get }

var kAudioFileComponent_CanRead: Int { get }

var kAudioFileComponent_CanRead: AudioFilePropertyID { get }

var kAudioFileComponent_CanWrite: Int { get }

var kAudioFileComponent_CanWrite: AudioFilePropertyID { get }

var kAudioFileComponent_ExtensionsForType: Int { get }

var kAudioFileComponent_ExtensionsForType: AudioFilePropertyID { get }

var kAudioFileComponent_FastDispatchTable: Int { get }

var kAudioFileComponent_FastDispatchTable: AudioFilePropertyID { get }

var kAudioFileComponent_FileTypeName: Int { get }

var kAudioFileComponent_FileTypeName: AudioFilePropertyID { get }

var kAudioFileComponent_HFSTypeCodesForType: Int { get }

var kAudioFileComponent_HFSTypeCodesForType: AudioFilePropertyID { get }

var kAudioFileComponent_MIMETypesForType: Int { get }

var kAudioFileComponent_MIMETypesForType: AudioFilePropertyID { get }

var kAudioFileComponent_UTIsForType: Int { get }

var kAudioFileComponent_UTIsForType: AudioFilePropertyID { get }

var kAudioFileDoesNotAllow64BitDataSizeError: Int { get }

var kAudioFileDoesNotAllow64BitDataSizeError: OSStatus { get }

var kAudioFileEndOfFileError: Int { get }

var kAudioFileEndOfFileError: OSStatus { get }

var kAudioFileFileNotFoundError: Int { get }

var kAudioFileFileNotFoundError: OSStatus { get }

var kAudioFileGlobalInfo_AllExtensions: Int { get }

var kAudioFileGlobalInfo_AllExtensions: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_AllHFSTypeCodes: Int { get }

var kAudioFileGlobalInfo_AllHFSTypeCodes: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_AllMIMETypes: Int { get }

var kAudioFileGlobalInfo_AllMIMETypes: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_AllUTIs: Int { get }

var kAudioFileGlobalInfo_AllUTIs: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_AvailableFormatIDs: Int { get }

var kAudioFileGlobalInfo_AvailableFormatIDs: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_AvailableStreamDescriptionsForFormat: Int { get }

var kAudioFileGlobalInfo_AvailableStreamDescriptionsForFormat: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_ExtensionsForType: Int { get }

var kAudioFileGlobalInfo_ExtensionsForType: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_FileTypeName: Int { get }

var kAudioFileGlobalInfo_FileTypeName: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_HFSTypeCodesForType: Int { get }

var kAudioFileGlobalInfo_HFSTypeCodesForType: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_MIMETypesForType: Int { get }

var kAudioFileGlobalInfo_MIMETypesForType: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_ReadableTypes: Int { get }

var kAudioFileGlobalInfo_ReadableTypes: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_TypesForExtension: Int { get }

var kAudioFileGlobalInfo_TypesForExtension: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_TypesForHFSTypeCode: Int { get }

var kAudioFileGlobalInfo_TypesForHFSTypeCode: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_TypesForMIMEType: Int { get }

var kAudioFileGlobalInfo_TypesForMIMEType: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_TypesForUTI: Int { get }

var kAudioFileGlobalInfo_TypesForUTI: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_UTIsForType: Int { get }

var kAudioFileGlobalInfo_UTIsForType: AudioFilePropertyID { get }

var kAudioFileGlobalInfo_WritableTypes: Int { get }

var kAudioFileGlobalInfo_WritableTypes: AudioFilePropertyID { get }

var kAudioFileInvalidChunkError: Int { get }

var kAudioFileInvalidChunkError: OSStatus { get }

var kAudioFileInvalidFileError: Int { get }

var kAudioFileInvalidFileError: OSStatus { get }

var kAudioFileInvalidPacketOffsetError: Int { get }

var kAudioFileInvalidPacketOffsetError: OSStatus { get }

var kAudioFileLoopDirection_Backward: Int { get }

var kAudioFileLoopDirection_Backward: UInt32 { get }

var kAudioFileLoopDirection_Forward: Int { get }

var kAudioFileLoopDirection_Forward: UInt32 { get }

var kAudioFileLoopDirection_ForwardAndBackward: Int { get }

var kAudioFileLoopDirection_ForwardAndBackward: UInt32 { get }

var kAudioFileLoopDirection_NoLooping: Int { get }

var kAudioFileLoopDirection_NoLooping: UInt32 { get }

var kAudioFileM4AType: Int { get }

var kAudioFileM4AType: AudioFileTypeID { get }

var kAudioFileM4BType: Int { get }

var kAudioFileM4BType: AudioFileTypeID { get }

var kAudioFileMarkerType_Generic: Int { get }

var kAudioFileMarkerType_Generic: UInt32 { get }

var kAudioFileMP1Type: Int { get }

var kAudioFileMP1Type: AudioFileTypeID { get }

var kAudioFileMP2Type: Int { get }

var kAudioFileMP2Type: AudioFileTypeID { get }

var kAudioFileMP3Type: Int { get }

var kAudioFileMP3Type: AudioFileTypeID { get }

var kAudioFileMPEG4Type: Int { get }

var kAudioFileMPEG4Type: AudioFileTypeID { get }

var kAudioFileNextType: Int { get }

var kAudioFileNextType: AudioFileTypeID { get }

var kAudioFileNotOpenError: Int { get }

var kAudioFileNotOpenError: OSStatus { get }

var kAudioFileNotOptimizedError: Int { get }

var kAudioFileNotOptimizedError: OSStatus { get }

var kAudioFileOperationNotSupportedError: Int { get }

var kAudioFileOperationNotSupportedError: OSStatus { get }

var kAudioFilePermissionsError: Int { get }

var kAudioFilePermissionsError: OSStatus { get }

var kAudioFilePositionError: Int { get }

var kAudioFilePositionError: OSStatus { get }

var kAudioFilePropertyAlbumArtwork: Int { get }

var kAudioFilePropertyAlbumArtwork: AudioFilePropertyID { get }

var kAudioFilePropertyAudioDataByteCount: Int { get }

var kAudioFilePropertyAudioDataByteCount: AudioFilePropertyID { get }

var kAudioFilePropertyAudioDataPacketCount: Int { get }

var kAudioFilePropertyAudioDataPacketCount: AudioFilePropertyID { get }

var kAudioFilePropertyAudioTrackCount: Int { get }

var kAudioFilePropertyAudioTrackCount: AudioFilePropertyID { get }

var kAudioFilePropertyBitRate: Int { get }

var kAudioFilePropertyBitRate: AudioFilePropertyID { get }

var kAudioFilePropertyByteToPacket: Int { get }

var kAudioFilePropertyByteToPacket: AudioFilePropertyID { get }

var kAudioFilePropertyChannelLayout: Int { get }

var kAudioFilePropertyChannelLayout: AudioFilePropertyID { get }

var kAudioFilePropertyChunkIDs: Int { get }

var kAudioFilePropertyChunkIDs: AudioFilePropertyID { get }

var kAudioFilePropertyDataFormat: Int { get }

var kAudioFilePropertyDataFormat: AudioFilePropertyID { get }

var kAudioFilePropertyDataFormatName: Int { get }

var kAudioFilePropertyDataFormatName: AudioFilePropertyID { get }

var kAudioFilePropertyDataOffset: Int { get }

var kAudioFilePropertyDataOffset: AudioFilePropertyID { get }

var kAudioFilePropertyDeferSizeUpdates: Int { get }

var kAudioFilePropertyDeferSizeUpdates: AudioFilePropertyID { get }

var kAudioFilePropertyEstimatedDuration: Int { get }

var kAudioFilePropertyEstimatedDuration: AudioFilePropertyID { get }

var kAudioFilePropertyFileFormat: Int { get }

var kAudioFilePropertyFileFormat: AudioFilePropertyID { get }

var kAudioFilePropertyFormatList: Int { get }

var kAudioFilePropertyFormatList: AudioFilePropertyID { get }

var kAudioFilePropertyFrameToPacket: Int { get }

var kAudioFilePropertyFrameToPacket: AudioFilePropertyID { get }

var kAudioFilePropertyID3Tag: Int { get }

var kAudioFilePropertyID3Tag: AudioFilePropertyID { get }

var kAudioFilePropertyInfoDictionary: Int { get }

var kAudioFilePropertyInfoDictionary: AudioFilePropertyID { get }

var kAudioFilePropertyIsOptimized: Int { get }

var kAudioFilePropertyIsOptimized: AudioFilePropertyID { get }

var kAudioFilePropertyMagicCookieData: Int { get }

var kAudioFilePropertyMagicCookieData: AudioFilePropertyID { get }

var kAudioFilePropertyMarkerList: Int { get }

var kAudioFilePropertyMarkerList: AudioFilePropertyID { get }

var kAudioFilePropertyMaximumPacketSize: Int { get }

var kAudioFilePropertyMaximumPacketSize: AudioFilePropertyID { get }

var kAudioFilePropertyPacketSizeUpperBound: Int { get }

var kAudioFilePropertyPacketSizeUpperBound: AudioFilePropertyID { get }

var kAudioFilePropertyPacketTableInfo: Int { get }

var kAudioFilePropertyPacketTableInfo: AudioFilePropertyID { get }

var kAudioFilePropertyPacketToByte: Int { get }

var kAudioFilePropertyPacketToByte: AudioFilePropertyID { get }

var kAudioFilePropertyPacketToFrame: Int { get }

var kAudioFilePropertyPacketToFrame: AudioFilePropertyID { get }

var kAudioFilePropertyRegionList: Int { get }

var kAudioFilePropertyRegionList: AudioFilePropertyID { get }

var kAudioFilePropertyReserveDuration: Int { get }

var kAudioFilePropertyReserveDuration: AudioFilePropertyID { get }

var kAudioFilePropertySourceBitDepth: Int { get }

var kAudioFilePropertySourceBitDepth: AudioFilePropertyID { get }

var kAudioFilePropertyUseAudioTrack: Int { get }

var kAudioFilePropertyUseAudioTrack: AudioFilePropertyID { get }

var kAudioFileSoundDesigner2Type: Int { get }

var kAudioFileSoundDesigner2Type: AudioFileTypeID { get }

var kAudioFileStreamError_BadPropertySize: Int { get }

var kAudioFileStreamError_BadPropertySize: OSStatus { get }

var kAudioFileStreamError_DataUnavailable: Int { get }

var kAudioFileStreamError_DataUnavailable: OSStatus { get }

var kAudioFileStreamError_DiscontinuityCantRecover: Int { get }

var kAudioFileStreamError_DiscontinuityCantRecover: OSStatus { get }

var kAudioFileStreamError_IllegalOperation: Int { get }

var kAudioFileStreamError_IllegalOperation: OSStatus { get }

var kAudioFileStreamError_InvalidFile: Int { get }

var kAudioFileStreamError_InvalidFile: OSStatus { get }

var kAudioFileStreamError_InvalidPacketOffset: Int { get }

var kAudioFileStreamError_InvalidPacketOffset: OSStatus { get }

var kAudioFileStreamError_NotOptimized: Int { get }

var kAudioFileStreamError_NotOptimized: OSStatus { get }

var kAudioFileStreamError_UnspecifiedError: Int { get }

var kAudioFileStreamError_UnspecifiedError: OSStatus { get }

var kAudioFileStreamError_UnsupportedDataFormat: Int { get }

var kAudioFileStreamError_UnsupportedDataFormat: OSStatus { get }

var kAudioFileStreamError_UnsupportedFileType: Int { get }

var kAudioFileStreamError_UnsupportedFileType: OSStatus { get }

var kAudioFileStreamError_UnsupportedProperty: Int { get }

var kAudioFileStreamError_UnsupportedProperty: OSStatus { get }

var kAudioFileStreamError_ValueUnknown: Int { get }

var kAudioFileStreamError_ValueUnknown: OSStatus { get }

var kAudioFileStreamProperty_AudioDataByteCount: Int { get }

var kAudioFileStreamProperty_AudioDataByteCount: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_AudioDataPacketCount: Int { get }

var kAudioFileStreamProperty_AudioDataPacketCount: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_AverageBytesPerPacket: Int { get }

var kAudioFileStreamProperty_AverageBytesPerPacket: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_BitRate: Int { get }

var kAudioFileStreamProperty_BitRate: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_ByteToPacket: Int { get }

var kAudioFileStreamProperty_ByteToPacket: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_ChannelLayout: Int { get }

var kAudioFileStreamProperty_ChannelLayout: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_DataFormat: Int { get }

var kAudioFileStreamProperty_DataFormat: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_DataOffset: Int { get }

var kAudioFileStreamProperty_DataOffset: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_FileFormat: Int { get }

var kAudioFileStreamProperty_FileFormat: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_FormatList: Int { get }

var kAudioFileStreamProperty_FormatList: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_FrameToPacket: Int { get }

var kAudioFileStreamProperty_FrameToPacket: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_InfoDictionary: Int { get }

var kAudioFileStreamProperty_InfoDictionary: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_MagicCookieData: Int { get }

var kAudioFileStreamProperty_MagicCookieData: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_MaximumPacketSize: Int { get }

var kAudioFileStreamProperty_MaximumPacketSize: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_PacketSizeUpperBound: Int { get }

var kAudioFileStreamProperty_PacketSizeUpperBound: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_PacketTableInfo: Int { get }

var kAudioFileStreamProperty_PacketTableInfo: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_PacketToByte: Int { get }

var kAudioFileStreamProperty_PacketToByte: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_PacketToFrame: Int { get }

var kAudioFileStreamProperty_PacketToFrame: AudioFileStreamPropertyID { get }

var kAudioFileStreamProperty_ReadyToProducePackets: Int { get }

var kAudioFileStreamProperty_ReadyToProducePackets: AudioFileStreamPropertyID { get }

var kAudioFileUnspecifiedError: Int { get }

var kAudioFileUnspecifiedError: OSStatus { get }

var kAudioFileUnsupportedDataFormatError: Int { get }

var kAudioFileUnsupportedDataFormatError: OSStatus { get }

var kAudioFileUnsupportedFileTypeError: Int { get }

var kAudioFileUnsupportedFileTypeError: OSStatus { get }

var kAudioFileUnsupportedPropertyError: Int { get }

var kAudioFileUnsupportedPropertyError: OSStatus { get }

var kAudioFileWAVEType: Int { get }

var kAudioFileWAVEType: AudioFileTypeID { get }

var kAudioFormatBadPropertySizeError: Int { get }

var kAudioFormatBadPropertySizeError: OSStatus { get }

var kAudioFormatBadSpecifierSizeError: Int { get }

var kAudioFormatBadSpecifierSizeError: OSStatus { get }

var kAudioFormatProperty_AreChannelLayoutsEquivalent: Int { get }

var kAudioFormatProperty_AreChannelLayoutsEquivalent: AudioFormatPropertyID { get }

var kAudioFormatProperty_ASBDFromESDS: Int { get }

var kAudioFormatProperty_ASBDFromESDS: AudioFormatPropertyID { get }

var kAudioFormatProperty_ASBDFromMPEGPacket: Int { get }

var kAudioFormatProperty_ASBDFromMPEGPacket: AudioFormatPropertyID { get }

var kAudioFormatProperty_AvailableEncodeBitRates: Int { get }

var kAudioFormatProperty_AvailableEncodeBitRates: AudioFormatPropertyID { get }

var kAudioFormatProperty_AvailableEncodeChannelLayoutTags: Int { get }

var kAudioFormatProperty_AvailableEncodeChannelLayoutTags: AudioFormatPropertyID { get }

var kAudioFormatProperty_AvailableEncodeNumberChannels: Int { get }

var kAudioFormatProperty_AvailableEncodeNumberChannels: AudioFormatPropertyID { get }

var kAudioFormatProperty_AvailableEncodeSampleRates: Int { get }

var kAudioFormatProperty_AvailableEncodeSampleRates: AudioFormatPropertyID { get }

var kAudioFormatProperty_BalanceFade: Int { get }

var kAudioFormatProperty_BalanceFade: AudioFormatPropertyID { get }

var kAudioFormatProperty_BitmapForLayoutTag: Int { get }

var kAudioFormatProperty_BitmapForLayoutTag: AudioFormatPropertyID { get }

var kAudioFormatProperty_ChannelLayoutForBitmap: Int { get }

var kAudioFormatProperty_ChannelLayoutForBitmap: AudioFormatPropertyID { get }

var kAudioFormatProperty_ChannelLayoutForTag: Int { get }

var kAudioFormatProperty_ChannelLayoutForTag: AudioFormatPropertyID { get }

var kAudioFormatProperty_ChannelLayoutFromESDS: Int { get }

var kAudioFormatProperty_ChannelLayoutFromESDS: AudioFormatPropertyID { get }

var kAudioFormatProperty_ChannelLayoutHash: Int { get }

var kAudioFormatProperty_ChannelLayoutHash: AudioFormatPropertyID { get }

var kAudioFormatProperty_ChannelLayoutName: Int { get }

var kAudioFormatProperty_ChannelLayoutName: AudioFormatPropertyID { get }

var kAudioFormatProperty_ChannelLayoutSimpleName: Int { get }

var kAudioFormatProperty_ChannelLayoutSimpleName: AudioFormatPropertyID { get }

var kAudioFormatProperty_ChannelMap: Int { get }

var kAudioFormatProperty_ChannelMap: AudioFormatPropertyID { get }

var kAudioFormatProperty_ChannelName: Int { get }

var kAudioFormatProperty_ChannelName: AudioFormatPropertyID { get }

var kAudioFormatProperty_ChannelShortName: Int { get }

var kAudioFormatProperty_ChannelShortName: AudioFormatPropertyID { get }

var kAudioFormatProperty_DecodeFormatIDs: Int { get }

var kAudioFormatProperty_DecodeFormatIDs: AudioFormatPropertyID { get }

var kAudioFormatProperty_Decoders: Int { get }

var kAudioFormatProperty_Decoders: AudioFormatPropertyID { get }

var kAudioFormatProperty_EncodeFormatIDs: Int { get }

var kAudioFormatProperty_EncodeFormatIDs: AudioFormatPropertyID { get }

var kAudioFormatProperty_Encoders: Int { get }

var kAudioFormatProperty_Encoders: AudioFormatPropertyID { get }

var kAudioFormatProperty_FirstPlayableFormatFromList: Int { get }

var kAudioFormatProperty_FirstPlayableFormatFromList: AudioFormatPropertyID { get }

var kAudioFormatProperty_FormatInfo: Int { get }

var kAudioFormatProperty_FormatInfo: AudioFormatPropertyID { get }

var kAudioFormatProperty_FormatIsEncrypted: Int { get }

var kAudioFormatProperty_FormatIsEncrypted: AudioFormatPropertyID { get }

var kAudioFormatProperty_FormatIsExternallyFramed: Int { get }

var kAudioFormatProperty_FormatIsExternallyFramed: AudioFormatPropertyID { get }

var kAudioFormatProperty_FormatIsVBR: Int { get }

var kAudioFormatProperty_FormatIsVBR: AudioFormatPropertyID { get }

var kAudioFormatProperty_FormatList: Int { get }

var kAudioFormatProperty_FormatList: AudioFormatPropertyID { get }

var kAudioFormatProperty_FormatName: Int { get }

var kAudioFormatProperty_FormatName: AudioFormatPropertyID { get }

var kAudioFormatProperty_ID3TagSize: Int { get }

var kAudioFormatProperty_ID3TagSize: AudioFormatPropertyID { get }

var kAudioFormatProperty_ID3TagToDictionary: Int { get }

var kAudioFormatProperty_ID3TagToDictionary: AudioFormatPropertyID { get }

var kAudioFormatProperty_MatrixMixMap: Int { get }

var kAudioFormatProperty_MatrixMixMap: AudioFormatPropertyID { get }

var kAudioFormatProperty_NumberOfChannelsForLayout: Int { get }

var kAudioFormatProperty_NumberOfChannelsForLayout: AudioFormatPropertyID { get }

var kAudioFormatProperty_OutputFormatList: Int { get }

var kAudioFormatProperty_OutputFormatList: AudioFormatPropertyID { get }

var kAudioFormatProperty_PanningMatrix: Int { get }

var kAudioFormatProperty_PanningMatrix: AudioFormatPropertyID { get }

var kAudioFormatProperty_TagForChannelLayout: Int { get }

var kAudioFormatProperty_TagForChannelLayout: AudioFormatPropertyID { get }

var kAudioFormatProperty_TagsForNumberOfChannels: Int { get }

var kAudioFormatProperty_TagsForNumberOfChannels: AudioFormatPropertyID { get }

var kAudioFormatProperty_ValidateChannelLayout: Int { get }

var kAudioFormatProperty_ValidateChannelLayout: AudioFormatPropertyID { get }

var kAudioFormatUnknownFormatError: Int { get }

var kAudioFormatUnknownFormatError: OSStatus { get }

var kAudioFormatUnspecifiedError: Int { get }

var kAudioFormatUnspecifiedError: OSStatus { get }

var kAudioFormatUnsupportedDataFormatError: Int { get }

var kAudioFormatUnsupportedDataFormatError: OSStatus { get }

var kAudioFormatUnsupportedPropertyError: Int { get }

var kAudioFormatUnsupportedPropertyError: OSStatus { get }

var kAudioHardwareServiceDeviceProperty_VirtualMasterBalance: Int { get }

var kAudioHardwareServiceDeviceProperty_VirtualMasterBalance: AudioObjectPropertySelector { get }

var kAudioHardwareServiceDeviceProperty_VirtualMasterVolume: Int { get }

var kAudioHardwareServiceDeviceProperty_VirtualMasterVolume: AudioObjectPropertySelector { get }

var kAudioHardwareServiceProperty_ServiceRestarted: Int { get }

var kAudioHardwareServiceProperty_ServiceRestarted: AudioObjectPropertySelector { get }

var kAudioQueueDeviceProperty_NumberChannels: Int { get }

var kAudioQueueDeviceProperty_NumberChannels: AudioQueuePropertyID { get }

var kAudioQueueDeviceProperty_SampleRate: Int { get }

var kAudioQueueDeviceProperty_SampleRate: AudioQueuePropertyID { get }

var kAudioQueueErr_BufferEmpty: Int { get }

var kAudioQueueErr_BufferEmpty: OSStatus { get }

var kAudioQueueErr_BufferEnqueuedTwice: Int { get }

var kAudioQueueErr_BufferEnqueuedTwice: OSStatus { get }

var kAudioQueueErr_BufferInQueue: Int { get }

var kAudioQueueErr_BufferInQueue: OSStatus { get }

var kAudioQueueErr_CannotStart: Int { get }

var kAudioQueueErr_CannotStart: OSStatus { get }

var kAudioQueueErr_CodecNotFound: Int { get }

var kAudioQueueErr_CodecNotFound: OSStatus { get }

var kAudioQueueErr_DisposalPending: Int { get }

var kAudioQueueErr_DisposalPending: OSStatus { get }

var kAudioQueueErr_EnqueueDuringReset: Int { get }

var kAudioQueueErr_EnqueueDuringReset: OSStatus { get }

var kAudioQueueErr_InvalidBuffer: Int { get }

var kAudioQueueErr_InvalidBuffer: OSStatus { get }

var kAudioQueueErr_InvalidCodecAccess: Int { get }

var kAudioQueueErr_InvalidCodecAccess: OSStatus { get }

var kAudioQueueErr_InvalidDevice: Int { get }

var kAudioQueueErr_InvalidDevice: OSStatus { get }

var kAudioQueueErr_InvalidOfflineMode: Int { get }

var kAudioQueueErr_InvalidOfflineMode: OSStatus { get }

var kAudioQueueErr_InvalidParameter: Int { get }

var kAudioQueueErr_InvalidParameter: OSStatus { get }

var kAudioQueueErr_InvalidProperty: Int { get }

var kAudioQueueErr_InvalidProperty: OSStatus { get }

var kAudioQueueErr_InvalidPropertySize: Int { get }

var kAudioQueueErr_InvalidPropertySize: OSStatus { get }

var kAudioQueueErr_InvalidPropertyValue: Int { get }

var kAudioQueueErr_InvalidPropertyValue: OSStatus { get }

var kAudioQueueErr_InvalidQueueType: Int { get }

var kAudioQueueErr_InvalidQueueType: OSStatus { get }

var kAudioQueueErr_InvalidRunState: Int { get }

var kAudioQueueErr_InvalidRunState: OSStatus { get }

var kAudioQueueErr_InvalidTapContext: Int { get }

var kAudioQueueErr_InvalidTapContext: OSStatus { get }

var kAudioQueueErr_InvalidTapType: Int { get }

var kAudioQueueErr_InvalidTapType: OSStatus { get }

var kAudioQueueErr_Permissions: Int { get }

var kAudioQueueErr_Permissions: OSStatus { get }

var kAudioQueueErr_PrimeTimedOut: Int { get }

var kAudioQueueErr_PrimeTimedOut: OSStatus { get }

var kAudioQueueErr_QueueInvalidated: Int { get }

var kAudioQueueErr_QueueInvalidated: OSStatus { get }

var kAudioQueueErr_RecordUnderrun: Int { get }

var kAudioQueueErr_RecordUnderrun: OSStatus { get }

var kAudioQueueErr_TooManyTaps: Int { get }

var kAudioQueueErr_TooManyTaps: OSStatus { get }

var kAudioQueueParam_Pan: Int { get }

var kAudioQueueParam_Pan: AudioQueueParameterID { get }

var kAudioQueueParam_Pitch: Int { get }

var kAudioQueueParam_Pitch: AudioQueueParameterID { get }

var kAudioQueueParam_PlayRate: Int { get }

var kAudioQueueParam_PlayRate: AudioQueueParameterID { get }

var kAudioQueueParam_Volume: Int { get }

var kAudioQueueParam_Volume: AudioQueueParameterID { get }

var kAudioQueueParam_VolumeRampTime: Int { get }

var kAudioQueueParam_VolumeRampTime: AudioQueueParameterID { get }

var kAudioQueueProperty_ChannelLayout: Int { get }

var kAudioQueueProperty_ChannelLayout: AudioQueuePropertyID { get }

var kAudioQueueProperty_ConverterError: Int { get }

var kAudioQueueProperty_ConverterError: AudioQueuePropertyID { get }

var kAudioQueueProperty_CurrentDevice: Int { get }

var kAudioQueueProperty_CurrentDevice: AudioQueuePropertyID { get }

var kAudioQueueProperty_CurrentLevelMeter: Int { get }

var kAudioQueueProperty_CurrentLevelMeter: AudioQueuePropertyID { get }

var kAudioQueueProperty_CurrentLevelMeterDB: Int { get }

var kAudioQueueProperty_CurrentLevelMeterDB: AudioQueuePropertyID { get }

var kAudioQueueProperty_DecodeBufferSizeFrames: Int { get }

var kAudioQueueProperty_DecodeBufferSizeFrames: AudioQueuePropertyID { get }

var kAudioQueueProperty_EnableLevelMetering: Int { get }

var kAudioQueueProperty_EnableLevelMetering: AudioQueuePropertyID { get }

var kAudioQueueProperty_EnableTimePitch: Int { get }

var kAudioQueueProperty_EnableTimePitch: AudioQueuePropertyID { get }

var kAudioQueueProperty_IsRunning: Int { get }

var kAudioQueueProperty_IsRunning: AudioQueuePropertyID { get }

var kAudioQueueProperty_MagicCookie: Int { get }

var kAudioQueueProperty_MagicCookie: AudioQueuePropertyID { get }

var kAudioQueueProperty_MaximumOutputPacketSize: Int { get }

var kAudioQueueProperty_MaximumOutputPacketSize: AudioQueuePropertyID { get }

var kAudioQueueProperty_StreamDescription: Int { get }

var kAudioQueueProperty_StreamDescription: AudioQueuePropertyID { get }

var kAudioQueueProperty_TimePitchAlgorithm: Int { get }

var kAudioQueueProperty_TimePitchAlgorithm: AudioQueuePropertyID { get }

var kAudioQueueProperty_TimePitchBypass: Int { get }

var kAudioQueueProperty_TimePitchBypass: AudioQueuePropertyID { get }

var kAudioQueueTimePitchAlgorithm_Spectral: Int { get }

var kAudioQueueTimePitchAlgorithm_Spectral: UInt32 { get }

var kAudioQueueTimePitchAlgorithm_TimeDomain: Int { get }

var kAudioQueueTimePitchAlgorithm_TimeDomain: UInt32 { get }

var kAudioQueueTimePitchAlgorithm_Varispeed: Int { get }

var kAudioQueueTimePitchAlgorithm_Varispeed: UInt32 { get }

var kAudioServicesBadPropertySizeError: Int { get }

var kAudioServicesBadPropertySizeError: OSStatus { get }

var kAudioServicesBadSpecifierSizeError: Int { get }

var kAudioServicesBadSpecifierSizeError: OSStatus { get }

var kAudioServicesNoError: Int { get }

var kAudioServicesNoError: OSStatus { get }

var kAudioServicesPropertyCompletePlaybackIfAppDies: Int { get }

var kAudioServicesPropertyCompletePlaybackIfAppDies: AudioServicesPropertyID { get }

var kAudioServicesPropertyIsUISound: Int { get }

var kAudioServicesPropertyIsUISound: AudioServicesPropertyID { get }

var kAudioServicesSystemSoundClientTimedOutError: Int { get }

var kAudioServicesSystemSoundClientTimedOutError: OSStatus { get }

var kAudioServicesSystemSoundUnspecifiedError: Int { get }

var kAudioServicesSystemSoundUnspecifiedError: OSStatus { get }

var kAudioServicesUnsupportedPropertyError: Int { get }

var kAudioServicesUnsupportedPropertyError: OSStatus { get }

var kAudioToolboxErr_CannotDoInCurrentContext: Int { get }

var kAudioToolboxErr_CannotDoInCurrentContext: OSStatus { get }

var kAudioToolboxErr_EndOfTrack: Int { get }

var kAudioToolboxErr_EndOfTrack: OSStatus { get }

var kAudioToolboxErr_IllegalTrackDestination: Int { get }

var kAudioToolboxErr_IllegalTrackDestination: OSStatus { get }

var kAudioToolboxErr_InvalidEventType: Int { get }

var kAudioToolboxErr_InvalidEventType: OSStatus { get }

var kAudioToolboxErr_InvalidPlayerState: Int { get }

var kAudioToolboxErr_InvalidPlayerState: OSStatus { get }

var kAudioToolboxErr_InvalidSequenceType: Int { get }

var kAudioToolboxErr_InvalidSequenceType: OSStatus { get }

var kAudioToolboxErr_NoSequence: Int { get }

var kAudioToolboxErr_NoSequence: OSStatus { get }

var kAudioToolboxErr_StartOfTrack: Int { get }

var kAudioToolboxErr_StartOfTrack: OSStatus { get }

var kAudioToolboxErr_TrackIndexError: Int { get }

var kAudioToolboxErr_TrackIndexError: OSStatus { get }

var kAudioToolboxErr_TrackNotFound: Int { get }

var kAudioToolboxErr_TrackNotFound: OSStatus { get }

var kAUGraphErr_CannotDoInCurrentContext: Int { get }

var kAUGraphErr_CannotDoInCurrentContext: OSStatus { get }

var kAUGraphErr_InvalidAudioUnit: Int { get }

var kAUGraphErr_InvalidAudioUnit: OSStatus { get }

var kAUGraphErr_InvalidConnection: Int { get }

var kAUGraphErr_InvalidConnection: OSStatus { get }

var kAUGraphErr_NodeNotFound: Int { get }

var kAUGraphErr_NodeNotFound: OSStatus { get }

var kAUGraphErr_OutputNodeErr: Int { get }

var kAUGraphErr_OutputNodeErr: OSStatus { get }

var kAUNodeInteraction_Connection: Int { get }

var kAUNodeInteraction_Connection: UInt32 { get }

var kAUNodeInteraction_InputCallback: Int { get }

var kAUNodeInteraction_InputCallback: UInt32 { get }

var kAUParameterListener_AnyParameter: UInt32 { get }

var kAUParameterListener_AnyParameter: AudioUnitParameterID { get }

var kCAClock_CannotSetTimeError: Int { get }

var kCAClock_CannotSetTimeError: OSStatus { get }

var kCAClock_InvalidPlayRateError: Int { get }

var kCAClock_InvalidPlayRateError: OSStatus { get }

var kCAClock_InvalidPropertySizeError: Int { get }

var kCAClock_InvalidPropertySizeError: OSStatus { get }

var kCAClock_InvalidSMPTEFormatError: Int { get }

var kCAClock_InvalidSMPTEFormatError: OSStatus { get }

var kCAClock_InvalidSMPTEOffsetError: Int { get }

var kCAClock_InvalidSMPTEOffsetError: OSStatus { get }

var kCAClock_InvalidSyncModeError: Int { get }

var kCAClock_InvalidSyncModeError: OSStatus { get }

var kCAClock_InvalidSyncSourceError: Int { get }

var kCAClock_InvalidSyncSourceError: OSStatus { get }

var kCAClock_InvalidTimebaseError: Int { get }

var kCAClock_InvalidTimebaseError: OSStatus { get }

var kCAClock_InvalidTimebaseSourceError: Int { get }

var kCAClock_InvalidTimebaseSourceError: OSStatus { get }

var kCAClock_InvalidTimeFormatError: Int { get }

var kCAClock_InvalidTimeFormatError: OSStatus { get }

var kCAClock_InvalidUnitError: Int { get }

var kCAClock_InvalidUnitError: OSStatus { get }

var kCAClock_UnknownPropertyError: Int { get }

var kCAClock_UnknownPropertyError: OSStatus { get }

var kCAF_AudioDataChunkID: Int { get }

var kCAF_AudioDataChunkID: UInt32 { get }

var kCAF_ChannelLayoutChunkID: Int { get }

var kCAF_ChannelLayoutChunkID: UInt32 { get }