Documentation Archive Developer
Search

EventKit Changes for Swift

EventKit

Removed EKCalendarEventAvailabilityMask.None
Added EKError [struct]
Added EKError.alarmGreaterThanRecurrence
Added EKError.alarmProximityNotSupported
Added EKError.calendarDoesNotAllowEvents
Added EKError.calendarDoesNotAllowReminders
Added EKError.calendarHasNoSource
Added EKError.calendarIsImmutable
Added EKError.calendarReadOnly
Added EKError.calendarSourceCannotBeModified
Added EKError.datesInverted
Added EKError.durationGreaterThanRecurrence
Added EKError.eventNotMutable
Added EKError.eventStoreNotAuthorized
Added EKError.init(_nsError: NSError)
Added EKError.internalFailure
Added EKError.invalidEntityType
Added EKError.invalidSpan
Added EKError.invitesCannotBeMoved
Added EKError.last
Added EKError.noCalendar
Added EKError.noEndDate
Added EKError.noStartDate
Added EKError.objectBelongsToDifferentStore
Added EKError.osNotSupported
Added EKError.priorityIsInvalid
Added EKError.procedureAlarmsNotMutable
Added EKError.recurringReminderRequiresDueDate
Added EKError.reminderLocationsNotSupported
Added EKError.sourceDoesNotAllowCalendarAddDelete
Added EKError.sourceDoesNotAllowEvents
Added EKError.sourceDoesNotAllowReminders
Added EKError.startDateCollidesWithOtherOccurrence
Added EKError.startDateTooFarInFuture
Added EKError.structuredLocationsNotSupported
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?
}

Modified EKAlarm.absoluteDate
Declaration
From
@NSCopying var absoluteDate: NSDate?
To
var absoluteDate: Date?

Modified EKAlarm.init(absoluteDate: Date)
Declaration
From
init(absoluteDate date: NSDate)
To
init(absoluteDate date: Date)

Modified EKAlarm.init(relativeOffset: TimeInterval)
Declaration
From
init(relativeOffset offset: NSTimeInterval)
To
init(relativeOffset offset: TimeInterval)

Modified EKAlarm.relativeOffset
Declaration
From
var relativeOffset: NSTimeInterval
To
var relativeOffset: TimeInterval

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

Modified EKAlarmProximity.enter
Declaration
From
case Enter
To
case enter

Modified EKAlarmProximity.leave
Declaration
From
case Leave
To
case leave

Modified EKAlarmProximity.none
Declaration
From
case None
To
case none

Modified EKAlarmType [enum]
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
}

Modified EKAlarmType.audio
Declaration
From
case Audio
To
case audio

Modified EKAlarmType.display
Declaration
From
case Display
To
case display

Modified EKAlarmType.email
Declaration
From
case Email
To
case email

Modified EKAlarmType.procedure
Declaration
From
case Procedure
To
case procedure

Modified EKAuthorizationStatus [enum]
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
}

Modified EKAuthorizationStatus.authorized
Declaration
From
case Authorized
To
case authorized

Modified EKAuthorizationStatus.denied
Declaration
From
case Denied
To
case denied

Modified EKAuthorizationStatus.notDetermined
Declaration
From
case NotDetermined
To
case notDetermined

Modified EKAuthorizationStatus.restricted
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 }
}

Modified EKCalendar.cgColor
Declaration
From
var CGColor: CGColor
To
var cgColor: CGColor

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

Modified EKCalendar.isImmutable
Declaration
From
var immutable: Bool { get }
To
var isImmutable: Bool { get }

Modified EKCalendar.isSubscribed
Declaration
From
var subscribed: Bool { get }
To
var isSubscribed: Bool { get }

Modified EKCalendarEventAvailabilityMask [struct]
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

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

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

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

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

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

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

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

Modified EKCalendarItem.timeZone
Declaration
From
@NSCopying var timeZone: NSTimeZone?
To
var timeZone: TimeZone?

Modified EKCalendarItem.url
Declaration
From
@NSCopying var URL: NSURL?
To
var url: URL?

Modified EKCalendarType [enum]
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
}

Modified EKCalendarType.birthday
Declaration
From
case Birthday
To
case birthday

Modified EKCalendarType.calDAV
Declaration
From
case CalDAV
To
case calDAV

Modified EKCalendarType.exchange
Declaration
From
case Exchange
To
case exchange

Modified EKCalendarType.local
Declaration
From
case Local
To
case local

Modified EKCalendarType.subscription
Declaration
From
case Subscription
To
case subscription

Modified EKEntityMask [struct]
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

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

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

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

Modified EKEntityType.event
Declaration
From
case Event
To
case event

