Documentation Archive Developer
Search

EventKit Changes for Swift

EventKit

Removed EKCalendarType [struct]
Removed EKCalendarType.init(_: UInt32)
Removed EKCalendarType.value
Removed EKErrorCode.init(_: UInt32)
Removed EKErrorCode.value
Removed EKEventAvailability [struct]
Removed EKEventAvailability.init(_: Int32)
Removed EKEventAvailability.value
Removed EKEventStatus [struct]
Removed EKEventStatus.init(_: UInt32)
Removed EKEventStatus.value
Removed EKEventStore.sources() -> [AnyObject]!
Removed EKObject.hasChanges() -> Bool
Removed EKParticipant.isCurrentUser
Removed EKParticipantRole [struct]
Removed EKParticipantRole.init(_: UInt32)
Removed EKParticipantRole.value
Removed EKParticipantStatus [struct]
Removed EKParticipantStatus.init(_: UInt32)
Removed EKParticipantStatus.value
Removed EKParticipantType [struct]
Removed EKParticipantType.init(_: UInt32)
Removed EKParticipantType.value
Removed EKRecurrenceFrequency [struct]
Removed EKRecurrenceFrequency.init(_: UInt32)
Removed EKRecurrenceFrequency.value
Removed EKSourceType [struct]
Removed EKSourceType.init(_: UInt32)
Removed EKSourceType.value
Removed EKSpan [struct]
Removed EKSpan.init(_: UInt32)
Removed EKSpan.value
Removed EKAlarmProximity
Removed EKAlarmProximityEnter
Removed EKAlarmProximityLeave
Removed EKAlarmProximityNone
Removed EKCalendarEventAvailabilityBusy
Removed EKCalendarEventAvailabilityFree
Removed EKCalendarEventAvailabilityMask
Removed EKCalendarEventAvailabilityNone
Removed EKCalendarEventAvailabilityTentative
Removed EKCalendarEventAvailabilityUnavailable
Removed EKCalendarTypeBirthday
Removed EKCalendarTypeCalDAV
Removed EKCalendarTypeExchange
Removed EKCalendarTypeLocal
Removed EKCalendarTypeSubscription
Removed EKEntityMask
Removed EKEntityMaskEvent
Removed EKEntityMaskReminder
Removed EKEntityType
Removed EKEntityTypeEvent
Removed EKEntityTypeReminder
Removed EKEventAvailabilityBusy
Removed EKEventAvailabilityFree
Removed EKEventAvailabilityNotSupported
Removed EKEventAvailabilityTentative
Removed EKEventAvailabilityUnavailable
Removed EKEventStatusCanceled
Removed EKEventStatusConfirmed
Removed EKEventStatusNone
Removed EKEventStatusTentative
Removed EKFriday
Removed EKMonday
Removed EKParticipantRoleChair
Removed EKParticipantRoleNonParticipant
Removed EKParticipantRoleOptional
Removed EKParticipantRoleRequired
Removed EKParticipantRoleUnknown
Removed EKParticipantStatusAccepted
Removed EKParticipantStatusCompleted
Removed EKParticipantStatusDeclined
Removed EKParticipantStatusDelegated
Removed EKParticipantStatusInProcess
Removed EKParticipantStatusPending
Removed EKParticipantStatusTentative
Removed EKParticipantStatusUnknown
Removed EKParticipantTypeGroup
Removed EKParticipantTypePerson
Removed EKParticipantTypeResource
Removed EKParticipantTypeRoom
Removed EKParticipantTypeUnknown
Removed EKRecurrenceFrequencyDaily
Removed EKRecurrenceFrequencyMonthly
Removed EKRecurrenceFrequencyWeekly
Removed EKRecurrenceFrequencyYearly
Removed EKSaturday
Removed EKSourceTypeBirthdays
Removed EKSourceTypeCalDAV
Removed EKSourceTypeExchange
Removed EKSourceTypeLocal
Removed EKSourceTypeMobileMe
Removed EKSourceTypeSubscribed
Removed EKSpanFutureEvents
Removed EKSpanThisEvent
Removed EKSunday
Removed EKThursday
Removed EKTuesday
Removed EKWednesday
Added EKCalendarEventAvailabilityMask.init(rawValue: UInt)
Added EKEntityMask.init(rawValue: UInt)
Modified EKAlarm
Declaration
From
class EKAlarm : EKObject, NSCopying {
    init!(absoluteDate date: NSDate!) -> EKAlarm
    class func alarmWithAbsoluteDate(_ date: NSDate!) -> EKAlarm!
    init!(relativeOffset offset: NSTimeInterval) -> EKAlarm
    class func alarmWithRelativeOffset(_ offset: NSTimeInterval) -> EKAlarm!
    var relativeOffset: NSTimeInterval
    @NSCopying var absoluteDate: NSDate!
    @NSCopying var structuredLocation: EKStructuredLocation!
    var proximity: EKAlarmProximity
}
To
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?
}

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

