Documentation Archive Developer
Search

EventKit Changes for Swift

EventKit

Modified EKAlarm
Declaration
From
class EKAlarm : EKObject, NSCopying {
     init(absoluteDate date: NSDate)
    class func alarmWithAbsoluteDate(_ date: NSDate) -> EKAlarm
     init(relativeOffset offset: NSTimeInterval)
    class func alarmWithRelativeOffset(_ offset: NSTimeInterval) -> EKAlarm
    var relativeOffset: NSTimeInterval
    @NSCopying var absoluteDate: NSDate?
    @NSCopying var structuredLocation: EKStructuredLocation?
    var proximity: EKAlarmProximity
    var type: EKAlarmType { get }
    var emailAddress: String?
    var soundName: String?
    @NSCopying var url: NSURL?
}
To
class EKAlarm : EKObject, NSCopying {
     init(absoluteDate date: Date)
    class func withAbsoluteDate(_ date: Date) -> EKAlarm
     init(relativeOffset offset: TimeInterval)
    class func withRelativeOffset(_ offset: TimeInterval) -> EKAlarm
    var relativeOffset: TimeInterval
    var absoluteDate: Date?
    @NSCopying var structuredLocation: EKStructuredLocation?
    var proximity: EKAlarmProximity
    var type: EKAlarmType { get }
    var emailAddress: String?
    var soundName: String?
    var url: URL?
}

Declaration
From
@NSCopying var absoluteDate: NSDate?
To
var absoluteDate: Date?

Declaration
From
init(absoluteDate date: NSDate)
To
init(absoluteDate date: Date)

Declaration
From
init(relativeOffset offset: NSTimeInterval)
To
init(relativeOffset offset: TimeInterval)

Declaration
From
var relativeOffset: NSTimeInterval
To
var relativeOffset: TimeInterval

Declaration
From
enum EKAlarmProximity : Int {
    case None
    case Enter
    case Leave
}
To
enum EKAlarmProximity : Int {
    case none
    case enter
    case leave
}

Declaration
From
case Enter
To
case enter

Declaration
From
case Leave
To
case leave

Declaration
From
case None
To
case none

Declaration
From
enum EKAlarmType : Int {
    case Display
    case Audio
    case Procedure
    case Email
}
To
enum EKAlarmType : Int {
    case display
    case audio
    case procedure
    case email
}

Declaration
From
case Audio
To
case audio

Declaration
From
case Display
To
case display

Declaration
From
case Email
To
case email

Declaration
From
case Procedure
To
case procedure

Declaration
From
enum EKAuthorizationStatus : Int {
    case NotDetermined
    case Restricted
    case Denied
    case Authorized
}
To
enum EKAuthorizationStatus : Int {
    case notDetermined
    case restricted
    case denied
    case authorized
}

Declaration
From
case Authorized
To
case authorized

Declaration
From
case Denied
To
case denied

Declaration
From
case NotDetermined
To
case notDetermined

Declaration
From
case Restricted
To
case restricted

Modified EKCalendar
Declaration
From
class EKCalendar : EKObject {
     init(eventStore eventStore: EKEventStore)
    class func calendarWithEventStore(_ eventStore: EKEventStore) -> EKCalendar
     init(forEntityType entityType: EKEntityType, eventStore eventStore: EKEventStore)
    class func calendarForEntityType(_ entityType: EKEntityType, eventStore eventStore: EKEventStore) -> EKCalendar
    var source: EKSource
    var calendarIdentifier: String { get }
    var title: String
    var type: EKCalendarType { get }
    var allowsContentModifications: Bool { get }
    var subscribed: Bool { get }
    var immutable: Bool { get }
    var CGColor: CGColor
    var supportedEventAvailabilities: EKCalendarEventAvailabilityMask { get }
    var allowedEntityTypes: EKEntityMask { get }
}
To
class EKCalendar : EKObject {
     init(eventStore eventStore: EKEventStore)
    class func withEventStore(_ eventStore: EKEventStore) -> EKCalendar
     init(for entityType: EKEntityType, eventStore eventStore: EKEventStore)
    class func forEntityType(_ entityType: EKEntityType, eventStore eventStore: EKEventStore) -> EKCalendar
    var source: EKSource
    var calendarIdentifier: String { get }
    var title: String
    var type: EKCalendarType { get }
    var allowsContentModifications: Bool { get }
    var isSubscribed: Bool { get }
    var isImmutable: Bool { get }
    var cgColor: CGColor
    var supportedEventAvailabilities: EKCalendarEventAvailabilityMask { get }
    var allowedEntityTypes: EKEntityMask { get }
}

Declaration
From
var CGColor: CGColor
To
var cgColor: CGColor

Declaration
From
init(forEntityType entityType: EKEntityType, eventStore eventStore: EKEventStore)
To
init(for entityType: EKEntityType, eventStore eventStore: EKEventStore)

Declaration
From
var immutable: Bool { get }
To
var isImmutable: Bool { get }

Declaration
From
var subscribed: Bool { get }
To
var isSubscribed: Bool { get }

DeclarationProtocols
From
struct EKCalendarEventAvailabilityMask : OptionSetType {
    init(rawValue rawValue: UInt)
    static var None: EKCalendarEventAvailabilityMask { get }
    static var Busy: EKCalendarEventAvailabilityMask { get }
    static var Free: EKCalendarEventAvailabilityMask { get }
    static var Tentative: EKCalendarEventAvailabilityMask { get }
    static var Unavailable: EKCalendarEventAvailabilityMask { get }
}
OptionSetType
To
struct EKCalendarEventAvailabilityMask : OptionSet {
    init(rawValue rawValue: UInt)
    static var none: EKCalendarEventAvailabilityMask { get }
    static var busy: EKCalendarEventAvailabilityMask { get }
    static var free: EKCalendarEventAvailabilityMask { get }
    static var tentative: EKCalendarEventAvailabilityMask { get }
    static var unavailable: EKCalendarEventAvailabilityMask { get }
    func intersect(_ other: EKCalendarEventAvailabilityMask) -> EKCalendarEventAvailabilityMask
    func exclusiveOr(_ other: EKCalendarEventAvailabilityMask) -> EKCalendarEventAvailabilityMask
    mutating func unionInPlace(_ other: EKCalendarEventAvailabilityMask)
    mutating func intersectInPlace(_ other: EKCalendarEventAvailabilityMask)
    mutating func exclusiveOrInPlace(_ other: EKCalendarEventAvailabilityMask)
    func isSubsetOf(_ other: EKCalendarEventAvailabilityMask) -> Bool
    func isDisjointWith(_ other: EKCalendarEventAvailabilityMask) -> Bool
    func isSupersetOf(_ other: EKCalendarEventAvailabilityMask) -> Bool
    mutating func subtractInPlace(_ other: EKCalendarEventAvailabilityMask)
    func isStrictSupersetOf(_ other: EKCalendarEventAvailabilityMask) -> Bool
    func isStrictSubsetOf(_ other: EKCalendarEventAvailabilityMask) -> Bool
}
extension EKCalendarEventAvailabilityMask {
    func union(_ other: EKCalendarEventAvailabilityMask) -> EKCalendarEventAvailabilityMask
    func intersection(_ other: EKCalendarEventAvailabilityMask) -> EKCalendarEventAvailabilityMask
    func symmetricDifference(_ other: EKCalendarEventAvailabilityMask) -> EKCalendarEventAvailabilityMask
}
extension EKCalendarEventAvailabilityMask {
    func contains(_ member: EKCalendarEventAvailabilityMask) -> Bool
    mutating func insert(_ newMember: EKCalendarEventAvailabilityMask) -> (inserted: Bool, memberAfterInsert: EKCalendarEventAvailabilityMask)
    mutating func remove(_ member: EKCalendarEventAvailabilityMask) -> EKCalendarEventAvailabilityMask?
    mutating func update(with newMember: EKCalendarEventAvailabilityMask) -> EKCalendarEventAvailabilityMask?
}
extension EKCalendarEventAvailabilityMask {
    convenience init()
    mutating func formUnion(_ other: EKCalendarEventAvailabilityMask)
    mutating func formIntersection(_ other: EKCalendarEventAvailabilityMask)
    mutating func formSymmetricDifference(_ other: EKCalendarEventAvailabilityMask)
}
extension EKCalendarEventAvailabilityMask {
    convenience init<S : Sequence where S.Iterator.Element == EKCalendarEventAvailabilityMask>(_ sequence: S)
    convenience init(arrayLiteral arrayLiteral: EKCalendarEventAvailabilityMask...)
    mutating func subtract(_ other: EKCalendarEventAvailabilityMask)
    func isSubset(of other: EKCalendarEventAvailabilityMask) -> Bool
    func isSuperset(of other: EKCalendarEventAvailabilityMask) -> Bool
    func isDisjoint(with other: EKCalendarEventAvailabilityMask) -> Bool
    func subtracting(_ other: EKCalendarEventAvailabilityMask) -> EKCalendarEventAvailabilityMask
    var isEmpty: Bool { get }
    func isStrictSuperset(of other: EKCalendarEventAvailabilityMask) -> Bool
    func isStrictSubset(of other: EKCalendarEventAvailabilityMask) -> Bool
}
OptionSet

