struct CFAllocatorContext {
    var version: CFIndex
    var info: UnsafePointer<()>
    var retain: CFAllocatorRetainCallBack
    var release: CFAllocatorReleaseCallBack
    var copyDescription: CFAllocatorCopyDescriptionCallBack
    var allocate: CFAllocatorAllocateCallBack
    var reallocate: CFAllocatorReallocateCallBack
    var deallocate: CFAllocatorDeallocateCallBack
    var 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 info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

struct CFArrayCallBacks {
    var version: CFIndex
    var retain: CFArrayRetainCallBack
    var release: CFArrayReleaseCallBack
    var copyDescription: CFArrayCopyDescriptionCallBack
    var 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)
}

struct CFBagCallBacks {
    var version: CFIndex
    var retain: CFBagRetainCallBack
    var release: CFBagReleaseCallBack
    var copyDescription: CFBagCopyDescriptionCallBack
    var equal: CFBagEqualCallBack
    var 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)
}

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

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

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

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

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

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

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

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

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

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

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

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>!)>)
}

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

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

var retain: CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

struct CFCalendarUnit : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFDataSearchFlags : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: CFOptionFlags
    static var Backwards: CFDataSearchFlags { get }
    static var Anchored: CFDataSearchFlags { get }
}

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

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFDictionaryKeyCallBacks {
    var version: CFIndex
    var retain: CFDictionaryRetainCallBack
    var release: CFDictionaryReleaseCallBack
    var copyDescription: CFDictionaryCopyDescriptionCallBack
    var equal: CFDictionaryEqualCallBack
    var 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)
}

struct CFDictionaryValueCallBacks {
    var version: CFIndex
    var retain: CFDictionaryRetainCallBack
    var release: CFDictionaryReleaseCallBack
    var copyDescription: CFDictionaryCopyDescriptionCallBack
    var 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)
}

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

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>!)>)
}

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

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

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

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

struct CFFileSecurityClearOptions : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFGregorianDate {
    var year: Int32
    var month: Int8
    var day: Int8
    var hour: Int8
    var minute: Int8
    var second: Double
}

struct CFGregorianDate {
    var year: Int32
    var month: Int8
    var day: Int8
    var hour: Int8
    var minute: Int8
    var second: Double
    init()
    init(year year: Int32, month month: Int8, day day: Int8, hour hour: Int8, minute minute: Int8, second second: Double)
}

struct CFGregorianUnitFlags : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFGregorianUnits {
    var years: Int32
    var months: Int32
    var days: Int32
    var hours: Int32
    var minutes: Int32
    var seconds: Double
}

struct CFGregorianUnits {
    var years: Int32
    var months: Int32
    var days: Int32
    var hours: Int32
    var minutes: Int32
    var seconds: Double
    init()
    init(years years: Int32, months months: Int32, days days: Int32, hours hours: Int32, minutes minutes: Int32, seconds seconds: Double)
}

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

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>!)>)
}

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

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

var retain: CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

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

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>!)>)
}

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

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

var retain: CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

struct CFNumberFormatterOptionFlags : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: CFOptionFlags
    static var ParseIntegersOnly: CFNumberFormatterOptionFlags { get }
}

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

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFPropertyListMutabilityOptions : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: CFOptionFlags
    static var Immutable: CFPropertyListMutabilityOptions { get }
    static var MutableContainers: CFPropertyListMutabilityOptions { get }
    static var MutableContainersAndLeaves: CFPropertyListMutabilityOptions { 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFRange {
    var location: CFIndex
    var length: CFIndex
}

struct CFRange {
    var location: CFIndex
    var length: CFIndex
    init()
    init(location location: CFIndex, length length: CFIndex)
}

struct CFRunLoopActivity : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

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

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>!)>)
}

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

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

var retain: CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

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

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

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

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

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

var equal: CFunctionPointer<((ConstUnsafePointer<()>, ConstUnsafePointer<()>) -> Boolean)>

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

var hash: CFunctionPointer<((ConstUnsafePointer<()>) -> CFHashCode)>

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

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

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

var retain: CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

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

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

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

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

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

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

var equal: CFunctionPointer<((ConstUnsafePointer<()>, ConstUnsafePointer<()>) -> Boolean)>

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

var getPort: CFunctionPointer<((UnsafePointer<()>) -> mach_port_t)>

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

var hash: CFunctionPointer<((ConstUnsafePointer<()>) -> CFHashCode)>

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

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

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

var retain: CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

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

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>!)>)
}

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

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

var retain: CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

struct CFSetCallBacks {
    var version: CFIndex
    var retain: CFSetRetainCallBack
    var release: CFSetReleaseCallBack
    var copyDescription: CFSetCopyDescriptionCallBack
    var equal: CFSetEqualCallBack
    var 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)
}

struct CFSocketCallBackType : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

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

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>!)>)
}

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

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

var retain: CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

struct CFSocketSignature {
    var protocolFamily: Int32
    var socketType: Int32
    var `protocol`: Int32
    var address: Unmanaged<CFData>!
}

struct CFSocketSignature {
    var protocolFamily: Int32
    var socketType: Int32
    var `protocol`: Int32
    var address: Unmanaged<CFData>!
    init()
    init(protocolFamily protocolFamily: Int32, socketType socketType: Int32, `protocol` `protocol`: Int32, address address: Unmanaged<CFData>!)
}

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

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>!)>)
}

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

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

var info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

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

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

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

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

struct CFStreamError {
    var domain: CFIndex
    var error: Int32
}

struct CFStreamError {
    var domain: CFIndex
    var error: Int32
    init()
    init(domain domain: CFIndex, error error: Int32)
}

struct CFStreamEventType : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFStringCompareFlags : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFStringInlineBuffer {
    var buffer: (UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar)
    var theString: Unmanaged<CFString>!
    var directUniCharBuffer: ConstUnsafePointer<UniChar>
    var directCStringBuffer: ConstUnsafePointer<Int8>
    var rangeToBuffer: CFRange
    var bufferedRangeStart: CFIndex
    var bufferedRangeEnd: CFIndex
}

struct CFStringInlineBuffer {
    var buffer: (UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar)
    var theString: Unmanaged<CFString>!
    var directUniCharBuffer: UnsafePointer<UniChar>
    var directCStringBuffer: UnsafePointer<Int8>
    var rangeToBuffer: CFRange
    var bufferedRangeStart: CFIndex
    var bufferedRangeEnd: CFIndex
    init()
    init(buffer buffer: (UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar, UniChar), theString theString: Unmanaged<CFString>!, directUniCharBuffer directUniCharBuffer: UnsafePointer<UniChar>, directCStringBuffer directCStringBuffer: UnsafePointer<Int8>, rangeToBuffer rangeToBuffer: CFRange, bufferedRangeStart bufferedRangeStart: CFIndex, bufferedRangeEnd bufferedRangeEnd: CFIndex)
}

var directCStringBuffer: ConstUnsafePointer<Int8>

var directCStringBuffer: UnsafePointer<Int8>

var directUniCharBuffer: ConstUnsafePointer<UniChar>

var directUniCharBuffer: UnsafePointer<UniChar>

struct CFStringTokenizerTokenType : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFSwappedFloat32 {
    var v: UInt32
}

struct CFSwappedFloat32 {
    var v: UInt32
    init()
    init(v v: UInt32)
}

struct CFSwappedFloat64 {
    var v: UInt64
}

struct CFSwappedFloat64 {
    var v: UInt64
    init()
    init(v v: UInt64)
}