Declaration
From
init!(absoluteDate date: NSDate!) -> EKAlarm
To
init(absoluteDate date: NSDate)

Declaration
From
init!(relativeOffset offset: NSTimeInterval) -> EKAlarm
To
init(relativeOffset offset: NSTimeInterval)

Declaration
From
@NSCopying var structuredLocation: EKStructuredLocation!
To
@NSCopying var structuredLocation: EKStructuredLocation?

Raw Value Type
From--
ToInt

Modified EKCalendar
Declaration
From
class EKCalendar : EKObject {
    init!(eventStore eventStore: EKEventStore!) -> EKCalendar
    class func calendarWithEventStore(_ eventStore: EKEventStore!) -> EKCalendar!
    init!(forEntityType entityType: EKEntityType, eventStore eventStore: EKEventStore!) -> EKCalendar
    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 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 }
}

Declaration
From
var calendarIdentifier: String! { get }
To
var calendarIdentifier: String { get }

Declaration
From
var CGColor: CGColor!
To
var CGColor: CGColor

Declaration
From
init!(forEntityType entityType: EKEntityType, eventStore eventStore: EKEventStore!) -> EKCalendar
To
init(forEntityType entityType: EKEntityType, eventStore eventStore: EKEventStore)

Declaration
From
var source: EKSource!
To
var source: EKSource

Declaration
From
var title: String!
To
var title: String

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: [AnyObject]! { get }
    var alarms: [AnyObject]!
    func addAlarm(_ alarm: EKAlarm!)
    func removeAlarm(_ alarm: EKAlarm!)
    var recurrenceRules: [AnyObject]!
    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?
    @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)
}

Declaration
From
func addAlarm(_ alarm: EKAlarm!)
To
func addAlarm(_ alarm: EKAlarm)

Declaration
From
func addRecurrenceRule(_ rule: EKRecurrenceRule!)
To
func addRecurrenceRule(_ rule: EKRecurrenceRule)

Declaration
From
var alarms: [AnyObject]!
To
var alarms: [EKAlarm]?

Declaration
From
var attendees: [AnyObject]! { get }
To
var attendees: [EKParticipant]? { get }

Declaration
From
var calendar: EKCalendar!
To
var calendar: EKCalendar

Declaration
From
var calendarItemExternalIdentifier: String! { get }
To
var calendarItemExternalIdentifier: String { get }

Declaration
From
var calendarItemIdentifier: String! { get }
To
var calendarItemIdentifier: String { get }

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

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

Declaration
From
var location: String!
To
var location: String?

Declaration
From
var notes: String!
To
var notes: String?

Declaration
From
var recurrenceRules: [AnyObject]!
To
var recurrenceRules: [EKRecurrenceRule]?

Declaration
From
func removeAlarm(_ alarm: EKAlarm!)
To
func removeAlarm(_ alarm: EKAlarm)

Declaration
From
func removeRecurrenceRule(_ rule: EKRecurrenceRule!)
To
func removeRecurrenceRule(_ rule: EKRecurrenceRule)

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

