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
}

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

@NSCopying var absoluteDate: NSDate!

@NSCopying var absoluteDate: NSDate?

init!(absoluteDate date: NSDate!) -> EKAlarm

init(absoluteDate date: NSDate)

init!(relativeOffset offset: NSTimeInterval) -> EKAlarm

init(relativeOffset offset: NSTimeInterval)

@NSCopying var structuredLocation: EKStructuredLocation!

@NSCopying var structuredLocation: EKStructuredLocation?

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

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

var calendarIdentifier: String! { get }

var calendarIdentifier: String { get }

var CGColor: CGColor!

var CGColor: CGColor

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

init(forEntityType entityType: EKEntityType, eventStore eventStore: EKEventStore)

var source: EKSource!

var source: EKSource

var title: String!

var title: String

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

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

func addAlarm(_ alarm: EKAlarm!)

func addAlarm(_ alarm: EKAlarm)

func addRecurrenceRule(_ rule: EKRecurrenceRule!)

func addRecurrenceRule(_ rule: EKRecurrenceRule)

var alarms: [AnyObject]!

var alarms: [EKAlarm]?

var attendees: [AnyObject]! { get }

var attendees: [EKParticipant]? { get }

var calendar: EKCalendar!

var calendar: EKCalendar

var calendarItemExternalIdentifier: String! { get }

var calendarItemExternalIdentifier: String { get }

var calendarItemIdentifier: String! { get }

var calendarItemIdentifier: String { get }

var creationDate: NSDate! { get }

var creationDate: NSDate? { get }

var lastModifiedDate: NSDate! { get }

var lastModifiedDate: NSDate? { get }

var location: String!

var location: String?

var notes: String!

var notes: String?

var recurrenceRules: [AnyObject]!

var recurrenceRules: [EKRecurrenceRule]?

func removeAlarm(_ alarm: EKAlarm!)

func removeAlarm(_ alarm: EKAlarm)

func removeRecurrenceRule(_ rule: EKRecurrenceRule!)

func removeRecurrenceRule(_ rule: EKRecurrenceRule)

@NSCopying var timeZone: NSTimeZone!

@NSCopying var timeZone: NSTimeZone?

var title: String!

var title: String

@NSCopying var URL: NSURL!

@NSCopying var URL: NSURL?

struct EKErrorCode {
    init(_ value: UInt32)
    var value: UInt32
}

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

var EKErrorAlarmGreaterThanRecurrence: EKErrorCode { get }

case AlarmGreaterThanRecurrence

var EKErrorAlarmProximityNotSupported: EKErrorCode { get }

case AlarmProximityNotSupported

var EKErrorCalendarDoesNotAllowEvents: EKErrorCode { get }

case CalendarDoesNotAllowEvents

var EKErrorCalendarDoesNotAllowReminders: EKErrorCode { get }

case CalendarDoesNotAllowReminders

var EKErrorCalendarHasNoSource: EKErrorCode { get }

case CalendarHasNoSource

var EKErrorCalendarIsImmutable: EKErrorCode { get }

case CalendarIsImmutable

var EKErrorCalendarReadOnly: EKErrorCode { get }

case CalendarReadOnly

var EKErrorCalendarSourceCannotBeModified: EKErrorCode { get }

case CalendarSourceCannotBeModified

var EKErrorDatesInverted: EKErrorCode { get }

case DatesInverted

var EKErrorDurationGreaterThanRecurrence: EKErrorCode { get }

case DurationGreaterThanRecurrence

var EKErrorEventNotMutable: EKErrorCode { get }

case EventNotMutable

var EKErrorInternalFailure: EKErrorCode { get }

case InternalFailure

var EKErrorInvalidEntityType: EKErrorCode { get }

case InvalidEntityType

var EKErrorInvalidSpan: EKErrorCode { get }

case InvalidSpan

var EKErrorInvitesCannotBeMoved: EKErrorCode { get }

case InvitesCannotBeMoved

var EKErrorLast: EKErrorCode { get }

case Last

var EKErrorNoCalendar: EKErrorCode { get }

case NoCalendar

var EKErrorNoEndDate: EKErrorCode { get }

case NoEndDate

var EKErrorNoStartDate: EKErrorCode { get }

case NoStartDate

var EKErrorObjectBelongsToDifferentStore: EKErrorCode { get }

case ObjectBelongsToDifferentStore

var EKErrorPriorityIsInvalid: EKErrorCode { get }

case PriorityIsInvalid

var EKErrorRecurringReminderRequiresDueDate: EKErrorCode { get }

case RecurringReminderRequiresDueDate

var EKErrorReminderLocationsNotSupported: EKErrorCode { get }

case ReminderLocationsNotSupported

var EKErrorSourceDoesNotAllowCalendarAddDelete: EKErrorCode { get }

case SourceDoesNotAllowCalendarAddDelete