struct CFTreeContext {
    var version: CFIndex
    var info: UnsafePointer<()>
    var retain: CFTreeRetainCallBack
    var release: CFTreeReleaseCallBack
    var 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 info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

struct CFURLBookmarkCreationOptions : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFURLBookmarkResolutionOptions : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFURLEnumeratorOptions : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFUUIDBytes {
    var byte0: UInt8
    var byte1: UInt8
    var byte2: UInt8
    var byte3: UInt8
    var byte4: UInt8
    var byte5: UInt8
    var byte6: UInt8
    var byte7: UInt8
    var byte8: UInt8
    var byte9: UInt8
    var byte10: UInt8
    var byte11: UInt8
    var byte12: UInt8
    var byte13: UInt8
    var byte14: UInt8
    var byte15: UInt8
}

struct CFUUIDBytes {
    var byte0: UInt8
    var byte1: UInt8
    var byte2: UInt8
    var byte3: UInt8
    var byte4: UInt8
    var byte5: UInt8
    var byte6: UInt8
    var byte7: UInt8
    var byte8: UInt8
    var byte9: UInt8
    var byte10: UInt8
    var byte11: UInt8
    var byte12: UInt8
    var byte13: UInt8
    var byte14: UInt8
    var byte15: UInt8
    init()
    init(byte0 byte0: UInt8, byte1 byte1: UInt8, byte2 byte2: UInt8, byte3 byte3: UInt8, byte4 byte4: UInt8, byte5 byte5: UInt8, byte6 byte6: UInt8, byte7 byte7: UInt8, byte8 byte8: UInt8, byte9 byte9: UInt8, byte10 byte10: UInt8, byte11 byte11: UInt8, byte12 byte12: UInt8, byte13 byte13: UInt8, byte14 byte14: UInt8, byte15 byte15: UInt8)
}

struct CFXMLAttributeDeclarationInfo {
    var attributeName: Unmanaged<CFString>!
    var typeString: Unmanaged<CFString>!
    var defaultString: Unmanaged<CFString>!
}

struct CFXMLAttributeDeclarationInfo {
    var attributeName: Unmanaged<CFString>!
    var typeString: Unmanaged<CFString>!
    var defaultString: Unmanaged<CFString>!
    init()
    init(attributeName attributeName: Unmanaged<CFString>!, typeString typeString: Unmanaged<CFString>!, defaultString defaultString: Unmanaged<CFString>!)
}

struct CFXMLAttributeListDeclarationInfo {
    var numberOfAttributes: CFIndex
    var attributes: UnsafePointer<CFXMLAttributeDeclarationInfo>
}

struct CFXMLAttributeListDeclarationInfo {
    var numberOfAttributes: CFIndex
    var attributes: UnsafeMutablePointer<CFXMLAttributeDeclarationInfo>
    init()
    init(numberOfAttributes numberOfAttributes: CFIndex, attributes attributes: UnsafeMutablePointer<CFXMLAttributeDeclarationInfo>)
}

var attributes: UnsafePointer<CFXMLAttributeDeclarationInfo>

var attributes: UnsafeMutablePointer<CFXMLAttributeDeclarationInfo>

struct CFXMLDocumentInfo {
    var sourceURL: Unmanaged<CFURL>!
    var encoding: CFStringEncoding
}

struct CFXMLDocumentInfo {
    var sourceURL: Unmanaged<CFURL>!
    var encoding: CFStringEncoding
    init()
    init(sourceURL sourceURL: Unmanaged<CFURL>!, encoding encoding: CFStringEncoding)
}

struct CFXMLDocumentTypeInfo {
    var externalID: CFXMLExternalID
}

struct CFXMLDocumentTypeInfo {
    var externalID: CFXMLExternalID
    init()
    init(externalID externalID: CFXMLExternalID)
}

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

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 CFXMLElementTypeDeclarationInfo {
    var contentDescription: Unmanaged<CFString>!
}

struct CFXMLElementTypeDeclarationInfo {
    var contentDescription: Unmanaged<CFString>!
    init()
    init(contentDescription contentDescription: Unmanaged<CFString>!)
}

struct CFXMLEntityInfo {
    var entityType: CFXMLEntityTypeCode
    var replacementText: Unmanaged<CFString>!
    var entityID: CFXMLExternalID
    var notationName: Unmanaged<CFString>!
}

struct CFXMLEntityInfo {
    var entityType: CFXMLEntityTypeCode
    var replacementText: Unmanaged<CFString>!
    var entityID: CFXMLExternalID
    var notationName: Unmanaged<CFString>!
    init()
    init(entityType entityType: CFXMLEntityTypeCode, replacementText replacementText: Unmanaged<CFString>!, entityID entityID: CFXMLExternalID, notationName notationName: Unmanaged<CFString>!)
}

struct CFXMLEntityReferenceInfo {
    var entityType: CFXMLEntityTypeCode
}

struct CFXMLEntityReferenceInfo {
    var entityType: CFXMLEntityTypeCode
    init()
    init(entityType entityType: CFXMLEntityTypeCode)
}

struct CFXMLExternalID {
    var systemID: Unmanaged<CFURL>!
    var publicID: Unmanaged<CFString>!
}

struct CFXMLExternalID {
    var systemID: Unmanaged<CFURL>!
    var publicID: Unmanaged<CFString>!
    init()
    init(systemID systemID: Unmanaged<CFURL>!, publicID publicID: Unmanaged<CFString>!)
}

struct CFXMLNotationInfo {
    var externalID: CFXMLExternalID
}

struct CFXMLNotationInfo {
    var externalID: CFXMLExternalID
    init()
    init(externalID externalID: CFXMLExternalID)
}

struct CFXMLParserCallBacks {
    var version: CFIndex
    var createXMLStructure: CFXMLParserCreateXMLStructureCallBack
    var addChild: CFXMLParserAddChildCallBack
    var endXMLStructure: CFXMLParserEndXMLStructureCallBack
    var resolveExternalEntity: CFXMLParserResolveExternalEntityCallBack
    var 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)
}

struct CFXMLParserContext {
    var version: CFIndex
    var info: UnsafePointer<()>
    var retain: CFXMLParserRetainCallBack
    var release: CFXMLParserReleaseCallBack
    var 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 info: UnsafePointer<()>

var info: UnsafeMutablePointer<Void>

struct CFXMLParserOptions : RawOptionSet {
    init(_ value: CFOptionFlags)
    var value: 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 : 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 }
}

init(_ value: CFOptionFlags)

init(_ rawValue: CFOptionFlags)

struct CFXMLParserStatusCode : RawOptionSet {
    init(_ value: CFIndex)
    var value: 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 : 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 }
}

init(_ value: CFIndex)

init(_ rawValue: CFIndex)

struct CFXMLProcessingInstructionInfo {
    var dataString: Unmanaged<CFString>!
}

struct CFXMLProcessingInstructionInfo {
    var dataString: Unmanaged<CFString>!
    init()
    init(dataString dataString: Unmanaged<CFString>!)
}

func CFAllocatorAllocate(_ allocator: CFAllocator!, _ size: CFIndex, _ hint: CFOptionFlags) -> UnsafePointer<()>

func CFAllocatorAllocate(_ allocator: CFAllocator!, _ size: CFIndex, _ hint: CFOptionFlags) -> UnsafeMutablePointer<Void>

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

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

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

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

func CFAllocatorCreate(_ allocator: CFAllocator!, _ context: UnsafePointer<CFAllocatorContext>) -> Unmanaged<CFAllocator>!

func CFAllocatorCreate(_ allocator: CFAllocator!, _ context: UnsafeMutablePointer<CFAllocatorContext>) -> Unmanaged<CFAllocator>!

func CFAllocatorDeallocate(_ allocator: CFAllocator!, _ ptr: UnsafePointer<()>)

func CFAllocatorDeallocate(_ allocator: CFAllocator!, _ ptr: UnsafeMutablePointer<Void>)

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

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

func CFAllocatorGetContext(_ allocator: CFAllocator!, _ context: UnsafePointer<CFAllocatorContext>)

func CFAllocatorGetContext(_ allocator: CFAllocator!, _ context: UnsafeMutablePointer<CFAllocatorContext>)

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

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

func CFAllocatorReallocate(_ allocator: CFAllocator!, _ ptr: UnsafePointer<()>, _ newsize: CFIndex, _ hint: CFOptionFlags) -> UnsafePointer<()>

func CFAllocatorReallocate(_ allocator: CFAllocator!, _ ptr: UnsafeMutablePointer<Void>, _ newsize: CFIndex, _ hint: CFOptionFlags) -> UnsafeMutablePointer<Void>

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

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

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

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

typealias CFAllocatorRetainCallBack = CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

func CFArrayAppendValue(_ theArray: CFMutableArray!, _ value: ConstUnsafePointer<()>)

func CFArrayAppendValue(_ theArray: CFMutableArray!, _ value: UnsafePointer<Void>)

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

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

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

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

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

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

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

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

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

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

func CFArrayCreate(_ allocator: CFAllocator!, _ values: UnsafePointer<ConstUnsafePointer<()>>, _ numValues: CFIndex, _ callBacks: ConstUnsafePointer<CFArrayCallBacks>) -> CFArray!