Declaration
From
var title: String!
To
var title: String

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

DeclarationProtocolsIntroductionRaw Value Type
From
struct EKErrorCode {
    init(_ value: UInt32)
    var value: UInt32
}
--iOS 8.1--
To
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 : Hashable, Equatable, __BridgedNSError, ErrorType, RawRepresentable, _ObjectiveCBridgeableErrorType, _BridgedNSError {
}
extension EKErrorCode : Hashable, Equatable, __BridgedNSError, ErrorType, RawRepresentable, _ObjectiveCBridgeableErrorType, _BridgedNSError {
}
Equatable, ErrorType, Hashable, RawRepresentableiOS 9.0Int

NameDeclarationIntroduction
FromEKErrorAlarmGreaterThanRecurrence
var EKErrorAlarmGreaterThanRecurrence: EKErrorCode { get }
iOS 8.0
ToAlarmGreaterThanRecurrence
case AlarmGreaterThanRecurrence
iOS 9.0

NameDeclarationIntroduction
FromEKErrorAlarmProximityNotSupported
var EKErrorAlarmProximityNotSupported: EKErrorCode { get }
iOS 8.0
ToAlarmProximityNotSupported
case AlarmProximityNotSupported
iOS 9.0

NameDeclarationIntroduction
FromEKErrorCalendarDoesNotAllowEvents
var EKErrorCalendarDoesNotAllowEvents: EKErrorCode { get }
iOS 8.0
ToCalendarDoesNotAllowEvents
case CalendarDoesNotAllowEvents
iOS 9.0

NameDeclarationIntroduction
FromEKErrorCalendarDoesNotAllowReminders
var EKErrorCalendarDoesNotAllowReminders: EKErrorCode { get }
iOS 8.0
ToCalendarDoesNotAllowReminders
case CalendarDoesNotAllowReminders
iOS 9.0

NameDeclarationIntroduction
FromEKErrorCalendarHasNoSource
var EKErrorCalendarHasNoSource: EKErrorCode { get }
iOS 8.0
ToCalendarHasNoSource
case CalendarHasNoSource
iOS 9.0

NameDeclarationIntroduction
FromEKErrorCalendarIsImmutable
var EKErrorCalendarIsImmutable: EKErrorCode { get }
iOS 8.0
ToCalendarIsImmutable
case CalendarIsImmutable
iOS 9.0

NameDeclarationIntroduction
FromEKErrorCalendarReadOnly
var EKErrorCalendarReadOnly: EKErrorCode { get }
iOS 8.0
ToCalendarReadOnly
case CalendarReadOnly
iOS 9.0

NameDeclarationIntroduction
FromEKErrorCalendarSourceCannotBeModified
var EKErrorCalendarSourceCannotBeModified: EKErrorCode { get }
iOS 8.0
ToCalendarSourceCannotBeModified
case CalendarSourceCannotBeModified
iOS 9.0

NameDeclarationIntroduction
FromEKErrorDatesInverted
var EKErrorDatesInverted: EKErrorCode { get }
iOS 8.0
ToDatesInverted
case DatesInverted
iOS 9.0

NameDeclarationIntroduction
FromEKErrorDurationGreaterThanRecurrence
var EKErrorDurationGreaterThanRecurrence: EKErrorCode { get }
iOS 8.0
ToDurationGreaterThanRecurrence
case DurationGreaterThanRecurrence
iOS 9.0

NameDeclarationIntroduction
FromEKErrorEventNotMutable
var EKErrorEventNotMutable: EKErrorCode { get }
iOS 8.0
ToEventNotMutable
case EventNotMutable
iOS 9.0

NameDeclarationIntroduction
FromEKErrorInternalFailure
var EKErrorInternalFailure: EKErrorCode { get }
iOS 8.0
ToInternalFailure
case InternalFailure
iOS 9.0