Declaration
From
static var Busy: EKCalendarEventAvailabilityMask { get }
To
static var busy: EKCalendarEventAvailabilityMask { get }

Declaration
From
static var Free: EKCalendarEventAvailabilityMask { get }
To
static var free: EKCalendarEventAvailabilityMask { get }

Declaration
From
static var Tentative: EKCalendarEventAvailabilityMask { get }
To
static var tentative: EKCalendarEventAvailabilityMask { get }

Declaration
From
static var Unavailable: EKCalendarEventAvailabilityMask { get }
To
static var unavailable: EKCalendarEventAvailabilityMask { get }

Declaration
From
class EKCalendarItem : EKObject {
    var UUID: String { get }
    var calendar: EKCalendar
    var calendarItemIdentifier: String { get }
    var calendarItemExternalIdentifier: String { get }
    var title: String
    var location: String?
    var notes: String?
    @NSCopying var URL: NSURL?
    var lastModifiedDate: NSDate? { get }
    var creationDate: NSDate? { get }
    @NSCopying var timeZone: NSTimeZone?
    var hasAlarms: Bool { get }
    var hasRecurrenceRules: Bool { get }
    var hasAttendees: Bool { get }
    var hasNotes: Bool { get }
    var attendees: [EKParticipant]? { get }
    var alarms: [EKAlarm]?
    func addAlarm(_ alarm: EKAlarm)
    func removeAlarm(_ alarm: EKAlarm)
    var recurrenceRules: [EKRecurrenceRule]?
    func addRecurrenceRule(_ rule: EKRecurrenceRule)
    func removeRecurrenceRule(_ rule: EKRecurrenceRule)
}
To
class EKCalendarItem : EKObject {
    var uuid: String { get }
    var calendar: EKCalendar
    var calendarItemIdentifier: String { get }
    var calendarItemExternalIdentifier: String { get }
    var title: String
    var location: String?
    var notes: String?
    var url: URL?
    var lastModifiedDate: Date? { get }
    var creationDate: Date? { get }
    var timeZone: TimeZone?
    var hasAlarms: Bool { get }
    var hasRecurrenceRules: Bool { get }
    var hasAttendees: Bool { get }
    var hasNotes: Bool { get }
    var attendees: [EKParticipant]? { get }
    var alarms: [EKAlarm]?
    func addAlarm(_ alarm: EKAlarm)
    func removeAlarm(_ alarm: EKAlarm)
    var recurrenceRules: [EKRecurrenceRule]?
    func addRecurrenceRule(_ rule: EKRecurrenceRule)
    func removeRecurrenceRule(_ rule: EKRecurrenceRule)
}

Declaration
From
var creationDate: NSDate? { get }
To
var creationDate: Date? { get }

Declaration
From
var lastModifiedDate: NSDate? { get }
To
var lastModifiedDate: Date? { get }

Declaration
From
@NSCopying var timeZone: NSTimeZone?
To
var timeZone: TimeZone?

Declaration
From
@NSCopying var URL: NSURL?
To
var url: URL?

Declaration
From
enum EKCalendarType : Int {
    case Local
    case CalDAV
    case Exchange
    case Subscription
    case Birthday
}
To
enum EKCalendarType : Int {
    case local
    case calDAV
    case exchange
    case subscription
    case birthday
}

Declaration
From
case Birthday
To
case birthday

Declaration
From
case CalDAV
To
case calDAV

Declaration
From
case Exchange
To
case exchange

Declaration
From
case Local
To
case local

Declaration
From
case Subscription
To
case subscription

DeclarationProtocols
From
struct EKEntityMask : OptionSetType {
    init(rawValue rawValue: UInt)
    static var Event: EKEntityMask { get }
    static var Reminder: EKEntityMask { get }
}
OptionSetType
To
struct EKEntityMask : OptionSet {
    init(rawValue rawValue: UInt)
    static var event: EKEntityMask { get }
    static var reminder: EKEntityMask { get }
    func intersect(_ other: EKEntityMask) -> EKEntityMask
    func exclusiveOr(_ other: EKEntityMask) -> EKEntityMask
    mutating func unionInPlace(_ other: EKEntityMask)
    mutating func intersectInPlace(_ other: EKEntityMask)
    mutating func exclusiveOrInPlace(_ other: EKEntityMask)
    func isSubsetOf(_ other: EKEntityMask) -> Bool
    func isDisjointWith(_ other: EKEntityMask) -> Bool
    func isSupersetOf(_ other: EKEntityMask) -> Bool
    mutating func subtractInPlace(_ other: EKEntityMask)
    func isStrictSupersetOf(_ other: EKEntityMask) -> Bool
    func isStrictSubsetOf(_ other: EKEntityMask) -> Bool
}
extension EKEntityMask {
    func union(_ other: EKEntityMask) -> EKEntityMask
    func intersection(_ other: EKEntityMask) -> EKEntityMask
    func symmetricDifference(_ other: EKEntityMask) -> EKEntityMask
}
extension EKEntityMask {
    func contains(_ member: EKEntityMask) -> Bool
    mutating func insert(_ newMember: EKEntityMask) -> (inserted: Bool, memberAfterInsert: EKEntityMask)
    mutating func remove(_ member: EKEntityMask) -> EKEntityMask?
    mutating func update(with newMember: EKEntityMask) -> EKEntityMask?
}
extension EKEntityMask {
    convenience init()
    mutating func formUnion(_ other: EKEntityMask)
    mutating func formIntersection(_ other: EKEntityMask)
    mutating func formSymmetricDifference(_ other: EKEntityMask)
}
extension EKEntityMask {
    convenience init<S : Sequence where S.Iterator.Element == EKEntityMask>(_ sequence: S)
    convenience init(arrayLiteral arrayLiteral: EKEntityMask...)
    mutating func subtract(_ other: EKEntityMask)
    func isSubset(of other: EKEntityMask) -> Bool
    func isSuperset(of other: EKEntityMask) -> Bool
    func isDisjoint(with other: EKEntityMask) -> Bool
    func subtracting(_ other: EKEntityMask) -> EKEntityMask
    var isEmpty: Bool { get }
    func isStrictSuperset(of other: EKEntityMask) -> Bool
    func isStrictSubset(of other: EKEntityMask) -> Bool
}
OptionSet

Declaration
From
static var Event: EKEntityMask { get }
To
static var event: EKEntityMask { get }

Declaration
From
static var Reminder: EKEntityMask { get }
To
static var reminder: EKEntityMask { get }

Declaration
From
enum EKEntityType : UInt {
    case Event
    case Reminder
}
To
enum EKEntityType : UInt {
    case event
    case reminder
}

Declaration
From
case Event
To
case event

Declaration
From
case Reminder
To
case reminder

Declaration
From
enum EKErrorCode : Int {
    case EventNotMutable
    case NoCalendar
    case NoStartDate
    case NoEndDate
    case DatesInverted
    case InternalFailure
    case CalendarReadOnly
    case DurationGreaterThanRecurrence
    case AlarmGreaterThanRecurrence
    case StartDateTooFarInFuture
    case StartDateCollidesWithOtherOccurrence
    case ObjectBelongsToDifferentStore
    case InvitesCannotBeMoved
    case InvalidSpan
    case CalendarHasNoSource
    case CalendarSourceCannotBeModified
    case CalendarIsImmutable
    case SourceDoesNotAllowCalendarAddDelete
    case RecurringReminderRequiresDueDate
    case StructuredLocationsNotSupported
    case ReminderLocationsNotSupported
    case AlarmProximityNotSupported
    case CalendarDoesNotAllowEvents
    case CalendarDoesNotAllowReminders
    case SourceDoesNotAllowReminders
    case SourceDoesNotAllowEvents
    case PriorityIsInvalid
    case InvalidEntityType
    case ProcedureAlarmsNotMutable
    case EventStoreNotAuthorized
    case OSNotSupported
    case Last
}
extension EKErrorCode : _BridgedNSError {
}
extension EKErrorCode : _BridgedNSError {
}
To
enum Code : Int {
        typealias _ErrorType = EKError
        case eventNotMutable
        case noCalendar
        case noStartDate
        case noEndDate
        case datesInverted
        case internalFailure
        case calendarReadOnly
        case durationGreaterThanRecurrence
        case alarmGreaterThanRecurrence
        case startDateTooFarInFuture
        case startDateCollidesWithOtherOccurrence
        case objectBelongsToDifferentStore
        case invitesCannotBeMoved
        case invalidSpan
        case calendarHasNoSource
        case calendarSourceCannotBeModified
        case calendarIsImmutable
        case sourceDoesNotAllowCalendarAddDelete
        case recurringReminderRequiresDueDate
        case structuredLocationsNotSupported
        case reminderLocationsNotSupported
        case alarmProximityNotSupported
        case calendarDoesNotAllowEvents
        case calendarDoesNotAllowReminders
        case sourceDoesNotAllowReminders
        case sourceDoesNotAllowEvents
        case priorityIsInvalid
        case invalidEntityType
        case procedureAlarmsNotMutable
        case eventStoreNotAuthorized
        case osNotSupported
        case last
    }