func CFArrayCreate(_ allocator: CFAllocator!, _ values: UnsafeMutablePointer<UnsafePointer<Void>>, _ numValues: CFIndex, _ callBacks: UnsafePointer<CFArrayCallBacks>) -> CFArray!

func CFArrayCreateMutable(_ allocator: CFAllocator!, _ capacity: CFIndex, _ callBacks: ConstUnsafePointer<CFArrayCallBacks>) -> CFMutableArray!

func CFArrayCreateMutable(_ allocator: CFAllocator!, _ capacity: CFIndex, _ callBacks: UnsafePointer<CFArrayCallBacks>) -> CFMutableArray!

typealias CFArrayEqualCallBack = CFunctionPointer<((ConstUnsafePointer<()>, ConstUnsafePointer<()>) -> Boolean)>

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

func CFArrayGetCountOfValue(_ theArray: CFArray!, _ range: CFRange, _ value: ConstUnsafePointer<()>) -> CFIndex

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

func CFArrayGetFirstIndexOfValue(_ theArray: CFArray!, _ range: CFRange, _ value: ConstUnsafePointer<()>) -> CFIndex

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

func CFArrayGetLastIndexOfValue(_ theArray: CFArray!, _ range: CFRange, _ value: ConstUnsafePointer<()>) -> CFIndex

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

func CFArrayGetValueAtIndex(_ theArray: CFArray!, _ idx: CFIndex) -> ConstUnsafePointer<()>

func CFArrayGetValueAtIndex(_ theArray: CFArray!, _ idx: CFIndex) -> UnsafePointer<Void>

func CFArrayGetValues(_ theArray: CFArray!, _ range: CFRange, _ values: UnsafePointer<ConstUnsafePointer<()>>)

func CFArrayGetValues(_ theArray: CFArray!, _ range: CFRange, _ values: UnsafeMutablePointer<UnsafePointer<Void>>)

func CFArrayInsertValueAtIndex(_ theArray: CFMutableArray!, _ idx: CFIndex, _ value: ConstUnsafePointer<()>)

func CFArrayInsertValueAtIndex(_ theArray: CFMutableArray!, _ idx: CFIndex, _ value: UnsafePointer<Void>)

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

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

func CFArrayReplaceValues(_ theArray: CFMutableArray!, _ range: CFRange, _ newValues: UnsafePointer<ConstUnsafePointer<()>>, _ newCount: CFIndex)

func CFArrayReplaceValues(_ theArray: CFMutableArray!, _ range: CFRange, _ newValues: UnsafeMutablePointer<UnsafePointer<Void>>, _ newCount: CFIndex)

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

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

func CFArraySetValueAtIndex(_ theArray: CFMutableArray!, _ idx: CFIndex, _ value: ConstUnsafePointer<()>)

func CFArraySetValueAtIndex(_ theArray: CFMutableArray!, _ idx: CFIndex, _ value: UnsafePointer<Void>)

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

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

func CFAttributedStringGetAttribute(_ aStr: CFAttributedString!, _ loc: CFIndex, _ attrName: CFString!, _ effectiveRange: UnsafePointer<CFRange>) -> AnyObject!

func CFAttributedStringGetAttribute(_ aStr: CFAttributedString!, _ loc: CFIndex, _ attrName: CFString!, _ effectiveRange: UnsafeMutablePointer<CFRange>) -> AnyObject!

func CFAttributedStringGetAttributeAndLongestEffectiveRange(_ aStr: CFAttributedString!, _ loc: CFIndex, _ attrName: CFString!, _ inRange: CFRange, _ longestEffectiveRange: UnsafePointer<CFRange>) -> AnyObject!

func CFAttributedStringGetAttributeAndLongestEffectiveRange(_ aStr: CFAttributedString!, _ loc: CFIndex, _ attrName: CFString!, _ inRange: CFRange, _ longestEffectiveRange: UnsafeMutablePointer<CFRange>) -> AnyObject!

func CFAttributedStringGetAttributes(_ aStr: CFAttributedString!, _ loc: CFIndex, _ effectiveRange: UnsafePointer<CFRange>) -> CFDictionary!

func CFAttributedStringGetAttributes(_ aStr: CFAttributedString!, _ loc: CFIndex, _ effectiveRange: UnsafeMutablePointer<CFRange>) -> CFDictionary!

func CFAttributedStringGetAttributesAndLongestEffectiveRange(_ aStr: CFAttributedString!, _ loc: CFIndex, _ inRange: CFRange, _ longestEffectiveRange: UnsafePointer<CFRange>) -> CFDictionary!

func CFAttributedStringGetAttributesAndLongestEffectiveRange(_ aStr: CFAttributedString!, _ loc: CFIndex, _ inRange: CFRange, _ longestEffectiveRange: UnsafeMutablePointer<CFRange>) -> CFDictionary!

func CFBagAddValue(_ theBag: CFMutableBag!, _ value: ConstUnsafePointer<()>)

func CFBagAddValue(_ theBag: CFMutableBag!, _ value: UnsafePointer<Void>)

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

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

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

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

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

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

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

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

func CFBagCreate(_ allocator: CFAllocator!, _ values: UnsafePointer<ConstUnsafePointer<()>>, _ numValues: CFIndex, _ callBacks: ConstUnsafePointer<CFBagCallBacks>) -> CFBag!

func CFBagCreate(_ allocator: CFAllocator!, _ values: UnsafeMutablePointer<UnsafePointer<Void>>, _ numValues: CFIndex, _ callBacks: UnsafePointer<CFBagCallBacks>) -> CFBag!

func CFBagCreateMutable(_ allocator: CFAllocator!, _ capacity: CFIndex, _ callBacks: ConstUnsafePointer<CFBagCallBacks>) -> CFMutableBag!

func CFBagCreateMutable(_ allocator: CFAllocator!, _ capacity: CFIndex, _ callBacks: UnsafePointer<CFBagCallBacks>) -> CFMutableBag!

typealias CFBagEqualCallBack = CFunctionPointer<((ConstUnsafePointer<()>, ConstUnsafePointer<()>) -> Boolean)>

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

func CFBagGetCountOfValue(_ theBag: CFBag!, _ value: ConstUnsafePointer<()>) -> CFIndex

func CFBagGetCountOfValue(_ theBag: CFBag!, _ value: UnsafePointer<Void>) -> CFIndex

func CFBagGetValue(_ theBag: CFBag!, _ value: ConstUnsafePointer<()>) -> ConstUnsafePointer<()>

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

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

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

func CFBagGetValues(_ theBag: CFBag!, _ values: UnsafePointer<ConstUnsafePointer<()>>)

func CFBagGetValues(_ theBag: CFBag!, _ values: UnsafeMutablePointer<UnsafePointer<Void>>)

typealias CFBagHashCallBack = CFunctionPointer<((ConstUnsafePointer<()>) -> CFHashCode)>

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

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

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

func CFBagRemoveValue(_ theBag: CFMutableBag!, _ value: ConstUnsafePointer<()>)

func CFBagRemoveValue(_ theBag: CFMutableBag!, _ value: UnsafePointer<Void>)

func CFBagReplaceValue(_ theBag: CFMutableBag!, _ value: ConstUnsafePointer<()>)

func CFBagReplaceValue(_ theBag: CFMutableBag!, _ value: UnsafePointer<Void>)

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

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

func CFBagSetValue(_ theBag: CFMutableBag!, _ value: ConstUnsafePointer<()>)

func CFBagSetValue(_ theBag: CFMutableBag!, _ value: UnsafePointer<Void>)

func CFBinaryHeapAddValue(_ heap: CFBinaryHeap!, _ value: ConstUnsafePointer<()>)

func CFBinaryHeapAddValue(_ heap: CFBinaryHeap!, _ value: UnsafePointer<Void>)

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

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

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

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

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

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

func CFBinaryHeapCreate(_ allocator: CFAllocator!, _ capacity: CFIndex, _ callBacks: ConstUnsafePointer<CFBinaryHeapCallBacks>, _ compareContext: ConstUnsafePointer<CFBinaryHeapCompareContext>) -> CFBinaryHeap!

func CFBinaryHeapCreate(_ allocator: CFAllocator!, _ capacity: CFIndex, _ callBacks: UnsafePointer<CFBinaryHeapCallBacks>, _ compareContext: UnsafePointer<CFBinaryHeapCompareContext>) -> CFBinaryHeap!

func CFBinaryHeapGetCountOfValue(_ heap: CFBinaryHeap!, _ value: ConstUnsafePointer<()>) -> CFIndex

