amSymbol

import Foundation

class NSCalendar

@frozen struct String

A Unicode string value that is a collection of characters.

init?(calendarIdentifier ident: NSCalendar.Identifier)

required convenience init?(coder aDecoder: NSCoder)

init?(identifier calendarIdentifierConstant: NSCalendar.Identifier)

static var supportsSecureCoding: Bool { get }

class var autoupdatingCurrent: Calendar { get }

class var current: Calendar { get }

var calendarIdentifier: NSCalendar.Identifier { get }

override var description: String { get }

var eraSymbols: [String] { get }

var firstWeekday: Int { get set }

override var hash: Int { get }

var locale: Locale? { get set }

var longEraSymbols: [String] { get }

var minimumDaysInFirstWeek: Int { get set }

var monthSymbols: [String] { get }

var pmSymbol: String { get }

var quarterSymbols: [String] { get }

var shortMonthSymbols: [String] { get }

var shortQuarterSymbols: [String] { get }

var shortStandaloneMonthSymbols: [String] { get }

var shortStandaloneQuarterSymbols: [String] { get }

var shortStandaloneWeekdaySymbols: [String] { get }

var shortWeekdaySymbols: [String] { get }

var standaloneMonthSymbols: [String] { get }

var standaloneQuarterSymbols: [String] { get }

var standaloneWeekdaySymbols: [String] { get }

var timeZone: TimeZone { get set }

var veryShortMonthSymbols: [String] { get }

var veryShortStandaloneMonthSymbols: [String] { get }

var veryShortStandaloneWeekdaySymbols: [String] { get }

var veryShortWeekdaySymbols: [String] { get }

var weekdaySymbols: [String] { get }

func compare(_ date1: Date, to date2: Date, toUnitGranularity unit: NSCalendar.Unit) -> ComparisonResult

func component(_ unit: NSCalendar.Unit, from date: Date) -> Int

func components(_ unitFlags: NSCalendar.Unit, from date: Date) -> DateComponents

func components(_ unitFlags: NSCalendar.Unit, from startingDateComp: DateComponents, to resultDateComp: DateComponents, options: NSCalendar.Options = []) -> DateComponents

func components(_ unitFlags: NSCalendar.Unit, from startingDate: Date, to resultDate: Date, options opts: NSCalendar.Options = []) -> DateComponents

func components(in timezone: TimeZone, from date: Date) -> DateComponents

override func copy() -> Any

func copy(with zone: NSZone? = nil) -> Any

func date(_ date: Date, matchesComponents components: DateComponents) -> Bool

func date(byAdding comps: DateComponents, to date: Date, options opts: NSCalendar.Options = []) -> Date?

func date(byAdding unit: NSCalendar.Unit, value: Int, to date: Date, options: NSCalendar.Options = []) -> Date?

func date(bySettingHour h: Int, minute m: Int, second s: Int, of date: Date, options opts: NSCalendar.Options = []) -> Date?

func date(bySettingUnit unit: NSCalendar.Unit, value v: Int, of date: Date, options opts: NSCalendar.Options = []) -> Date?

func date(era eraValue: Int, year yearValue: Int, month monthValue: Int, day dayValue: Int, hour hourValue: Int, minute minuteValue: Int, second secondValue: Int, nanosecond nanosecondValue: Int) -> Date?

func date(era eraValue: Int, yearForWeekOfYear yearValue: Int, weekOfYear weekValue: Int, weekday weekdayValue: Int, hour hourValue: Int, minute minuteValue: Int, second secondValue: Int, nanosecond nanosecondValue: Int) -> Date?

func date(from comps: DateComponents) -> Date?

func encode(with aCoder: NSCoder)

func enumerateDates(startingAfter start: Date, matching comps: DateComponents, options opts: NSCalendar.Options = [], using block: (Date?, Bool, UnsafeMutablePointer<ObjCBool>) -> Void)