Modified EKEntityType.reminder
Declaration
From
case Reminder
To
case reminder

Modified EKError.Code [enum]
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
    }

Modified EKError.Code.alarmGreaterThanRecurrence
Declaration
From
case AlarmGreaterThanRecurrence
To
case alarmGreaterThanRecurrence

Modified EKError.Code.alarmProximityNotSupported
Declaration
From
case AlarmProximityNotSupported
To
case alarmProximityNotSupported

Modified EKError.Code.calendarDoesNotAllowEvents
Declaration
From
case CalendarDoesNotAllowEvents
To
case calendarDoesNotAllowEvents

Modified EKError.Code.calendarDoesNotAllowReminders
Declaration
From
case CalendarDoesNotAllowReminders
To
case calendarDoesNotAllowReminders

Modified EKError.Code.calendarHasNoSource
Declaration
From
case CalendarHasNoSource
To
case calendarHasNoSource

Modified EKError.Code.calendarIsImmutable
Declaration
From
case CalendarIsImmutable
To
case calendarIsImmutable

Modified EKError.Code.calendarReadOnly
Declaration
From
case CalendarReadOnly
To
case calendarReadOnly

Modified EKError.Code.calendarSourceCannotBeModified
Declaration
From
case CalendarSourceCannotBeModified
To
case calendarSourceCannotBeModified

Modified EKError.Code.datesInverted
DeclarationIntroduction
From
case DatesInverted
iOS 9.0
To
case datesInverted
iOS 10.0

Modified EKError.Code.durationGreaterThanRecurrence
DeclarationIntroduction
From
case DurationGreaterThanRecurrence
iOS 9.0
To
case durationGreaterThanRecurrence
iOS 10.0

Modified EKError.Code.eventNotMutable
Declaration
From
case EventNotMutable
To
case eventNotMutable

Modified EKError.Code.eventStoreNotAuthorized
Declaration
From
case EventStoreNotAuthorized
To
case eventStoreNotAuthorized

Modified EKError.Code.internalFailure
Declaration
From
case InternalFailure
To
case internalFailure

Modified EKError.Code.invalidEntityType
Declaration
From
case InvalidEntityType
To
case invalidEntityType

Modified EKError.Code.invalidSpan
DeclarationIntroduction
From
case InvalidSpan
iOS 9.0
To
case invalidSpan
iOS 10.0

Modified EKError.Code.invitesCannotBeMoved
Declaration
From
case InvitesCannotBeMoved
To
case invitesCannotBeMoved

Modified EKError.Code.last
Declaration
From
case Last
To
case last

Modified EKError.Code.noCalendar
Declaration
From
case NoCalendar
To
case noCalendar

Modified EKError.Code.noEndDate
Declaration
From
case NoEndDate
To
case noEndDate

Modified EKError.Code.noStartDate
Declaration
From
case NoStartDate
To
case noStartDate

Modified EKError.Code.objectBelongsToDifferentStore
Declaration
From
case ObjectBelongsToDifferentStore
To
case objectBelongsToDifferentStore

Modified EKError.Code.osNotSupported
Declaration
From
case OSNotSupported
To
case osNotSupported

Modified EKError.Code.priorityIsInvalid
Declaration
From
case PriorityIsInvalid
To
case priorityIsInvalid

Modified EKError.Code.procedureAlarmsNotMutable
Declaration
From
case ProcedureAlarmsNotMutable
To
case procedureAlarmsNotMutable

Modified EKError.Code.recurringReminderRequiresDueDate
DeclarationIntroduction
From
case RecurringReminderRequiresDueDate
iOS 9.0
To
case recurringReminderRequiresDueDate
iOS 10.0

Modified EKError.Code.reminderLocationsNotSupported
DeclarationIntroduction
From
case ReminderLocationsNotSupported
iOS 9.0
To
case reminderLocationsNotSupported
iOS 10.0

Modified EKError.Code.sourceDoesNotAllowCalendarAddDelete
Declaration
From
case SourceDoesNotAllowCalendarAddDelete
To
case sourceDoesNotAllowCalendarAddDelete

Modified EKError.Code.sourceDoesNotAllowEvents
Declaration
From
case SourceDoesNotAllowEvents
To
case sourceDoesNotAllowEvents

Modified EKError.Code.sourceDoesNotAllowReminders
Declaration
From
case SourceDoesNotAllowReminders
To
case sourceDoesNotAllowReminders

Modified EKError.Code.startDateCollidesWithOtherOccurrence
Declaration
From
case StartDateCollidesWithOtherOccurrence
To
case startDateCollidesWithOtherOccurrence