func CFBinaryHeapGetCountOfValue(_ heap: CFBinaryHeap!, _ value: UnsafePointer<Void>) -> CFIndex

func CFBinaryHeapGetMinimum(_ heap: CFBinaryHeap!) -> ConstUnsafePointer<()>

func CFBinaryHeapGetMinimum(_ heap: CFBinaryHeap!) -> UnsafePointer<Void>

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

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

func CFBinaryHeapGetValues(_ heap: CFBinaryHeap!, _ values: UnsafePointer<ConstUnsafePointer<()>>)

func CFBinaryHeapGetValues(_ heap: CFBinaryHeap!, _ values: UnsafeMutablePointer<UnsafePointer<Void>>)

func CFBitVectorCreate(_ allocator: CFAllocator!, _ bytes: ConstUnsafePointer<UInt8>, _ numBits: CFIndex) -> CFBitVector!

func CFBitVectorCreate(_ allocator: CFAllocator!, _ bytes: UnsafePointer<UInt8>, _ numBits: CFIndex) -> CFBitVector!

func CFBitVectorGetBits(_ bv: CFBitVector!, _ range: CFRange, _ bytes: UnsafePointer<UInt8>)

func CFBitVectorGetBits(_ bv: CFBitVector!, _ range: CFRange, _ bytes: UnsafeMutablePointer<UInt8>)

func CFBundleGetDataPointerForName(_ bundle: CFBundle!, _ symbolName: CFString!) -> UnsafePointer<()>

func CFBundleGetDataPointerForName(_ bundle: CFBundle!, _ symbolName: CFString!) -> UnsafeMutablePointer<Void>

func CFBundleGetDataPointersForNames(_ bundle: CFBundle!, _ symbolNames: CFArray!, _ stbl: UnsafePointer<UnsafePointer<()>>)

func CFBundleGetDataPointersForNames(_ bundle: CFBundle!, _ symbolNames: CFArray!, _ stbl: UnsafeMutablePointer<UnsafeMutablePointer<Void>>)

func CFBundleGetFunctionPointerForName(_ bundle: CFBundle!, _ functionName: CFString!) -> UnsafePointer<()>

func CFBundleGetFunctionPointerForName(_ bundle: CFBundle!, _ functionName: CFString!) -> UnsafeMutablePointer<Void>

func CFBundleGetFunctionPointersForNames(_ bundle: CFBundle!, _ functionNames: CFArray!, _ ftbl: UnsafePointer<UnsafePointer<()>>)

func CFBundleGetFunctionPointersForNames(_ bundle: CFBundle!, _ functionNames: CFArray!, _ ftbl: UnsafeMutablePointer<UnsafeMutablePointer<Void>>)

func CFBundleGetPackageInfo(_ bundle: CFBundle!, _ packageType: UnsafePointer<UInt32>, _ packageCreator: UnsafePointer<UInt32>)

func CFBundleGetPackageInfo(_ bundle: CFBundle!, _ packageType: UnsafeMutablePointer<UInt32>, _ packageCreator: UnsafeMutablePointer<UInt32>)

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

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

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

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

func CFBundleOpenBundleResourceFiles(_ bundle: CFBundle!, _ refNum: UnsafePointer<CFBundleRefNum>, _ localizedRefNum: UnsafePointer<CFBundleRefNum>) -> Int32

func CFBundleOpenBundleResourceFiles(_ bundle: CFBundle!, _ refNum: UnsafeMutablePointer<CFBundleRefNum>, _ localizedRefNum: UnsafeMutablePointer<CFBundleRefNum>) -> Int32

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

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

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

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

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

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

func CFDataAppendBytes(_ theData: CFMutableData!, _ bytes: ConstUnsafePointer<UInt8>, _ length: CFIndex)

func CFDataAppendBytes(_ theData: CFMutableData!, _ bytes: UnsafePointer<UInt8>, _ length: CFIndex)

func CFDataCreate(_ allocator: CFAllocator!, _ bytes: ConstUnsafePointer<UInt8>, _ length: CFIndex) -> CFData!

func CFDataCreate(_ allocator: CFAllocator!, _ bytes: UnsafePointer<UInt8>, _ length: CFIndex) -> CFData!

func CFDataCreateWithBytesNoCopy(_ allocator: CFAllocator!, _ bytes: ConstUnsafePointer<UInt8>, _ length: CFIndex, _ bytesDeallocator: CFAllocator!) -> CFData!

func CFDataCreateWithBytesNoCopy(_ allocator: CFAllocator!, _ bytes: UnsafePointer<UInt8>, _ length: CFIndex, _ bytesDeallocator: CFAllocator!) -> CFData!

func CFDataGetBytePtr(_ theData: CFData!) -> ConstUnsafePointer<UInt8>

func CFDataGetBytePtr(_ theData: CFData!) -> UnsafePointer<UInt8>

func CFDataGetBytes(_ theData: CFData!, _ range: CFRange, _ buffer: UnsafePointer<UInt8>)

func CFDataGetBytes(_ theData: CFData!, _ range: CFRange, _ buffer: UnsafeMutablePointer<UInt8>)

func CFDataGetMutableBytePtr(_ theData: CFMutableData!) -> UnsafePointer<UInt8>

func CFDataGetMutableBytePtr(_ theData: CFMutableData!) -> UnsafeMutablePointer<UInt8>

func CFDataReplaceBytes(_ theData: CFMutableData!, _ range: CFRange, _ newBytes: ConstUnsafePointer<UInt8>, _ newLength: CFIndex)

func CFDataReplaceBytes(_ theData: CFMutableData!, _ range: CFRange, _ newBytes: UnsafePointer<UInt8>, _ newLength: CFIndex)

func CFDateCompare(_ theDate: CFDate!, _ otherDate: CFDate!, _ context: UnsafePointer<()>) -> CFComparisonResult

func CFDateCompare(_ theDate: CFDate!, _ otherDate: CFDate!, _ context: UnsafeMutablePointer<Void>) -> CFComparisonResult

func CFDateFormatterCreateDateFromString(_ allocator: CFAllocator!, _ formatter: CFDateFormatter!, _ string: CFString!, _ rangep: UnsafePointer<CFRange>) -> CFDate!

func CFDateFormatterCreateDateFromString(_ allocator: CFAllocator!, _ formatter: CFDateFormatter!, _ string: CFString!, _ rangep: UnsafeMutablePointer<CFRange>) -> CFDate!

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

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

func CFDictionaryAddValue(_ theDict: CFMutableDictionary!, _ key: ConstUnsafePointer<()>, _ value: ConstUnsafePointer<()>)

func CFDictionaryAddValue(_ theDict: CFMutableDictionary!, _ key: UnsafePointer<Void>, _ value: UnsafePointer<Void>)

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

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

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

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

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

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

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

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

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

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

func CFDictionaryCreate(_ allocator: CFAllocator!, _ keys: UnsafePointer<ConstUnsafePointer<()>>, _ values: UnsafePointer<ConstUnsafePointer<()>>, _ numValues: CFIndex, _ keyCallBacks: ConstUnsafePointer<CFDictionaryKeyCallBacks>, _ valueCallBacks: ConstUnsafePointer<CFDictionaryValueCallBacks>) -> CFDictionary!

func CFDictionaryCreate(_ allocator: CFAllocator!, _ keys: UnsafeMutablePointer<UnsafePointer<Void>>, _ values: UnsafeMutablePointer<UnsafePointer<Void>>, _ numValues: CFIndex, _ keyCallBacks: UnsafePointer<CFDictionaryKeyCallBacks>, _ valueCallBacks: UnsafePointer<CFDictionaryValueCallBacks>) -> CFDictionary!

func CFDictionaryCreateMutable(_ allocator: CFAllocator!, _ capacity: CFIndex, _ keyCallBacks: ConstUnsafePointer<CFDictionaryKeyCallBacks>, _ valueCallBacks: ConstUnsafePointer<CFDictionaryValueCallBacks>) -> CFMutableDictionary!

func CFDictionaryCreateMutable(_ allocator: CFAllocator!, _ capacity: CFIndex, _ keyCallBacks: UnsafePointer<CFDictionaryKeyCallBacks>, _ valueCallBacks: UnsafePointer<CFDictionaryValueCallBacks>) -> CFMutableDictionary!

typealias CFDictionaryEqualCallBack = CFunctionPointer<((ConstUnsafePointer<()>, ConstUnsafePointer<()>) -> Boolean)>

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