func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>?, year yearValuePointer: UnsafeMutablePointer<Int>?, month monthValuePointer: UnsafeMutablePointer<Int>?, day dayValuePointer: UnsafeMutablePointer<Int>?, from date: Date)

func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>?, yearForWeekOfYear yearValuePointer: UnsafeMutablePointer<Int>?, weekOfYear weekValuePointer: UnsafeMutablePointer<Int>?, weekday weekdayValuePointer: UnsafeMutablePointer<Int>?, from date: Date)

func getHour(_ hourValuePointer: UnsafeMutablePointer<Int>?, minute minuteValuePointer: UnsafeMutablePointer<Int>?, second secondValuePointer: UnsafeMutablePointer<Int>?, nanosecond nanosecondValuePointer: UnsafeMutablePointer<Int>?, from date: Date)

func isDate(_ date1: Date, equalTo date2: Date, toUnitGranularity unit: NSCalendar.Unit) -> Bool

func isDate(_ date1: Date, inSameDayAs date2: Date) -> Bool

func isDateInToday(_ date: Date) -> Bool

func isDateInTomorrow(_ date: Date) -> Bool

func isDateInWeekend(_ date: Date) -> Bool

func isDateInYesterday(_ date: Date) -> Bool

override func isEqual(_ value: Any?) -> Bool

func maximumRange(of unit: NSCalendar.Unit) -> NSRange

func minimumRange(of unit: NSCalendar.Unit) -> NSRange

func nextDate(after date: Date, matching comps: DateComponents, options: NSCalendar.Options = []) -> Date?

func nextDate(after date: Date, matching unit: NSCalendar.Unit, value: Int, options: NSCalendar.Options = []) -> Date?

func nextDate(after date: Date, matchingHour hourValue: Int, minute minuteValue: Int, second secondValue: Int, options: NSCalendar.Options = []) -> Date?

func nextWeekendAfter(_ date: Date, options: NSCalendar.Options) -> DateInterval?

Revised API for avoiding usage of AutoreleasingUnsafeMutablePointer. The current exposed API in Foundation on Darwin platforms is: open func nextWeekendStartDate(_ datep: AutoreleasingUnsafeMutablePointer<NSDate?>, interval tip: UnsafeMutablePointer, options: Options, afterDate date: NSDate) -> Bool Returns the range of the next weekend, via two by-reference parameters, which starts strictly after the given date. The .SearchBackwards option can be used to find the previous weekend range strictly before the date. Returns nil if there are no such things as weekend in the calendar and its locale.

func ordinality(of smaller: NSCalendar.Unit, in larger: NSCalendar.Unit, for date: Date) -> Int

func range(of unit: NSCalendar.Unit, for date: Date) -> DateInterval?

Revised API for avoiding usage of AutoreleasingUnsafeMutablePointer. The current exposed API in Foundation on Darwin platforms is: open func rangeOfUnit(_ unit: Unit, startDate datep: AutoreleasingUnsafeMutablePointer<NSDate?>, interval tip: UnsafeMutablePointer, forDate date: NSDate) -> Bool which is not implementable on Linux due to the lack of being able to properly implement AutoreleasingUnsafeMutablePointer.

func range(of smaller: NSCalendar.Unit, in larger: NSCalendar.Unit, for date: Date) -> NSRange

func range(ofWeekendContaining date: Date) -> DateInterval?

Revised API for avoiding usage of AutoreleasingUnsafeMutablePointer. The current exposed API in Foundation on Darwin platforms is: open func rangeOfWeekendStartDate(_ datep: AutoreleasingUnsafeMutablePointer<NSDate?>, interval tip: UnsafeMutablePointer, containingDate date: NSDate) -> Bool which is not implementable on Linux due to the lack of being able to properly implement AutoreleasingUnsafeMutablePointer. Find the range of the weekend around the given date, returned via two by-reference parameters. Returns nil if the given date is not in a weekend.

func startOfDay(for date: Date) -> Date

struct Identifier

struct Options

struct Unit