NameDeclarationIntroduction
FromEKErrorInvalidEntityType
var EKErrorInvalidEntityType: EKErrorCode { get }
iOS 8.0
ToInvalidEntityType
case InvalidEntityType
iOS 9.0

NameDeclarationIntroduction
FromEKErrorInvalidSpan
var EKErrorInvalidSpan: EKErrorCode { get }
iOS 8.0
ToInvalidSpan
case InvalidSpan
iOS 9.0

NameDeclarationIntroduction
FromEKErrorInvitesCannotBeMoved
var EKErrorInvitesCannotBeMoved: EKErrorCode { get }
iOS 8.0
ToInvitesCannotBeMoved
case InvitesCannotBeMoved
iOS 9.0

NameDeclarationIntroduction
FromEKErrorLast
var EKErrorLast: EKErrorCode { get }
iOS 8.0
ToLast
case Last
iOS 9.0

NameDeclarationIntroduction
FromEKErrorNoCalendar
var EKErrorNoCalendar: EKErrorCode { get }
iOS 8.0
ToNoCalendar
case NoCalendar
iOS 9.0

NameDeclarationIntroduction
FromEKErrorNoEndDate
var EKErrorNoEndDate: EKErrorCode { get }
iOS 8.0
ToNoEndDate
case NoEndDate
iOS 9.0

NameDeclarationIntroduction
FromEKErrorNoStartDate
var EKErrorNoStartDate: EKErrorCode { get }
iOS 8.0
ToNoStartDate
case NoStartDate
iOS 9.0

NameDeclarationIntroduction
FromEKErrorObjectBelongsToDifferentStore
var EKErrorObjectBelongsToDifferentStore: EKErrorCode { get }
iOS 8.0
ToObjectBelongsToDifferentStore
case ObjectBelongsToDifferentStore
iOS 9.0

NameDeclarationIntroduction
FromEKErrorPriorityIsInvalid
var EKErrorPriorityIsInvalid: EKErrorCode { get }
iOS 8.0
ToPriorityIsInvalid
case PriorityIsInvalid
iOS 9.0

NameDeclarationIntroduction
FromEKErrorRecurringReminderRequiresDueDate
var EKErrorRecurringReminderRequiresDueDate: EKErrorCode { get }
iOS 8.0
ToRecurringReminderRequiresDueDate
case RecurringReminderRequiresDueDate
iOS 9.0

NameDeclarationIntroduction
FromEKErrorReminderLocationsNotSupported
var EKErrorReminderLocationsNotSupported: EKErrorCode { get }
iOS 8.0
ToReminderLocationsNotSupported
case ReminderLocationsNotSupported
iOS 9.0

NameDeclarationIntroduction
FromEKErrorSourceDoesNotAllowCalendarAddDelete
var EKErrorSourceDoesNotAllowCalendarAddDelete: EKErrorCode { get }
iOS 8.0
ToSourceDoesNotAllowCalendarAddDelete
case SourceDoesNotAllowCalendarAddDelete
iOS 9.0

NameDeclarationIntroduction
FromEKErrorSourceDoesNotAllowReminders
var EKErrorSourceDoesNotAllowReminders: EKErrorCode { get }
iOS 8.0
ToSourceDoesNotAllowReminders
case SourceDoesNotAllowReminders
iOS 9.0

NameDeclarationIntroduction
FromEKErrorStartDateCollidesWithOtherOccurrence
var EKErrorStartDateCollidesWithOtherOccurrence: EKErrorCode { get }
iOS 8.0
ToStartDateCollidesWithOtherOccurrence
case StartDateCollidesWithOtherOccurrence
iOS 9.0

NameDeclarationIntroduction
FromEKErrorStartDateTooFarInFuture
var EKErrorStartDateTooFarInFuture: EKErrorCode { get }
iOS 8.0
ToStartDateTooFarInFuture
case StartDateTooFarInFuture
iOS 9.0

NameDeclarationIntroduction
FromEKErrorStructuredLocationsNotSupported
var EKErrorStructuredLocationsNotSupported: EKErrorCode { get }
iOS 8.0
ToStructuredLocationsNotSupported
case StructuredLocationsNotSupported
iOS 9.0