Modified EKError.Code.startDateTooFarInFuture
Declaration
From
case StartDateTooFarInFuture
To
case startDateTooFarInFuture

Modified EKError.Code.structuredLocationsNotSupported
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 }
}

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

Modified EKEvent.endDate
Declaration
From
@NSCopying var endDate: NSDate
To
var endDate: Date

Modified EKEvent.isAllDay
Declaration
From
var allDay: Bool
To
var isAllDay: Bool

Modified EKEvent.occurrenceDate
Declaration
From
var occurrenceDate: NSDate { get }
To
var occurrenceDate: Date { get }

Modified EKEvent.startDate
Declaration
From
@NSCopying var startDate: NSDate
To
var startDate: Date

Modified EKEventAvailability [enum]
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
}

Modified EKEventAvailability.busy
Declaration
From
case Busy
To
case busy

Modified EKEventAvailability.free
Declaration
From
case Free
To
case free

Modified EKEventAvailability.notSupported
Declaration
From
case NotSupported
To
case notSupported

Modified EKEventAvailability.tentative
Declaration
From
case Tentative
To
case tentative

Modified EKEventAvailability.unavailable
Declaration
From
case Unavailable
To
case unavailable

Modified EKEventStatus [enum]
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
}

Modified EKEventStatus.canceled
Declaration
From
case Canceled
To
case canceled

Modified EKEventStatus.confirmed
Declaration
From
case Confirmed
To
case confirmed

Modified EKEventStatus.none
Declaration
From
case None
To
case none

Modified EKEventStatus.tentative
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

Modified EKEventStore.authorizationStatus(for: EKEntityType) -> EKAuthorizationStatus [class]
Declaration
From
class func authorizationStatusForEntityType(_ entityType: EKEntityType) -> EKAuthorizationStatus
To
class func authorizationStatus(for entityType: EKEntityType) -> EKAuthorizationStatus

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

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

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

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

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

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

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

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

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

Modified EKEventStore.predicateForCompletedReminders(withCompletionDateStarting: Date?, ending: Date?, calendars: [EKCalendar]?) -> NSPredicate
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

Modified EKEventStore.predicateForEvents(withStart: Date, end: Date, 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

Modified EKEventStore.predicateForIncompleteReminders(withDueDateStarting: Date?, ending: Date?, 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

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

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

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

Modified EKEventStore.remove(_: EKEvent, span: EKSpan, commit: Bool) 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

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

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

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

Modified EKEventStore.save(_: EKEvent, span: EKSpan, commit: Bool) 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

Modified EKEventStore.source(withIdentifier: String) -> EKSource
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

Modified EKObject.isNew
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?
}

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

Modified EKParticipant.isCurrentUser
Declaration
From
var currentUser: Bool { get }
To
var isCurrentUser: Bool { get }

Modified EKParticipant.url
Declaration
From
var URL: NSURL { get }
To
var url: URL { get }

Modified EKParticipantRole [enum]
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
}

Modified EKParticipantRole.chair
Declaration
From
case Chair
To
case chair

Modified EKParticipantRole.nonParticipant
Declaration
From
case NonParticipant
To
case nonParticipant

Modified EKParticipantRole.optional
Declaration
From
case Optional
To
case optional

Modified EKParticipantRole.required
Declaration
From
case Required
To
case required

Modified EKParticipantRole.unknown
Declaration
From
case Unknown
To
case unknown

Modified EKParticipantScheduleStatus [enum]
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
}

Modified EKParticipantScheduleStatus.cannotDeliver
Declaration
From
case CannotDeliver
To
case cannotDeliver

Modified EKParticipantScheduleStatus.delivered
Declaration
From
case Delivered
To
case delivered

Modified EKParticipantScheduleStatus.deliveryFailed
Declaration
From
case DeliveryFailed
To
case deliveryFailed

Modified EKParticipantScheduleStatus.none
Declaration
From
case None
To
case none

Modified EKParticipantScheduleStatus.noPrivileges
Declaration
From
case NoPrivileges
To
case noPrivileges

Modified EKParticipantScheduleStatus.pending
Declaration
From
case Pending
To
case pending

Modified EKParticipantScheduleStatus.recipientNotAllowed
Declaration
From
case RecipientNotAllowed
To
case recipientNotAllowed

Modified EKParticipantScheduleStatus.recipientNotRecognized
Declaration
From
case RecipientNotRecognized
To
case recipientNotRecognized

Modified EKParticipantScheduleStatus.sent
Declaration
From
case Sent
To
case sent

Modified EKParticipantStatus [enum]
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
}

Modified EKParticipantStatus.accepted
Declaration
From
case Accepted
To
case accepted