Declaration
From
case AlarmGreaterThanRecurrence
To
case alarmGreaterThanRecurrence

Declaration
From
case AlarmProximityNotSupported
To
case alarmProximityNotSupported

Declaration
From
case CalendarDoesNotAllowEvents
To
case calendarDoesNotAllowEvents

Declaration
From
case CalendarDoesNotAllowReminders
To
case calendarDoesNotAllowReminders

Declaration
From
case CalendarHasNoSource
To
case calendarHasNoSource

Declaration
From
case CalendarIsImmutable
To
case calendarIsImmutable

Declaration
From
case CalendarReadOnly
To
case calendarReadOnly

Declaration
From
case CalendarSourceCannotBeModified
To
case calendarSourceCannotBeModified

DeclarationIntroduction
From
case DatesInverted
iOS 9.0
To
case datesInverted
iOS 10.0

DeclarationIntroduction
From
case DurationGreaterThanRecurrence
iOS 9.0
To
case durationGreaterThanRecurrence
iOS 10.0

Declaration
From
case EventNotMutable
To
case eventNotMutable

Declaration
From
case EventStoreNotAuthorized
To
case eventStoreNotAuthorized

Declaration
From
case InternalFailure
To
case internalFailure

Declaration
From
case InvalidEntityType
To
case invalidEntityType

DeclarationIntroduction
From
case InvalidSpan
iOS 9.0
To
case invalidSpan
iOS 10.0

Declaration
From
case InvitesCannotBeMoved
To
case invitesCannotBeMoved

Declaration
From
case Last
To
case last

Declaration
From
case NoCalendar
To
case noCalendar

Declaration
From
case NoEndDate
To
case noEndDate

Declaration
From
case NoStartDate
To
case noStartDate

Declaration
From
case ObjectBelongsToDifferentStore
To
case objectBelongsToDifferentStore

Declaration
From
case OSNotSupported
To
case osNotSupported

Declaration
From
case PriorityIsInvalid
To
case priorityIsInvalid

Declaration
From
case ProcedureAlarmsNotMutable
To
case procedureAlarmsNotMutable

DeclarationIntroduction
From
case RecurringReminderRequiresDueDate
iOS 9.0
To
case recurringReminderRequiresDueDate
iOS 10.0

DeclarationIntroduction
From
case ReminderLocationsNotSupported
iOS 9.0
To
case reminderLocationsNotSupported
iOS 10.0

Declaration
From
case SourceDoesNotAllowCalendarAddDelete
To
case sourceDoesNotAllowCalendarAddDelete

Declaration
From
case SourceDoesNotAllowEvents
To
case sourceDoesNotAllowEvents

Declaration
From
case SourceDoesNotAllowReminders
To
case sourceDoesNotAllowReminders

Declaration
From
case StartDateCollidesWithOtherOccurrence
To
case startDateCollidesWithOtherOccurrence

Declaration
From
case StartDateTooFarInFuture
To
case startDateTooFarInFuture

DeclarationIntroduction
From
case StructuredLocationsNotSupported
iOS 9.0
To
case structuredLocationsNotSupported
iOS 10.0

Modified EKEvent
Declaration
From
class EKEvent : EKCalendarItem {
     init(eventStore eventStore: EKEventStore)
    class func eventWithEventStore(_ eventStore: EKEventStore) -> EKEvent
    var eventIdentifier: String { get }
    var allDay: Bool
    @NSCopying var startDate: NSDate
    @NSCopying var endDate: NSDate
    @NSCopying var structuredLocation: EKStructuredLocation?
    func compareStartDateWithEvent(_ other: EKEvent) -> NSComparisonResult
    var organizer: EKParticipant? { get }
    var availability: EKEventAvailability
    var status: EKEventStatus { get }
    var isDetached: Bool { get }
    var occurrenceDate: NSDate { get }
    func refresh() -> Bool
    var birthdayContactIdentifier: String? { get }
    var birthdayPersonID: Int { get }
    var birthdayPersonUniqueID: String? { get }
}
To
class EKEvent : EKCalendarItem {
     init(eventStore eventStore: EKEventStore)
    class func withEventStore(_ eventStore: EKEventStore) -> EKEvent
    var eventIdentifier: String { get }
    var isAllDay: Bool
    var startDate: Date
    var endDate: Date
    @NSCopying var structuredLocation: EKStructuredLocation?
    func compareStartDate(with other: EKEvent) -> ComparisonResult
    var organizer: EKParticipant? { get }
    var availability: EKEventAvailability
    var status: EKEventStatus { get }
    var isDetached: Bool { get }
    var occurrenceDate: Date { get }
    func refresh() -> Bool
    var birthdayContactIdentifier: String? { get }
    var birthdayPersonID: Int { get }
    var birthdayPersonUniqueID: String? { get }
}

Declaration
From
func compareStartDateWithEvent(_ other: EKEvent) -> NSComparisonResult
To
func compareStartDate(with other: EKEvent) -> ComparisonResult

Declaration
From
@NSCopying var endDate: NSDate
To
var endDate: Date

Declaration
From
var allDay: Bool
To
var isAllDay: Bool

Declaration
From
var occurrenceDate: NSDate { get }
To
var occurrenceDate: Date { get }

Declaration
From
@NSCopying var startDate: NSDate
To
var startDate: Date

Declaration
From
enum EKEventAvailability : Int {
    case NotSupported
    case Busy
    case Free
    case Tentative
    case Unavailable
}
To
enum EKEventAvailability : Int {
    case notSupported
    case busy
    case free
    case tentative
    case unavailable
}

Declaration
From
case Busy
To
case busy

Declaration
From
case Free
To
case free

Declaration
From
case NotSupported
To
case notSupported

Declaration
From
case Tentative
To
case tentative

Declaration
From
case Unavailable
To
case unavailable

Declaration
From
enum EKEventStatus : Int {
    case None
    case Confirmed
    case Tentative
    case Canceled
}
To
enum EKEventStatus : Int {
    case none
    case confirmed
    case tentative
    case canceled
}

Declaration
From
case Canceled
To
case canceled

Declaration
From
case Confirmed
To
case confirmed

Declaration
From
case None
To
case none

Declaration
From
case Tentative
To
case tentative