Modified EKEvent
Declaration
From
class EKEvent : EKCalendarItem {
    init!(eventStore eventStore: EKEventStore!) -> EKEvent
    class func eventWithEventStore(_ eventStore: EKEventStore!) -> EKEvent!
    var eventIdentifier: String! { get }
    var allDay: Bool
    @NSCopying var startDate: NSDate!
    @NSCopying var endDate: NSDate!
    func compareStartDateWithEvent(_ other: EKEvent!) -> NSComparisonResult
    var organizer: EKParticipant! { get }
    var availability: EKEventAvailability
    var status: EKEventStatus { get }
    var isDetached: Bool { get }
    func refresh() -> Bool
    var birthdayPersonID: Int { get }
}
To
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 }
}

Deprecation
From--
ToiOS 9.0

Declaration
From
func compareStartDateWithEvent(_ other: EKEvent!) -> NSComparisonResult
To
func compareStartDateWithEvent(_ other: EKEvent) -> NSComparisonResult

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

Declaration
From
var eventIdentifier: String! { get }
To
var eventIdentifier: String { get }

Declaration
From
init!(eventStore eventStore: EKEventStore!) -> EKEvent
To
init(eventStore eventStore: EKEventStore)

Declaration
From
var organizer: EKParticipant! { get }
To
var organizer: EKParticipant? { get }

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

Modified EKEventStore
Declaration
From
class EKEventStore : NSObject {
    class func authorizationStatusForEntityType(_ entityType: EKEntityType) -> EKAuthorizationStatus
    func requestAccessToEntityType(_ entityType: EKEntityType, completion completion: EKEventStoreRequestAccessCompletionHandler!)
    var eventStoreIdentifier: String! { get }
    func sources() -> [AnyObject]!
    func sourceWithIdentifier(_ identifier: String!) -> EKSource!
    var calendars: [AnyObject]! { get }
    func calendarsForEntityType(_ entityType: EKEntityType) -> [AnyObject]!
    var defaultCalendarForNewEvents: EKCalendar! { get }
    func defaultCalendarForNewReminders() -> EKCalendar!
    func calendarWithIdentifier(_ identifier: String!) -> EKCalendar!
    func saveCalendar(_ calendar: EKCalendar!, commit commit: Bool, error error: NSErrorPointer) -> Bool
    func removeCalendar(_ calendar: EKCalendar!, commit commit: Bool, error error: NSErrorPointer) -> Bool
    func calendarItemWithIdentifier(_ identifier: String!) -> EKCalendarItem!
    func calendarItemsWithExternalIdentifier(_ externalIdentifier: String!) -> [AnyObject]!
    func saveEvent(_ event: EKEvent!, span span: EKSpan, error error: NSErrorPointer) -> Bool
    func removeEvent(_ event: EKEvent!, span span: EKSpan, error error: NSErrorPointer) -> Bool
    func saveEvent(_ event: EKEvent!, span span: EKSpan, commit commit: Bool, error error: NSErrorPointer) -> Bool
    func removeEvent(_ event: EKEvent!, span span: EKSpan, commit commit: Bool, error error: NSErrorPointer) -> Bool
    func eventWithIdentifier(_ identifier: String!) -> EKEvent!
    func eventsMatchingPredicate(_ predicate: NSPredicate!) -> [AnyObject]!
    func enumerateEventsMatchingPredicate(_ predicate: NSPredicate!, usingBlock block: EKEventSearchCallback!)
    func predicateForEventsWithStartDate(_ startDate: NSDate!, endDate endDate: NSDate!, calendars calendars: [AnyObject]!) -> NSPredicate!
    func saveReminder(_ reminder: EKReminder!, commit commit: Bool, error error: NSErrorPointer) -> Bool
    func removeReminder(_ reminder: EKReminder!, commit commit: Bool, error error: NSErrorPointer) -> Bool
    func fetchRemindersMatchingPredicate(_ predicate: NSPredicate!, completion completion: (([AnyObject]!) -> Void)!) -> AnyObject!
    func cancelFetchRequest(_ fetchIdentifier: AnyObject!)
    func predicateForRemindersInCalendars(_ calendars: [AnyObject]!) -> NSPredicate!
    func predicateForIncompleteRemindersWithDueDateStarting(_ startDate: NSDate!, ending endDate: NSDate!, calendars calendars: [AnyObject]!) -> NSPredicate!
    func predicateForCompletedRemindersWithCompletionDateStarting(_ startDate: NSDate!, ending endDate: NSDate!, calendars calendars: [AnyObject]!) -> NSPredicate!
    func commit(_ error: NSErrorPointer) -> Bool
    func reset()
    func refreshSourcesIfNecessary()
}
To
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()
}

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

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

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

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

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

