struct CFAllocatorContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFAllocatorRetainCallBack
    var release: CFAllocatorReleaseCallBack
    var copyDescription: CFAllocatorCopyDescriptionCallBack
    var allocate: CFAllocatorAllocateCallBack
    var reallocate: CFAllocatorReallocateCallBack
    var deallocate: CFAllocatorDeallocateCallBack
    var preferredSize: CFAllocatorPreferredSizeCallBack
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFAllocatorRetainCallBack, release release: CFAllocatorReleaseCallBack, copyDescription copyDescription: CFAllocatorCopyDescriptionCallBack, allocate allocate: CFAllocatorAllocateCallBack, reallocate reallocate: CFAllocatorReallocateCallBack, deallocate deallocate: CFAllocatorDeallocateCallBack, preferredSize preferredSize: CFAllocatorPreferredSizeCallBack)
}

struct CFAllocatorContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFAllocatorRetainCallBack!
    var release: CFAllocatorReleaseCallBack!
    var copyDescription: CFAllocatorCopyDescriptionCallBack!
    var allocate: CFAllocatorAllocateCallBack!
    var reallocate: CFAllocatorReallocateCallBack!
    var deallocate: CFAllocatorDeallocateCallBack!
    var preferredSize: CFAllocatorPreferredSizeCallBack!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFAllocatorRetainCallBack!, release release: CFAllocatorReleaseCallBack!, copyDescription copyDescription: CFAllocatorCopyDescriptionCallBack!, allocate allocate: CFAllocatorAllocateCallBack!, reallocate reallocate: CFAllocatorReallocateCallBack!, deallocate deallocate: CFAllocatorDeallocateCallBack!, preferredSize preferredSize: CFAllocatorPreferredSizeCallBack!)
}

var allocate: CFAllocatorAllocateCallBack

var allocate: CFAllocatorAllocateCallBack!

var copyDescription: CFAllocatorCopyDescriptionCallBack

var copyDescription: CFAllocatorCopyDescriptionCallBack!

var deallocate: CFAllocatorDeallocateCallBack

var deallocate: CFAllocatorDeallocateCallBack!

var preferredSize: CFAllocatorPreferredSizeCallBack

var preferredSize: CFAllocatorPreferredSizeCallBack!

var reallocate: CFAllocatorReallocateCallBack

var reallocate: CFAllocatorReallocateCallBack!

var release: CFAllocatorReleaseCallBack

var release: CFAllocatorReleaseCallBack!

var retain: CFAllocatorRetainCallBack

var retain: CFAllocatorRetainCallBack!

struct CFArrayCallBacks {
    var version: CFIndex
    var retain: CFArrayRetainCallBack
    var release: CFArrayReleaseCallBack
    var copyDescription: CFArrayCopyDescriptionCallBack
    var equal: CFArrayEqualCallBack
    init()
    init(version version: CFIndex, retain retain: CFArrayRetainCallBack, release release: CFArrayReleaseCallBack, copyDescription copyDescription: CFArrayCopyDescriptionCallBack, equal equal: CFArrayEqualCallBack)
}

struct CFArrayCallBacks {
    var version: CFIndex
    var retain: CFArrayRetainCallBack!
    var release: CFArrayReleaseCallBack!
    var copyDescription: CFArrayCopyDescriptionCallBack!
    var equal: CFArrayEqualCallBack!
    init()
    init(version version: CFIndex, retain retain: CFArrayRetainCallBack!, release release: CFArrayReleaseCallBack!, copyDescription copyDescription: CFArrayCopyDescriptionCallBack!, equal equal: CFArrayEqualCallBack!)
}

var copyDescription: CFArrayCopyDescriptionCallBack

var copyDescription: CFArrayCopyDescriptionCallBack!

var equal: CFArrayEqualCallBack

var equal: CFArrayEqualCallBack!

var release: CFArrayReleaseCallBack

var release: CFArrayReleaseCallBack!

var retain: CFArrayRetainCallBack

var retain: CFArrayRetainCallBack!

struct CFBagCallBacks {
    var version: CFIndex
    var retain: CFBagRetainCallBack
    var release: CFBagReleaseCallBack
    var copyDescription: CFBagCopyDescriptionCallBack
    var equal: CFBagEqualCallBack
    var hash: CFBagHashCallBack
    init()
    init(version version: CFIndex, retain retain: CFBagRetainCallBack, release release: CFBagReleaseCallBack, copyDescription copyDescription: CFBagCopyDescriptionCallBack, equal equal: CFBagEqualCallBack, hash hash: CFBagHashCallBack)
}

struct CFBagCallBacks {
    var version: CFIndex
    var retain: CFBagRetainCallBack!
    var release: CFBagReleaseCallBack!
    var copyDescription: CFBagCopyDescriptionCallBack!
    var equal: CFBagEqualCallBack!
    var hash: CFBagHashCallBack!
    init()
    init(version version: CFIndex, retain retain: CFBagRetainCallBack!, release release: CFBagReleaseCallBack!, copyDescription copyDescription: CFBagCopyDescriptionCallBack!, equal equal: CFBagEqualCallBack!, hash hash: CFBagHashCallBack!)
}

var copyDescription: CFBagCopyDescriptionCallBack

var copyDescription: CFBagCopyDescriptionCallBack!

var equal: CFBagEqualCallBack

var equal: CFBagEqualCallBack!

var hash: CFBagHashCallBack

var hash: CFBagHashCallBack!

var release: CFBagReleaseCallBack

var release: CFBagReleaseCallBack!

var retain: CFBagRetainCallBack

var retain: CFBagRetainCallBack!

struct CFBinaryHeapCallBacks {
    var version: CFIndex
    var retain: CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)>
    var release: CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>
    var compare: CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> CFComparisonResult)>
    init()
    init(version version: CFIndex, retain retain: CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)>, release release: CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>, compare compare: CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> CFComparisonResult)>)
}

struct CFBinaryHeapCallBacks {
    var version: CFIndex
    var retain: ((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)!
    var release: ((CFAllocator!, UnsafePointer<Void>) -> Void)!
    var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!
    var compare: ((UnsafePointer<Void>, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> CFComparisonResult)!
    init()
    init(version version: CFIndex, retain retain: ((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)!, release release: ((CFAllocator!, UnsafePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!, compare compare: ((UnsafePointer<Void>, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> CFComparisonResult)!)
}

var compare: CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> CFComparisonResult)>

var compare: ((UnsafePointer<Void>, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> CFComparisonResult)!

var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!

var release: CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> Void)>

var release: ((CFAllocator!, UnsafePointer<Void>) -> Void)!

var retain: CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)>

var retain: ((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)!

struct CFBinaryHeapCompareContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>
    var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>, release release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>)
}

struct CFBinaryHeapCompareContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!
    var release: ((UnsafePointer<Void>) -> Void)!
    var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!, release release: ((UnsafePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!)
}

var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!

var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>

var release: ((UnsafePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!

struct CFCalendarUnit : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var Era: CFCalendarUnit { get }
    static var Year: CFCalendarUnit { get }
    static var Month: CFCalendarUnit { get }
    static var Day: CFCalendarUnit { get }
    static var Hour: CFCalendarUnit { get }
    static var Minute: CFCalendarUnit { get }
    static var Second: CFCalendarUnit { get }
    static var Week: CFCalendarUnit { get }
    static var Weekday: CFCalendarUnit { get }
    static var WeekdayOrdinal: CFCalendarUnit { get }
    static var Quarter: CFCalendarUnit { get }
    static var WeekOfMonth: CFCalendarUnit { get }
    static var WeekOfYear: CFCalendarUnit { get }
    static var YearForWeekOfYear: CFCalendarUnit { get }
}

struct CFCalendarUnit : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var Era: CFCalendarUnit { get }
    static var Year: CFCalendarUnit { get }
    static var Month: CFCalendarUnit { get }
    static var Day: CFCalendarUnit { get }
    static var Hour: CFCalendarUnit { get }
    static var Minute: CFCalendarUnit { get }
    static var Second: CFCalendarUnit { get }
    static var Week: CFCalendarUnit { get }
    static var Weekday: CFCalendarUnit { get }
    static var WeekdayOrdinal: CFCalendarUnit { get }
    static var Quarter: CFCalendarUnit { get }
    static var WeekOfMonth: CFCalendarUnit { get }
    static var WeekOfYear: CFCalendarUnit { get }
    static var YearForWeekOfYear: CFCalendarUnit { get }
}

struct CFDataSearchFlags : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var Backwards: CFDataSearchFlags { get }
    static var Anchored: CFDataSearchFlags { get }
}

struct CFDataSearchFlags : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var Backwards: CFDataSearchFlags { get }
    static var Anchored: CFDataSearchFlags { get }
}

struct CFDictionaryKeyCallBacks {
    var version: CFIndex
    var retain: CFDictionaryRetainCallBack
    var release: CFDictionaryReleaseCallBack
    var copyDescription: CFDictionaryCopyDescriptionCallBack
    var equal: CFDictionaryEqualCallBack
    var hash: CFDictionaryHashCallBack
    init()
    init(version version: CFIndex, retain retain: CFDictionaryRetainCallBack, release release: CFDictionaryReleaseCallBack, copyDescription copyDescription: CFDictionaryCopyDescriptionCallBack, equal equal: CFDictionaryEqualCallBack, hash hash: CFDictionaryHashCallBack)
}

struct CFDictionaryKeyCallBacks {
    var version: CFIndex
    var retain: CFDictionaryRetainCallBack!
    var release: CFDictionaryReleaseCallBack!
    var copyDescription: CFDictionaryCopyDescriptionCallBack!
    var equal: CFDictionaryEqualCallBack!
    var hash: CFDictionaryHashCallBack!
    init()
    init(version version: CFIndex, retain retain: CFDictionaryRetainCallBack!, release release: CFDictionaryReleaseCallBack!, copyDescription copyDescription: CFDictionaryCopyDescriptionCallBack!, equal equal: CFDictionaryEqualCallBack!, hash hash: CFDictionaryHashCallBack!)
}

var copyDescription: CFDictionaryCopyDescriptionCallBack

var copyDescription: CFDictionaryCopyDescriptionCallBack!

var equal: CFDictionaryEqualCallBack

var equal: CFDictionaryEqualCallBack!

var hash: CFDictionaryHashCallBack

var hash: CFDictionaryHashCallBack!

var release: CFDictionaryReleaseCallBack

var release: CFDictionaryReleaseCallBack!

var retain: CFDictionaryRetainCallBack

var retain: CFDictionaryRetainCallBack!

struct CFDictionaryValueCallBacks {
    var version: CFIndex
    var retain: CFDictionaryRetainCallBack
    var release: CFDictionaryReleaseCallBack
    var copyDescription: CFDictionaryCopyDescriptionCallBack
    var equal: CFDictionaryEqualCallBack
    init()
    init(version version: CFIndex, retain retain: CFDictionaryRetainCallBack, release release: CFDictionaryReleaseCallBack, copyDescription copyDescription: CFDictionaryCopyDescriptionCallBack, equal equal: CFDictionaryEqualCallBack)
}

struct CFDictionaryValueCallBacks {
    var version: CFIndex
    var retain: CFDictionaryRetainCallBack!
    var release: CFDictionaryReleaseCallBack!
    var copyDescription: CFDictionaryCopyDescriptionCallBack!
    var equal: CFDictionaryEqualCallBack!
    init()
    init(version version: CFIndex, retain retain: CFDictionaryRetainCallBack!, release release: CFDictionaryReleaseCallBack!, copyDescription copyDescription: CFDictionaryCopyDescriptionCallBack!, equal equal: CFDictionaryEqualCallBack!)
}

var copyDescription: CFDictionaryCopyDescriptionCallBack

var copyDescription: CFDictionaryCopyDescriptionCallBack!

var equal: CFDictionaryEqualCallBack

var equal: CFDictionaryEqualCallBack!

var release: CFDictionaryReleaseCallBack

var release: CFDictionaryReleaseCallBack!

var retain: CFDictionaryRetainCallBack

var retain: CFDictionaryRetainCallBack!

struct CFFileDescriptorContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>
    var release: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>, release release: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)>)
}

struct CFFileDescriptorContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)!
    var release: ((UnsafeMutablePointer<Void>) -> Void)!
    var copyDescription: ((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)!, release release: ((UnsafeMutablePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)!)
}

var copyDescription: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)!

var release: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>

var release: ((UnsafeMutablePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>

var retain: ((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)!

struct CFFileSecurityClearOptions : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var Owner: CFFileSecurityClearOptions { get }
    static var Group: CFFileSecurityClearOptions { get }
    static var Mode: CFFileSecurityClearOptions { get }
    static var OwnerUUID: CFFileSecurityClearOptions { get }
    static var GroupUUID: CFFileSecurityClearOptions { get }
    static var AccessControlList: CFFileSecurityClearOptions { get }
}

struct CFFileSecurityClearOptions : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var Owner: CFFileSecurityClearOptions { get }
    static var Group: CFFileSecurityClearOptions { get }
    static var Mode: CFFileSecurityClearOptions { get }
    static var OwnerUUID: CFFileSecurityClearOptions { get }
    static var GroupUUID: CFFileSecurityClearOptions { get }
    static var AccessControlList: CFFileSecurityClearOptions { get }
}

struct CFGregorianUnitFlags : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var UnitsYears: CFGregorianUnitFlags { get }
    static var UnitsMonths: CFGregorianUnitFlags { get }
    static var UnitsDays: CFGregorianUnitFlags { get }
    static var UnitsHours: CFGregorianUnitFlags { get }
    static var UnitsMinutes: CFGregorianUnitFlags { get }
    static var UnitsSeconds: CFGregorianUnitFlags { get }
    static var AllUnits: CFGregorianUnitFlags { get }
}

struct CFGregorianUnitFlags : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var UnitsYears: CFGregorianUnitFlags { get }
    static var UnitsMonths: CFGregorianUnitFlags { get }
    static var UnitsDays: CFGregorianUnitFlags { get }
    static var UnitsHours: CFGregorianUnitFlags { get }
    static var UnitsMinutes: CFGregorianUnitFlags { get }
    static var UnitsSeconds: CFGregorianUnitFlags { get }
    static var AllUnits: CFGregorianUnitFlags { get }
}

struct CFMachPortContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>
    var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>, release release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>)
}

struct CFMachPortContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!
    var release: ((UnsafePointer<Void>) -> Void)!
    var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!, release release: ((UnsafePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!)
}

var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!

var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>

var release: ((UnsafePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!

struct CFMessagePortContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>
    var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>, release release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>)
}