Modified EKParticipantStatus.completed
Declaration
From
case Completed
To
case completed

Modified EKParticipantStatus.declined
Declaration
From
case Declined
To
case declined

Modified EKParticipantStatus.delegated
Declaration
From
case Delegated
To
case delegated

Modified EKParticipantStatus.inProcess
Declaration
From
case InProcess
To
case inProcess

Modified EKParticipantStatus.pending
Declaration
From
case Pending
To
case pending

Modified EKParticipantStatus.tentative
Declaration
From
case Tentative
To
case tentative

Modified EKParticipantStatus.unknown
Declaration
From
case Unknown
To
case unknown

Modified EKParticipantType [enum]
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
}

Modified EKParticipantType.group
Declaration
From
case Group
To
case group

Modified EKParticipantType.person
Declaration
From
case Person
To
case person

Modified EKParticipantType.resource
Declaration
From
case Resource
To
case resource

Modified EKParticipantType.room
Declaration
From
case Room
To
case room

Modified EKParticipantType.unknown
Declaration
From
case Unknown
To
case unknown

Modified EKRecurrenceDayOfWeek
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

Modified EKRecurrenceEnd
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

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

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

Modified EKRecurrenceFrequency [enum]
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
}

Modified EKRecurrenceFrequency.daily
Declaration
From
case Daily
To
case daily

Modified EKRecurrenceFrequency.monthly
Declaration
From
case Monthly
To
case monthly

Modified EKRecurrenceFrequency.weekly
Declaration
From
case Weekly
To
case weekly

Modified EKRecurrenceFrequency.yearly
Declaration
From
case Yearly
To
case yearly

Modified EKRecurrenceRule
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 }
}

Modified EKRecurrenceRule.init(recurrenceWith: EKRecurrenceFrequency, interval: Int, daysOfTheWeek: [EKRecurrenceDayOfWeek]?, daysOfTheMonth: [NSNumber]?, monthsOfTheYear: [NSNumber]?, weeksOfTheYear: [NSNumber]?, daysOfTheYear: [NSNumber]?, setPositions: [NSNumber]?, end: EKRecurrenceEnd?)
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?)

Modified EKRecurrenceRule.init(recurrenceWith: EKRecurrenceFrequency, interval: Int, 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
}

Modified EKReminder.completionDate
Declaration
From
@NSCopying var completionDate: NSDate?
To
var completionDate: Date?

Modified EKReminder.dueDateComponents
Declaration
From
@NSCopying var dueDateComponents: NSDateComponents?
To
var dueDateComponents: DateComponents?

Modified EKReminder.isCompleted
Declaration
From
var completed: Bool
To
var isCompleted: Bool

Modified EKReminder.startDateComponents
Declaration
From
@NSCopying var startDateComponents: NSDateComponents?
To
var startDateComponents: DateComponents?

Modified EKReminderPriority [enum]
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
}

Modified EKReminderPriority.high
Declaration
From
case High
To
case high

Modified EKReminderPriority.low
Declaration
From
case Low
To
case low

Modified EKReminderPriority.medium
Declaration
From
case Medium
To
case medium

Modified EKReminderPriority.none
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>
}

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

Modified EKSourceType [enum]
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
}

Modified EKSourceType.birthdays
Declaration
From
case Birthdays
To
case birthdays

Modified EKSourceType.calDAV
Declaration
From
case CalDAV
To
case calDAV

Modified EKSourceType.exchange
Declaration
From
case Exchange
To
case exchange

Modified EKSourceType.local
Declaration
From
case Local
To
case local

Modified EKSourceType.mobileMe
Declaration
From
case MobileMe
To
case mobileMe

Modified EKSourceType.subscribed
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
}

Modified EKSpan.futureEvents
Declaration
From
case FutureEvents
To
case futureEvents

Modified EKSpan.thisEvent
Declaration
From
case ThisEvent
To
case thisEvent

Modified EKStructuredLocation
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
}

Modified EKWeekday [enum]
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 }
}

Modified EKWeekday.friday
Declaration
From
case Friday
To
case friday

Modified EKWeekday.monday
Declaration
From
case Monday
To
case monday

Modified EKWeekday.saturday
Declaration
From
case Saturday
To
case saturday

Modified EKWeekday.sunday
Declaration
From
case Sunday
To
case sunday

Modified EKWeekday.thursday
Declaration
From
case Thursday
To
case thursday

Modified EKWeekday.tuesday
Declaration
From
case Tuesday
To
case tuesday

Modified EKWeekday.wednesday
Declaration
From
case Wednesday
To
case wednesday

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

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

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