func CFDictionaryGetCountOfKey(_ theDict: CFDictionary!, _ key: ConstUnsafePointer<()>) -> CFIndex

func CFDictionaryGetCountOfKey(_ theDict: CFDictionary!, _ key: UnsafePointer<Void>) -> CFIndex

func CFDictionaryGetCountOfValue(_ theDict: CFDictionary!, _ value: ConstUnsafePointer<()>) -> CFIndex

func CFDictionaryGetCountOfValue(_ theDict: CFDictionary!, _ value: UnsafePointer<Void>) -> CFIndex

func CFDictionaryGetKeysAndValues(_ theDict: CFDictionary!, _ keys: UnsafePointer<ConstUnsafePointer<()>>, _ values: UnsafePointer<ConstUnsafePointer<()>>)

func CFDictionaryGetKeysAndValues(_ theDict: CFDictionary!, _ keys: UnsafeMutablePointer<UnsafePointer<Void>>, _ values: UnsafeMutablePointer<UnsafePointer<Void>>)

func CFDictionaryGetValue(_ theDict: CFDictionary!, _ key: ConstUnsafePointer<()>) -> ConstUnsafePointer<()>

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

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

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

typealias CFDictionaryHashCallBack = CFunctionPointer<((ConstUnsafePointer<()>) -> CFHashCode)>

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

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

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

func CFDictionaryRemoveValue(_ theDict: CFMutableDictionary!, _ key: ConstUnsafePointer<()>)

func CFDictionaryRemoveValue(_ theDict: CFMutableDictionary!, _ key: UnsafePointer<Void>)

func CFDictionaryReplaceValue(_ theDict: CFMutableDictionary!, _ key: ConstUnsafePointer<()>, _ value: ConstUnsafePointer<()>)

func CFDictionaryReplaceValue(_ theDict: CFMutableDictionary!, _ key: UnsafePointer<Void>, _ value: UnsafePointer<Void>)

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

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

func CFDictionarySetValue(_ theDict: CFMutableDictionary!, _ key: ConstUnsafePointer<()>, _ value: ConstUnsafePointer<()>)

func CFDictionarySetValue(_ theDict: CFMutableDictionary!, _ key: UnsafePointer<Void>, _ value: UnsafePointer<Void>)

func CFErrorCreateWithUserInfoKeysAndValues(_ allocator: CFAllocator!, _ domain: CFString!, _ code: CFIndex, _ userInfoKeys: ConstUnsafePointer<ConstUnsafePointer<()>>, _ userInfoValues: ConstUnsafePointer<ConstUnsafePointer<()>>, _ numUserInfoValues: CFIndex) -> CFError!

func CFErrorCreateWithUserInfoKeysAndValues(_ allocator: CFAllocator!, _ domain: CFString!, _ code: CFIndex, _ userInfoKeys: UnsafePointer<UnsafePointer<Void>>, _ userInfoValues: UnsafePointer<UnsafePointer<Void>>, _ numUserInfoValues: CFIndex) -> CFError!

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

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

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

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

func CFFileDescriptorGetContext(_ f: CFFileDescriptor!, _ context: UnsafePointer<CFFileDescriptorContext>)

func CFFileDescriptorGetContext(_ f: CFFileDescriptor!, _ context: UnsafeMutablePointer<CFFileDescriptorContext>)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func CFMachPortGetContext(_ port: CFMachPort!, _ context: UnsafePointer<CFMachPortContext>)

func CFMachPortGetContext(_ port: CFMachPort!, _ context: UnsafeMutablePointer<CFMachPortContext>)

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

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

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

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

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

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

func CFMessagePortGetContext(_ ms: CFMessagePort!, _ context: UnsafePointer<CFMessagePortContext>)

func CFMessagePortGetContext(_ ms: CFMessagePort!, _ context: UnsafeMutablePointer<CFMessagePortContext>)

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

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

func CFMessagePortSendRequest(_ remote: CFMessagePort!, _ msgid: Int32, _ data: CFData!, _ sendTimeout: CFTimeInterval, _ rcvTimeout: CFTimeInterval, _ replyMode: CFString!, _ returnData: UnsafePointer<Unmanaged<CFData>?>) -> Int32

func CFMessagePortSendRequest(_ remote: CFMessagePort!, _ msgid: Int32, _ data: CFData!, _ sendTimeout: CFTimeInterval, _ rcvTimeout: CFTimeInterval, _ replyMode: CFString!, _ returnData: UnsafeMutablePointer<Unmanaged<CFData>?>) -> Int32

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

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

func CFNotificationCenterAddObserver(_ center: CFNotificationCenter!, _ observer: ConstUnsafePointer<()>, _ callBack: CFNotificationCallback, _ name: CFString!, _ object: ConstUnsafePointer<()>, _ 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: ConstUnsafePointer<()>, _ userInfo: CFDictionary!, _ deliverImmediately: Boolean)

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

func CFNotificationCenterPostNotificationWithOptions(_ center: CFNotificationCenter!, _ name: CFString!, _ object: ConstUnsafePointer<()>, _ userInfo: CFDictionary!, _ options: CFOptionFlags)

func CFNotificationCenterPostNotificationWithOptions(_ center: CFNotificationCenter!, _ name: CFString!, _ object: UnsafePointer<Void>, _ userInfo: CFDictionary!, _ options: CFOptionFlags)

func CFNotificationCenterRemoveEveryObserver(_ center: CFNotificationCenter!, _ observer: ConstUnsafePointer<()>)

func CFNotificationCenterRemoveEveryObserver(_ center: CFNotificationCenter!, _ observer: UnsafePointer<Void>)

func CFNotificationCenterRemoveObserver(_ center: CFNotificationCenter!, _ observer: ConstUnsafePointer<()>, _ name: CFString!, _ object: ConstUnsafePointer<()>)

func CFNotificationCenterRemoveObserver(_ center: CFNotificationCenter!, _ observer: UnsafePointer<Void>, _ name: CFString!, _ object: UnsafePointer<Void>)

func CFNumberCompare(_ number: CFNumber!, _ otherNumber: CFNumber!, _ context: UnsafePointer<()>) -> CFComparisonResult

func CFNumberCompare(_ number: CFNumber!, _ otherNumber: CFNumber!, _ context: UnsafeMutablePointer<Void>) -> CFComparisonResult

func CFNumberCreate(_ allocator: CFAllocator!, _ theType: CFNumberType, _ valuePtr: ConstUnsafePointer<()>) -> CFNumber!

func CFNumberCreate(_ allocator: CFAllocator!, _ theType: CFNumberType, _ valuePtr: UnsafePointer<Void>) -> CFNumber!

func CFNumberFormatterCreateNumberFromString(_ allocator: CFAllocator!, _ formatter: CFNumberFormatter!, _ string: CFString!, _ rangep: UnsafePointer<CFRange>, _ options: CFOptionFlags) -> CFNumber!

func CFNumberFormatterCreateNumberFromString(_ allocator: CFAllocator!, _ formatter: CFNumberFormatter!, _ string: CFString!, _ rangep: UnsafeMutablePointer<CFRange>, _ options: CFOptionFlags) -> CFNumber!

func CFNumberFormatterCreateStringWithValue(_ allocator: CFAllocator!, _ formatter: CFNumberFormatter!, _ numberType: CFNumberType, _ valuePtr: ConstUnsafePointer<()>) -> CFString!

func CFNumberFormatterCreateStringWithValue(_ allocator: CFAllocator!, _ formatter: CFNumberFormatter!, _ numberType: CFNumberType, _ valuePtr: UnsafePointer<Void>) -> CFString!

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

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

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

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

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

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

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

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

func CFPlugInInstanceCreate(_ allocator: CFAllocator!, _ factoryUUID: CFUUID!, _ typeUUID: CFUUID!) -> UnsafePointer<()>

func CFPlugInInstanceCreate(_ allocator: CFAllocator!, _ factoryUUID: CFUUID!, _ typeUUID: CFUUID!) -> UnsafeMutablePointer<Void>

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

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

func CFPlugInInstanceGetInstanceData(_ instance: CFPlugInInstance!) -> UnsafePointer<()>

func CFPlugInInstanceGetInstanceData(_ instance: CFPlugInInstance!) -> UnsafeMutablePointer<Void>

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

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

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

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

func CFPreferencesCopyAppValue(_ key: CFString!, _ applicationID: CFString!) -> CFPropertyListRef!