Modified EKEventStore
DeclarationProtocols
From
class EKEventStore : NSObject {
    class func authorizationStatusForEntityType(_ entityType: EKEntityType) -> EKAuthorizationStatus
    init(accessToEntityTypes entityTypes: EKEntityMask)
    init()
    init(sources sources: [EKSource])
    func requestAccessToEntityType(_ entityType: EKEntityType, completion completion: EKEventStoreRequestAccessCompletionHandler)
    var eventStoreIdentifier: String { get }
    var delegateSources: [EKSource] { get }
    var sources: [EKSource] { get }
    func sourceWithIdentifier(_ identifier: String) -> EKSource
    var calendars: [EKCalendar] { get }
    func calendarsForEntityType(_ entityType: EKEntityType) -> [EKCalendar]
    var defaultCalendarForNewEvents: EKCalendar { get }
    func defaultCalendarForNewReminders() -> EKCalendar
    func calendarWithIdentifier(_ identifier: String) -> EKCalendar?
    func saveCalendar(_ calendar: EKCalendar, commit commit: Bool) throws
    func removeCalendar(_ calendar: EKCalendar, commit commit: Bool) throws
    func calendarItemWithIdentifier(_ identifier: String) -> EKCalendarItem
    func calendarItemsWithExternalIdentifier(_ externalIdentifier: String) -> [EKCalendarItem]
    func saveEvent(_ event: EKEvent, span span: EKSpan) throws
    func removeEvent(_ event: EKEvent, span span: EKSpan) throws
    func saveEvent(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws
    func removeEvent(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws
    func eventWithIdentifier(_ identifier: String) -> EKEvent?
    func eventsMatchingPredicate(_ predicate: NSPredicate) -> [EKEvent]
    func enumerateEventsMatchingPredicate(_ predicate: NSPredicate, usingBlock block: EKEventSearchCallback)
    func predicateForEventsWithStartDate(_ startDate: NSDate, endDate endDate: NSDate, calendars calendars: [EKCalendar]?) -> NSPredicate
    func saveReminder(_ reminder: EKReminder, commit commit: Bool) throws
    func removeReminder(_ reminder: EKReminder, commit commit: Bool) throws
    func fetchRemindersMatchingPredicate(_ predicate: NSPredicate, completion completion: ([EKReminder]?) -> Void) -> AnyObject
    func cancelFetchRequest(_ fetchIdentifier: AnyObject)
    func predicateForRemindersInCalendars(_ calendars: [EKCalendar]?) -> NSPredicate
    func predicateForIncompleteRemindersWithDueDateStarting(_ startDate: NSDate?, ending endDate: NSDate?, calendars calendars: [EKCalendar]?) -> NSPredicate
    func predicateForCompletedRemindersWithCompletionDateStarting(_ startDate: NSDate?, ending endDate: NSDate?, calendars calendars: [EKCalendar]?) -> NSPredicate
    func commit() throws
    func reset()
    func refreshSourcesIfNecessary()
}
--
To
class EKEventStore : NSObject {
    class func authorizationStatus(for entityType: EKEntityType) -> EKAuthorizationStatus
    init(accessToEntityTypes entityTypes: EKEntityMask)
    init()
    init(sources sources: [EKSource])
    func requestAccess(to entityType: EKEntityType, completion completion: EventKit.EKEventStoreRequestAccessCompletionHandler)
    var eventStoreIdentifier: String { get }
    var delegateSources: [EKSource] { get }
    var sources: [EKSource] { get }
    func source(withIdentifier identifier: String) -> EKSource
    var calendars: [EKCalendar] { get }
    func calendars(for entityType: EKEntityType) -> [EKCalendar]
    var defaultCalendarForNewEvents: EKCalendar { get }
    func defaultCalendarForNewReminders() -> EKCalendar
    func calendar(withIdentifier identifier: String) -> EKCalendar?
    func saveCalendar(_ calendar: EKCalendar, commit commit: Bool) throws
    func removeCalendar(_ calendar: EKCalendar, commit commit: Bool) throws
    func calendarItem(withIdentifier identifier: String) -> EKCalendarItem
    func calendarItems(withExternalIdentifier externalIdentifier: String) -> [EKCalendarItem]
    func save(_ event: EKEvent, span span: EKSpan) throws
    func remove(_ event: EKEvent, span span: EKSpan) throws
    func save(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws
    func remove(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws
    func event(withIdentifier identifier: String) -> EKEvent?
    func events(matching predicate: NSPredicate) -> [EKEvent]
    func enumerateEvents(matching predicate: NSPredicate, using block: EventKit.EKEventSearchCallback)
    func predicateForEvents(withStart startDate: Date, end endDate: Date, calendars calendars: [EKCalendar]?) -> NSPredicate
    func save(_ reminder: EKReminder, commit commit: Bool) throws
    func remove(_ reminder: EKReminder, commit commit: Bool) throws
    func fetchReminders(matching predicate: NSPredicate, completion completion: @escaping ([EKReminder]?) -> Swift.Void) -> Any
    func cancelFetchRequest(_ fetchIdentifier: Any)
    func predicateForReminders(in calendars: [EKCalendar]?) -> NSPredicate
    func predicateForIncompleteReminders(withDueDateStarting startDate: Date?, ending endDate: Date?, calendars calendars: [EKCalendar]?) -> NSPredicate
    func predicateForCompletedReminders(withCompletionDateStarting startDate: Date?, ending endDate: Date?, calendars calendars: [EKCalendar]?) -> NSPredicate
    func commit() throws
    func reset()
    func refreshSourcesIfNecessary()
    func performSelector(onMainThread aSelector: Selector, with arg: Any?, waitUntilDone wait: Bool, modes array: [String]?)
    func performSelector(onMainThread aSelector: Selector, with arg: Any?, waitUntilDone wait: Bool)
    func perform(_ aSelector: Selector, on thr: Thread, with arg: Any?, waitUntilDone wait: Bool, modes array: [String]?)
    func perform(_ aSelector: Selector, on thr: Thread, with arg: Any?, waitUntilDone wait: Bool)
    func performSelector(inBackground aSelector: Selector, with arg: Any?)
    class func classForKeyedUnarchiver() -> AnyClass
    var classForKeyedArchiver: AnyClass? { get }
    func replacementObject(for archiver: NSKeyedArchiver) -> Any?
    class func classFallbacksForKeyedArchiver() -> [String]
    class func keyPathsForValuesAffectingValue(forKey key: String) -> Set<String>
    class func automaticallyNotifiesObservers(forKey key: String) -> Bool
    var observationInfo: UnsafeMutableRawPointer?
    func willChangeValue(forKey key: String)
    func didChangeValue(forKey key: String)
    func willChange(_ changeKind: NSKeyValueChange, valuesAt indexes: IndexSet, forKey key: String)
    func didChange(_ changeKind: NSKeyValueChange, valuesAt indexes: IndexSet, forKey key: String)
    func willChangeValue(forKey key: String, withSetMutation mutationKind: NSKeyValueSetMutationKind, using objects: Set<AnyHashable>)
    func didChangeValue(forKey key: String, withSetMutation mutationKind: NSKeyValueSetMutationKind, using objects: Set<AnyHashable>)
    func addObserver(_ observer: NSObject, forKeyPath keyPath: String, options options: NSKeyValueObservingOptions = [], context context: UnsafeMutableRawPointer?)
    func removeObserver(_ observer: NSObject, forKeyPath keyPath: String, context context: UnsafeMutableRawPointer?)
    func removeObserver(_ observer: NSObject, forKeyPath keyPath: String)
    func observeValue(forKeyPath keyPath: String?, of object: Any?, change change: [NSKeyValueChangeKey : Any]?, context context: UnsafeMutableRawPointer?)
    class var accessInstanceVariablesDirectly: Bool { get }
    func value(forKey key: String) -> Any?
    func setValue(_ value: Any?, forKey key: String)
    func validateValue(_ ioValue: AutoreleasingUnsafeMutablePointer<AnyObject?>, forKey inKey: String) throws
    func mutableArrayValue(forKey key: String) -> NSMutableArray
    func mutableOrderedSetValue(forKey key: String) -> NSMutableOrderedSet
    func mutableSetValue(forKey key: String) -> NSMutableSet
    func value(forKeyPath keyPath: String) -> Any?
    func setValue(_ value: Any?, forKeyPath keyPath: String)
    func validateValue(_ ioValue: AutoreleasingUnsafeMutablePointer<AnyObject?>, forKeyPath inKeyPath: String) throws
    func mutableArrayValue(forKeyPath keyPath: String) -> NSMutableArray
    func mutableOrderedSetValue(forKeyPath keyPath: String) -> NSMutableOrderedSet
    func mutableSetValue(forKeyPath keyPath: String) -> NSMutableSet
    func value(forUndefinedKey key: String) -> Any?
    func setValue(_ value: Any?, forUndefinedKey key: String)
    func setNilValueForKey(_ key: String)
    func dictionaryWithValues(forKeys keys: [String]) -> [String : Any]
    func setValuesForKeys(_ keyedValues: [String : Any])
    func fileManager(_ fm: FileManager, shouldProceedAfterError errorInfo: [AnyHashable : Any]) -> Bool
    func fileManager(_ fm: FileManager, willProcessPath path: String)
    func perform(_ aSelector: Selector, with anArgument: Any?, afterDelay delay: TimeInterval, inModes modes: [RunLoopMode])
    func perform(_ aSelector: Selector, with anArgument: Any?, afterDelay delay: TimeInterval)
    class func cancelPreviousPerformRequests(withTarget aTarget: Any, selector aSelector: Selector, object anArgument: Any?)
    class func cancelPreviousPerformRequests(withTarget aTarget: Any)
    func attemptRecovery(fromError error: Error, optionIndex recoveryOptionIndex: Int, delegate delegate: Any?, didRecoverSelector didRecoverSelector: Selector?, contextInfo contextInfo: UnsafeMutableRawPointer?)
    func attemptRecovery(fromError error: Error, optionIndex recoveryOptionIndex: Int) -> Bool
    var autoContentAccessingProxy: Any { get }
    class func version() -> Int
    class func setVersion(_ aVersion: Int)
    var classForCoder: AnyClass { get }
    func awakeAfter(using aDecoder: NSCoder) -> Any?
}
extension EKEventStore : CVarArg {
}
extension EKEventStore : Equatable, Hashable {
    var hashValue: Int { get }
}
CVarArg, Equatable, Hashable

Declaration
From
class func authorizationStatusForEntityType(_ entityType: EKEntityType) -> EKAuthorizationStatus
To
class func authorizationStatus(for entityType: EKEntityType) -> EKAuthorizationStatus

Declaration
From
func calendarWithIdentifier(_ identifier: String) -> EKCalendar?
To
func calendar(withIdentifier identifier: String) -> EKCalendar?

Declaration
From
func calendarItemWithIdentifier(_ identifier: String) -> EKCalendarItem
To
func calendarItem(withIdentifier identifier: String) -> EKCalendarItem

Declaration
From
func calendarItemsWithExternalIdentifier(_ externalIdentifier: String) -> [EKCalendarItem]
To
func calendarItems(withExternalIdentifier externalIdentifier: String) -> [EKCalendarItem]

Declaration
From
func calendarsForEntityType(_ entityType: EKEntityType) -> [EKCalendar]
To
func calendars(for entityType: EKEntityType) -> [EKCalendar]

Declaration
From
func cancelFetchRequest(_ fetchIdentifier: AnyObject)
To
func cancelFetchRequest(_ fetchIdentifier: Any)

Declaration
From
func enumerateEventsMatchingPredicate(_ predicate: NSPredicate, usingBlock block: EKEventSearchCallback)
To
func enumerateEvents(matching predicate: NSPredicate, using block: EventKit.EKEventSearchCallback)

Declaration
From
func eventWithIdentifier(_ identifier: String) -> EKEvent?
To
func event(withIdentifier identifier: String) -> EKEvent?

Declaration
From
func eventsMatchingPredicate(_ predicate: NSPredicate) -> [EKEvent]
To
func events(matching predicate: NSPredicate) -> [EKEvent]

Declaration
From
func fetchRemindersMatchingPredicate(_ predicate: NSPredicate, completion completion: ([EKReminder]?) -> Void) -> AnyObject
To
func fetchReminders(matching predicate: NSPredicate, completion completion: @escaping ([EKReminder]?) -> Swift.Void) -> Any

Declaration
From
func predicateForCompletedRemindersWithCompletionDateStarting(_ startDate: NSDate?, ending endDate: NSDate?, calendars calendars: [EKCalendar]?) -> NSPredicate
To
func predicateForCompletedReminders(withCompletionDateStarting startDate: Date?, ending endDate: Date?, calendars calendars: [EKCalendar]?) -> NSPredicate

Declaration
From
func predicateForEventsWithStartDate(_ startDate: NSDate, endDate endDate: NSDate, calendars calendars: [EKCalendar]?) -> NSPredicate
To
func predicateForEvents(withStart startDate: Date, end endDate: Date, calendars calendars: [EKCalendar]?) -> NSPredicate

Declaration
From
func predicateForIncompleteRemindersWithDueDateStarting(_ startDate: NSDate?, ending endDate: NSDate?, calendars calendars: [EKCalendar]?) -> NSPredicate
To
func predicateForIncompleteReminders(withDueDateStarting startDate: Date?, ending endDate: Date?, calendars calendars: [EKCalendar]?) -> NSPredicate

Declaration
From
func predicateForRemindersInCalendars(_ calendars: [EKCalendar]?) -> NSPredicate
To
func predicateForReminders(in calendars: [EKCalendar]?) -> NSPredicate

Declaration
From
func removeReminder(_ reminder: EKReminder, commit commit: Bool) throws
To
func remove(_ reminder: EKReminder, commit commit: Bool) throws

Declaration
From
func removeEvent(_ event: EKEvent, span span: EKSpan) throws
To
func remove(_ event: EKEvent, span span: EKSpan) throws

Declaration
From
func removeEvent(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws
To
func remove(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws

Declaration
From
func requestAccessToEntityType(_ entityType: EKEntityType, completion completion: EKEventStoreRequestAccessCompletionHandler)
To
func requestAccess(to entityType: EKEntityType, completion completion: EventKit.EKEventStoreRequestAccessCompletionHandler)

Declaration
From
func saveReminder(_ reminder: EKReminder, commit commit: Bool) throws
To
func save(_ reminder: EKReminder, commit commit: Bool) throws

Declaration
From
func saveEvent(_ event: EKEvent, span span: EKSpan) throws
To
func save(_ event: EKEvent, span span: EKSpan) throws

Declaration
From
func saveEvent(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws
To
func save(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws

Declaration
From
func sourceWithIdentifier(_ identifier: String) -> EKSource
To
func source(withIdentifier identifier: String) -> EKSource

Modified EKObject
DeclarationProtocols
From
class EKObject : NSObject {
    var hasChanges: Bool { get }
    var new: Bool { get }
    func reset()
    func rollback()
    func refresh() -> Bool
}
--
To
class EKObject : NSObject {
    var hasChanges: Bool { get }
    var isNew: Bool { get }
    func reset()
    func rollback()
    func refresh() -> Bool
    func performSelector(onMainThread aSelector: Selector, with arg: Any?, waitUntilDone wait: Bool, modes array: [String]?)
    func performSelector(onMainThread aSelector: Selector, with arg: Any?, waitUntilDone wait: Bool)
    func perform(_ aSelector: Selector, on thr: Thread, with arg: Any?, waitUntilDone wait: Bool, modes array: [String]?)
    func perform(_ aSelector: Selector, on thr: Thread, with arg: Any?, waitUntilDone wait: Bool)
    func performSelector(inBackground aSelector: Selector, with arg: Any?)
    class func classForKeyedUnarchiver() -> AnyClass
    var classForKeyedArchiver: AnyClass? { get }
    func replacementObject(for archiver: NSKeyedArchiver) -> Any?
    class func classFallbacksForKeyedArchiver() -> [String]
    class func keyPathsForValuesAffectingValue(forKey key: String) -> Set<String>
    class func automaticallyNotifiesObservers(forKey key: String) -> Bool
    var observationInfo: UnsafeMutableRawPointer?
    func willChangeValue(forKey key: String)
    func didChangeValue(forKey key: String)
    func willChange(_ changeKind: NSKeyValueChange, valuesAt indexes: IndexSet, forKey key: String)
    func didChange(_ changeKind: NSKeyValueChange, valuesAt indexes: IndexSet, forKey key: String)
    func willChangeValue(forKey key: String, withSetMutation mutationKind: NSKeyValueSetMutationKind, using objects: Set<AnyHashable>)
    func didChangeValue(forKey key: String, withSetMutation mutationKind: NSKeyValueSetMutationKind, using objects: Set<AnyHashable>)
    func addObserver(_ observer: NSObject, forKeyPath keyPath: String, options options: NSKeyValueObservingOptions = [], context context: UnsafeMutableRawPointer?)
    func removeObserver(_ observer: NSObject, forKeyPath keyPath: String, context context: UnsafeMutableRawPointer?)
    func removeObserver(_ observer: NSObject, forKeyPath keyPath: String)
    func observeValue(forKeyPath keyPath: String?, of object: Any?, change change: [NSKeyValueChangeKey : Any]?, context context: UnsafeMutableRawPointer?)
    class var accessInstanceVariablesDirectly: Bool { get }
    func value(forKey key: String) -> Any?
    func setValue(_ value: Any?, forKey key: String)
    func validateValue(_ ioValue: AutoreleasingUnsafeMutablePointer<AnyObject?>, forKey inKey: String) throws
    func mutableArrayValue(forKey key: String) -> NSMutableArray
    func mutableOrderedSetValue(forKey key: String) -> NSMutableOrderedSet
    func mutableSetValue(forKey key: String) -> NSMutableSet
    func value(forKeyPath keyPath: String) -> Any?
    func setValue(_ value: Any?, forKeyPath keyPath: String)
    func validateValue(_ ioValue: AutoreleasingUnsafeMutablePointer<AnyObject?>, forKeyPath inKeyPath: String) throws
    func mutableArrayValue(forKeyPath keyPath: String) -> NSMutableArray
    func mutableOrderedSetValue(forKeyPath keyPath: String) -> NSMutableOrderedSet
    func mutableSetValue(forKeyPath keyPath: String) -> NSMutableSet
    func value(forUndefinedKey key: String) -> Any?
    func setValue(_ value: Any?, forUndefinedKey key: String)
    func setNilValueForKey(_ key: String)
    func dictionaryWithValues(forKeys keys: [String]) -> [String : Any]
    func setValuesForKeys(_ keyedValues: [String : Any])
    func fileManager(_ fm: FileManager, shouldProceedAfterError errorInfo: [AnyHashable : Any]) -> Bool
    func fileManager(_ fm: FileManager, willProcessPath path: String)
    func perform(_ aSelector: Selector, with anArgument: Any?, afterDelay delay: TimeInterval, inModes modes: [RunLoopMode])
    func perform(_ aSelector: Selector, with anArgument: Any?, afterDelay delay: TimeInterval)
    class func cancelPreviousPerformRequests(withTarget aTarget: Any, selector aSelector: Selector, object anArgument: Any?)
    class func cancelPreviousPerformRequests(withTarget aTarget: Any)
    func attemptRecovery(fromError error: Error, optionIndex recoveryOptionIndex: Int, delegate delegate: Any?, didRecoverSelector didRecoverSelector: Selector?, contextInfo contextInfo: UnsafeMutableRawPointer?)
    func attemptRecovery(fromError error: Error, optionIndex recoveryOptionIndex: Int) -> Bool
    var autoContentAccessingProxy: Any { get }
    class func version() -> Int
    class func setVersion(_ aVersion: Int)
    var classForCoder: AnyClass { get }
    func awakeAfter(using aDecoder: NSCoder) -> Any?
}
extension EKObject : CVarArg {
}
extension EKObject : Equatable, Hashable {
    var hashValue: Int { get }
}
CVarArg, Equatable, Hashable

Declaration
From
var new: Bool { get }
To
var isNew: Bool { get }

Modified EKParticipant
Declaration
From
class EKParticipant : EKObject, NSCopying {
    var URL: NSURL { get }
    var name: String? { get }
    var participantStatus: EKParticipantStatus { get }
    var participantRole: EKParticipantRole { get }
    var participantType: EKParticipantType { get }
    var currentUser: Bool { get }
    var contactPredicate: NSPredicate { get }
    func ABRecordWithAddressBook(_ addressBook: ABAddressBook) -> ABRecord?
}
To
class EKParticipant : EKObject, NSCopying {
    var url: URL { get }
    var name: String? { get }
    var participantStatus: EKParticipantStatus { get }
    var participantRole: EKParticipantRole { get }
    var participantType: EKParticipantType { get }
    var isCurrentUser: Bool { get }
    var contactPredicate: NSPredicate { get }
    func abRecord(with addressBook: ABAddressBook) -> ABRecord?
}

Declaration
From
func ABRecordWithAddressBook(_ addressBook: ABAddressBook) -> ABRecord?
To
func abRecord(with addressBook: ABAddressBook) -> ABRecord?

Declaration
From
var currentUser: Bool { get }
To
var isCurrentUser: Bool { get }

Declaration
From
var URL: NSURL { get }
To
var url: URL { get }

Declaration
From
enum EKParticipantRole : Int {
    case Unknown
    case Required
    case Optional
    case Chair
    case NonParticipant
}
To
enum EKParticipantRole : Int {
    case unknown
    case required
    case optional
    case chair
    case nonParticipant
}

Declaration
From
case Chair
To
case chair

Declaration
From
case NonParticipant
To
case nonParticipant

Declaration
From
case Optional
To
case optional

Declaration
From
case Required
To
case required

Declaration
From
case Unknown
To
case unknown

Declaration
From
enum EKParticipantScheduleStatus : Int {
    case None
    case Pending
    case Sent
    case Delivered
    case RecipientNotRecognized
    case NoPrivileges
    case DeliveryFailed
    case CannotDeliver
    case RecipientNotAllowed
}
To
enum EKParticipantScheduleStatus : Int {
    case none
    case pending
    case sent
    case delivered
    case recipientNotRecognized
    case noPrivileges
    case deliveryFailed
    case cannotDeliver
    case recipientNotAllowed
}

Declaration
From
case CannotDeliver
To
case cannotDeliver

Declaration
From
case Delivered
To
case delivered

Declaration
From
case DeliveryFailed
To
case deliveryFailed

Declaration
From
case None
To
case none

Declaration
From
case NoPrivileges
To
case noPrivileges

Declaration
From
case Pending
To
case pending

Declaration
From
case RecipientNotAllowed
To
case recipientNotAllowed

Declaration
From
case RecipientNotRecognized
To
case recipientNotRecognized

Declaration
From
case Sent
To
case sent

Declaration
From
enum EKParticipantStatus : Int {
    case Unknown
    case Pending
    case Accepted
    case Declined
    case Tentative
    case Delegated
    case Completed
    case InProcess
}
To
enum EKParticipantStatus : Int {
    case unknown
    case pending
    case accepted
    case declined
    case tentative
    case delegated
    case completed
    case inProcess
}

Declaration
From
case Accepted
To
case accepted

Declaration
From
case Completed
To
case completed

Declaration
From
case Declined
To
case declined

Declaration
From
case Delegated
To
case delegated

Declaration
From
case InProcess
To
case inProcess

Declaration
From
case Pending
To
case pending

Declaration
From
case Tentative
To
case tentative

Declaration
From
case Unknown
To
case unknown

Declaration
From
enum EKParticipantType : Int {
    case Unknown
    case Person
    case Room
    case Resource
    case Group
}
To
enum EKParticipantType : Int {
    case unknown
    case person
    case room
    case resource
    case group
}

Declaration
From
case Group
To
case group

Declaration
From
case Person
To
case person

Declaration
From
case Resource
To
case resource

Declaration
From
case Room
To
case room

Declaration
From
case Unknown
To
case unknown

DeclarationProtocols
From
class EKRecurrenceDayOfWeek : NSObject, NSCopying {
    convenience init(_ dayOfTheWeek: EKWeekday)
    class func dayOfWeek(_ dayOfTheWeek: EKWeekday) -> Self
    convenience init(_ dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int)
    class func dayOfWeek(_ dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int) -> Self
    init(dayOfTheWeek dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int)
    var dayOfTheWeek: EKWeekday { get }
    var weekNumber: Int { get }
}
NSCopying
To
class EKRecurrenceDayOfWeek : NSObject, NSCopying {
    convenience init(_ dayOfTheWeek: EKWeekday)
    class func day(ofWeek dayOfTheWeek: EKWeekday) -> Self
    convenience init(_ dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int)
    class func day(ofWeek dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int) -> Self
    init(dayOfTheWeek dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int)
    var dayOfTheWeek: EKWeekday { get }
    var weekNumber: Int { get }
    func performSelector(onMainThread aSelector: Selector, with arg: Any?, waitUntilDone wait: Bool, modes array: [String]?)
    func performSelector(onMainThread aSelector: Selector, with arg: Any?, waitUntilDone wait: Bool)
    func perform(_ aSelector: Selector, on thr: Thread, with arg: Any?, waitUntilDone wait: Bool, modes array: [String]?)
    func perform(_ aSelector: Selector, on thr: Thread, with arg: Any?, waitUntilDone wait: Bool)
    func performSelector(inBackground aSelector: Selector, with arg: Any?)
    class func classForKeyedUnarchiver() -> AnyClass
    var classForKeyedArchiver: AnyClass? { get }
    func replacementObject(for archiver: NSKeyedArchiver) -> Any?
    class func classFallbacksForKeyedArchiver() -> [String]
    class func keyPathsForValuesAffectingValue(forKey key: String) -> Set<String>
    class func automaticallyNotifiesObservers(forKey key: String) -> Bool
    var observationInfo: UnsafeMutableRawPointer?
    func willChangeValue(forKey key: String)
    func didChangeValue(forKey key: String)
    func willChange(_ changeKind: NSKeyValueChange, valuesAt indexes: IndexSet, forKey key: String)
    func didChange(_ changeKind: NSKeyValueChange, valuesAt indexes: IndexSet, forKey key: String)
    func willChangeValue(forKey key: String, withSetMutation mutationKind: NSKeyValueSetMutationKind, using objects: Set<AnyHashable>)
    func didChangeValue(forKey key: String, withSetMutation mutationKind: NSKeyValueSetMutationKind, using objects: Set<AnyHashable>)
    func addObserver(_ observer: NSObject, forKeyPath keyPath: String, options options: NSKeyValueObservingOptions = [], context context: UnsafeMutableRawPointer?)
    func removeObserver(_ observer: NSObject, forKeyPath keyPath: String, context context: UnsafeMutableRawPointer?)
    func removeObserver(_ observer: NSObject, forKeyPath keyPath: String)
    func observeValue(forKeyPath keyPath: String?, of object: Any?, change change: [NSKeyValueChangeKey : Any]?, context context: UnsafeMutableRawPointer?)
    class var accessInstanceVariablesDirectly: Bool { get }
    func value(forKey key: String) -> Any?
    func setValue(_ value: Any?, forKey key: String)
    func validateValue(_ ioValue: AutoreleasingUnsafeMutablePointer<AnyObject?>, forKey inKey: String) throws
    func mutableArrayValue(forKey key: String) -> NSMutableArray
    func mutableOrderedSetValue(forKey key: String) -> NSMutableOrderedSet
    func mutableSetValue(forKey key: String) -> NSMutableSet
    func value(forKeyPath keyPath: String) -> Any?
    func setValue(_ value: Any?, forKeyPath keyPath: String)
    func validateValue(_ ioValue: AutoreleasingUnsafeMutablePointer<AnyObject?>, forKeyPath inKeyPath: String) throws
    func mutableArrayValue(forKeyPath keyPath: String) -> NSMutableArray
    func mutableOrderedSetValue(forKeyPath keyPath: String) -> NSMutableOrderedSet
    func mutableSetValue(forKeyPath keyPath: String) -> NSMutableSet
    func value(forUndefinedKey key: String) -> Any?
    func setValue(_ value: Any?, forUndefinedKey key: String)
    func setNilValueForKey(_ key: String)
    func dictionaryWithValues(forKeys keys: [String]) -> [String : Any]
    func setValuesForKeys(_ keyedValues: [String : Any])
    func fileManager(_ fm: FileManager, shouldProceedAfterError errorInfo: [AnyHashable : Any]) -> Bool
    func fileManager(_ fm: FileManager, willProcessPath path: String)
    func perform(_ aSelector: Selector, with anArgument: Any?, afterDelay delay: TimeInterval, inModes modes: [RunLoopMode])
    func perform(_ aSelector: Selector, with anArgument: Any?, afterDelay delay: TimeInterval)
    class func cancelPreviousPerformRequests(withTarget aTarget: Any, selector aSelector: Selector, object anArgument: Any?)
    class func cancelPreviousPerformRequests(withTarget aTarget: Any)
    func attemptRecovery(fromError error: Error, optionIndex recoveryOptionIndex: Int, delegate delegate: Any?, didRecoverSelector didRecoverSelector: Selector?, contextInfo contextInfo: UnsafeMutableRawPointer?)
    func attemptRecovery(fromError error: Error, optionIndex recoveryOptionIndex: Int) -> Bool
    var autoContentAccessingProxy: Any { get }
    class func version() -> Int
    class func setVersion(_ aVersion: Int)
    var classForCoder: AnyClass { get }
    func awakeAfter(using aDecoder: NSCoder) -> Any?
}
extension EKRecurrenceDayOfWeek : CVarArg {
}
extension EKRecurrenceDayOfWeek : Equatable, Hashable {
    var hashValue: Int { get }
}
CVarArg, Equatable, Hashable, NSCopying

DeclarationProtocols
From
class EKRecurrenceEnd : NSObject, NSCopying {
    convenience init(endDate endDate: NSDate)
    class func recurrenceEndWithEndDate(_ endDate: NSDate) -> Self
    convenience init(occurrenceCount occurrenceCount: Int)
    class func recurrenceEndWithOccurrenceCount(_ occurrenceCount: Int) -> Self
    var endDate: NSDate? { get }
    var occurrenceCount: Int { get }
}
NSCopying
To
class EKRecurrenceEnd : NSObject, NSCopying {
    convenience init(end endDate: Date)
    class func withEnd(_ endDate: Date) -> Self
    convenience init(occurrenceCount occurrenceCount: Int)
    class func withOccurrenceCount(_ occurrenceCount: Int) -> Self
    var endDate: Date? { get }
    var occurrenceCount: Int { get }
    func performSelector(onMainThread aSelector: Selector, with arg: Any?, waitUntilDone wait: Bool, modes array: [String]?)
    func performSelector(onMainThread aSelector: Selector, with arg: Any?, waitUntilDone wait: Bool)
    func perform(_ aSelector: Selector, on thr: Thread, with arg: Any?, waitUntilDone wait: Bool, modes array: [String]?)
    func perform(_ aSelector: Selector, on thr: Thread, with arg: Any?, waitUntilDone wait: Bool)
    func performSelector(inBackground aSelector: Selector, with arg: Any?)
    class func classForKeyedUnarchiver() -> AnyClass
    var classForKeyedArchiver: AnyClass? { get }
    func replacementObject(for archiver: NSKeyedArchiver) -> Any?
    class func classFallbacksForKeyedArchiver() -> [String]
    class func keyPathsForValuesAffectingValue(forKey key: String) -> Set<String>
    class func automaticallyNotifiesObservers(forKey key: String) -> Bool
    var observationInfo: UnsafeMutableRawPointer?
    func willChangeValue(forKey key: String)
    func didChangeValue(forKey key: String)
    func willChange(_ changeKind: NSKeyValueChange, valuesAt indexes: IndexSet, forKey key: String)
    func didChange(_ changeKind: NSKeyValueChange, valuesAt indexes: IndexSet, forKey key: String)
    func willChangeValue(forKey key: String, withSetMutation mutationKind: NSKeyValueSetMutationKind, using objects: Set<AnyHashable>)
    func didChangeValue(forKey key: String, withSetMutation mutationKind: NSKeyValueSetMutationKind, using objects: Set<AnyHashable>)
    func addObserver(_ observer: NSObject, forKeyPath keyPath: String, options options: NSKeyValueObservingOptions = [], context context: UnsafeMutableRawPointer?)
    func removeObserver(_ observer: NSObject, forKeyPath keyPath: String, context context: UnsafeMutableRawPointer?)
    func removeObserver(_ observer: NSObject, forKeyPath keyPath: String)
    func observeValue(forKeyPath keyPath: String?, of object: Any?, change change: [NSKeyValueChangeKey : Any]?, context context: UnsafeMutableRawPointer?)
    class var accessInstanceVariablesDirectly: Bool { get }
    func value(forKey key: String) -> Any?
    func setValue(_ value: Any?, forKey key: String)
    func validateValue(_ ioValue: AutoreleasingUnsafeMutablePointer<AnyObject?>, forKey inKey: String) throws
    func mutableArrayValue(forKey key: String) -> NSMutableArray
    func mutableOrderedSetValue(forKey key: String) -> NSMutableOrderedSet
    func mutableSetValue(forKey key: String) -> NSMutableSet
    func value(forKeyPath keyPath: String) -> Any?
    func setValue(_ value: Any?, forKeyPath keyPath: String)
    func validateValue(_ ioValue: AutoreleasingUnsafeMutablePointer<AnyObject?>, forKeyPath inKeyPath: String) throws
    func mutableArrayValue(forKeyPath keyPath: String) -> NSMutableArray
    func mutableOrderedSetValue(forKeyPath keyPath: String) -> NSMutableOrderedSet
    func mutableSetValue(forKeyPath keyPath: String) -> NSMutableSet
    func value(forUndefinedKey key: String) -> Any?
    func setValue(_ value: Any?, forUndefinedKey key: String)
    func setNilValueForKey(_ key: String)
    func dictionaryWithValues(forKeys keys: [String]) -> [String : Any]
    func setValuesForKeys(_ keyedValues: [String : Any])
    func fileManager(_ fm: FileManager, shouldProceedAfterError errorInfo: [AnyHashable : Any]) -> Bool
    func fileManager(_ fm: FileManager, willProcessPath path: String)
    func perform(_ aSelector: Selector, with anArgument: Any?, afterDelay delay: TimeInterval, inModes modes: [RunLoopMode])
    func perform(_ aSelector: Selector, with anArgument: Any?, afterDelay delay: TimeInterval)
    class func cancelPreviousPerformRequests(withTarget aTarget: Any, selector aSelector: Selector, object anArgument: Any?)
    class func cancelPreviousPerformRequests(withTarget aTarget: Any)
    func attemptRecovery(fromError error: Error, optionIndex recoveryOptionIndex: Int, delegate delegate: Any?, didRecoverSelector didRecoverSelector: Selector?, contextInfo contextInfo: UnsafeMutableRawPointer?)
    func attemptRecovery(fromError error: Error, optionIndex recoveryOptionIndex: Int) -> Bool
    var autoContentAccessingProxy: Any { get }
    class func version() -> Int
    class func setVersion(_ aVersion: Int)
    var classForCoder: AnyClass { get }
    func awakeAfter(using aDecoder: NSCoder) -> Any?
}
extension EKRecurrenceEnd : CVarArg {
}
extension EKRecurrenceEnd : Equatable, Hashable {
    var hashValue: Int { get }
}
CVarArg, Equatable, Hashable, NSCopying

Declaration
From
var endDate: NSDate? { get }
To
var endDate: Date? { get }

Declaration
From
convenience init(endDate endDate: NSDate)
To
convenience init(end endDate: Date)

Declaration
From
enum EKRecurrenceFrequency : Int {
    case Daily
    case Weekly
    case Monthly
    case Yearly
}
To
enum EKRecurrenceFrequency : Int {
    case daily
    case weekly
    case monthly
    case yearly
}

Declaration
From
case Daily
To
case daily

Declaration
From
case Monthly
To
case monthly

Declaration
From
case Weekly
To
case weekly

Declaration
From
case Yearly
To
case yearly

Declaration
From
class EKRecurrenceRule : EKObject, NSCopying {
    init(recurrenceWithFrequency type: EKRecurrenceFrequency, interval interval: Int, end end: EKRecurrenceEnd?)
    init(recurrenceWithFrequency type: EKRecurrenceFrequency, interval interval: Int, daysOfTheWeek days: [EKRecurrenceDayOfWeek]?, daysOfTheMonth monthDays: [NSNumber]?, monthsOfTheYear months: [NSNumber]?, weeksOfTheYear weeksOfTheYear: [NSNumber]?, daysOfTheYear daysOfTheYear: [NSNumber]?, setPositions setPositions: [NSNumber]?, end end: EKRecurrenceEnd?)
    var calendarIdentifier: String { get }
    @NSCopying var recurrenceEnd: EKRecurrenceEnd?
    var frequency: EKRecurrenceFrequency { get }
    var interval: Int { get }
    var firstDayOfTheWeek: Int { get }
    var daysOfTheWeek: [EKRecurrenceDayOfWeek]? { get }
    var daysOfTheMonth: [NSNumber]? { get }
    var daysOfTheYear: [NSNumber]? { get }
    var weeksOfTheYear: [NSNumber]? { get }
    var monthsOfTheYear: [NSNumber]? { get }
    var setPositions: [NSNumber]? { get }
}
To
class EKRecurrenceRule : EKObject, NSCopying {
    init(recurrenceWith type: EKRecurrenceFrequency, interval interval: Int, end end: EKRecurrenceEnd?)
    init(recurrenceWith type: EKRecurrenceFrequency, interval interval: Int, daysOfTheWeek days: [EKRecurrenceDayOfWeek]?, daysOfTheMonth monthDays: [NSNumber]?, monthsOfTheYear months: [NSNumber]?, weeksOfTheYear weeksOfTheYear: [NSNumber]?, daysOfTheYear daysOfTheYear: [NSNumber]?, setPositions setPositions: [NSNumber]?, end end: EKRecurrenceEnd?)
    var calendarIdentifier: String { get }
    @NSCopying var recurrenceEnd: EKRecurrenceEnd?
    var frequency: EKRecurrenceFrequency { get }
    var interval: Int { get }
    var firstDayOfTheWeek: Int { get }
    var daysOfTheWeek: [EKRecurrenceDayOfWeek]? { get }
    var daysOfTheMonth: [NSNumber]? { get }
    var daysOfTheYear: [NSNumber]? { get }
    var weeksOfTheYear: [NSNumber]? { get }
    var monthsOfTheYear: [NSNumber]? { get }
    var setPositions: [NSNumber]? { get }
}

Declaration
From
init(recurrenceWithFrequency type: EKRecurrenceFrequency, interval interval: Int, daysOfTheWeek days: [EKRecurrenceDayOfWeek]?, daysOfTheMonth monthDays: [NSNumber]?, monthsOfTheYear months: [NSNumber]?, weeksOfTheYear weeksOfTheYear: [NSNumber]?, daysOfTheYear daysOfTheYear: [NSNumber]?, setPositions setPositions: [NSNumber]?, end end: EKRecurrenceEnd?)
To
init(recurrenceWith type: EKRecurrenceFrequency, interval interval: Int, daysOfTheWeek days: [EKRecurrenceDayOfWeek]?, daysOfTheMonth monthDays: [NSNumber]?, monthsOfTheYear months: [NSNumber]?, weeksOfTheYear weeksOfTheYear: [NSNumber]?, daysOfTheYear daysOfTheYear: [NSNumber]?, setPositions setPositions: [NSNumber]?, end end: EKRecurrenceEnd?)

Declaration
From
init(recurrenceWithFrequency type: EKRecurrenceFrequency, interval interval: Int, end end: EKRecurrenceEnd?)
To
init(recurrenceWith type: EKRecurrenceFrequency, interval interval: Int, end end: EKRecurrenceEnd?)

Modified EKReminder
Declaration
From
class EKReminder : EKCalendarItem {
     init(eventStore eventStore: EKEventStore)
    class func reminderWithEventStore(_ eventStore: EKEventStore) -> EKReminder
    @NSCopying var startDateComponents: NSDateComponents?
    @NSCopying var dueDateComponents: NSDateComponents?
    var completed: Bool
    @NSCopying var completionDate: NSDate?
    var priority: Int
}
To
class EKReminder : EKCalendarItem {
     init(eventStore eventStore: EKEventStore)
    class func withEventStore(_ eventStore: EKEventStore) -> EKReminder
    var startDateComponents: DateComponents?
    var dueDateComponents: DateComponents?
    var isCompleted: Bool
    var completionDate: Date?
    var priority: Int
}

Declaration
From
@NSCopying var completionDate: NSDate?
To
var completionDate: Date?

Declaration
From
@NSCopying var dueDateComponents: NSDateComponents?
To
var dueDateComponents: DateComponents?

Declaration
From
var completed: Bool
To
var isCompleted: Bool

Declaration
From
@NSCopying var startDateComponents: NSDateComponents?
To
var startDateComponents: DateComponents?

Declaration
From
enum EKReminderPriority : UInt {
    case None
    case High
    case Medium
    case Low
}
To
enum EKReminderPriority : UInt {
    case none
    case high
    case medium
    case low
}

Declaration
From
case High
To
case high

Declaration
From
case Low
To
case low

Declaration
From
case Medium
To
case medium

Declaration
From
case None
To
case none

Modified EKSource
Declaration
From
class EKSource : EKObject {
    var sourceIdentifier: String { get }
    var sourceType: EKSourceType { get }
    var title: String { get }
    var calendars: Set<EKCalendar> { get }
    func calendarsForEntityType(_ entityType: EKEntityType) -> Set<EKCalendar>
}
To
class EKSource : EKObject {
    var sourceIdentifier: String { get }
    var sourceType: EKSourceType { get }
    var title: String { get }
    var calendars: Set<EKCalendar> { get }
    func calendars(for entityType: EKEntityType) -> Set<EKCalendar>
}

Declaration
From
func calendarsForEntityType(_ entityType: EKEntityType) -> Set<EKCalendar>
To
func calendars(for entityType: EKEntityType) -> Set<EKCalendar>

Declaration
From
enum EKSourceType : Int {
    case Local
    case Exchange
    case CalDAV
    case MobileMe
    case Subscribed
    case Birthdays
}
To
enum EKSourceType : Int {
    case local
    case exchange
    case calDAV
    case mobileMe
    case subscribed
    case birthdays
}

Declaration
From
case Birthdays
To
case birthdays

Declaration
From
case CalDAV
To
case calDAV

Declaration
From
case Exchange
To
case exchange

Declaration
From
case Local
To
case local

Declaration
From
case MobileMe
To
case mobileMe

Declaration
From
case Subscribed
To
case subscribed

Modified EKSpan [enum]
Declaration
From
enum EKSpan : Int {
    case ThisEvent
    case FutureEvents
}
To
enum EKSpan : Int {
    case thisEvent
    case futureEvents
}

Declaration
From
case FutureEvents
To
case futureEvents

Declaration
From
case ThisEvent
To
case thisEvent

Declaration
From
class EKStructuredLocation : EKObject, NSCopying {
    convenience init(title title: String)
    class func locationWithTitle(_ title: String) -> Self
    convenience init(mapItem mapItem: MKMapItem)
    class func locationWithMapItem(_ mapItem: MKMapItem) -> Self
    var title: String
    var geoLocation: CLLocation?
    var radius: Double
}
To
class EKStructuredLocation : EKObject, NSCopying {
    convenience init(title title: String)
    class func withTitle(_ title: String) -> Self
    convenience init(mapItem mapItem: MKMapItem)
    class func withMapItem(_ mapItem: MKMapItem) -> Self
    var title: String
    var geoLocation: CLLocation?
    var radius: Double
}

Declaration
From
enum EKWeekday : Int {
    case Sunday
    case Monday
    case Tuesday
    case Wednesday
    case Thursday
    case Friday
    case Saturday
    static var EKSunday: EKWeekday { get }
    static var EKMonday: EKWeekday { get }
    static var EKTuesday: EKWeekday { get }
    static var EKWednesday: EKWeekday { get }
    static var EKThursday: EKWeekday { get }
    static var EKFriday: EKWeekday { get }
    static var EKSaturday: EKWeekday { get }
}
To
enum EKWeekday : Int {
    case sunday
    case monday
    case tuesday
    case wednesday
    case thursday
    case friday
    case saturday
    static var EKSunday: EKWeekday { get }
    static var EKMonday: EKWeekday { get }
    static var EKTuesday: EKWeekday { get }
    static var EKWednesday: EKWeekday { get }
    static var EKThursday: EKWeekday { get }
    static var EKFriday: EKWeekday { get }
    static var EKSaturday: EKWeekday { get }
}

Declaration
From
case Friday
To
case friday

Declaration
From
case Monday
To
case monday

Declaration
From
case Saturday
To
case saturday

Declaration
From
case Sunday
To
case sunday

Declaration
From
case Thursday
To
case thursday

Declaration
From
case Tuesday
To
case tuesday

Declaration
From
case Wednesday
To
case wednesday

NameDeclaration
FromEKEventStoreChangedNotification
let EKEventStoreChangedNotification: String
ToEKEventStoreChanged
static let EKEventStoreChanged: NSNotification.Name

Declaration
From
typealias EKEventSearchCallback = (EKEvent, UnsafeMutablePointer<ObjCBool>) -> Void
To
typealias EKEventSearchCallback = (EKEvent, UnsafeMutablePointer<ObjCBool>) -> Swift.Void

Declaration
From
typealias EKEventStoreRequestAccessCompletionHandler = (Bool, NSError?) -> Void
To
typealias EKEventStoreRequestAccessCompletionHandler = (Bool, Error?) -> Swift.Void