var EKErrorSourceDoesNotAllowReminders: EKErrorCode { get }

case SourceDoesNotAllowReminders

var EKErrorStartDateCollidesWithOtherOccurrence: EKErrorCode { get }

case StartDateCollidesWithOtherOccurrence

var EKErrorStartDateTooFarInFuture: EKErrorCode { get }

case StartDateTooFarInFuture

var EKErrorStructuredLocationsNotSupported: EKErrorCode { get }

case StructuredLocationsNotSupported

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

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

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

func compareStartDateWithEvent(_ other: EKEvent) -> NSComparisonResult

@NSCopying var endDate: NSDate!

@NSCopying var endDate: NSDate

var eventIdentifier: String! { get }

var eventIdentifier: String { get }

init!(eventStore eventStore: EKEventStore!) -> EKEvent

init(eventStore eventStore: EKEventStore)

var organizer: EKParticipant! { get }

var organizer: EKParticipant? { get }

@NSCopying var startDate: NSDate!

@NSCopying var startDate: NSDate

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

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

func calendarItemsWithExternalIdentifier(_ externalIdentifier: String!) -> [AnyObject]!

func calendarItemsWithExternalIdentifier(_ externalIdentifier: String) -> [EKCalendarItem]

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

func calendarItemWithIdentifier(_ identifier: String) -> EKCalendarItem

func calendarsForEntityType(_ entityType: EKEntityType) -> [AnyObject]!

func calendarsForEntityType(_ entityType: EKEntityType) -> [EKCalendar]

func calendarWithIdentifier(_ identifier: String!) -> EKCalendar!

func calendarWithIdentifier(_ identifier: String) -> EKCalendar?

func cancelFetchRequest(_ fetchIdentifier: AnyObject!)

func cancelFetchRequest(_ fetchIdentifier: AnyObject)

func commit(_ error: NSErrorPointer) -> Bool

func commit() throws

var defaultCalendarForNewEvents: EKCalendar! { get }

var defaultCalendarForNewEvents: EKCalendar { get }

func defaultCalendarForNewReminders() -> EKCalendar!

func defaultCalendarForNewReminders() -> EKCalendar

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

func enumerateEventsMatchingPredicate(_ predicate: NSPredicate, usingBlock block: EKEventSearchCallback)

func eventsMatchingPredicate(_ predicate: NSPredicate!) -> [AnyObject]!

func eventsMatchingPredicate(_ predicate: NSPredicate) -> [EKEvent]

var eventStoreIdentifier: String! { get }

var eventStoreIdentifier: String { get }

func eventWithIdentifier(_ identifier: String!) -> EKEvent!

func eventWithIdentifier(_ identifier: String) -> EKEvent?

func fetchRemindersMatchingPredicate(_ predicate: NSPredicate!, completion completion: (([AnyObject]!) -> Void)!) -> AnyObject!

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

func predicateForCompletedRemindersWithCompletionDateStarting(_ startDate: NSDate!, ending endDate: NSDate!, calendars calendars: [AnyObject]!) -> NSPredicate!

func predicateForCompletedRemindersWithCompletionDateStarting(_ startDate: NSDate?, ending endDate: NSDate?, calendars calendars: [EKCalendar]?) -> NSPredicate

func predicateForEventsWithStartDate(_ startDate: NSDate!, endDate endDate: NSDate!, calendars calendars: [AnyObject]!) -> NSPredicate!

func predicateForEventsWithStartDate(_ startDate: NSDate, endDate endDate: NSDate, calendars calendars: [EKCalendar]?) -> NSPredicate

func predicateForIncompleteRemindersWithDueDateStarting(_ startDate: NSDate!, ending endDate: NSDate!, calendars calendars: [AnyObject]!) -> NSPredicate!

func predicateForIncompleteRemindersWithDueDateStarting(_ startDate: NSDate?, ending endDate: NSDate?, calendars calendars: [EKCalendar]?) -> NSPredicate

func predicateForRemindersInCalendars(_ calendars: [AnyObject]!) -> NSPredicate!

func predicateForRemindersInCalendars(_ calendars: [EKCalendar]?) -> NSPredicate

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

func removeCalendar(_ calendar: EKCalendar, commit commit: Bool) throws

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

func removeEvent(_ event: EKEvent, span span: EKSpan) throws

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