func CFPreferencesCopyAppValue(_ key: CFString!, _ applicationID: CFString!) -> CFPropertyList!

func CFPreferencesCopyValue(_ key: CFString!, _ applicationID: CFString!, _ userName: CFString!, _ hostName: CFString!) -> CFPropertyListRef!

func CFPreferencesCopyValue(_ key: CFString!, _ applicationID: CFString!, _ userName: CFString!, _ hostName: CFString!) -> CFPropertyList!

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

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

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

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

func CFPreferencesSetAppValue(_ key: CFString!, _ value: CFPropertyListRef!, _ applicationID: CFString!)

func CFPreferencesSetAppValue(_ key: CFString!, _ value: CFPropertyList!, _ applicationID: CFString!)

func CFPreferencesSetValue(_ key: CFString!, _ value: CFPropertyListRef!, _ applicationID: CFString!, _ userName: CFString!, _ hostName: CFString!)

func CFPreferencesSetValue(_ key: CFString!, _ value: CFPropertyList!, _ applicationID: CFString!, _ userName: CFString!, _ hostName: CFString!)

func CFPropertyListCreateData(_ allocator: CFAllocator!, _ propertyList: CFPropertyListRef!, _ format: CFPropertyListFormat, _ options: CFOptionFlags, _ error: UnsafePointer<Unmanaged<CFError>?>) -> Unmanaged<CFData>!