Declaration
From
func commit(_ error: NSErrorPointer) -> Bool
To
func commit() throws

Declaration
From
var defaultCalendarForNewEvents: EKCalendar! { get }
To
var defaultCalendarForNewEvents: EKCalendar { get }

Declaration
From
func defaultCalendarForNewReminders() -> EKCalendar!
To
func defaultCalendarForNewReminders() -> EKCalendar

Declaration
From
func enumerateEventsMatchingPredicate(_ predicate: NSPredicate!, usingBlock block: EKEventSearchCallback!)
To
func enumerateEventsMatchingPredicate(_ predicate: NSPredicate, usingBlock block: EKEventSearchCallback)

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

Declaration
From
var eventStoreIdentifier: String! { get }
To
var eventStoreIdentifier: String { get }

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

Declaration
From
func fetchRemindersMatchingPredicate(_ predicate: NSPredicate!, completion completion: (([AnyObject]!) -> Void)!) -> AnyObject!
To
func fetchRemindersMatchingPredicate(_ predicate: NSPredicate, completion completion: ([EKReminder]?) -> Void) -> AnyObject

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

Declaration
From
func predicateForEventsWithStartDate(_ startDate: NSDate!, endDate endDate: NSDate!, calendars calendars: [AnyObject]!) -> NSPredicate!
To
func predicateForEventsWithStartDate(_ startDate: NSDate, endDate endDate: NSDate, calendars calendars: [EKCalendar]?) -> NSPredicate

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

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

Declaration
From
func removeCalendar(_ calendar: EKCalendar!, commit commit: Bool, error error: NSErrorPointer) -> Bool
To
func removeCalendar(_ calendar: EKCalendar, commit commit: Bool) throws

Declaration
From
func removeEvent(_ event: EKEvent!, span span: EKSpan, error error: NSErrorPointer) -> Bool
To
func removeEvent(_ event: EKEvent, span span: EKSpan) throws

Declaration
From
func removeEvent(_ event: EKEvent!, span span: EKSpan, commit commit: Bool, error error: NSErrorPointer) -> Bool
To
func removeEvent(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws

Declaration
From
func removeReminder(_ reminder: EKReminder!, commit commit: Bool, error error: NSErrorPointer) -> Bool
To
func removeReminder(_ reminder: EKReminder, commit commit: Bool) throws

Declaration
From
func requestAccessToEntityType(_ entityType: EKEntityType, completion completion: EKEventStoreRequestAccessCompletionHandler!)
To
func requestAccessToEntityType(_ entityType: EKEntityType, completion completion: EKEventStoreRequestAccessCompletionHandler)

Declaration
From
func saveCalendar(_ calendar: EKCalendar!, commit commit: Bool, error error: NSErrorPointer) -> Bool
To
func saveCalendar(_ calendar: EKCalendar, commit commit: Bool) throws

Declaration
From
func saveEvent(_ event: EKEvent!, span span: EKSpan, error error: NSErrorPointer) -> Bool
To
func saveEvent(_ event: EKEvent, span span: EKSpan) throws

Declaration
From
func saveEvent(_ event: EKEvent!, span span: EKSpan, commit commit: Bool, error error: NSErrorPointer) -> Bool
To
func saveEvent(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws

Declaration
From
func saveReminder(_ reminder: EKReminder!, commit commit: Bool, error error: NSErrorPointer) -> Bool
To
func saveReminder(_ reminder: EKReminder, commit commit: Bool) throws

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

Modified EKObject
Declaration
From
class EKObject : NSObject {
    func hasChanges() -> Bool
    func isNew() -> Bool
    func reset()
    func rollback()
    func refresh() -> Bool
}
To
class EKObject : NSObject {
    var hasChanges: Bool { get }
    var new: Bool { get }
    func reset()
    func rollback()
    func refresh() -> Bool
}

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 isCurrentUser: Bool { get }
    func ABRecordWithAddressBook(_ addressBook: ABAddressBook!) -> Unmanaged<ABRecord>!
}
To
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?
}