struct CFMessagePortContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!
    var release: ((UnsafePointer<Void>) -> Void)!
    var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!, release release: ((UnsafePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!)
}

var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!

var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>

var release: ((UnsafePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!

struct CFNumberFormatterOptionFlags : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var ParseIntegersOnly: CFNumberFormatterOptionFlags { get }
}

struct CFNumberFormatterOptionFlags : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var ParseIntegersOnly: CFNumberFormatterOptionFlags { get }
}

enum CFNumberFormatterStyle : CFIndex {
    case NoStyle
    case DecimalStyle
    case CurrencyStyle
    case PercentStyle
    case ScientificStyle
    case SpellOutStyle
}

enum CFNumberFormatterStyle : CFIndex {
    case NoStyle
    case DecimalStyle
    case CurrencyStyle
    case PercentStyle
    case ScientificStyle
    case SpellOutStyle
    case OrdinalStyle
    case CurrencyISOCodeStyle
    case CurrencyPluralStyle
    case CurrencyAccountingStyle
}

enum CFNumberType : CFIndex {
    case SInt8Type
    case SInt16Type
    case SInt32Type
    case SInt64Type
    case Float32Type
    case Float64Type
    case CharType
    case ShortType
    case IntType
    case LongType
    case LongLongType
    case FloatType
    case DoubleType
    case CFIndexType
    case NSIntegerType
    case CGFloatType
}

enum CFNumberType : CFIndex {
    case SInt8Type
    case SInt16Type
    case SInt32Type
    case SInt64Type
    case Float32Type
    case Float64Type
    case CharType
    case ShortType
    case IntType
    case LongType
    case LongLongType
    case FloatType
    case DoubleType
    case CFIndexType
    case NSIntegerType
    case CGFloatType
    static var MaxType: CFNumberType { get }
}

struct CFPropertyListMutabilityOptions : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var Immutable: CFPropertyListMutabilityOptions { get }
    static var MutableContainers: CFPropertyListMutabilityOptions { get }
    static var MutableContainersAndLeaves: CFPropertyListMutabilityOptions { get }
}

struct CFPropertyListMutabilityOptions : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var Immutable: CFPropertyListMutabilityOptions { get }
    static var MutableContainers: CFPropertyListMutabilityOptions { get }
    static var MutableContainersAndLeaves: CFPropertyListMutabilityOptions { get }
}

struct CFRunLoopActivity : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var Entry: CFRunLoopActivity { get }
    static var BeforeTimers: CFRunLoopActivity { get }
    static var BeforeSources: CFRunLoopActivity { get }
    static var BeforeWaiting: CFRunLoopActivity { get }
    static var AfterWaiting: CFRunLoopActivity { get }
    static var Exit: CFRunLoopActivity { get }
    static var AllActivities: CFRunLoopActivity { get }
}

struct CFRunLoopActivity : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var Entry: CFRunLoopActivity { get }
    static var BeforeTimers: CFRunLoopActivity { get }
    static var BeforeSources: CFRunLoopActivity { get }
    static var BeforeWaiting: CFRunLoopActivity { get }
    static var AfterWaiting: CFRunLoopActivity { get }
    static var Exit: CFRunLoopActivity { get }
    static var AllActivities: CFRunLoopActivity { get }
}

struct CFRunLoopObserverContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>
    var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>, release release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>)
}

struct CFRunLoopObserverContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!
    var release: ((UnsafePointer<Void>) -> Void)!
    var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!, release release: ((UnsafePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!)
}

var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!

var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>