func CFPropertyListCreateData(_ allocator: CFAllocator!, _ propertyList: CFPropertyList!, _ format: CFPropertyListFormat, _ options: CFOptionFlags, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Unmanaged<CFData>!

func CFPropertyListCreateDeepCopy(_ allocator: CFAllocator!, _ propertyList: CFPropertyListRef!, _ mutabilityOption: CFOptionFlags) -> CFPropertyListRef!

func CFPropertyListCreateDeepCopy(_ allocator: CFAllocator!, _ propertyList: CFPropertyList!, _ mutabilityOption: CFOptionFlags) -> CFPropertyList!

func CFPropertyListCreateFromStream(_ allocator: CFAllocator!, _ stream: CFReadStream!, _ streamLength: CFIndex, _ mutabilityOption: CFOptionFlags, _ format: UnsafePointer<CFPropertyListFormat>, _ errorString: UnsafePointer<Unmanaged<CFString>?>) -> Unmanaged<CFPropertyListRef>!

func CFPropertyListCreateFromStream(_ allocator: CFAllocator!, _ stream: CFReadStream!, _ streamLength: CFIndex, _ mutabilityOption: CFOptionFlags, _ format: UnsafeMutablePointer<CFPropertyListFormat>, _ errorString: UnsafeMutablePointer<Unmanaged<CFString>?>) -> Unmanaged<CFPropertyList>!

func CFPropertyListCreateFromXMLData(_ allocator: CFAllocator!, _ xmlData: CFData!, _ mutabilityOption: CFOptionFlags, _ errorString: UnsafePointer<Unmanaged<CFString>?>) -> Unmanaged<CFPropertyListRef>!

func CFPropertyListCreateFromXMLData(_ allocator: CFAllocator!, _ xmlData: CFData!, _ mutabilityOption: CFOptionFlags, _ errorString: UnsafeMutablePointer<Unmanaged<CFString>?>) -> Unmanaged<CFPropertyList>!

func CFPropertyListCreateWithData(_ allocator: CFAllocator!, _ data: CFData!, _ options: CFOptionFlags, _ format: UnsafePointer<CFPropertyListFormat>, _ error: UnsafePointer<Unmanaged<CFError>?>) -> Unmanaged<CFPropertyListRef>!

func CFPropertyListCreateWithData(_ allocator: CFAllocator!, _ data: CFData!, _ options: CFOptionFlags, _ format: UnsafeMutablePointer<CFPropertyListFormat>, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Unmanaged<CFPropertyList>!

func CFPropertyListCreateWithStream(_ allocator: CFAllocator!, _ stream: CFReadStream!, _ streamLength: CFIndex, _ options: CFOptionFlags, _ format: UnsafePointer<CFPropertyListFormat>, _ error: UnsafePointer<Unmanaged<CFError>?>) -> Unmanaged<CFPropertyListRef>!

func CFPropertyListCreateWithStream(_ allocator: CFAllocator!, _ stream: CFReadStream!, _ streamLength: CFIndex, _ options: CFOptionFlags, _ format: UnsafeMutablePointer<CFPropertyListFormat>, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Unmanaged<CFPropertyList>!

func CFPropertyListCreateXMLData(_ allocator: CFAllocator!, _ propertyList: CFPropertyListRef!) -> Unmanaged<CFData>!

func CFPropertyListCreateXMLData(_ allocator: CFAllocator!, _ propertyList: CFPropertyList!) -> Unmanaged<CFData>!

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

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

typealias CFPropertyListRef = AnyObject

typealias CFPropertyListRef = CFPropertyList

func CFPropertyListWrite(_ propertyList: CFPropertyListRef!, _ stream: CFWriteStream!, _ format: CFPropertyListFormat, _ options: CFOptionFlags, _ error: UnsafePointer<Unmanaged<CFError>?>) -> CFIndex

func CFPropertyListWrite(_ propertyList: CFPropertyList!, _ stream: CFWriteStream!, _ format: CFPropertyListFormat, _ options: CFOptionFlags, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> CFIndex

func CFPropertyListWriteToStream(_ propertyList: CFPropertyListRef!, _ stream: CFWriteStream!, _ format: CFPropertyListFormat, _ errorString: UnsafePointer<Unmanaged<CFString>?>) -> CFIndex

func CFPropertyListWriteToStream(_ propertyList: CFPropertyList!, _ stream: CFWriteStream!, _ format: CFPropertyListFormat, _ errorString: UnsafeMutablePointer<Unmanaged<CFString>?>) -> CFIndex

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

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

func CFReadStreamCreateWithBytesNoCopy(_ alloc: CFAllocator!, _ bytes: ConstUnsafePointer<UInt8>, _ length: CFIndex, _ bytesDeallocator: CFAllocator!) -> CFReadStream!

func CFReadStreamCreateWithBytesNoCopy(_ alloc: CFAllocator!, _ bytes: UnsafePointer<UInt8>, _ length: CFIndex, _ bytesDeallocator: CFAllocator!) -> CFReadStream!

func CFReadStreamGetBuffer(_ stream: CFReadStream!, _ maxBytesToRead: CFIndex, _ numBytesRead: UnsafePointer<CFIndex>) -> ConstUnsafePointer<UInt8>

func CFReadStreamGetBuffer(_ stream: CFReadStream!, _ maxBytesToRead: CFIndex, _ numBytesRead: UnsafeMutablePointer<CFIndex>) -> UnsafePointer<UInt8>

func CFReadStreamRead(_ stream: CFReadStream!, _ buffer: UnsafePointer<UInt8>, _ bufferLength: CFIndex) -> CFIndex

func CFReadStreamRead(_ stream: CFReadStream!, _ buffer: UnsafeMutablePointer<UInt8>, _ bufferLength: CFIndex) -> CFIndex

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

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

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

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

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

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

func CFRunLoopObserverGetContext(_ observer: CFRunLoopObserver!, _ context: UnsafePointer<CFRunLoopObserverContext>)

func CFRunLoopObserverGetContext(_ observer: CFRunLoopObserver!, _ context: UnsafeMutablePointer<CFRunLoopObserverContext>)

func CFRunLoopSourceCreate(_ allocator: CFAllocator!, _ order: CFIndex, _ context: UnsafePointer<CFRunLoopSourceContext>) -> CFRunLoopSource!

func CFRunLoopSourceCreate(_ allocator: CFAllocator!, _ order: CFIndex, _ context: UnsafeMutablePointer<CFRunLoopSourceContext>) -> CFRunLoopSource!

func CFRunLoopSourceGetContext(_ source: CFRunLoopSource!, _ context: UnsafePointer<CFRunLoopSourceContext>)

func CFRunLoopSourceGetContext(_ source: CFRunLoopSource!, _ context: UnsafeMutablePointer<CFRunLoopSourceContext>)

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

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

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

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

func CFRunLoopTimerGetContext(_ timer: CFRunLoopTimer!, _ context: UnsafePointer<CFRunLoopTimerContext>)

func CFRunLoopTimerGetContext(_ timer: CFRunLoopTimer!, _ context: UnsafeMutablePointer<CFRunLoopTimerContext>)

func CFSetAddValue(_ theSet: CFMutableSet!, _ value: ConstUnsafePointer<()>)

func CFSetAddValue(_ theSet: CFMutableSet!, _ value: UnsafePointer<Void>)

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

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

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

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

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

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

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

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

func CFSetCreate(_ allocator: CFAllocator!, _ values: UnsafePointer<ConstUnsafePointer<()>>, _ numValues: CFIndex, _ callBacks: ConstUnsafePointer<CFSetCallBacks>) -> CFSet!

func CFSetCreate(_ allocator: CFAllocator!, _ values: UnsafeMutablePointer<UnsafePointer<Void>>, _ numValues: CFIndex, _ callBacks: UnsafePointer<CFSetCallBacks>) -> CFSet!

func CFSetCreateMutable(_ allocator: CFAllocator!, _ capacity: CFIndex, _ callBacks: ConstUnsafePointer<CFSetCallBacks>) -> CFMutableSet!

func CFSetCreateMutable(_ allocator: CFAllocator!, _ capacity: CFIndex, _ callBacks: UnsafePointer<CFSetCallBacks>) -> CFMutableSet!

typealias CFSetEqualCallBack = CFunctionPointer<((ConstUnsafePointer<()>, ConstUnsafePointer<()>) -> Boolean)>

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

func CFSetGetCountOfValue(_ theSet: CFSet!, _ value: ConstUnsafePointer<()>) -> CFIndex

func CFSetGetCountOfValue(_ theSet: CFSet!, _ value: UnsafePointer<Void>) -> CFIndex

func CFSetGetValue(_ theSet: CFSet!, _ value: ConstUnsafePointer<()>) -> ConstUnsafePointer<()>

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

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

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

func CFSetGetValues(_ theSet: CFSet!, _ values: UnsafePointer<ConstUnsafePointer<()>>)

func CFSetGetValues(_ theSet: CFSet!, _ values: UnsafeMutablePointer<UnsafePointer<Void>>)

typealias CFSetHashCallBack = CFunctionPointer<((ConstUnsafePointer<()>) -> CFHashCode)>

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

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

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

func CFSetRemoveValue(_ theSet: CFMutableSet!, _ value: ConstUnsafePointer<()>)

func CFSetRemoveValue(_ theSet: CFMutableSet!, _ value: UnsafePointer<Void>)

func CFSetReplaceValue(_ theSet: CFMutableSet!, _ value: ConstUnsafePointer<()>)

func CFSetReplaceValue(_ theSet: CFMutableSet!, _ value: UnsafePointer<Void>)

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

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

func CFSetSetValue(_ theSet: CFMutableSet!, _ value: ConstUnsafePointer<()>)

func CFSetSetValue(_ theSet: CFMutableSet!, _ value: UnsafePointer<Void>)

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

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

func CFSocketCopyRegisteredSocketSignature(_ nameServerSignature: ConstUnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!, _ signature: UnsafePointer<CFSocketSignature>, _ nameServerAddress: UnsafePointer<Unmanaged<CFData>?>) -> CFSocketError

func CFSocketCopyRegisteredSocketSignature(_ nameServerSignature: UnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!, _ signature: UnsafeMutablePointer<CFSocketSignature>, _ nameServerAddress: UnsafeMutablePointer<Unmanaged<CFData>?>) -> CFSocketError

func CFSocketCopyRegisteredValue(_ nameServerSignature: ConstUnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!, _ value: UnsafePointer<Unmanaged<CFPropertyListRef>?>, _ nameServerAddress: UnsafePointer<Unmanaged<CFData>?>) -> CFSocketError

func CFSocketCopyRegisteredValue(_ nameServerSignature: UnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!, _ value: UnsafeMutablePointer<Unmanaged<CFPropertyList>?>, _ nameServerAddress: UnsafeMutablePointer<Unmanaged<CFData>?>) -> CFSocketError

func CFSocketCreate(_ allocator: CFAllocator!, _ protocolFamily: Int32, _ socketType: Int32, _ `protocol`: Int32, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack, _ context: ConstUnsafePointer<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: ConstUnsafePointer<CFSocketSignature>, _ callBackTypes: CFOptionFlags, _ callout: CFSocketCallBack, _ context: ConstUnsafePointer<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: ConstUnsafePointer<CFSocketContext>) -> CFSocket!

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

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

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

func CFSocketGetContext(_ s: CFSocket!, _ context: UnsafePointer<CFSocketContext>)

func CFSocketGetContext(_ s: CFSocket!, _ context: UnsafeMutablePointer<CFSocketContext>)

func CFSocketRegisterSocketSignature(_ nameServerSignature: ConstUnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!, _ signature: ConstUnsafePointer<CFSocketSignature>) -> CFSocketError

func CFSocketRegisterSocketSignature(_ nameServerSignature: UnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!, _ signature: UnsafePointer<CFSocketSignature>) -> CFSocketError

func CFSocketRegisterValue(_ nameServerSignature: ConstUnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!, _ value: CFPropertyListRef!) -> CFSocketError

func CFSocketRegisterValue(_ nameServerSignature: UnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!, _ value: CFPropertyList!) -> CFSocketError

func CFSocketUnregister(_ nameServerSignature: ConstUnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!) -> CFSocketError

func CFSocketUnregister(_ nameServerSignature: UnsafePointer<CFSocketSignature>, _ timeout: CFTimeInterval, _ name: CFString!) -> CFSocketError

func CFStreamCreateBoundPair(_ alloc: CFAllocator!, _ readStream: UnsafePointer<Unmanaged<CFReadStream>?>, _ writeStream: UnsafePointer<Unmanaged<CFWriteStream>?>, _ transferBufferSize: CFIndex)

func CFStreamCreateBoundPair(_ alloc: CFAllocator!, _ readStream: UnsafeMutablePointer<Unmanaged<CFReadStream>?>, _ writeStream: UnsafeMutablePointer<Unmanaged<CFWriteStream>?>, _ transferBufferSize: CFIndex)

func CFStreamCreatePairWithPeerSocketSignature(_ alloc: CFAllocator!, _ signature: ConstUnsafePointer<CFSocketSignature>, _ readStream: UnsafePointer<Unmanaged<CFReadStream>?>, _ writeStream: UnsafePointer<Unmanaged<CFWriteStream>?>)

func CFStreamCreatePairWithPeerSocketSignature(_ alloc: CFAllocator!, _ signature: UnsafePointer<CFSocketSignature>, _ readStream: UnsafeMutablePointer<Unmanaged<CFReadStream>?>, _ writeStream: UnsafeMutablePointer<Unmanaged<CFWriteStream>?>)

func CFStreamCreatePairWithSocket(_ alloc: CFAllocator!, _ sock: CFSocketNativeHandle, _ readStream: UnsafePointer<Unmanaged<CFReadStream>?>, _ writeStream: UnsafePointer<Unmanaged<CFWriteStream>?>)

func CFStreamCreatePairWithSocket(_ alloc: CFAllocator!, _ sock: CFSocketNativeHandle, _ readStream: UnsafeMutablePointer<Unmanaged<CFReadStream>?>, _ writeStream: UnsafeMutablePointer<Unmanaged<CFWriteStream>?>)

func CFStreamCreatePairWithSocketToHost(_ alloc: CFAllocator!, _ host: CFString!, _ port: UInt32, _ readStream: UnsafePointer<Unmanaged<CFReadStream>?>, _ writeStream: UnsafePointer<Unmanaged<CFWriteStream>?>)

func CFStreamCreatePairWithSocketToHost(_ alloc: CFAllocator!, _ host: CFString!, _ port: UInt32, _ readStream: UnsafeMutablePointer<Unmanaged<CFReadStream>?>, _ writeStream: UnsafeMutablePointer<Unmanaged<CFWriteStream>?>)

func CFStringAppendCString(_ theString: CFMutableString!, _ cStr: ConstUnsafePointer<Int8>, _ encoding: CFStringEncoding)

func CFStringAppendCString(_ theString: CFMutableString!, _ cStr: UnsafePointer<Int8>, _ encoding: CFStringEncoding)

func CFStringAppendCharacters(_ theString: CFMutableString!, _ chars: ConstUnsafePointer<UniChar>, _ numChars: CFIndex)

func CFStringAppendCharacters(_ theString: CFMutableString!, _ chars: UnsafePointer<UniChar>, _ numChars: CFIndex)

func CFStringCreateMutableWithExternalCharactersNoCopy(_ alloc: CFAllocator!, _ chars: UnsafePointer<UniChar>, _ numChars: CFIndex, _ capacity: CFIndex, _ externalCharactersAllocator: CFAllocator!) -> CFMutableString!

func CFStringCreateMutableWithExternalCharactersNoCopy(_ alloc: CFAllocator!, _ chars: UnsafeMutablePointer<UniChar>, _ numChars: CFIndex, _ capacity: CFIndex, _ externalCharactersAllocator: CFAllocator!) -> CFMutableString!

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

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

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

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

func CFStringCreateWithCString(_ alloc: CFAllocator!, _ cStr: ConstUnsafePointer<Int8>, _ encoding: CFStringEncoding) -> CFString!

func CFStringCreateWithCString(_ alloc: CFAllocator!, _ cStr: UnsafePointer<Int8>, _ encoding: CFStringEncoding) -> CFString!

func CFStringCreateWithCStringNoCopy(_ alloc: CFAllocator!, _ cStr: ConstUnsafePointer<Int8>, _ encoding: CFStringEncoding, _ contentsDeallocator: CFAllocator!) -> CFString!

func CFStringCreateWithCStringNoCopy(_ alloc: CFAllocator!, _ cStr: UnsafePointer<Int8>, _ encoding: CFStringEncoding, _ contentsDeallocator: CFAllocator!) -> CFString!

func CFStringCreateWithCharacters(_ alloc: CFAllocator!, _ chars: ConstUnsafePointer<UniChar>, _ numChars: CFIndex) -> CFString!

func CFStringCreateWithCharacters(_ alloc: CFAllocator!, _ chars: UnsafePointer<UniChar>, _ numChars: CFIndex) -> CFString!

func CFStringCreateWithCharactersNoCopy(_ alloc: CFAllocator!, _ chars: ConstUnsafePointer<UniChar>, _ numChars: CFIndex, _ contentsDeallocator: CFAllocator!) -> CFString!

func CFStringCreateWithCharactersNoCopy(_ alloc: CFAllocator!, _ chars: UnsafePointer<UniChar>, _ numChars: CFIndex, _ contentsDeallocator: CFAllocator!) -> CFString!

func CFStringCreateWithFileSystemRepresentation(_ alloc: CFAllocator!, _ buffer: ConstUnsafePointer<Int8>) -> CFString!

func CFStringCreateWithFileSystemRepresentation(_ alloc: CFAllocator!, _ buffer: UnsafePointer<Int8>) -> CFString!

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

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

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

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

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

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

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

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

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

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

func CFStringGetCStringPtr(_ theString: CFString!, _ encoding: CFStringEncoding) -> ConstUnsafePointer<Int8>

func CFStringGetCStringPtr(_ theString: CFString!, _ encoding: CFStringEncoding) -> UnsafePointer<Int8>

func CFStringGetCharacterFromInlineBuffer(_ buf: UnsafePointer<CFStringInlineBuffer>, _ idx: CFIndex) -> UniChar

func CFStringGetCharacterFromInlineBuffer(_ buf: UnsafeMutablePointer<CFStringInlineBuffer>, _ idx: CFIndex) -> UniChar

func CFStringGetCharacters(_ theString: CFString!, _ range: CFRange, _ buffer: UnsafePointer<UniChar>)

func CFStringGetCharacters(_ theString: CFString!, _ range: CFRange, _ buffer: UnsafeMutablePointer<UniChar>)

func CFStringGetCharactersPtr(_ theString: CFString!) -> ConstUnsafePointer<UniChar>

func CFStringGetCharactersPtr(_ theString: CFString!) -> UnsafePointer<UniChar>

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

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

func CFStringGetHyphenationLocationBeforeIndex(_ string: CFString!, _ location: CFIndex, _ limitRange: CFRange, _ options: CFOptionFlags, _ locale: CFLocale!, _ character: UnsafePointer<UTF32Char>) -> CFIndex

func CFStringGetHyphenationLocationBeforeIndex(_ string: CFString!, _ location: CFIndex, _ limitRange: CFRange, _ options: CFOptionFlags, _ locale: CFLocale!, _ character: UnsafeMutablePointer<UTF32Char>) -> CFIndex

func CFStringGetLineBounds(_ theString: CFString!, _ range: CFRange, _ lineBeginIndex: UnsafePointer<CFIndex>, _ lineEndIndex: UnsafePointer<CFIndex>, _ contentsEndIndex: UnsafePointer<CFIndex>)

func CFStringGetLineBounds(_ theString: CFString!, _ range: CFRange, _ lineBeginIndex: UnsafeMutablePointer<CFIndex>, _ lineEndIndex: UnsafeMutablePointer<CFIndex>, _ contentsEndIndex: UnsafeMutablePointer<CFIndex>)

func CFStringGetListOfAvailableEncodings() -> ConstUnsafePointer<CFStringEncoding>

func CFStringGetListOfAvailableEncodings() -> UnsafePointer<CFStringEncoding>

func CFStringGetParagraphBounds(_ string: CFString!, _ range: CFRange, _ parBeginIndex: UnsafePointer<CFIndex>, _ parEndIndex: UnsafePointer<CFIndex>, _ contentsEndIndex: UnsafePointer<CFIndex>)

func CFStringGetParagraphBounds(_ string: CFString!, _ range: CFRange, _ parBeginIndex: UnsafeMutablePointer<CFIndex>, _ parEndIndex: UnsafeMutablePointer<CFIndex>, _ contentsEndIndex: UnsafeMutablePointer<CFIndex>)

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

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

func CFStringInitInlineBuffer(_ str: CFString!, _ buf: UnsafePointer<CFStringInlineBuffer>, _ range: CFRange)

func CFStringInitInlineBuffer(_ str: CFString!, _ buf: UnsafeMutablePointer<CFStringInlineBuffer>, _ range: CFRange)

func CFStringSetExternalCharactersNoCopy(_ theString: CFMutableString!, _ chars: UnsafePointer<UniChar>, _ length: CFIndex, _ capacity: CFIndex)

func CFStringSetExternalCharactersNoCopy(_ theString: CFMutableString!, _ chars: UnsafeMutablePointer<UniChar>, _ length: CFIndex, _ capacity: CFIndex)

func CFStringTokenizerGetCurrentSubTokens(_ tokenizer: CFStringTokenizer!, _ ranges: UnsafePointer<CFRange>, _ maxRangeLength: CFIndex, _ derivedSubTokens: CFMutableArray!) -> CFIndex

func CFStringTokenizerGetCurrentSubTokens(_ tokenizer: CFStringTokenizer!, _ ranges: UnsafeMutablePointer<CFRange>, _ maxRangeLength: CFIndex, _ derivedSubTokens: CFMutableArray!) -> CFIndex

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

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

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

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

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

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

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

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

func CFTreeCreate(_ allocator: CFAllocator!, _ context: ConstUnsafePointer<CFTreeContext>) -> CFTree!

func CFTreeCreate(_ allocator: CFAllocator!, _ context: UnsafePointer<CFTreeContext>) -> CFTree!

func CFTreeGetChildren(_ tree: CFTree!, _ children: UnsafePointer<Unmanaged<CFTree>?>)

func CFTreeGetChildren(_ tree: CFTree!, _ children: UnsafeMutablePointer<Unmanaged<CFTree>?>)

func CFTreeGetContext(_ tree: CFTree!, _ context: UnsafePointer<CFTreeContext>)

func CFTreeGetContext(_ tree: CFTree!, _ context: UnsafeMutablePointer<CFTreeContext>)

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

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

typealias CFTreeRetainCallBack = CFunctionPointer<((ConstUnsafePointer<()>) -> ConstUnsafePointer<()>)>

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

func CFTreeSetContext(_ tree: CFTree!, _ context: ConstUnsafePointer<CFTreeContext>)

func CFTreeSetContext(_ tree: CFTree!, _ context: UnsafePointer<CFTreeContext>)

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

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

func CFURLCopyResourcePropertiesForKeys(_ url: CFURL!, _ keys: CFArray!, _ error: UnsafePointer<Unmanaged<CFError>?>) -> Unmanaged<CFDictionary>!

func CFURLCopyResourcePropertiesForKeys(_ url: CFURL!, _ keys: CFArray!, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Unmanaged<CFDictionary>!

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

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