DeclarationDeprecation
From
func ABRecordWithAddressBook(_ addressBook: ABAddressBook!) -> Unmanaged<ABRecord>!
--
To
func ABRecordWithAddressBook(_ addressBook: ABAddressBook) -> ABRecord?
iOS 9.0

Declaration
From
var name: String! { get }
To
var name: String? { get }

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

Declaration
From
class EKRecurrenceDayOfWeek : NSObject, NSCopying {
    init!(_ dayOfTheWeek: Int) -> EKRecurrenceDayOfWeek
    class func dayOfWeek(_ dayOfTheWeek: Int) -> EKRecurrenceDayOfWeek!
    init!(_ dayOfTheWeek: Int, weekNumber weekNumber: Int) -> EKRecurrenceDayOfWeek
    class func dayOfWeek(_ dayOfTheWeek: Int, weekNumber weekNumber: Int) -> EKRecurrenceDayOfWeek!
    init!(dayOfTheWeek dayOfTheWeek: Int, weekNumber weekNumber: Int)
    var dayOfTheWeek: Int { get }
    var weekNumber: Int { get }
}
To
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 }
}

Declaration
From
var dayOfTheWeek: Int { get }
To
var dayOfTheWeek: EKWeekday { get }

Declaration
From
init!(_ dayOfTheWeek: Int) -> EKRecurrenceDayOfWeek
To
convenience init(_ dayOfTheWeek: EKWeekday)

Declaration
From
init!(_ dayOfTheWeek: Int, weekNumber weekNumber: Int) -> EKRecurrenceDayOfWeek
To
convenience init(_ dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int)

Declaration
From
init!(dayOfTheWeek dayOfTheWeek: Int, weekNumber weekNumber: Int)
To
init(dayOfTheWeek dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int)

Declaration
From
class EKRecurrenceEnd : NSObject, NSCopying {
    class func recurrenceEndWithEndDate(_ endDate: NSDate!) -> AnyObject!
    class func recurrenceEndWithOccurrenceCount(_ occurrenceCount: Int) -> AnyObject!
    var endDate: NSDate! { get }
    var occurrenceCount: Int { get }
}
To
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 }
}

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

NameDeclarationIntroduction
FromrecurrenceEndWithEndDate(_:)
class func recurrenceEndWithEndDate(_ endDate: NSDate!) -> AnyObject!
iOS 8.0
Toinit(endDate:)
convenience init(endDate endDate: NSDate)
iOS 9.0

NameDeclarationIntroduction
FromrecurrenceEndWithOccurrenceCount(_:)
class func recurrenceEndWithOccurrenceCount(_ occurrenceCount: Int) -> AnyObject!
iOS 8.0
Toinit(occurrenceCount:)
convenience init(occurrenceCount occurrenceCount: Int)
iOS 9.0

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: [AnyObject]!, daysOfTheMonth monthDays: [AnyObject]!, monthsOfTheYear months: [AnyObject]!, weeksOfTheYear weeksOfTheYear: [AnyObject]!, daysOfTheYear daysOfTheYear: [AnyObject]!, setPositions setPositions: [AnyObject]!, 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: [AnyObject]! { get }
    var daysOfTheMonth: [AnyObject]! { get }
    var daysOfTheYear: [AnyObject]! { get }
    var weeksOfTheYear: [AnyObject]! { get }
    var monthsOfTheYear: [AnyObject]! { get }
    var setPositions: [AnyObject]! { get }
}
To
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 }
}