func removeEvent(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws

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

func removeReminder(_ reminder: EKReminder, commit commit: Bool) throws

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

func requestAccessToEntityType(_ entityType: EKEntityType, completion completion: EKEventStoreRequestAccessCompletionHandler)

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

func saveCalendar(_ calendar: EKCalendar, commit commit: Bool) throws

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

func saveEvent(_ event: EKEvent, span span: EKSpan) throws

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

func saveEvent(_ event: EKEvent, span span: EKSpan, commit commit: Bool) throws

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

func saveReminder(_ reminder: EKReminder, commit commit: Bool) throws

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

func sourceWithIdentifier(_ identifier: String) -> EKSource

class EKObject : NSObject {
    func hasChanges() -> Bool
    func isNew() -> Bool
    func reset()
    func rollback()
    func refresh() -> Bool
}

class EKObject : NSObject {
    var hasChanges: Bool { get }
    var new: Bool { get }
    func reset()
    func rollback()
    func refresh() -> Bool
}

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

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

func ABRecordWithAddressBook(_ addressBook: ABAddressBook!) -> Unmanaged<ABRecord>!

func ABRecordWithAddressBook(_ addressBook: ABAddressBook) -> ABRecord?

var name: String! { get }

var name: String? { get }

var URL: NSURL! { get }

var URL: NSURL { get }

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

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

var dayOfTheWeek: Int { get }

var dayOfTheWeek: EKWeekday { get }

init!(_ dayOfTheWeek: Int) -> EKRecurrenceDayOfWeek

convenience init(_ dayOfTheWeek: EKWeekday)

init!(_ dayOfTheWeek: Int, weekNumber weekNumber: Int) -> EKRecurrenceDayOfWeek

convenience init(_ dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int)

init!(dayOfTheWeek dayOfTheWeek: Int, weekNumber weekNumber: Int)

init(dayOfTheWeek dayOfTheWeek: EKWeekday, weekNumber weekNumber: Int)

class EKRecurrenceEnd : NSObject, NSCopying {
    class func recurrenceEndWithEndDate(_ endDate: NSDate!) -> AnyObject!
    class func recurrenceEndWithOccurrenceCount(_ occurrenceCount: Int) -> AnyObject!
    var endDate: NSDate! { get }
    var occurrenceCount: Int { get }
}

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

var endDate: NSDate! { get }

var endDate: NSDate? { get }

class func recurrenceEndWithEndDate(_ endDate: NSDate!) -> AnyObject!

convenience init(endDate endDate: NSDate)

class func recurrenceEndWithOccurrenceCount(_ occurrenceCount: Int) -> AnyObject!

convenience init(occurrenceCount occurrenceCount: Int)

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

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

var calendarIdentifier: String! { get }

var calendarIdentifier: String { get }

var daysOfTheMonth: [AnyObject]! { get }

var daysOfTheMonth: [NSNumber]? { get }

var daysOfTheWeek: [AnyObject]! { get }

var daysOfTheWeek: [EKRecurrenceDayOfWeek]? { get }

var daysOfTheYear: [AnyObject]! { get }

var daysOfTheYear: [NSNumber]? { get }

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

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

init!(recurrenceWithFrequency type: EKRecurrenceFrequency, interval interval: Int, end end: EKRecurrenceEnd!)

init(recurrenceWithFrequency type: EKRecurrenceFrequency, interval interval: Int, end end: EKRecurrenceEnd?)

var monthsOfTheYear: [AnyObject]! { get }

var monthsOfTheYear: [NSNumber]? { get }

@NSCopying var recurrenceEnd: EKRecurrenceEnd!

@NSCopying var recurrenceEnd: EKRecurrenceEnd?

var setPositions: [AnyObject]! { get }

var setPositions: [NSNumber]? { get }

var weeksOfTheYear: [AnyObject]! { get }

var weeksOfTheYear: [NSNumber]? { get }

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
}

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
}

@NSCopying var completionDate: NSDate!

@NSCopying var completionDate: NSDate?

@NSCopying var dueDateComponents: NSDateComponents!

@NSCopying var dueDateComponents: NSDateComponents?

init!(eventStore eventStore: EKEventStore!) -> EKReminder

init(eventStore eventStore: EKEventStore)

@NSCopying var startDateComponents: NSDateComponents!

@NSCopying var startDateComponents: NSDateComponents?

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

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

func calendarsForEntityType(_ entityType: EKEntityType) -> Set<NSObject>!

func calendarsForEntityType(_ entityType: EKEntityType) -> Set<EKCalendar>

var sourceIdentifier: String! { get }

var sourceIdentifier: String { get }

var title: String! { get }

var title: String { get }

class EKStructuredLocation : EKObject, NSCopying {
    init!(title title: String!) -> EKStructuredLocation
    class func locationWithTitle(_ title: String!) -> EKStructuredLocation!
    var title: String!
    var geoLocation: CLLocation!
    var radius: Double
}

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
}

var geoLocation: CLLocation!

var geoLocation: CLLocation?

init!(title title: String!) -> EKStructuredLocation

convenience init(title title: String)

var title: String!

var title: String

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

typealias EKEventSearchCallback = (EKEvent, UnsafeMutablePointer<ObjCBool>) -> Void

typealias EKEventStoreRequestAccessCompletionHandler = (Bool, NSError!) -> Void

typealias EKEventStoreRequestAccessCompletionHandler = (Bool, NSError?) -> Void