var release: ((UnsafePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!

struct CFRunLoopSourceContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>
    var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>
    var equal: CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>
    var hash: CFunctionPointer<((UnsafePointer<Void>) -> CFHashCode)>
    var schedule: CFunctionPointer<((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)>
    var cancel: CFunctionPointer<((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)>
    var perform: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>, release release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>, equal equal: CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>, hash hash: CFunctionPointer<((UnsafePointer<Void>) -> CFHashCode)>, schedule schedule: CFunctionPointer<((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)>, cancel cancel: CFunctionPointer<((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)>, perform perform: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>)
}

struct CFRunLoopSourceContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!
    var release: ((UnsafePointer<Void>) -> Void)!
    var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!
    var equal: ((UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean)!
    var hash: ((UnsafePointer<Void>) -> CFHashCode)!
    var schedule: ((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)!
    var cancel: ((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)!
    var perform: ((UnsafeMutablePointer<Void>) -> Void)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!, release release: ((UnsafePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!, equal equal: ((UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean)!, hash hash: ((UnsafePointer<Void>) -> CFHashCode)!, schedule schedule: ((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)!, cancel cancel: ((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)!, perform perform: ((UnsafeMutablePointer<Void>) -> Void)!)
}

var cancel: CFunctionPointer<((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)>

var cancel: ((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)!

var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!

var equal: CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>

var equal: ((UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean)!

var hash: CFunctionPointer<((UnsafePointer<Void>) -> CFHashCode)>

var hash: ((UnsafePointer<Void>) -> CFHashCode)!

var perform: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>

var perform: ((UnsafeMutablePointer<Void>) -> Void)!

var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>

var release: ((UnsafePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!

var schedule: CFunctionPointer<((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)>

var schedule: ((UnsafeMutablePointer<Void>, CFRunLoop!, CFString!) -> Void)!

struct CFRunLoopSourceContext1 {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>
    var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>
    var equal: CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>
    var hash: CFunctionPointer<((UnsafePointer<Void>) -> CFHashCode)>
    var getPort: CFunctionPointer<((UnsafeMutablePointer<Void>) -> mach_port_t)>
    var perform: CFunctionPointer<((UnsafeMutablePointer<Void>, CFIndex, CFAllocator!, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>, release release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>, equal equal: CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>, hash hash: CFunctionPointer<((UnsafePointer<Void>) -> CFHashCode)>, getPort getPort: CFunctionPointer<((UnsafeMutablePointer<Void>) -> mach_port_t)>, perform perform: CFunctionPointer<((UnsafeMutablePointer<Void>, CFIndex, CFAllocator!, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>)
}

struct CFRunLoopSourceContext1 {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!
    var release: ((UnsafePointer<Void>) -> Void)!
    var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!
    var equal: ((UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean)!
    var hash: ((UnsafePointer<Void>) -> CFHashCode)!
    var getPort: ((UnsafeMutablePointer<Void>) -> mach_port_t)!
    var perform: ((UnsafeMutablePointer<Void>, CFIndex, CFAllocator!, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!, release release: ((UnsafePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!, equal equal: ((UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean)!, hash hash: ((UnsafePointer<Void>) -> CFHashCode)!, getPort getPort: ((UnsafeMutablePointer<Void>) -> mach_port_t)!, perform perform: ((UnsafeMutablePointer<Void>, CFIndex, CFAllocator!, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)!)
}

var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!

var equal: CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>

var equal: ((UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean)!

var getPort: CFunctionPointer<((UnsafeMutablePointer<Void>) -> mach_port_t)>

var getPort: ((UnsafeMutablePointer<Void>) -> mach_port_t)!

var hash: CFunctionPointer<((UnsafePointer<Void>) -> CFHashCode)>

var hash: ((UnsafePointer<Void>) -> CFHashCode)!

var perform: CFunctionPointer<((UnsafeMutablePointer<Void>, CFIndex, CFAllocator!, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>

var perform: ((UnsafeMutablePointer<Void>, CFIndex, CFAllocator!, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)!

var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>

var release: ((UnsafePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!

struct CFRunLoopTimerContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>
    var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>, release release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>)
}

struct CFRunLoopTimerContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!
    var release: ((UnsafePointer<Void>) -> Void)!
    var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!, release release: ((UnsafePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!)
}

var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!

var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>

var release: ((UnsafePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!

struct CFSetCallBacks {
    var version: CFIndex
    var retain: CFSetRetainCallBack
    var release: CFSetReleaseCallBack
    var copyDescription: CFSetCopyDescriptionCallBack
    var equal: CFSetEqualCallBack
    var hash: CFSetHashCallBack
    init()
    init(version version: CFIndex, retain retain: CFSetRetainCallBack, release release: CFSetReleaseCallBack, copyDescription copyDescription: CFSetCopyDescriptionCallBack, equal equal: CFSetEqualCallBack, hash hash: CFSetHashCallBack)
}

struct CFSetCallBacks {
    var version: CFIndex
    var retain: CFSetRetainCallBack!
    var release: CFSetReleaseCallBack!
    var copyDescription: CFSetCopyDescriptionCallBack!
    var equal: CFSetEqualCallBack!
    var hash: CFSetHashCallBack!
    init()
    init(version version: CFIndex, retain retain: CFSetRetainCallBack!, release release: CFSetReleaseCallBack!, copyDescription copyDescription: CFSetCopyDescriptionCallBack!, equal equal: CFSetEqualCallBack!, hash hash: CFSetHashCallBack!)
}

var copyDescription: CFSetCopyDescriptionCallBack

var copyDescription: CFSetCopyDescriptionCallBack!

var equal: CFSetEqualCallBack

var equal: CFSetEqualCallBack!

var hash: CFSetHashCallBack

var hash: CFSetHashCallBack!

var release: CFSetReleaseCallBack

var release: CFSetReleaseCallBack!

var retain: CFSetRetainCallBack

var retain: CFSetRetainCallBack!

struct CFSocketCallBackType : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var NoCallBack: CFSocketCallBackType { get }
    static var ReadCallBack: CFSocketCallBackType { get }
    static var AcceptCallBack: CFSocketCallBackType { get }
    static var DataCallBack: CFSocketCallBackType { get }
    static var ConnectCallBack: CFSocketCallBackType { get }
    static var WriteCallBack: CFSocketCallBackType { get }
}

struct CFSocketCallBackType : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var NoCallBack: CFSocketCallBackType { get }
    static var ReadCallBack: CFSocketCallBackType { get }
    static var AcceptCallBack: CFSocketCallBackType { get }
    static var DataCallBack: CFSocketCallBackType { get }
    static var ConnectCallBack: CFSocketCallBackType { get }
    static var WriteCallBack: CFSocketCallBackType { get }
}

struct CFSocketContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>
    var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>, release release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>)
}

struct CFSocketContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!
    var release: ((UnsafePointer<Void>) -> Void)!
    var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!, release release: ((UnsafePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!)
}

var copyDescription: CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafePointer<Void>) -> Unmanaged<CFString>!)!

var release: CFunctionPointer<((UnsafePointer<Void>) -> Void)>

var release: ((UnsafePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

var retain: ((UnsafePointer<Void>) -> UnsafePointer<Void>)!

struct CFStreamClientContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFunctionPointer<((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>
    var release: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>
    var copyDescription: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)>
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFunctionPointer<((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>, release release: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>, copyDescription copyDescription: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)>)
}

struct CFStreamClientContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: ((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)!
    var release: ((UnsafeMutablePointer<Void>) -> Void)!
    var copyDescription: ((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: ((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)!, release release: ((UnsafeMutablePointer<Void>) -> Void)!, copyDescription copyDescription: ((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)!)
}

var copyDescription: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)>

var copyDescription: ((UnsafeMutablePointer<Void>) -> Unmanaged<CFString>!)!

var release: CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>

var release: ((UnsafeMutablePointer<Void>) -> Void)!

var retain: CFunctionPointer<((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>

var retain: ((UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)!

struct CFStreamEventType : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var None: CFStreamEventType { get }
    static var OpenCompleted: CFStreamEventType { get }
    static var HasBytesAvailable: CFStreamEventType { get }
    static var CanAcceptBytes: CFStreamEventType { get }
    static var ErrorOccurred: CFStreamEventType { get }
    static var EndEncountered: CFStreamEventType { get }
}

struct CFStreamEventType : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var None: CFStreamEventType { get }
    static var OpenCompleted: CFStreamEventType { get }
    static var HasBytesAvailable: CFStreamEventType { get }
    static var CanAcceptBytes: CFStreamEventType { get }
    static var ErrorOccurred: CFStreamEventType { get }
    static var EndEncountered: CFStreamEventType { get }
}

enum CFStringBuiltInEncodings : CFStringEncoding {
    case MacRoman
    case WindowsLatin1
    case ISOLatin1
    case NextStepLatin
    case ASCII
    case Unicode
    case UTF8
    case NonLossyASCII
    case UTF16BE
    case UTF16LE
    case UTF32
    case UTF32BE
    case UTF32LE
}

enum CFStringBuiltInEncodings : CFStringEncoding {
    case MacRoman
    case WindowsLatin1
    case ISOLatin1
    case NextStepLatin
    case ASCII
    case Unicode
    case UTF8
    case NonLossyASCII
    static var UTF16: CFStringBuiltInEncodings { get }
    case UTF16BE
    case UTF16LE
    case UTF32
    case UTF32BE
    case UTF32LE
}

struct CFStringCompareFlags : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var CompareCaseInsensitive: CFStringCompareFlags { get }
    static var CompareBackwards: CFStringCompareFlags { get }
    static var CompareAnchored: CFStringCompareFlags { get }
    static var CompareNonliteral: CFStringCompareFlags { get }
    static var CompareLocalized: CFStringCompareFlags { get }
    static var CompareNumerically: CFStringCompareFlags { get }
    static var CompareDiacriticInsensitive: CFStringCompareFlags { get }
    static var CompareWidthInsensitive: CFStringCompareFlags { get }
    static var CompareForcedOrdering: CFStringCompareFlags { get }
}

struct CFStringCompareFlags : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var CompareCaseInsensitive: CFStringCompareFlags { get }
    static var CompareBackwards: CFStringCompareFlags { get }
    static var CompareAnchored: CFStringCompareFlags { get }
    static var CompareNonliteral: CFStringCompareFlags { get }
    static var CompareLocalized: CFStringCompareFlags { get }
    static var CompareNumerically: CFStringCompareFlags { get }
    static var CompareDiacriticInsensitive: CFStringCompareFlags { get }
    static var CompareWidthInsensitive: CFStringCompareFlags { get }
    static var CompareForcedOrdering: CFStringCompareFlags { get }
}

enum CFStringEncodings : CFIndex {
    case MacJapanese
    case MacChineseTrad
    case MacKorean
    case MacArabic
    case MacHebrew
    case MacGreek
    case MacCyrillic
    case MacDevanagari
    case MacGurmukhi
    case MacGujarati
    case MacOriya
    case MacBengali
    case MacTamil
    case MacTelugu
    case MacKannada
    case MacMalayalam
    case MacSinhalese
    case MacBurmese
    case MacKhmer
    case MacThai
    case MacLaotian
    case MacGeorgian
    case MacArmenian
    case MacChineseSimp
    case MacTibetan
    case MacMongolian
    case MacEthiopic
    case MacCentralEurRoman
    case MacVietnamese
    case MacExtArabic
    case MacSymbol
    case MacDingbats
    case MacTurkish
    case MacCroatian
    case MacIcelandic
    case MacRomanian
    case MacCeltic
    case MacGaelic
    case MacFarsi
    case MacUkrainian
    case MacInuit
    case MacVT100
    case MacHFS
    case ISOLatin2
    case ISOLatin3
    case ISOLatin4
    case ISOLatinCyrillic
    case ISOLatinArabic
    case ISOLatinGreek
    case ISOLatinHebrew
    case ISOLatin5
    case ISOLatin6
    case ISOLatinThai
    case ISOLatin7
    case ISOLatin8
    case ISOLatin9
    case ISOLatin10
    case DOSLatinUS
    case DOSGreek
    case DOSBalticRim
    case DOSLatin1
    case DOSGreek1
    case DOSLatin2
    case DOSCyrillic
    case DOSTurkish
    case DOSPortuguese
    case DOSIcelandic
    case DOSHebrew
    case DOSCanadianFrench
    case DOSArabic
    case DOSNordic
    case DOSRussian
    case DOSGreek2
    case DOSThai
    case DOSJapanese
    case DOSChineseSimplif
    case DOSKorean
    case DOSChineseTrad
    case WindowsLatin2
    case WindowsCyrillic
    case WindowsGreek
    case WindowsLatin5
    case WindowsHebrew
    case WindowsArabic
    case WindowsBalticRim
    case WindowsVietnamese
    case WindowsKoreanJohab
    case ANSEL
    case JIS_X0201_76
    case JIS_X0208_83
    case JIS_X0208_90
    case JIS_X0212_90
    case JIS_C6226_78
    case ShiftJIS_X0213
    case ShiftJIS_X0213_MenKuTen
    case GB_2312_80
    case GBK_95
    case GB_18030_2000
    case KSC_5601_87
    case KSC_5601_92_Johab
    case CNS_11643_92_P1
    case CNS_11643_92_P2
    case CNS_11643_92_P3
    case ISO_2022_JP
    case ISO_2022_JP_2
    case ISO_2022_JP_1
    case ISO_2022_JP_3
    case ISO_2022_CN
    case ISO_2022_CN_EXT
    case ISO_2022_KR
    case EUC_JP
    case EUC_CN
    case EUC_TW
    case EUC_KR
    case ShiftJIS
    case KOI8_R
    case Big5
    case MacRomanLatin1
    case HZ_GB_2312
    case Big5_HKSCS_1999
    case VISCII
    case KOI8_U
    case Big5_E
    case NextStepJapanese
    case EBCDIC_US
    case EBCDIC_CP037
    case UTF7
    case UTF7_IMAP
}

enum CFStringEncodings : CFIndex {
    case MacJapanese
    case MacChineseTrad
    case MacKorean
    case MacArabic
    case MacHebrew
    case MacGreek
    case MacCyrillic
    case MacDevanagari
    case MacGurmukhi
    case MacGujarati
    case MacOriya
    case MacBengali
    case MacTamil
    case MacTelugu
    case MacKannada
    case MacMalayalam
    case MacSinhalese
    case MacBurmese
    case MacKhmer
    case MacThai
    case MacLaotian
    case MacGeorgian
    case MacArmenian
    case MacChineseSimp
    case MacTibetan
    case MacMongolian
    case MacEthiopic
    case MacCentralEurRoman
    case MacVietnamese
    case MacExtArabic
    case MacSymbol
    case MacDingbats
    case MacTurkish
    case MacCroatian
    case MacIcelandic
    case MacRomanian
    case MacCeltic
    case MacGaelic
    case MacFarsi
    case MacUkrainian
    case MacInuit
    case MacVT100
    case MacHFS
    case ISOLatin2
    case ISOLatin3
    case ISOLatin4
    case ISOLatinCyrillic
    case ISOLatinArabic
    case ISOLatinGreek
    case ISOLatinHebrew
    case ISOLatin5
    case ISOLatin6
    case ISOLatinThai
    case ISOLatin7
    case ISOLatin8
    case ISOLatin9
    case ISOLatin10
    case DOSLatinUS
    case DOSGreek
    case DOSBalticRim
    case DOSLatin1
    case DOSGreek1
    case DOSLatin2
    case DOSCyrillic
    case DOSTurkish
    case DOSPortuguese
    case DOSIcelandic
    case DOSHebrew
    case DOSCanadianFrench
    case DOSArabic
    case DOSNordic
    case DOSRussian
    case DOSGreek2
    case DOSThai
    case DOSJapanese
    case DOSChineseSimplif
    case DOSKorean
    case DOSChineseTrad
    case WindowsLatin2
    case WindowsCyrillic
    case WindowsGreek
    case WindowsLatin5
    case WindowsHebrew
    case WindowsArabic
    case WindowsBalticRim
    case WindowsVietnamese
    case WindowsKoreanJohab
    case ANSEL
    case JIS_X0201_76
    case JIS_X0208_83
    case JIS_X0208_90
    case JIS_X0212_90
    case JIS_C6226_78
    case ShiftJIS_X0213
    case ShiftJIS_X0213_MenKuTen
    case GB_2312_80
    case GBK_95
    case GB_18030_2000
    case KSC_5601_87
    case KSC_5601_92_Johab
    case CNS_11643_92_P1
    case CNS_11643_92_P2
    case CNS_11643_92_P3
    case ISO_2022_JP
    case ISO_2022_JP_2
    case ISO_2022_JP_1
    case ISO_2022_JP_3
    case ISO_2022_CN
    case ISO_2022_CN_EXT
    case ISO_2022_KR
    case EUC_JP
    case EUC_CN
    case EUC_TW
    case EUC_KR
    case ShiftJIS
    case KOI8_R
    case Big5
    case MacRomanLatin1
    case HZ_GB_2312
    case Big5_HKSCS_1999
    case VISCII
    case KOI8_U
    case Big5_E
    case NextStepJapanese
    case EBCDIC_US
    case EBCDIC_CP037
    case UTF7
    case UTF7_IMAP
    static var ShiftJIS_X0213_00: CFStringEncodings { get }
}

struct CFStringTokenizerTokenType : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var None: CFStringTokenizerTokenType { get }
    static var Normal: CFStringTokenizerTokenType { get }
    static var HasSubTokensMask: CFStringTokenizerTokenType { get }
    static var HasDerivedSubTokensMask: CFStringTokenizerTokenType { get }
    static var HasHasNumbersMask: CFStringTokenizerTokenType { get }
    static var HasNonLettersMask: CFStringTokenizerTokenType { get }
    static var IsCJWordMask: CFStringTokenizerTokenType { get }
}

struct CFStringTokenizerTokenType : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var None: CFStringTokenizerTokenType { get }
    static var Normal: CFStringTokenizerTokenType { get }
    static var HasSubTokensMask: CFStringTokenizerTokenType { get }
    static var HasDerivedSubTokensMask: CFStringTokenizerTokenType { get }
    static var HasHasNumbersMask: CFStringTokenizerTokenType { get }
    static var HasNonLettersMask: CFStringTokenizerTokenType { get }
    static var IsCJWordMask: CFStringTokenizerTokenType { get }
}

struct CFTreeContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFTreeRetainCallBack
    var release: CFTreeReleaseCallBack
    var copyDescription: CFTreeCopyDescriptionCallBack
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFTreeRetainCallBack, release release: CFTreeReleaseCallBack, copyDescription copyDescription: CFTreeCopyDescriptionCallBack)
}

struct CFTreeContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFTreeRetainCallBack!
    var release: CFTreeReleaseCallBack!
    var copyDescription: CFTreeCopyDescriptionCallBack!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFTreeRetainCallBack!, release release: CFTreeReleaseCallBack!, copyDescription copyDescription: CFTreeCopyDescriptionCallBack!)
}

var copyDescription: CFTreeCopyDescriptionCallBack

var copyDescription: CFTreeCopyDescriptionCallBack!

var release: CFTreeReleaseCallBack

var release: CFTreeReleaseCallBack!

var retain: CFTreeRetainCallBack

var retain: CFTreeRetainCallBack!

struct CFURLBookmarkCreationOptions : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var MinimalBookmarkMask: CFURLBookmarkCreationOptions { get }
    static var SuitableForBookmarkFile: CFURLBookmarkCreationOptions { get }
    static var WithSecurityScope: CFURLBookmarkCreationOptions { get }
    static var SecurityScopeAllowOnlyReadAccess: CFURLBookmarkCreationOptions { get }
    static var PreferFileIDResolutionMask: CFURLBookmarkCreationOptions { get }
}

struct CFURLBookmarkCreationOptions : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var MinimalBookmarkMask: CFURLBookmarkCreationOptions { get }
    static var SuitableForBookmarkFile: CFURLBookmarkCreationOptions { get }
    static var WithSecurityScope: CFURLBookmarkCreationOptions { get }
    static var SecurityScopeAllowOnlyReadAccess: CFURLBookmarkCreationOptions { get }
    static var PreferFileIDResolutionMask: CFURLBookmarkCreationOptions { get }
}

struct CFURLBookmarkResolutionOptions : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var CFURLBookmarkResolutionWithoutUIMask: CFURLBookmarkResolutionOptions { get }
    static var CFURLBookmarkResolutionWithoutMountingMask: CFURLBookmarkResolutionOptions { get }
    static var CFURLBookmarkResolutionWithSecurityScope: CFURLBookmarkResolutionOptions { get }
    static var CFBookmarkResolutionWithoutUIMask: CFURLBookmarkResolutionOptions { get }
    static var CFBookmarkResolutionWithoutMountingMask: CFURLBookmarkResolutionOptions { get }
}

struct CFURLBookmarkResolutionOptions : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var CFURLBookmarkResolutionWithoutUIMask: CFURLBookmarkResolutionOptions { get }
    static var CFURLBookmarkResolutionWithoutMountingMask: CFURLBookmarkResolutionOptions { get }
    static var CFURLBookmarkResolutionWithSecurityScope: CFURLBookmarkResolutionOptions { get }
    static var CFBookmarkResolutionWithoutUIMask: CFURLBookmarkResolutionOptions { get }
    static var CFBookmarkResolutionWithoutMountingMask: CFURLBookmarkResolutionOptions { get }
}

struct CFURLEnumeratorOptions : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var DefaultBehavior: CFURLEnumeratorOptions { get }
    static var DescendRecursively: CFURLEnumeratorOptions { get }
    static var SkipInvisibles: CFURLEnumeratorOptions { get }
    static var GenerateFileReferenceURLs: CFURLEnumeratorOptions { get }
    static var SkipPackageContents: CFURLEnumeratorOptions { get }
    static var IncludeDirectoriesPreOrder: CFURLEnumeratorOptions { get }
    static var IncludeDirectoriesPostOrder: CFURLEnumeratorOptions { get }
}

struct CFURLEnumeratorOptions : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var DefaultBehavior: CFURLEnumeratorOptions { get }
    static var DescendRecursively: CFURLEnumeratorOptions { get }
    static var SkipInvisibles: CFURLEnumeratorOptions { get }
    static var GenerateFileReferenceURLs: CFURLEnumeratorOptions { get }
    static var SkipPackageContents: CFURLEnumeratorOptions { get }
    static var IncludeDirectoriesPreOrder: CFURLEnumeratorOptions { get }
    static var IncludeDirectoriesPostOrder: CFURLEnumeratorOptions { get }
}

struct CFXMLElementInfo {
    var attributes: Unmanaged<CFDictionary>!
    var attributeOrder: Unmanaged<CFArray>!
    var isEmpty: Boolean
    var _reserved: (Int8, Int8, Int8)
    init()
    init(attributes attributes: Unmanaged<CFDictionary>!, attributeOrder attributeOrder: Unmanaged<CFArray>!, isEmpty isEmpty: Boolean, _reserved _reserved: (Int8, Int8, Int8))
}

struct CFXMLElementInfo {
    var attributes: Unmanaged<CFDictionary>!
    var attributeOrder: Unmanaged<CFArray>!
    var isEmpty: DarwinBoolean
    var _reserved: (Int8, Int8, Int8)
    init()
    init(attributes attributes: Unmanaged<CFDictionary>!, attributeOrder attributeOrder: Unmanaged<CFArray>!, isEmpty isEmpty: DarwinBoolean, _reserved _reserved: (Int8, Int8, Int8))
}

var isEmpty: Boolean

var isEmpty: DarwinBoolean

struct CFXMLParserCallBacks {
    var version: CFIndex
    var createXMLStructure: CFXMLParserCreateXMLStructureCallBack
    var addChild: CFXMLParserAddChildCallBack
    var endXMLStructure: CFXMLParserEndXMLStructureCallBack
    var resolveExternalEntity: CFXMLParserResolveExternalEntityCallBack
    var handleError: CFXMLParserHandleErrorCallBack
    init()
    init(version version: CFIndex, createXMLStructure createXMLStructure: CFXMLParserCreateXMLStructureCallBack, addChild addChild: CFXMLParserAddChildCallBack, endXMLStructure endXMLStructure: CFXMLParserEndXMLStructureCallBack, resolveExternalEntity resolveExternalEntity: CFXMLParserResolveExternalEntityCallBack, handleError handleError: CFXMLParserHandleErrorCallBack)
}

struct CFXMLParserCallBacks {
    var version: CFIndex
    var createXMLStructure: CFXMLParserCreateXMLStructureCallBack!
    var addChild: CFXMLParserAddChildCallBack!
    var endXMLStructure: CFXMLParserEndXMLStructureCallBack!
    var resolveExternalEntity: CFXMLParserResolveExternalEntityCallBack!
    var handleError: CFXMLParserHandleErrorCallBack!
    init()
    init(version version: CFIndex, createXMLStructure createXMLStructure: CFXMLParserCreateXMLStructureCallBack!, addChild addChild: CFXMLParserAddChildCallBack!, endXMLStructure endXMLStructure: CFXMLParserEndXMLStructureCallBack!, resolveExternalEntity resolveExternalEntity: CFXMLParserResolveExternalEntityCallBack!, handleError handleError: CFXMLParserHandleErrorCallBack!)
}

var addChild: CFXMLParserAddChildCallBack

var addChild: CFXMLParserAddChildCallBack!

var createXMLStructure: CFXMLParserCreateXMLStructureCallBack

var createXMLStructure: CFXMLParserCreateXMLStructureCallBack!

var endXMLStructure: CFXMLParserEndXMLStructureCallBack

var endXMLStructure: CFXMLParserEndXMLStructureCallBack!

var handleError: CFXMLParserHandleErrorCallBack

var handleError: CFXMLParserHandleErrorCallBack!

var resolveExternalEntity: CFXMLParserResolveExternalEntityCallBack

var resolveExternalEntity: CFXMLParserResolveExternalEntityCallBack!

struct CFXMLParserContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFXMLParserRetainCallBack
    var release: CFXMLParserReleaseCallBack
    var copyDescription: CFXMLParserCopyDescriptionCallBack
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFXMLParserRetainCallBack, release release: CFXMLParserReleaseCallBack, copyDescription copyDescription: CFXMLParserCopyDescriptionCallBack)
}

struct CFXMLParserContext {
    var version: CFIndex
    var info: UnsafeMutablePointer<Void>
    var retain: CFXMLParserRetainCallBack!
    var release: CFXMLParserReleaseCallBack!
    var copyDescription: CFXMLParserCopyDescriptionCallBack!
    init()
    init(version version: CFIndex, info info: UnsafeMutablePointer<Void>, retain retain: CFXMLParserRetainCallBack!, release release: CFXMLParserReleaseCallBack!, copyDescription copyDescription: CFXMLParserCopyDescriptionCallBack!)
}

var copyDescription: CFXMLParserCopyDescriptionCallBack

var copyDescription: CFXMLParserCopyDescriptionCallBack!

var release: CFXMLParserReleaseCallBack

var release: CFXMLParserReleaseCallBack!

var retain: CFXMLParserRetainCallBack

var retain: CFXMLParserRetainCallBack!

struct CFXMLParserOptions : RawOptionSetType {
    init(_ rawValue: CFOptionFlags)
    init(rawValue rawValue: CFOptionFlags)
    static var ValidateDocument: CFXMLParserOptions { get }
    static var SkipMetaData: CFXMLParserOptions { get }
    static var ReplacePhysicalEntities: CFXMLParserOptions { get }
    static var SkipWhitespace: CFXMLParserOptions { get }
    static var ResolveExternalEntities: CFXMLParserOptions { get }
    static var AddImpliedAttributes: CFXMLParserOptions { get }
    static var AllOptions: CFXMLParserOptions { get }
    static var NoOptions: CFXMLParserOptions { get }
}

struct CFXMLParserOptions : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var ValidateDocument: CFXMLParserOptions { get }
    static var SkipMetaData: CFXMLParserOptions { get }
    static var ReplacePhysicalEntities: CFXMLParserOptions { get }
    static var SkipWhitespace: CFXMLParserOptions { get }
    static var ResolveExternalEntities: CFXMLParserOptions { get }
    static var AddImpliedAttributes: CFXMLParserOptions { get }
    static var AllOptions: CFXMLParserOptions { get }
    static var NoOptions: CFXMLParserOptions { get }
}

struct CFXMLParserStatusCode : RawOptionSetType {
    init(_ rawValue: CFIndex)
    init(rawValue rawValue: CFIndex)
    static var StatusParseNotBegun: CFXMLParserStatusCode { get }
    static var StatusParseInProgress: CFXMLParserStatusCode { get }
    static var StatusParseSuccessful: CFXMLParserStatusCode { get }
    static var ErrorUnexpectedEOF: CFXMLParserStatusCode { get }
    static var ErrorUnknownEncoding: CFXMLParserStatusCode { get }
    static var ErrorEncodingConversionFailure: CFXMLParserStatusCode { get }
    static var ErrorMalformedProcessingInstruction: CFXMLParserStatusCode { get }
    static var ErrorMalformedDTD: CFXMLParserStatusCode { get }
    static var ErrorMalformedName: CFXMLParserStatusCode { get }
    static var ErrorMalformedCDSect: CFXMLParserStatusCode { get }
    static var ErrorMalformedCloseTag: CFXMLParserStatusCode { get }
    static var ErrorMalformedStartTag: CFXMLParserStatusCode { get }
    static var ErrorMalformedDocument: CFXMLParserStatusCode { get }
    static var ErrorElementlessDocument: CFXMLParserStatusCode { get }
    static var ErrorMalformedComment: CFXMLParserStatusCode { get }
    static var ErrorMalformedCharacterReference: CFXMLParserStatusCode { get }
    static var ErrorMalformedParsedCharacterData: CFXMLParserStatusCode { get }
    static var ErrorNoData: CFXMLParserStatusCode { get }
}

struct CFXMLParserStatusCode : OptionSetType {
    init(rawValue rawValue: CFIndex)
    static var StatusParseNotBegun: CFXMLParserStatusCode { get }
    static var StatusParseInProgress: CFXMLParserStatusCode { get }
    static var StatusParseSuccessful: CFXMLParserStatusCode { get }
    static var ErrorUnexpectedEOF: CFXMLParserStatusCode { get }
    static var ErrorUnknownEncoding: CFXMLParserStatusCode { get }
    static var ErrorEncodingConversionFailure: CFXMLParserStatusCode { get }
    static var ErrorMalformedProcessingInstruction: CFXMLParserStatusCode { get }
    static var ErrorMalformedDTD: CFXMLParserStatusCode { get }
    static var ErrorMalformedName: CFXMLParserStatusCode { get }
    static var ErrorMalformedCDSect: CFXMLParserStatusCode { get }
    static var ErrorMalformedCloseTag: CFXMLParserStatusCode { get }
    static var ErrorMalformedStartTag: CFXMLParserStatusCode { get }
    static var ErrorMalformedDocument: CFXMLParserStatusCode { get }
    static var ErrorElementlessDocument: CFXMLParserStatusCode { get }
    static var ErrorMalformedComment: CFXMLParserStatusCode { get }
    static var ErrorMalformedCharacterReference: CFXMLParserStatusCode { get }
    static var ErrorMalformedParsedCharacterData: CFXMLParserStatusCode { get }
    static var ErrorNoData: CFXMLParserStatusCode { get }
}

typealias CFAllocatorAllocateCallBack = CFunctionPointer<((CFIndex, CFOptionFlags, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>

typealias CFAllocatorAllocateCallBack = (CFIndex, CFOptionFlags, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>

typealias CFAllocatorCopyDescriptionCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

typealias CFAllocatorCopyDescriptionCallBack = (UnsafePointer<Void>) -> Unmanaged<CFString>!

typealias CFAllocatorDeallocateCallBack = CFunctionPointer<((UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>) -> Void)>

typealias CFAllocatorDeallocateCallBack = (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>) -> Void

typealias CFAllocatorPreferredSizeCallBack = CFunctionPointer<((CFIndex, CFOptionFlags, UnsafeMutablePointer<Void>) -> CFIndex)>

typealias CFAllocatorPreferredSizeCallBack = (CFIndex, CFOptionFlags, UnsafeMutablePointer<Void>) -> CFIndex

typealias CFAllocatorReallocateCallBack = CFunctionPointer<((UnsafeMutablePointer<Void>, CFIndex, CFOptionFlags, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>

typealias CFAllocatorReallocateCallBack = (UnsafeMutablePointer<Void>, CFIndex, CFOptionFlags, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>

typealias CFAllocatorReleaseCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Void)>

typealias CFAllocatorReleaseCallBack = (UnsafePointer<Void>) -> Void

typealias CFAllocatorRetainCallBack = CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

typealias CFAllocatorRetainCallBack = (UnsafePointer<Void>) -> UnsafePointer<Void>

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

typealias CFArrayApplierFunction = (UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> Void

func CFArrayApplyFunction(_ theArray: CFArray!, _ range: CFRange, _ applier: CFArrayApplierFunction, _ context: UnsafeMutablePointer<Void>)

func CFArrayApplyFunction(_ theArray: CFArray!, _ range: CFRange, _ applier: CFArrayApplierFunction!, _ context: UnsafeMutablePointer<Void>)

func CFArrayBSearchValues(_ theArray: CFArray!, _ range: CFRange, _ value: UnsafePointer<Void>, _ comparator: CFComparatorFunction, _ context: UnsafeMutablePointer<Void>) -> CFIndex

func CFArrayBSearchValues(_ theArray: CFArray!, _ range: CFRange, _ value: UnsafePointer<Void>, _ comparator: CFComparatorFunction!, _ context: UnsafeMutablePointer<Void>) -> CFIndex

func CFArrayContainsValue(_ theArray: CFArray!, _ range: CFRange, _ value: UnsafePointer<Void>) -> Boolean

func CFArrayContainsValue(_ theArray: CFArray!, _ range: CFRange, _ value: UnsafePointer<Void>) -> Bool

typealias CFArrayCopyDescriptionCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

typealias CFArrayCopyDescriptionCallBack = (UnsafePointer<Void>) -> Unmanaged<CFString>!

typealias CFArrayEqualCallBack = CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>

typealias CFArrayEqualCallBack = (UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean

typealias CFArrayReleaseCallBack = CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> Void)>

typealias CFArrayReleaseCallBack = (CFAllocator!, UnsafePointer<Void>) -> Void

typealias CFArrayRetainCallBack = CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)>

typealias CFArrayRetainCallBack = (CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>

func CFArraySortValues(_ theArray: CFMutableArray!, _ range: CFRange, _ comparator: CFComparatorFunction, _ context: UnsafeMutablePointer<Void>)

func CFArraySortValues(_ theArray: CFMutableArray!, _ range: CFRange, _ comparator: CFComparatorFunction!, _ context: UnsafeMutablePointer<Void>)

func CFAttributedStringSetAttributes(_ aStr: CFMutableAttributedString!, _ range: CFRange, _ replacement: CFDictionary!, _ clearOtherAttributes: Boolean)

func CFAttributedStringSetAttributes(_ aStr: CFMutableAttributedString!, _ range: CFRange, _ replacement: CFDictionary!, _ clearOtherAttributes: Bool)

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

typealias CFBagApplierFunction = (UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> Void

func CFBagApplyFunction(_ theBag: CFBag!, _ applier: CFBagApplierFunction, _ context: UnsafeMutablePointer<Void>)

func CFBagApplyFunction(_ theBag: CFBag!, _ applier: CFBagApplierFunction!, _ context: UnsafeMutablePointer<Void>)

func CFBagContainsValue(_ theBag: CFBag!, _ value: UnsafePointer<Void>) -> Boolean

func CFBagContainsValue(_ theBag: CFBag!, _ value: UnsafePointer<Void>) -> Bool

typealias CFBagCopyDescriptionCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

typealias CFBagCopyDescriptionCallBack = (UnsafePointer<Void>) -> Unmanaged<CFString>!

typealias CFBagEqualCallBack = CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>

typealias CFBagEqualCallBack = (UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean

func CFBagGetValueIfPresent(_ theBag: CFBag!, _ candidate: UnsafePointer<Void>, _ value: UnsafeMutablePointer<UnsafePointer<Void>>) -> Boolean

func CFBagGetValueIfPresent(_ theBag: CFBag!, _ candidate: UnsafePointer<Void>, _ value: UnsafeMutablePointer<UnsafePointer<Void>>) -> Bool

typealias CFBagHashCallBack = CFunctionPointer<((UnsafePointer<Void>) -> CFHashCode)>

typealias CFBagHashCallBack = (UnsafePointer<Void>) -> CFHashCode

typealias CFBagReleaseCallBack = CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> Void)>

typealias CFBagReleaseCallBack = (CFAllocator!, UnsafePointer<Void>) -> Void

typealias CFBagRetainCallBack = CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)>

typealias CFBagRetainCallBack = (CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>

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

typealias CFBinaryHeapApplierFunction = (UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> Void

func CFBinaryHeapApplyFunction(_ heap: CFBinaryHeap!, _ applier: CFBinaryHeapApplierFunction, _ context: UnsafeMutablePointer<Void>)

func CFBinaryHeapApplyFunction(_ heap: CFBinaryHeap!, _ applier: CFBinaryHeapApplierFunction!, _ context: UnsafeMutablePointer<Void>)

func CFBinaryHeapContainsValue(_ heap: CFBinaryHeap!, _ value: UnsafePointer<Void>) -> Boolean

func CFBinaryHeapContainsValue(_ heap: CFBinaryHeap!, _ value: UnsafePointer<Void>) -> Bool

func CFBinaryHeapGetMinimumIfPresent(_ heap: CFBinaryHeap!, _ value: UnsafeMutablePointer<UnsafePointer<Void>>) -> Boolean

func CFBinaryHeapGetMinimumIfPresent(_ heap: CFBinaryHeap!, _ value: UnsafeMutablePointer<UnsafePointer<Void>>) -> Bool

func CFBitVectorContainsBit(_ bv: CFBitVector!, _ range: CFRange, _ value: CFBit) -> Boolean

func CFBitVectorContainsBit(_ bv: CFBitVector!, _ range: CFRange, _ value: CFBit) -> Bool

func CFBooleanGetValue(_ boolean: CFBoolean!) -> Boolean

func CFBooleanGetValue(_ boolean: CFBoolean!) -> Bool

func CFBundleGetPackageInfoInDirectory(_ url: CFURL!, _ packageType: UnsafeMutablePointer<UInt32>, _ packageCreator: UnsafeMutablePointer<UInt32>) -> Boolean

func CFBundleGetPackageInfoInDirectory(_ url: CFURL!, _ packageType: UnsafeMutablePointer<UInt32>, _ packageCreator: UnsafeMutablePointer<UInt32>) -> Bool

func CFBundleIsExecutableLoaded(_ bundle: CFBundle!) -> Boolean

func CFBundleIsExecutableLoaded(_ bundle: CFBundle!) -> Bool

func CFBundleLoadExecutable(_ bundle: CFBundle!) -> Boolean

func CFBundleLoadExecutable(_ bundle: CFBundle!) -> Bool

func CFBundleLoadExecutableAndReturnError(_ bundle: CFBundle!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Boolean

func CFBundleLoadExecutableAndReturnError(_ bundle: CFBundle!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool

func CFBundlePreflightExecutable(_ bundle: CFBundle!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Boolean

func CFBundlePreflightExecutable(_ bundle: CFBundle!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool

func CFCalendarGetTimeRangeOfUnit(_ calendar: CFCalendar!, _ unit: CFCalendarUnit, _ at: CFAbsoluteTime, _ startp: UnsafeMutablePointer<CFAbsoluteTime>, _ tip: UnsafeMutablePointer<CFTimeInterval>) -> Boolean

func CFCalendarGetTimeRangeOfUnit(_ calendar: CFCalendar!, _ unit: CFCalendarUnit, _ at: CFAbsoluteTime, _ startp: UnsafeMutablePointer<CFAbsoluteTime>, _ tip: UnsafeMutablePointer<CFTimeInterval>) -> Bool

func CFCharacterSetHasMemberInPlane(_ theSet: CFCharacterSet!, _ thePlane: CFIndex) -> Boolean

func CFCharacterSetHasMemberInPlane(_ theSet: CFCharacterSet!, _ thePlane: CFIndex) -> Bool

func CFCharacterSetIsCharacterMember(_ theSet: CFCharacterSet!, _ theChar: UniChar) -> Boolean

func CFCharacterSetIsCharacterMember(_ theSet: CFCharacterSet!, _ theChar: UniChar) -> Bool

func CFCharacterSetIsLongCharacterMember(_ theSet: CFCharacterSet!, _ theChar: UTF32Char) -> Boolean

func CFCharacterSetIsLongCharacterMember(_ theSet: CFCharacterSet!, _ theChar: UTF32Char) -> Bool

func CFCharacterSetIsSupersetOfSet(_ theSet: CFCharacterSet!, _ theOtherset: CFCharacterSet!) -> Boolean

func CFCharacterSetIsSupersetOfSet(_ theSet: CFCharacterSet!, _ theOtherset: CFCharacterSet!) -> Bool

typealias CFComparatorFunction = CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> CFComparisonResult)>

typealias CFComparatorFunction = (UnsafePointer<Void>, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> CFComparisonResult

func CFDateFormatterGetAbsoluteTimeFromString(_ formatter: CFDateFormatter!, _ string: CFString!, _ rangep: UnsafeMutablePointer<CFRange>, _ atp: UnsafeMutablePointer<CFAbsoluteTime>) -> Boolean

func CFDateFormatterGetAbsoluteTimeFromString(_ formatter: CFDateFormatter!, _ string: CFString!, _ rangep: UnsafeMutablePointer<CFRange>, _ atp: UnsafeMutablePointer<CFAbsoluteTime>) -> Bool

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

typealias CFDictionaryApplierFunction = (UnsafePointer<Void>, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> Void

func CFDictionaryApplyFunction(_ theDict: CFDictionary!, _ applier: CFDictionaryApplierFunction, _ context: UnsafeMutablePointer<Void>)

func CFDictionaryApplyFunction(_ theDict: CFDictionary!, _ applier: CFDictionaryApplierFunction!, _ context: UnsafeMutablePointer<Void>)

func CFDictionaryContainsKey(_ theDict: CFDictionary!, _ key: UnsafePointer<Void>) -> Boolean

func CFDictionaryContainsKey(_ theDict: CFDictionary!, _ key: UnsafePointer<Void>) -> Bool

func CFDictionaryContainsValue(_ theDict: CFDictionary!, _ value: UnsafePointer<Void>) -> Boolean

func CFDictionaryContainsValue(_ theDict: CFDictionary!, _ value: UnsafePointer<Void>) -> Bool

typealias CFDictionaryCopyDescriptionCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

typealias CFDictionaryCopyDescriptionCallBack = (UnsafePointer<Void>) -> Unmanaged<CFString>!

typealias CFDictionaryEqualCallBack = CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>

typealias CFDictionaryEqualCallBack = (UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean

func CFDictionaryGetValueIfPresent(_ theDict: CFDictionary!, _ key: UnsafePointer<Void>, _ value: UnsafeMutablePointer<UnsafePointer<Void>>) -> Boolean

func CFDictionaryGetValueIfPresent(_ theDict: CFDictionary!, _ key: UnsafePointer<Void>, _ value: UnsafeMutablePointer<UnsafePointer<Void>>) -> Bool

typealias CFDictionaryHashCallBack = CFunctionPointer<((UnsafePointer<Void>) -> CFHashCode)>

typealias CFDictionaryHashCallBack = (UnsafePointer<Void>) -> CFHashCode

typealias CFDictionaryReleaseCallBack = CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> Void)>

typealias CFDictionaryReleaseCallBack = (CFAllocator!, UnsafePointer<Void>) -> Void

typealias CFDictionaryRetainCallBack = CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)>

typealias CFDictionaryRetainCallBack = (CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>

func CFEqual(_ cf1: AnyObject!, _ cf2: AnyObject!) -> Boolean

func CFEqual(_ cf1: AnyObject!, _ cf2: AnyObject!) -> Bool

typealias CFFileDescriptorCallBack = CFunctionPointer<((CFFileDescriptor!, CFOptionFlags, UnsafeMutablePointer<Void>) -> Void)>

typealias CFFileDescriptorCallBack = (CFFileDescriptor!, CFOptionFlags, UnsafeMutablePointer<Void>) -> Void

func CFFileDescriptorCreate(_ allocator: CFAllocator!, _ fd: CFFileDescriptorNativeDescriptor, _ closeOnInvalidate: Boolean, _ callout: CFFileDescriptorCallBack, _ context: UnsafePointer<CFFileDescriptorContext>) -> CFFileDescriptor!

func CFFileDescriptorCreate(_ allocator: CFAllocator!, _ fd: CFFileDescriptorNativeDescriptor, _ closeOnInvalidate: Bool, _ callout: CFFileDescriptorCallBack!, _ context: UnsafePointer<CFFileDescriptorContext>) -> CFFileDescriptor!

func CFFileDescriptorIsValid(_ f: CFFileDescriptor!) -> Boolean

func CFFileDescriptorIsValid(_ f: CFFileDescriptor!) -> Bool

func CFFileSecurityClearProperties(_ fileSec: CFFileSecurity!, _ clearPropertyMask: CFFileSecurityClearOptions) -> Boolean

func CFFileSecurityClearProperties(_ fileSec: CFFileSecurity!, _ clearPropertyMask: CFFileSecurityClearOptions) -> Bool

func CFFileSecurityCopyAccessControlList(_ fileSec: CFFileSecurity!, _ accessControlList: UnsafeMutablePointer<acl_t>) -> Boolean

func CFFileSecurityCopyAccessControlList(_ fileSec: CFFileSecurity!, _ accessControlList: UnsafeMutablePointer<acl_t>) -> Bool

func CFFileSecurityCopyGroupUUID(_ fileSec: CFFileSecurity!, _ groupUUID: UnsafeMutablePointer<Unmanaged<CFUUID>?>) -> Boolean

func CFFileSecurityCopyGroupUUID(_ fileSec: CFFileSecurity!, _ groupUUID: UnsafeMutablePointer<Unmanaged<CFUUID>?>) -> Bool

func CFFileSecurityCopyOwnerUUID(_ fileSec: CFFileSecurity!, _ ownerUUID: UnsafeMutablePointer<Unmanaged<CFUUID>?>) -> Boolean

func CFFileSecurityCopyOwnerUUID(_ fileSec: CFFileSecurity!, _ ownerUUID: UnsafeMutablePointer<Unmanaged<CFUUID>?>) -> Bool

func CFFileSecurityGetGroup(_ fileSec: CFFileSecurity!, _ group: UnsafeMutablePointer<gid_t>) -> Boolean

func CFFileSecurityGetGroup(_ fileSec: CFFileSecurity!, _ group: UnsafeMutablePointer<gid_t>) -> Bool

func CFFileSecurityGetMode(_ fileSec: CFFileSecurity!, _ mode: UnsafeMutablePointer<mode_t>) -> Boolean

func CFFileSecurityGetMode(_ fileSec: CFFileSecurity!, _ mode: UnsafeMutablePointer<mode_t>) -> Bool

func CFFileSecurityGetOwner(_ fileSec: CFFileSecurity!, _ owner: UnsafeMutablePointer<uid_t>) -> Boolean

func CFFileSecurityGetOwner(_ fileSec: CFFileSecurity!, _ owner: UnsafeMutablePointer<uid_t>) -> Bool

func CFFileSecuritySetAccessControlList(_ fileSec: CFFileSecurity!, _ accessControlList: acl_t) -> Boolean

func CFFileSecuritySetAccessControlList(_ fileSec: CFFileSecurity!, _ accessControlList: acl_t) -> Bool

func CFFileSecuritySetGroup(_ fileSec: CFFileSecurity!, _ group: gid_t) -> Boolean

func CFFileSecuritySetGroup(_ fileSec: CFFileSecurity!, _ group: gid_t) -> Bool

func CFFileSecuritySetGroupUUID(_ fileSec: CFFileSecurity!, _ groupUUID: CFUUID!) -> Boolean

func CFFileSecuritySetGroupUUID(_ fileSec: CFFileSecurity!, _ groupUUID: CFUUID!) -> Bool

func CFFileSecuritySetMode(_ fileSec: CFFileSecurity!, _ mode: mode_t) -> Boolean

func CFFileSecuritySetMode(_ fileSec: CFFileSecurity!, _ mode: mode_t) -> Bool

func CFFileSecuritySetOwner(_ fileSec: CFFileSecurity!, _ owner: uid_t) -> Boolean

func CFFileSecuritySetOwner(_ fileSec: CFFileSecurity!, _ owner: uid_t) -> Bool

func CFFileSecuritySetOwnerUUID(_ fileSec: CFFileSecurity!, _ ownerUUID: CFUUID!) -> Boolean

func CFFileSecuritySetOwnerUUID(_ fileSec: CFFileSecurity!, _ ownerUUID: CFUUID!) -> Bool

func CFGregorianDateIsValid(_ gdate: CFGregorianDate, _ unitFlags: CFOptionFlags) -> Boolean

func CFGregorianDateIsValid(_ gdate: CFGregorianDate, _ unitFlags: CFOptionFlags) -> Bool

typealias CFMachPortCallBack = CFunctionPointer<((CFMachPort!, UnsafeMutablePointer<Void>, CFIndex, UnsafeMutablePointer<Void>) -> Void)>

typealias CFMachPortCallBack = (CFMachPort!, UnsafeMutablePointer<Void>, CFIndex, UnsafeMutablePointer<Void>) -> Void

func CFMachPortCreate(_ allocator: CFAllocator!, _ callout: CFMachPortCallBack, _ context: UnsafeMutablePointer<CFMachPortContext>, _ shouldFreeInfo: UnsafeMutablePointer<Boolean>) -> CFMachPort!

func CFMachPortCreate(_ allocator: CFAllocator!, _ callout: CFMachPortCallBack!, _ context: UnsafeMutablePointer<CFMachPortContext>, _ shouldFreeInfo: UnsafeMutablePointer<DarwinBoolean>) -> CFMachPort!

func CFMachPortCreateWithPort(_ allocator: CFAllocator!, _ portNum: mach_port_t, _ callout: CFMachPortCallBack, _ context: UnsafeMutablePointer<CFMachPortContext>, _ shouldFreeInfo: UnsafeMutablePointer<Boolean>) -> CFMachPort!

func CFMachPortCreateWithPort(_ allocator: CFAllocator!, _ portNum: mach_port_t, _ callout: CFMachPortCallBack!, _ context: UnsafeMutablePointer<CFMachPortContext>, _ shouldFreeInfo: UnsafeMutablePointer<DarwinBoolean>) -> CFMachPort!

func CFMachPortGetInvalidationCallBack(_ port: CFMachPort!) -> CFMachPortInvalidationCallBack

func CFMachPortGetInvalidationCallBack(_ port: CFMachPort!) -> CFMachPortInvalidationCallBack!

typealias CFMachPortInvalidationCallBack = CFunctionPointer<((CFMachPort!, UnsafeMutablePointer<Void>) -> Void)>

typealias CFMachPortInvalidationCallBack = (CFMachPort!, UnsafeMutablePointer<Void>) -> Void

func CFMachPortIsValid(_ port: CFMachPort!) -> Boolean

func CFMachPortIsValid(_ port: CFMachPort!) -> Bool

func CFMachPortSetInvalidationCallBack(_ port: CFMachPort!, _ callout: CFMachPortInvalidationCallBack)

func CFMachPortSetInvalidationCallBack(_ port: CFMachPort!, _ callout: CFMachPortInvalidationCallBack!)

typealias CFMessagePortCallBack = CFunctionPointer<((CFMessagePort!, Int32, CFData!, UnsafeMutablePointer<Void>) -> Unmanaged<CFData>!)>

typealias CFMessagePortCallBack = (CFMessagePort!, Int32, CFData!, UnsafeMutablePointer<Void>) -> Unmanaged<CFData>!

func CFMessagePortCreateLocal(_ allocator: CFAllocator!, _ name: CFString!, _ callout: CFMessagePortCallBack, _ context: UnsafeMutablePointer<CFMessagePortContext>, _ shouldFreeInfo: UnsafeMutablePointer<Boolean>) -> CFMessagePort!

func CFMessagePortCreateLocal(_ allocator: CFAllocator!, _ name: CFString!, _ callout: CFMessagePortCallBack!, _ context: UnsafeMutablePointer<CFMessagePortContext>, _ shouldFreeInfo: UnsafeMutablePointer<DarwinBoolean>) -> CFMessagePort!

func CFMessagePortGetInvalidationCallBack(_ ms: CFMessagePort!) -> CFMessagePortInvalidationCallBack

func CFMessagePortGetInvalidationCallBack(_ ms: CFMessagePort!) -> CFMessagePortInvalidationCallBack!

typealias CFMessagePortInvalidationCallBack = CFunctionPointer<((CFMessagePort!, UnsafeMutablePointer<Void>) -> Void)>

typealias CFMessagePortInvalidationCallBack = (CFMessagePort!, UnsafeMutablePointer<Void>) -> Void

func CFMessagePortIsRemote(_ ms: CFMessagePort!) -> Boolean

func CFMessagePortIsRemote(_ ms: CFMessagePort!) -> Bool

func CFMessagePortIsValid(_ ms: CFMessagePort!) -> Boolean

func CFMessagePortIsValid(_ ms: CFMessagePort!) -> Bool

func CFMessagePortSetInvalidationCallBack(_ ms: CFMessagePort!, _ callout: CFMessagePortInvalidationCallBack)

func CFMessagePortSetInvalidationCallBack(_ ms: CFMessagePort!, _ callout: CFMessagePortInvalidationCallBack!)

func CFMessagePortSetName(_ ms: CFMessagePort!, _ newName: CFString!) -> Boolean

func CFMessagePortSetName(_ ms: CFMessagePort!, _ newName: CFString!) -> Bool

typealias CFNotificationCallback = CFunctionPointer<((CFNotificationCenter!, UnsafeMutablePointer<Void>, CFString!, UnsafePointer<Void>, CFDictionary!) -> Void)>

typealias CFNotificationCallback = (CFNotificationCenter!, UnsafeMutablePointer<Void>, CFString!, UnsafePointer<Void>, CFDictionary!) -> Void

func CFNotificationCenterAddObserver(_ center: CFNotificationCenter!, _ observer: UnsafePointer<Void>, _ callBack: CFNotificationCallback, _ name: CFString!, _ object: UnsafePointer<Void>, _ suspensionBehavior: CFNotificationSuspensionBehavior)

func CFNotificationCenterAddObserver(_ center: CFNotificationCenter!, _ observer: UnsafePointer<Void>, _ callBack: CFNotificationCallback!, _ name: CFString!, _ object: UnsafePointer<Void>, _ suspensionBehavior: CFNotificationSuspensionBehavior)

func CFNotificationCenterPostNotification(_ center: CFNotificationCenter!, _ name: CFString!, _ object: UnsafePointer<Void>, _ userInfo: CFDictionary!, _ deliverImmediately: Boolean)

func CFNotificationCenterPostNotification(_ center: CFNotificationCenter!, _ name: CFString!, _ object: UnsafePointer<Void>, _ userInfo: CFDictionary!, _ deliverImmediately: Bool)

func CFNumberFormatterGetDecimalInfoForCurrencyCode(_ currencyCode: CFString!, _ defaultFractionDigits: UnsafeMutablePointer<Int32>, _ roundingIncrement: UnsafeMutablePointer<Double>) -> Boolean

func CFNumberFormatterGetDecimalInfoForCurrencyCode(_ currencyCode: CFString!, _ defaultFractionDigits: UnsafeMutablePointer<Int32>, _ roundingIncrement: UnsafeMutablePointer<Double>) -> Bool

func CFNumberFormatterGetValueFromString(_ formatter: CFNumberFormatter!, _ string: CFString!, _ rangep: UnsafeMutablePointer<CFRange>, _ numberType: CFNumberType, _ valuePtr: UnsafeMutablePointer<Void>) -> Boolean

func CFNumberFormatterGetValueFromString(_ formatter: CFNumberFormatter!, _ string: CFString!, _ rangep: UnsafeMutablePointer<CFRange>, _ numberType: CFNumberType, _ valuePtr: UnsafeMutablePointer<Void>) -> Bool

func CFNumberGetValue(_ number: CFNumber!, _ theType: CFNumberType, _ valuePtr: UnsafeMutablePointer<Void>) -> Boolean

func CFNumberGetValue(_ number: CFNumber!, _ theType: CFNumberType, _ valuePtr: UnsafeMutablePointer<Void>) -> Bool

func CFNumberIsFloatType(_ number: CFNumber!) -> Boolean

func CFNumberIsFloatType(_ number: CFNumber!) -> Bool

typealias CFPlugInDynamicRegisterFunction = CFunctionPointer<((CFPlugIn!) -> Void)>

typealias CFPlugInDynamicRegisterFunction = (CFPlugIn!) -> Void

typealias CFPlugInFactoryFunction = CFunctionPointer<((CFAllocator!, CFUUID!) -> UnsafeMutablePointer<Void>)>

typealias CFPlugInFactoryFunction = (CFAllocator!, CFUUID!) -> UnsafeMutablePointer<Void>

func CFPlugInInstanceCreateWithInstanceDataSize(_ allocator: CFAllocator!, _ instanceDataSize: CFIndex, _ deallocateInstanceFunction: CFPlugInInstanceDeallocateInstanceDataFunction, _ factoryName: CFString!, _ getInterfaceFunction: CFPlugInInstanceGetInterfaceFunction) -> CFPlugInInstance!

func CFPlugInInstanceCreateWithInstanceDataSize(_ allocator: CFAllocator!, _ instanceDataSize: CFIndex, _ deallocateInstanceFunction: CFPlugInInstanceDeallocateInstanceDataFunction!, _ factoryName: CFString!, _ getInterfaceFunction: CFPlugInInstanceGetInterfaceFunction!) -> CFPlugInInstance!

typealias CFPlugInInstanceDeallocateInstanceDataFunction = CFunctionPointer<((UnsafeMutablePointer<Void>) -> Void)>

typealias CFPlugInInstanceDeallocateInstanceDataFunction = (UnsafeMutablePointer<Void>) -> Void

typealias CFPlugInInstanceGetInterfaceFunction = CFunctionPointer<((CFPlugInInstance!, CFString!, UnsafeMutablePointer<UnsafeMutablePointer<Void>>) -> Boolean)>

typealias CFPlugInInstanceGetInterfaceFunction = (CFPlugInInstance!, CFString!, UnsafeMutablePointer<UnsafeMutablePointer<Void>>) -> DarwinBoolean

func CFPlugInInstanceGetInterfaceFunctionTable(_ instance: CFPlugInInstance!, _ interfaceName: CFString!, _ ftbl: UnsafeMutablePointer<UnsafeMutablePointer<Void>>) -> Boolean

func CFPlugInInstanceGetInterfaceFunctionTable(_ instance: CFPlugInInstance!, _ interfaceName: CFString!, _ ftbl: UnsafeMutablePointer<UnsafeMutablePointer<Void>>) -> Bool

func CFPlugInIsLoadOnDemand(_ plugIn: CFPlugIn!) -> Boolean

func CFPlugInIsLoadOnDemand(_ plugIn: CFPlugIn!) -> Bool

func CFPlugInRegisterFactoryFunction(_ factoryUUID: CFUUID!, _ `func`: CFPlugInFactoryFunction) -> Boolean

func CFPlugInRegisterFactoryFunction(_ factoryUUID: CFUUID!, _ `func`: CFPlugInFactoryFunction!) -> Bool

func CFPlugInRegisterFactoryFunctionByName(_ factoryUUID: CFUUID!, _ plugIn: CFPlugIn!, _ functionName: CFString!) -> Boolean

func CFPlugInRegisterFactoryFunctionByName(_ factoryUUID: CFUUID!, _ plugIn: CFPlugIn!, _ functionName: CFString!) -> Bool

func CFPlugInRegisterPlugInType(_ factoryUUID: CFUUID!, _ typeUUID: CFUUID!) -> Boolean

func CFPlugInRegisterPlugInType(_ factoryUUID: CFUUID!, _ typeUUID: CFUUID!) -> Bool

func CFPlugInSetLoadOnDemand(_ plugIn: CFPlugIn!, _ flag: Boolean)

func CFPlugInSetLoadOnDemand(_ plugIn: CFPlugIn!, _ flag: Bool)

typealias CFPlugInUnloadFunction = CFunctionPointer<((CFPlugIn!) -> Void)>

typealias CFPlugInUnloadFunction = (CFPlugIn!) -> Void

func CFPlugInUnregisterFactory(_ factoryUUID: CFUUID!) -> Boolean

func CFPlugInUnregisterFactory(_ factoryUUID: CFUUID!) -> Bool

func CFPlugInUnregisterPlugInType(_ factoryUUID: CFUUID!, _ typeUUID: CFUUID!) -> Boolean

func CFPlugInUnregisterPlugInType(_ factoryUUID: CFUUID!, _ typeUUID: CFUUID!) -> Bool

func CFPreferencesAppSynchronize(_ applicationID: CFString!) -> Boolean

func CFPreferencesAppSynchronize(_ applicationID: CFString!) -> Bool

func CFPreferencesAppValueIsForced(_ key: CFString!, _ applicationID: CFString!) -> Boolean

func CFPreferencesAppValueIsForced(_ key: CFString!, _ applicationID: CFString!) -> Bool

func CFPreferencesGetAppBooleanValue(_ key: CFString!, _ applicationID: CFString!, _ keyExistsAndHasValidFormat: UnsafeMutablePointer<Boolean>) -> Boolean

func CFPreferencesGetAppBooleanValue(_ key: CFString!, _ applicationID: CFString!, _ keyExistsAndHasValidFormat: UnsafeMutablePointer<DarwinBoolean>) -> Bool

func CFPreferencesGetAppIntegerValue(_ key: CFString!, _ applicationID: CFString!, _ keyExistsAndHasValidFormat: UnsafeMutablePointer<Boolean>) -> CFIndex

func CFPreferencesGetAppIntegerValue(_ key: CFString!, _ applicationID: CFString!, _ keyExistsAndHasValidFormat: UnsafeMutablePointer<DarwinBoolean>) -> CFIndex

func CFPreferencesSynchronize(_ applicationID: CFString!, _ userName: CFString!, _ hostName: CFString!) -> Boolean

func CFPreferencesSynchronize(_ applicationID: CFString!, _ userName: CFString!, _ hostName: CFString!) -> Bool

func CFPropertyListIsValid(_ plist: CFPropertyList!, _ format: CFPropertyListFormat) -> Boolean

func CFPropertyListIsValid(_ plist: CFPropertyList!, _ format: CFPropertyListFormat) -> Bool

typealias CFReadStreamClientCallBack = CFunctionPointer<((CFReadStream!, CFStreamEventType, UnsafeMutablePointer<Void>) -> Void)>

typealias CFReadStreamClientCallBack = (CFReadStream!, CFStreamEventType, UnsafeMutablePointer<Void>) -> Void

func CFReadStreamHasBytesAvailable(_ stream: CFReadStream!) -> Boolean

func CFReadStreamHasBytesAvailable(_ stream: CFReadStream!) -> Bool

func CFReadStreamOpen(_ stream: CFReadStream!) -> Boolean

func CFReadStreamOpen(_ stream: CFReadStream!) -> Bool

func CFReadStreamSetClient(_ stream: CFReadStream!, _ streamEvents: CFOptionFlags, _ clientCB: CFReadStreamClientCallBack, _ clientContext: UnsafeMutablePointer<CFStreamClientContext>) -> Boolean

func CFReadStreamSetClient(_ stream: CFReadStream!, _ streamEvents: CFOptionFlags, _ clientCB: CFReadStreamClientCallBack!, _ clientContext: UnsafeMutablePointer<CFStreamClientContext>) -> Bool

func CFReadStreamSetProperty(_ stream: CFReadStream!, _ propertyName: CFString!, _ propertyValue: AnyObject!) -> Boolean

func CFReadStreamSetProperty(_ stream: CFReadStream!, _ propertyName: CFString!, _ propertyValue: AnyObject!) -> Bool

func CFRunLoopContainsObserver(_ rl: CFRunLoop!, _ observer: CFRunLoopObserver!, _ mode: CFString!) -> Boolean

func CFRunLoopContainsObserver(_ rl: CFRunLoop!, _ observer: CFRunLoopObserver!, _ mode: CFString!) -> Bool

func CFRunLoopContainsSource(_ rl: CFRunLoop!, _ source: CFRunLoopSource!, _ mode: CFString!) -> Boolean

func CFRunLoopContainsSource(_ rl: CFRunLoop!, _ source: CFRunLoopSource!, _ mode: CFString!) -> Bool

func CFRunLoopContainsTimer(_ rl: CFRunLoop!, _ timer: CFRunLoopTimer!, _ mode: CFString!) -> Boolean

func CFRunLoopContainsTimer(_ rl: CFRunLoop!, _ timer: CFRunLoopTimer!, _ mode: CFString!) -> Bool

func CFRunLoopIsWaiting(_ rl: CFRunLoop!) -> Boolean

func CFRunLoopIsWaiting(_ rl: CFRunLoop!) -> Bool

typealias CFRunLoopObserverCallBack = CFunctionPointer<((CFRunLoopObserver!, CFRunLoopActivity, UnsafeMutablePointer<Void>) -> Void)>

typealias CFRunLoopObserverCallBack = (CFRunLoopObserver!, CFRunLoopActivity, UnsafeMutablePointer<Void>) -> Void

func CFRunLoopObserverCreate(_ allocator: CFAllocator!, _ activities: CFOptionFlags, _ repeats: Boolean, _ order: CFIndex, _ callout: CFRunLoopObserverCallBack, _ context: UnsafeMutablePointer<CFRunLoopObserverContext>) -> CFRunLoopObserver!

func CFRunLoopObserverCreate(_ allocator: CFAllocator!, _ activities: CFOptionFlags, _ repeats: Bool, _ order: CFIndex, _ callout: CFRunLoopObserverCallBack!, _ context: UnsafeMutablePointer<CFRunLoopObserverContext>) -> CFRunLoopObserver!

func CFRunLoopObserverCreateWithHandler(_ allocator: CFAllocator!, _ activities: CFOptionFlags, _ repeats: Boolean, _ order: CFIndex, _ block: ((CFRunLoopObserver!, CFRunLoopActivity) -> Void)!) -> CFRunLoopObserver!

func CFRunLoopObserverCreateWithHandler(_ allocator: CFAllocator!, _ activities: CFOptionFlags, _ repeats: Bool, _ order: CFIndex, _ block: ((CFRunLoopObserver!, CFRunLoopActivity) -> Void)!) -> CFRunLoopObserver!

func CFRunLoopObserverDoesRepeat(_ observer: CFRunLoopObserver!) -> Boolean

func CFRunLoopObserverDoesRepeat(_ observer: CFRunLoopObserver!) -> Bool

func CFRunLoopObserverIsValid(_ observer: CFRunLoopObserver!) -> Boolean

func CFRunLoopObserverIsValid(_ observer: CFRunLoopObserver!) -> Bool

func CFRunLoopRunInMode(_ mode: CFString!, _ seconds: CFTimeInterval, _ returnAfterSourceHandled: Boolean) -> Int32

func CFRunLoopRunInMode(_ mode: CFString!, _ seconds: CFTimeInterval, _ returnAfterSourceHandled: Bool) -> CFRunLoopRunResult

func CFRunLoopSourceIsValid(_ source: CFRunLoopSource!) -> Boolean

func CFRunLoopSourceIsValid(_ source: CFRunLoopSource!) -> Bool

typealias CFRunLoopTimerCallBack = CFunctionPointer<((CFRunLoopTimer!, UnsafeMutablePointer<Void>) -> Void)>

typealias CFRunLoopTimerCallBack = (CFRunLoopTimer!, UnsafeMutablePointer<Void>) -> Void

func CFRunLoopTimerCreate(_ allocator: CFAllocator!, _ fireDate: CFAbsoluteTime, _ interval: CFTimeInterval, _ flags: CFOptionFlags, _ order: CFIndex, _ callout: CFRunLoopTimerCallBack, _ context: UnsafeMutablePointer<CFRunLoopTimerContext>) -> CFRunLoopTimer!

func CFRunLoopTimerCreate(_ allocator: CFAllocator!, _ fireDate: CFAbsoluteTime, _ interval: CFTimeInterval, _ flags: CFOptionFlags, _ order: CFIndex, _ callout: CFRunLoopTimerCallBack!, _ context: UnsafeMutablePointer<CFRunLoopTimerContext>) -> CFRunLoopTimer!

func CFRunLoopTimerDoesRepeat(_ timer: CFRunLoopTimer!) -> Boolean

func CFRunLoopTimerDoesRepeat(_ timer: CFRunLoopTimer!) -> Bool

func CFRunLoopTimerIsValid(_ timer: CFRunLoopTimer!) -> Boolean

func CFRunLoopTimerIsValid(_ timer: CFRunLoopTimer!) -> Bool

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

typealias CFSetApplierFunction = (UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> Void

func CFSetApplyFunction(_ theSet: CFSet!, _ applier: CFSetApplierFunction, _ context: UnsafeMutablePointer<Void>)

func CFSetApplyFunction(_ theSet: CFSet!, _ applier: CFSetApplierFunction!, _ context: UnsafeMutablePointer<Void>)

func CFSetContainsValue(_ theSet: CFSet!, _ value: UnsafePointer<Void>) -> Boolean

func CFSetContainsValue(_ theSet: CFSet!, _ value: UnsafePointer<Void>) -> Bool

typealias CFSetCopyDescriptionCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

typealias CFSetCopyDescriptionCallBack = (UnsafePointer<Void>) -> Unmanaged<CFString>!

typealias CFSetEqualCallBack = CFunctionPointer<((UnsafePointer<Void>, UnsafePointer<Void>) -> Boolean)>

typealias CFSetEqualCallBack = (UnsafePointer<Void>, UnsafePointer<Void>) -> DarwinBoolean

func CFSetGetValueIfPresent(_ theSet: CFSet!, _ candidate: UnsafePointer<Void>, _ value: UnsafeMutablePointer<UnsafePointer<Void>>) -> Boolean

func CFSetGetValueIfPresent(_ theSet: CFSet!, _ candidate: UnsafePointer<Void>, _ value: UnsafeMutablePointer<UnsafePointer<Void>>) -> Bool

typealias CFSetHashCallBack = CFunctionPointer<((UnsafePointer<Void>) -> CFHashCode)>

typealias CFSetHashCallBack = (UnsafePointer<Void>) -> CFHashCode

typealias CFSetReleaseCallBack = CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> Void)>

typealias CFSetReleaseCallBack = (CFAllocator!, UnsafePointer<Void>) -> Void

typealias CFSetRetainCallBack = CFunctionPointer<((CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>)>

typealias CFSetRetainCallBack = (CFAllocator!, UnsafePointer<Void>) -> UnsafePointer<Void>

typealias CFSocketCallBack = CFunctionPointer<((CFSocket!, CFSocketCallBackType, CFData!, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> Void)>

typealias CFSocketCallBack = (CFSocket!, CFSocketCallBackType, CFData!, UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> Void

func CFSocketCreate(_ allocator: CFAllocator!, _ protocolFamily: Int32, _ socketType: Int32, _ `protocol`: Int32, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack, _ context: UnsafePointer<CFSocketContext>) -> CFSocket!

func CFSocketCreate(_ allocator: CFAllocator!, _ protocolFamily: Int32, _ socketType: Int32, _ `protocol`: Int32, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack!, _ context: UnsafePointer<CFSocketContext>) -> CFSocket!

func CFSocketCreateConnectedToSocketSignature(_ allocator: CFAllocator!, _ signature: UnsafePointer<CFSocketSignature>, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack, _ context: UnsafePointer<CFSocketContext>, _ timeout: CFTimeInterval) -> CFSocket!

func CFSocketCreateConnectedToSocketSignature(_ allocator: CFAllocator!, _ signature: UnsafePointer<CFSocketSignature>, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack!, _ context: UnsafePointer<CFSocketContext>, _ timeout: CFTimeInterval) -> CFSocket!

func CFSocketCreateWithNative(_ allocator: CFAllocator!, _ sock: CFSocketNativeHandle, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack, _ context: UnsafePointer<CFSocketContext>) -> CFSocket!

func CFSocketCreateWithNative(_ allocator: CFAllocator!, _ sock: CFSocketNativeHandle, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack!, _ context: UnsafePointer<CFSocketContext>) -> CFSocket!

func CFSocketCreateWithSocketSignature(_ allocator: CFAllocator!, _ signature: UnsafePointer<CFSocketSignature>, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack, _ context: UnsafePointer<CFSocketContext>) -> CFSocket!

func CFSocketCreateWithSocketSignature(_ allocator: CFAllocator!, _ signature: UnsafePointer<CFSocketSignature>, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack!, _ context: UnsafePointer<CFSocketContext>) -> CFSocket!

func CFSocketIsValid(_ s: CFSocket!) -> Boolean

func CFSocketIsValid(_ s: CFSocket!) -> Bool

func CFStringCreateWithBytes(_ alloc: CFAllocator!, _ bytes: UnsafePointer<UInt8>, _ numBytes: CFIndex, _ encoding: CFStringEncoding, _ isExternalRepresentation: Boolean) -> CFString!

func CFStringCreateWithBytes(_ alloc: CFAllocator!, _ bytes: UnsafePointer<UInt8>, _ numBytes: CFIndex, _ encoding: CFStringEncoding, _ isExternalRepresentation: Bool) -> CFString!

func CFStringCreateWithBytesNoCopy(_ alloc: CFAllocator!, _ bytes: UnsafePointer<UInt8>, _ numBytes: CFIndex, _ encoding: CFStringEncoding, _ isExternalRepresentation: Boolean, _ contentsDeallocator: CFAllocator!) -> CFString!

func CFStringCreateWithBytesNoCopy(_ alloc: CFAllocator!, _ bytes: UnsafePointer<UInt8>, _ numBytes: CFIndex, _ encoding: CFStringEncoding, _ isExternalRepresentation: Bool, _ contentsDeallocator: CFAllocator!) -> CFString!

func CFStringFindCharacterFromSet(_ theString: CFString!, _ theSet: CFCharacterSet!, _ rangeToSearch: CFRange, _ searchOptions: CFStringCompareFlags, _ result: UnsafeMutablePointer<CFRange>) -> Boolean

func CFStringFindCharacterFromSet(_ theString: CFString!, _ theSet: CFCharacterSet!, _ rangeToSearch: CFRange, _ searchOptions: CFStringCompareFlags, _ result: UnsafeMutablePointer<CFRange>) -> Bool

func CFStringFindWithOptions(_ theString: CFString!, _ stringToFind: CFString!, _ rangeToSearch: CFRange, _ searchOptions: CFStringCompareFlags, _ result: UnsafeMutablePointer<CFRange>) -> Boolean

func CFStringFindWithOptions(_ theString: CFString!, _ stringToFind: CFString!, _ rangeToSearch: CFRange, _ searchOptions: CFStringCompareFlags, _ result: UnsafeMutablePointer<CFRange>) -> Bool

func CFStringFindWithOptionsAndLocale(_ theString: CFString!, _ stringToFind: CFString!, _ rangeToSearch: CFRange, _ searchOptions: CFStringCompareFlags, _ locale: CFLocale!, _ result: UnsafeMutablePointer<CFRange>) -> Boolean

func CFStringFindWithOptionsAndLocale(_ theString: CFString!, _ stringToFind: CFString!, _ rangeToSearch: CFRange, _ searchOptions: CFStringCompareFlags, _ locale: CFLocale!, _ result: UnsafeMutablePointer<CFRange>) -> Bool

func CFStringGetBytes(_ theString: CFString!, _ range: CFRange, _ encoding: CFStringEncoding, _ lossByte: UInt8, _ isExternalRepresentation: Boolean, _ buffer: UnsafeMutablePointer<UInt8>, _ maxBufLen: CFIndex, _ usedBufLen: UnsafeMutablePointer<CFIndex>) -> CFIndex

func CFStringGetBytes(_ theString: CFString!, _ range: CFRange, _ encoding: CFStringEncoding, _ lossByte: UInt8, _ isExternalRepresentation: Bool, _ buffer: UnsafeMutablePointer<UInt8>, _ maxBufLen: CFIndex, _ usedBufLen: UnsafeMutablePointer<CFIndex>) -> CFIndex

func CFStringGetCString(_ theString: CFString!, _ buffer: UnsafeMutablePointer<Int8>, _ bufferSize: CFIndex, _ encoding: CFStringEncoding) -> Boolean

func CFStringGetCString(_ theString: CFString!, _ buffer: UnsafeMutablePointer<Int8>, _ bufferSize: CFIndex, _ encoding: CFStringEncoding) -> Bool

func CFStringGetFileSystemRepresentation(_ string: CFString!, _ buffer: UnsafeMutablePointer<Int8>, _ maxBufLen: CFIndex) -> Boolean

func CFStringGetFileSystemRepresentation(_ string: CFString!, _ buffer: UnsafeMutablePointer<Int8>, _ maxBufLen: CFIndex) -> Bool

func CFStringGetPascalString(_ theString: CFString!, _ buffer: StringPtr, _ bufferSize: CFIndex, _ encoding: CFStringEncoding) -> Boolean

func CFStringGetPascalString(_ theString: CFString!, _ buffer: StringPtr, _ bufferSize: CFIndex, _ encoding: CFStringEncoding) -> Bool

func CFStringGetSurrogatePairForLongCharacter(_ character: UTF32Char, _ surrogates: UnsafeMutablePointer<UniChar>) -> Boolean

func CFStringGetSurrogatePairForLongCharacter(_ character: UTF32Char, _ surrogates: UnsafeMutablePointer<UniChar>) -> Bool

func CFStringHasPrefix(_ theString: CFString!, _ prefix: CFString!) -> Boolean

func CFStringHasPrefix(_ theString: CFString!, _ prefix: CFString!) -> Bool

func CFStringHasSuffix(_ theString: CFString!, _ suffix: CFString!) -> Boolean

func CFStringHasSuffix(_ theString: CFString!, _ suffix: CFString!) -> Bool

func CFStringIsEncodingAvailable(_ encoding: CFStringEncoding) -> Boolean

func CFStringIsEncodingAvailable(_ encoding: CFStringEncoding) -> Bool

func CFStringIsHyphenationAvailableForLocale(_ locale: CFLocale!) -> Boolean

func CFStringIsHyphenationAvailableForLocale(_ locale: CFLocale!) -> Bool

func CFStringIsSurrogateHighCharacter(_ character: UniChar) -> Boolean

func CFStringIsSurrogateHighCharacter(_ character: UniChar) -> Bool

func CFStringIsSurrogateLowCharacter(_ character: UniChar) -> Boolean

func CFStringIsSurrogateLowCharacter(_ character: UniChar) -> Bool

func CFStringTransform(_ string: CFMutableString!, _ range: UnsafeMutablePointer<CFRange>, _ transform: CFString!, _ reverse: Boolean) -> Boolean

func CFStringTransform(_ string: CFMutableString!, _ range: UnsafeMutablePointer<CFRange>, _ transform: CFString!, _ reverse: Bool) -> Bool

func CFTimeZoneCreateWithName(_ allocator: CFAllocator!, _ name: CFString!, _ tryAbbrev: Boolean) -> CFTimeZone!

func CFTimeZoneCreateWithName(_ allocator: CFAllocator!, _ name: CFString!, _ tryAbbrev: Bool) -> CFTimeZone!

func CFTimeZoneIsDaylightSavingTime(_ tz: CFTimeZone!, _ at: CFAbsoluteTime) -> Boolean

func CFTimeZoneIsDaylightSavingTime(_ tz: CFTimeZone!, _ at: CFAbsoluteTime) -> Bool

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

typealias CFTreeApplierFunction = (UnsafePointer<Void>, UnsafeMutablePointer<Void>) -> Void

func CFTreeApplyFunctionToChildren(_ tree: CFTree!, _ applier: CFTreeApplierFunction, _ context: UnsafeMutablePointer<Void>)

func CFTreeApplyFunctionToChildren(_ tree: CFTree!, _ applier: CFTreeApplierFunction!, _ context: UnsafeMutablePointer<Void>)

typealias CFTreeCopyDescriptionCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

typealias CFTreeCopyDescriptionCallBack = (UnsafePointer<Void>) -> Unmanaged<CFString>!

typealias CFTreeReleaseCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Void)>

typealias CFTreeReleaseCallBack = (UnsafePointer<Void>) -> Void

typealias CFTreeRetainCallBack = CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

typealias CFTreeRetainCallBack = (UnsafePointer<Void>) -> UnsafePointer<Void>

func CFTreeSortChildren(_ tree: CFTree!, _ comparator: CFComparatorFunction, _ context: UnsafeMutablePointer<Void>)

func CFTreeSortChildren(_ tree: CFTree!, _ comparator: CFComparatorFunction!, _ context: UnsafeMutablePointer<Void>)

func CFURLCanBeDecomposed(_ anURL: CFURL!) -> Boolean

func CFURLCanBeDecomposed(_ anURL: CFURL!) -> Bool

func CFURLCopyResourcePropertyForKey(_ url: CFURL!, _ key: CFString!, _ propertyValueTypeRefPtr: UnsafeMutablePointer<Void>, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Boolean

func CFURLCopyResourcePropertyForKey(_ url: CFURL!, _ key: CFString!, _ propertyValueTypeRefPtr: UnsafeMutablePointer<Void>, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool

func CFURLCopyStrictPath(_ anURL: CFURL!, _ isAbsolute: UnsafeMutablePointer<Boolean>) -> CFString!

func CFURLCopyStrictPath(_ anURL: CFURL!, _ isAbsolute: UnsafeMutablePointer<DarwinBoolean>) -> CFString!

func CFURLCreateAbsoluteURLWithBytes(_ alloc: CFAllocator!, _ relativeURLBytes: UnsafePointer<UInt8>, _ length: CFIndex, _ encoding: CFStringEncoding, _ baseURL: CFURL!, _ useCompatibilityMode: Boolean) -> CFURL!

func CFURLCreateAbsoluteURLWithBytes(_ alloc: CFAllocator!, _ relativeURLBytes: UnsafePointer<UInt8>, _ length: CFIndex, _ encoding: CFStringEncoding, _ baseURL: CFURL!, _ useCompatibilityMode: Bool) -> CFURL!

func CFURLCreateByResolvingBookmarkData(_ allocator: CFAllocator!, _ bookmark: CFData!, _ options: CFURLBookmarkResolutionOptions, _ relativeToURL: CFURL!, _ resourcePropertiesToInclude: CFArray!, _ isStale: UnsafeMutablePointer<Boolean>, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Unmanaged<CFURL>!

func CFURLCreateByResolvingBookmarkData(_ allocator: CFAllocator!, _ bookmark: CFData!, _ options: CFURLBookmarkResolutionOptions, _ relativeToURL: CFURL!, _ resourcePropertiesToInclude: CFArray!, _ isStale: UnsafeMutablePointer<DarwinBoolean>, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Unmanaged<CFURL>!

func CFURLCreateCopyAppendingPathComponent(_ allocator: CFAllocator!, _ url: CFURL!, _ pathComponent: CFString!, _ isDirectory: Boolean) -> CFURL!

func CFURLCreateCopyAppendingPathComponent(_ allocator: CFAllocator!, _ url: CFURL!, _ pathComponent: CFString!, _ isDirectory: Bool) -> CFURL!

func CFURLCreateData(_ allocator: CFAllocator!, _ url: CFURL!, _ encoding: CFStringEncoding, _ escapeWhitespace: Boolean) -> CFData!

func CFURLCreateData(_ allocator: CFAllocator!, _ url: CFURL!, _ encoding: CFStringEncoding, _ escapeWhitespace: Bool) -> CFData!

func CFURLCreateFromFileSystemRepresentation(_ allocator: CFAllocator!, _ buffer: UnsafePointer<UInt8>, _ bufLen: CFIndex, _ isDirectory: Boolean) -> CFURL!

func CFURLCreateFromFileSystemRepresentation(_ allocator: CFAllocator!, _ buffer: UnsafePointer<UInt8>, _ bufLen: CFIndex, _ isDirectory: Bool) -> CFURL!

func CFURLCreateFromFileSystemRepresentationRelativeToBase(_ allocator: CFAllocator!, _ buffer: UnsafePointer<UInt8>, _ bufLen: CFIndex, _ isDirectory: Boolean, _ baseURL: CFURL!) -> CFURL!

func CFURLCreateFromFileSystemRepresentationRelativeToBase(_ allocator: CFAllocator!, _ buffer: UnsafePointer<UInt8>, _ bufLen: CFIndex, _ isDirectory: Bool, _ baseURL: CFURL!) -> CFURL!

func CFURLCreateWithFileSystemPath(_ allocator: CFAllocator!, _ filePath: CFString!, _ pathStyle: CFURLPathStyle, _ isDirectory: Boolean) -> CFURL!

func CFURLCreateWithFileSystemPath(_ allocator: CFAllocator!, _ filePath: CFString!, _ pathStyle: CFURLPathStyle, _ isDirectory: Bool) -> CFURL!

func CFURLCreateWithFileSystemPathRelativeToBase(_ allocator: CFAllocator!, _ filePath: CFString!, _ pathStyle: CFURLPathStyle, _ isDirectory: Boolean, _ baseURL: CFURL!) -> CFURL!

func CFURLCreateWithFileSystemPathRelativeToBase(_ allocator: CFAllocator!, _ filePath: CFString!, _ pathStyle: CFURLPathStyle, _ isDirectory: Bool, _ baseURL: CFURL!) -> CFURL!

func CFURLGetFileSystemRepresentation(_ url: CFURL!, _ resolveAgainstBase: Boolean, _ buffer: UnsafeMutablePointer<UInt8>, _ maxBufLen: CFIndex) -> Boolean

func CFURLGetFileSystemRepresentation(_ url: CFURL!, _ resolveAgainstBase: Bool, _ buffer: UnsafeMutablePointer<UInt8>, _ maxBufLen: CFIndex) -> Bool

func CFURLHasDirectoryPath(_ anURL: CFURL!) -> Boolean

func CFURLHasDirectoryPath(_ anURL: CFURL!) -> Bool

func CFURLIsFileReferenceURL(_ url: CFURL!) -> Boolean

func CFURLIsFileReferenceURL(_ url: CFURL!) -> Bool

func CFURLResourceIsReachable(_ url: CFURL!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Boolean

func CFURLResourceIsReachable(_ url: CFURL!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool

func CFURLSetResourcePropertiesForKeys(_ url: CFURL!, _ keyedPropertyValues: CFDictionary!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Boolean

func CFURLSetResourcePropertiesForKeys(_ url: CFURL!, _ keyedPropertyValues: CFDictionary!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool

func CFURLSetResourcePropertyForKey(_ url: CFURL!, _ key: CFString!, _ propertyValue: AnyObject!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Boolean

func CFURLSetResourcePropertyForKey(_ url: CFURL!, _ key: CFString!, _ propertyValue: AnyObject!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool

func CFURLStartAccessingSecurityScopedResource(_ url: CFURL!) -> Boolean

func CFURLStartAccessingSecurityScopedResource(_ url: CFURL!) -> Bool

func CFURLWriteBookmarkDataToFile(_ bookmarkRef: CFData!, _ fileURL: CFURL!, _ options: CFURLBookmarkFileCreationOptions, _ errorRef: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Boolean

func CFURLWriteBookmarkDataToFile(_ bookmarkRef: CFData!, _ fileURL: CFURL!, _ options: CFURLBookmarkFileCreationOptions, _ errorRef: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool

typealias CFUserNotificationCallBack = CFunctionPointer<((CFUserNotification!, CFOptionFlags) -> Void)>

typealias CFUserNotificationCallBack = (CFUserNotification!, CFOptionFlags) -> Void

func CFUserNotificationCreateRunLoopSource(_ allocator: CFAllocator!, _ userNotification: CFUserNotification!, _ callout: CFUserNotificationCallBack, _ order: CFIndex) -> CFRunLoopSource!

func CFUserNotificationCreateRunLoopSource(_ allocator: CFAllocator!, _ userNotification: CFUserNotification!, _ callout: CFUserNotificationCallBack!, _ order: CFIndex) -> CFRunLoopSource!

func CFWriteStreamCanAcceptBytes(_ stream: CFWriteStream!) -> Boolean

func CFWriteStreamCanAcceptBytes(_ stream: CFWriteStream!) -> Bool

typealias CFWriteStreamClientCallBack = CFunctionPointer<((CFWriteStream!, CFStreamEventType, UnsafeMutablePointer<Void>) -> Void)>

typealias CFWriteStreamClientCallBack = (CFWriteStream!, CFStreamEventType, UnsafeMutablePointer<Void>) -> Void

func CFWriteStreamOpen(_ stream: CFWriteStream!) -> Boolean

func CFWriteStreamOpen(_ stream: CFWriteStream!) -> Bool

func CFWriteStreamSetClient(_ stream: CFWriteStream!, _ streamEvents: CFOptionFlags, _ clientCB: CFWriteStreamClientCallBack, _ clientContext: UnsafeMutablePointer<CFStreamClientContext>) -> Boolean

func CFWriteStreamSetClient(_ stream: CFWriteStream!, _ streamEvents: CFOptionFlags, _ clientCB: CFWriteStreamClientCallBack!, _ clientContext: UnsafeMutablePointer<CFStreamClientContext>) -> Bool

func CFWriteStreamSetProperty(_ stream: CFWriteStream!, _ propertyName: CFString!, _ propertyValue: AnyObject!) -> Boolean

func CFWriteStreamSetProperty(_ stream: CFWriteStream!, _ propertyName: CFString!, _ propertyValue: AnyObject!) -> Bool

typealias CFXMLParserAddChildCallBack = CFunctionPointer<((CFXMLParser!, UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>) -> Void)>

typealias CFXMLParserAddChildCallBack = (CFXMLParser!, UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>) -> Void

typealias CFXMLParserCopyDescriptionCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Unmanaged<CFString>!)>

typealias CFXMLParserCopyDescriptionCallBack = (UnsafePointer<Void>) -> Unmanaged<CFString>!

typealias CFXMLParserCreateXMLStructureCallBack = CFunctionPointer<((CFXMLParser!, CFXMLNode!, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>)>

typealias CFXMLParserCreateXMLStructureCallBack = (CFXMLParser!, CFXMLNode!, UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>

typealias CFXMLParserEndXMLStructureCallBack = CFunctionPointer<((CFXMLParser!, UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>) -> Void)>

typealias CFXMLParserEndXMLStructureCallBack = (CFXMLParser!, UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>) -> Void

typealias CFXMLParserHandleErrorCallBack = CFunctionPointer<((CFXMLParser!, CFXMLParserStatusCode, UnsafeMutablePointer<Void>) -> Boolean)>

typealias CFXMLParserHandleErrorCallBack = (CFXMLParser!, CFXMLParserStatusCode, UnsafeMutablePointer<Void>) -> DarwinBoolean

typealias CFXMLParserReleaseCallBack = CFunctionPointer<((UnsafePointer<Void>) -> Void)>

typealias CFXMLParserReleaseCallBack = (UnsafePointer<Void>) -> Void

typealias CFXMLParserResolveExternalEntityCallBack = CFunctionPointer<((CFXMLParser!, UnsafeMutablePointer<CFXMLExternalID>, UnsafeMutablePointer<Void>) -> Unmanaged<CFData>!)>

typealias CFXMLParserResolveExternalEntityCallBack = (CFXMLParser!, UnsafeMutablePointer<CFXMLExternalID>, UnsafeMutablePointer<Void>) -> Unmanaged<CFData>!

typealias CFXMLParserRetainCallBack = CFunctionPointer<((UnsafePointer<Void>) -> UnsafePointer<Void>)>

typealias CFXMLParserRetainCallBack = (UnsafePointer<Void>) -> UnsafePointer<Void>

var kCFCalendarComponentsWrap: Int { get }

var kCFCalendarComponentsWrap: CFOptionFlags { get }

var kCFFileDescriptorReadCallBack: Int { get }

var kCFFileDescriptorReadCallBack: CFOptionFlags { get }

var kCFFileDescriptorWriteCallBack: Int { get }

var kCFFileDescriptorWriteCallBack: CFOptionFlags { get }

var kCFMessagePortBecameInvalidError: Int { get }

var kCFMessagePortBecameInvalidError: Int32 { get }

var kCFMessagePortIsInvalid: Int { get }

var kCFMessagePortIsInvalid: Int32 { get }

var kCFMessagePortReceiveTimeout: Int { get }

var kCFMessagePortReceiveTimeout: Int32 { get }

var kCFMessagePortSendTimeout: Int { get }

var kCFMessagePortSendTimeout: Int32 { get }

var kCFMessagePortSuccess: Int { get }

var kCFMessagePortSuccess: Int32 { get }

var kCFMessagePortTransportError: Int { get }

var kCFMessagePortTransportError: Int32 { get }

var kCFNotFound: Int { get }

let kCFNotFound: CFIndex

var kCFNotificationDeliverImmediately: Int { get }

var kCFNotificationDeliverImmediately: CFOptionFlags { get }

var kCFNotificationPostToAllSessions: Int { get }

var kCFNotificationPostToAllSessions: CFOptionFlags { get }

var kCFPropertyListReadCorruptError: Int { get }

var kCFPropertyListReadCorruptError: CFIndex { get }

var kCFPropertyListReadStreamError: Int { get }

var kCFPropertyListReadStreamError: CFIndex { get }

var kCFPropertyListReadUnknownVersionError: Int { get }

var kCFPropertyListReadUnknownVersionError: CFIndex { get }

var kCFPropertyListWriteStreamError: Int { get }

var kCFPropertyListWriteStreamError: CFIndex { get }

var kCFSocketAutomaticallyReenableAcceptCallBack: Int { get }

var kCFSocketAutomaticallyReenableAcceptCallBack: CFOptionFlags { get }

var kCFSocketAutomaticallyReenableDataCallBack: Int { get }

var kCFSocketAutomaticallyReenableDataCallBack: CFOptionFlags { get }

var kCFSocketAutomaticallyReenableReadCallBack: Int { get }

var kCFSocketAutomaticallyReenableReadCallBack: CFOptionFlags { get }

var kCFSocketAutomaticallyReenableWriteCallBack: Int { get }

var kCFSocketAutomaticallyReenableWriteCallBack: CFOptionFlags { get }

var kCFSocketCloseOnInvalidate: Int { get }

var kCFSocketCloseOnInvalidate: CFOptionFlags { get }

var kCFSocketLeaveErrors: Int { get }

var kCFSocketLeaveErrors: CFOptionFlags { get }

var kCFStringTokenizerAttributeLanguage: Int { get }

var kCFStringTokenizerAttributeLanguage: CFOptionFlags { get }

var kCFStringTokenizerAttributeLatinTranscription: Int { get }

var kCFStringTokenizerAttributeLatinTranscription: CFOptionFlags { get }

var kCFStringTokenizerUnitLineBreak: Int { get }

var kCFStringTokenizerUnitLineBreak: CFOptionFlags { get }

var kCFStringTokenizerUnitParagraph: Int { get }

var kCFStringTokenizerUnitParagraph: CFOptionFlags { get }

var kCFStringTokenizerUnitSentence: Int { get }

var kCFStringTokenizerUnitSentence: CFOptionFlags { get }

var kCFStringTokenizerUnitWord: Int { get }

var kCFStringTokenizerUnitWord: CFOptionFlags { get }

var kCFStringTokenizerUnitWordBoundary: Int { get }

var kCFStringTokenizerUnitWordBoundary: CFOptionFlags { get }

var kCFUserNotificationAlternateResponse: Int { get }

var kCFUserNotificationAlternateResponse: CFOptionFlags { get }

var kCFUserNotificationCancelResponse: Int { get }

var kCFUserNotificationCancelResponse: CFOptionFlags { get }

var kCFUserNotificationCautionAlertLevel: Int { get }

var kCFUserNotificationCautionAlertLevel: CFOptionFlags { get }

var kCFUserNotificationDefaultResponse: Int { get }

var kCFUserNotificationDefaultResponse: CFOptionFlags { get }

var kCFUserNotificationNoDefaultButtonFlag: Int { get }

var kCFUserNotificationNoDefaultButtonFlag: CFOptionFlags { get }

var kCFUserNotificationNoteAlertLevel: Int { get }

var kCFUserNotificationNoteAlertLevel: CFOptionFlags { get }

var kCFUserNotificationOtherResponse: Int { get }

var kCFUserNotificationOtherResponse: CFOptionFlags { get }

var kCFUserNotificationPlainAlertLevel: Int { get }

var kCFUserNotificationPlainAlertLevel: CFOptionFlags { get }

var kCFUserNotificationStopAlertLevel: Int { get }

var kCFUserNotificationStopAlertLevel: CFOptionFlags { get }

var kCFUserNotificationUseRadioButtonsFlag: Int { get }

var kCFUserNotificationUseRadioButtonsFlag: CFOptionFlags { get }

var kCFXMLNodeCurrentVersion: Int { get }

var kCFXMLNodeCurrentVersion: CFIndex { get }