Declaration
From
var calendarIdentifier: String! { get }
To
var calendarIdentifier: String { get }

Declaration
From
var daysOfTheMonth: [AnyObject]! { get }
To
var daysOfTheMonth: [NSNumber]? { get }

Declaration
From
var daysOfTheWeek: [AnyObject]! { get }
To
var daysOfTheWeek: [EKRecurrenceDayOfWeek]? { get }

Declaration
From
var daysOfTheYear: [AnyObject]! { get }
To
var daysOfTheYear: [NSNumber]? { get }

Declaration
From
init!(recurrenceWithFrequency type: EKRecurrenceFrequency, interval interval: Int, daysOfTheWeek days: [AnyObject]!, daysOfTheMonth monthDays: [AnyObject]!, monthsOfTheYear months: [AnyObject]!, weeksOfTheYear weeksOfTheYear: [AnyObject]!, daysOfTheYear daysOfTheYear: [AnyObject]!, setPositions setPositions: [AnyObject]!, end end: EKRecurrenceEnd!)
To
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?)

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

Declaration
From
var monthsOfTheYear: [AnyObject]! { get }
To
var monthsOfTheYear: [NSNumber]? { get }

Declaration
From
@NSCopying var recurrenceEnd: EKRecurrenceEnd!
To
@NSCopying var recurrenceEnd: EKRecurrenceEnd?

Declaration
From
var setPositions: [AnyObject]! { get }
To
var setPositions: [NSNumber]? { get }

Declaration
From
var weeksOfTheYear: [AnyObject]! { get }
To
var weeksOfTheYear: [NSNumber]? { get }

Modified EKReminder
Declaration
From
class EKReminder : EKCalendarItem {
    init!(eventStore eventStore: EKEventStore!) -> EKReminder
    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 reminderWithEventStore(_ eventStore: EKEventStore) -> EKReminder
    @NSCopying var startDateComponents: NSDateComponents?
    @NSCopying var dueDateComponents: NSDateComponents?
    var completed: Bool
    @NSCopying var completionDate: NSDate?
    var priority: Int
}

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

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

Declaration
From
init!(eventStore eventStore: EKEventStore!) -> EKReminder
To
init(eventStore eventStore: EKEventStore)

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

Modified EKSource
Declaration
From
class EKSource : EKObject {
    var sourceIdentifier: String! { get }
    var sourceType: EKSourceType { get }
    var title: String! { get }
    var calendars: Set<NSObject>! { get }
    func calendarsForEntityType(_ entityType: EKEntityType) -> Set<NSObject>!
}
To
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>
}

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

Declaration
From
var sourceIdentifier: String! { get }
To
var sourceIdentifier: String { get }

Declaration
From
var title: String! { get }
To
var title: String { get }

Declaration
From
class EKStructuredLocation : EKObject, NSCopying {
    init!(title title: String!) -> EKStructuredLocation
    class func locationWithTitle(_ title: String!) -> EKStructuredLocation!
    var title: String!
    var geoLocation: CLLocation!
    var radius: Double
}
To
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
}

Declaration
From
var geoLocation: CLLocation!
To
var geoLocation: CLLocation?

Declaration
From
init!(title title: String!) -> EKStructuredLocation
To
convenience init(title title: String)

Declaration
From
var title: String!
To
var title: String

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

Declaration
From
typealias EKEventStoreRequestAccessCompletionHandler = (Bool, NSError!) -> Void
To
typealias EKEventStoreRequestAccessCompletionHandler = (Bool, NSError?) -> Void