Options
All
  • Public
  • Public/Protected
  • All
Menu

A class which describes when an event occurs over what time and if it repeats.

Type parameters

  • M

    The type of metadata stored in the schedule.

Hierarchy

  • Schedule

Index

Constructors

constructor

  • Creates a schedule based on the given input.

    Parameters

    • Optional input: ScheduleInput<M>

      The input which describes the schedule of events.

    Returns Schedule

Properties

cancel

cancel: ScheduleModifier<boolean>

A set of identifiers which mark what days, times, weeks, months, etc that should have all event occurrences cancelled.

checks

checks: FrequencyCheck[]

The array of frequency functions which had valid frequencies.

see

FrequencyCheck.given

day

How frequent the event occurs based on Day.day.

dayOfMonth

dayOfMonth: FrequencyCheck

How frequent the event occurs based on Day.dayOfMonth.

dayOfWeek

dayOfWeek: FrequencyCheck

How frequent the event occurs based on Day.dayOfWeek.

dayOfYear

dayOfYear: FrequencyCheck

How frequent the event occurs based on Day.dayOfYear.

duration

duration: number

The length of events in this schedule.

durationInDays

durationInDays: number

The number of days an event in this schedule lasts PAST the starting day. If this is a full day event with a duration greater than zero this value will be greater than one. If this event occurs at a specific time with a given duration that is taken into account and if it passes over into the next day this value will be greater than one. This value is used to look back in time when trying to figure out what events start or overlap on a given day.

durationUnit

durationUnit: Unit

The unit which describes the duration of the event.

end

end: Day

The latest an event can occur in the schedule, or null if there are no restrictions when the latest event can occur. This day is inclusive.

exclude

exclude: ScheduleModifier<boolean>

A set of identifiers which mark what days or times are excluded on the schedule. This typically represents the set of event occurrences removed.

fullWeekOfMonth

fullWeekOfMonth: FrequencyCheck

How frequent the event occurs based on Day.fullWeekOfMonth.

fullWeekOfYear

fullWeekOfYear: FrequencyCheck

How frequent the event occurs based on Day.fullWeekOfYear.

include

include: ScheduleModifier<boolean>

A set of identifiers which mark what days or times are included outside the normal series of days on the schedule. This typically represents an event occurrence which is moved so its added to the exclude and include sets.

lastDayOfMonth

lastDayOfMonth: FrequencyCheck

How frequent the event occurs based on Day.lastDayOfMonth.

lastFullWeekOfMonth

lastFullWeekOfMonth: FrequencyCheck

How frequent the event occurs based on Day.lastFullWeekOfMonth.

lastFullWeekOfYear

lastFullWeekOfYear: FrequencyCheck

How frequent the event occurs based on Day.lastFullWeekOfYear.

lastWeekspanOfMonth

lastWeekspanOfMonth: FrequencyCheck

How frequent the event occurs based on Day.lastWeekspanOfMonth.

lastWeekspanOfYear

lastWeekspanOfYear: FrequencyCheck

How frequent the event occurs based on Day.lastWeekspanOfYear.

meta

A map of metadata keyed by an identifier. The metadata is placed in CalendarEvent.

month

How frequent the event occurs based on Day.month.

quarter

How frequent the event occurs based on Day.quarter.

start

start: Day

The earliest an event can occur in the schedule, or null if there are no restrictions when the earliest event can occur. This day is inclusive.

times

times: Time[]

The times at which the events occur on the days they should. If there are no times specified its assumed to be an all day event - potentially over multiple days or weeks based on Schedule.duration and Schedule.durationUnit.

week

How frequent the event occurs based on Day.week.

weekOfMonth

weekOfMonth: FrequencyCheck

How frequent the event occurs based on Day.weekOfMonth.

weekOfYear

weekOfYear: FrequencyCheck

How frequent the event occurs based on Day.weekOfYear.

weekspanOfMonth

weekspanOfMonth: FrequencyCheck

How frequent the event occurs based on Day.weekspanOfMonth.

weekspanOfYear

weekspanOfYear: FrequencyCheck

How frequent the event occurs based on Day.weekspanOfYear.

year

How frequent the event occurs based on Day.year.

Accessors

identifierType

identifierType:

The Identifier for this schedule. Either Identifier.Day or Identifier.Time.

lastTime

lastTime:

Returns the last event time specified or undefined if this schedule is for an all day event.

maxOccurrences

maxOccurrences:

The maximum number of occurrences allowed in the Schedule. Schedule.start is required and Schedule.end is ignored and overwritten. This is an expensive check and should be avoided if possible. If this value is less than 1 it is ignored.

Methods

adjustDefinedSpan

  • adjustDefinedSpan(addSpan?: boolean): this
  • Adjusts the Schedule.start and Schedule.end dates specified on this schedule if this schedule represents a single event and the start and end are already set or addSpan is true.

    Parameters

    • Default value addSpan: boolean = false

      If true, the start and end dates will always be adjusted if this schedule is a single event.

    Returns this

clone

coversDay

  • coversDay(day: Day): boolean
  • Determines if the given day is covered by this schedule. A schedule can specify events that span multiple days - so even though the day does not match the starting day of a span - it can be a day that is within the schedule.

    Parameters

    • day: Day

      The day to test.

    Returns boolean

    true if the day is covered by an event on this schedule, otherwise false.

coversTime

  • coversTime(day: Day): boolean
  • Determines if the given timestamp lies in an event occurrence on this schedule.

    Parameters

    • day: Day

      The timestamp to test against the schedule.

    Returns boolean

    true if the timestamp lies in an event occurrent start and end timestamps, otherwise false.

describe

  • describe(thing?: string, includeRange?: boolean, includeTimes?: boolean, includeDuration?: boolean, includeExcludes?: boolean, includeIncludes?: boolean, includeCancels?: boolean): string
  • Describes the schedule in a human friendly string taking into account all possible values specified in this schedule.

    Parameters

    • Default value thing: string = "event"

      A brief description of the things (events) on the schedule.

    • Default value includeRange: boolean = true

      When true the Schedule.start and Schedule.end are possibly included in the description if they have values.

    • Default value includeTimes: boolean = true

      When true the Schedule.times are possibly included in the description.

    • Default value includeDuration: boolean = false

      When true the Schedule.duration and Schedule.durationUnit are added to the description if Schedule.duration is not equal to 1.

    • Default value includeExcludes: boolean = false

      When true the Schedule.exclude are added to the description if there are any.

    • Default value includeIncludes: boolean = false

      When true the Schedule.include are added to the description if there are any.

    • Default value includeCancels: boolean = false

      When true the Schedule.cancel are added to the description if there are any.

    Returns string

    The descroption of the schedule.

forecast

  • forecast(around: Day, covers?: boolean, daysAfter: number, daysBefore?: number, times?: boolean, lookAround?: number): Iter<M, ScheduleEventTuple>
  • Creates a forecast for this schedule which returns a number of event occurrences around a given day. A single item could be returned per day, or you could get an item for each timed event occurrence.

    Parameters

    • around: Day

      The day to find a forecast around.

    • Default value covers: boolean = true

      If true spans which span multiple days will be looked at to see if they intersect with the given day, otherwise false will only look at the given day for the start of events.

    • daysAfter: number

      The number of events to return after the given day.

    • Default value daysBefore: number = daysAfter

      The number of events to return before the given day.

    • Default value times: boolean = false

      If timed events should be returned, or only one for each day.

    • Default value lookAround: number = Constants.DAYS_IN_YEAR

      How many days to look before and after the given day for event occurrences.

    Returns Iter<M, ScheduleEventTuple>

    A new iterator which provides the event occurence span, the day it starts (or is covered if covers is true), and the identifier for the event.

getEnd

  • getEnd(): Day | null
  • Gets the end date of the schedule. Even if one is not specified, one can be calculated if this is a single event schedule.

    Returns Day | null

getFullSpan

  • Returns a span of time for a schedule with full day events starting on the start of the given day with the desired duration in days or weeks.

    Parameters

    • day: Day

      The day the span starts on.

    Returns DaySpan

    The span of time starting on the given day.

getMaximum

  • Estimates the maximum number of prop from the start date that events could be happening. If the start date is not specified -1 will be returned representing potentially infinite props. If specific props are specified the difference between the maximum prop and the start prop will be returned. After that if Schedule.maxOccurrences is not specified -1 will be returned unless the end date is specified. In that case the props between the start and end are returned. Otherwise if events occur every X props then that calculation is used taking into account Schedule.maxOccurrences. Finally no year rule is specified so worst case is assumed, Schedule.maxOccurrences.

    The returned value is always rounded up, so if the first and last occurrence happens the same prop 1 will be returned.

    Parameters

    Returns number

getMeta

  • getMeta(day: Day, otherwise?: M, lookAtTime?: boolean): M
  • Returns the metadata for the given day or null if there is none.

    Parameters

    • day: Day

      The day to return the metadata for.

    • Default value otherwise: M = null

      The data to return if none exists for the given day.

    • Default value lookAtTime: boolean = true

      lookAtTime If the specific time of the given day should be looked at.

    Returns M

    The metadata or null.

getMetas

  • getMetas(day: Day): M[]
  • Returns all metadata for the given day or an empty array if there is none.

    Parameters

    • day: Day

      The day to return the metadata for.

    Returns M[]

    The array of metadata ordered by priority or an empty array.

getOccurrences

  • Returns an iterator for all occurrences in this schedule. If a finite list of occurrences is not possible to generate, an empty iterator will be returned. A finite set of occurrences can be determine when a start and end date are specified.

    Returns Iterate<DaySpan, IdentifierInput, Schedule<M> | ScheduleModifier<M>>

getRange

  • getRange(useInclude?: boolean): Partial<DaySpan>
  • Attempts to calculate the entire range of the schedule taking into account any start date, end date, the included and excluded dates, and also even if the start and end date aren't specified, it checks to see if this is a single event schedule. If the start of the result is not defined, that means this schedule has occurred since the beginning of time. If the end of the result is not defined, that means the schedule will occurr until the end of time.

    Parameters

    • Default value useInclude: boolean = true

    Returns Partial<DaySpan>

getSingleEventSpan

  • Returns the span of the single event in this schedule if it's that type of schedule, otherwise null is returned.

    see

    Schedule.isSingleEvent

    Returns DaySpan

    A span of the single event, otherwise null.

getStart

  • getStart(): Day | null
  • Gets the start date of the schedule. Even if one is not specified, one can be calculated if this is a single event schedule.

    Returns Day | null

getTimeSpan

  • Returns a span of time starting on the given day at the given day with the duration specified on this schedule.

    Parameters

    • day: Day

      The day the span starts on.

    • time: Time

      The time of day the span starts.

    Returns DaySpan

    The span of time calculated.

hasIncludedTime

  • hasIncludedTime(day: Day): boolean
  • Determines whether the given day has events added through Schedule.include.

    Parameters

    • day: Day

      The day to look for included times on.

    Returns boolean

    true if there are included event instances on the given day, otherwise false.

isCancelled

  • isCancelled(day: Day, lookAtTime?: boolean): boolean
  • Determines whether the given day is cancelled in the schedule.

    Parameters

    • day: Day

      The day to test.

    • Default value lookAtTime: boolean = true

      lookAtTime If the specific time of the given day should be looked at.

    Returns boolean

    true if the day was cancelled, otherwise false.

isExcluded

  • isExcluded(day: Day, lookAtTime?: boolean): boolean
  • Determines whether the given day is explicitly excluded in the schedule.

    Parameters

    • day: Day

      The day to test.

    • Default value lookAtTime: boolean = true

      lookAtTime If the specific time of the given day should be looked at.

    Returns boolean

    true if the day was excluded, otherwise false.

isFullDay

  • isFullDay(): boolean
  • Returns whether the events in the schedule are all day long or start at specific times. Full day events start at the start of the day and end at the start of the next day (if the duration = 1 and durationUnit = 'days'). Full day events have no times specified and should have a durationUnit of either days or weeks.

    Returns boolean

isFullyExcluded

  • isFullyExcluded(day: Day): boolean
  • Determines whether the given day is fully excluded from the schedule. A fully excluded day is one that has a day-wide exclusion, or the schedule is not an all-day event and all times in the schedule are specifically excluded.

    Parameters

    • day: Day

      The day to test.*

    Returns boolean

    true if he day is fully excluded, otherwise false.

isIncluded

  • isIncluded(day: Day, lookAtTime?: boolean): boolean
  • Determines whether the given day is explicitly included in the schedule.

    Parameters

    • day: Day

      The day to test.

    • Default value lookAtTime: boolean = true

      lookAtTime If the specific time of the given day should be looked at.

    Returns boolean

    true if the day is NOT explicitly included, otherwise false.

isSingleDayOfMonth

  • isSingleDayOfMonth(): boolean

isSingleDayOfWeek

  • isSingleDayOfWeek(): boolean

isSingleDayOfYear

  • isSingleDayOfYear(): boolean

isSingleEvent

  • isSingleEvent(): boolean
  • Determines whether this schedule produces a single event, and no more. If this schedule has any includes, it's assumed to be a multiple event schedule. A single event can be detected in the following scenarios where each frequency has a single occurrence (see Schedule.isSingleFrequency).

    • year, day of year
    • year, month, day of month
    • year, month, week of month, day of week
    • year, week of year, day of week

    Returns boolean

    true if this schedule produces a single event, otherwise false.

isSingleFrequency

isSingleMonth

  • isSingleMonth(): boolean

isSingleWeekOfMonth

  • isSingleWeekOfMonth(): boolean

isSingleWeekOfYear

  • isSingleWeekOfYear(): boolean

isSingleYear

  • isSingleYear(): boolean

iterateDaycast

  • iterateDaycast(day: Day, max: number, next: boolean, includeDay?: boolean, lookup?: number): Iter<M>
  • Iterates over days that events start in the schedule given a day to start, a maximum number of days to find, and a direction to look.

    see

    Schedule.iterateSpans

    Parameters

    • day: Day

      The day to start to search from.

    • max: number

      The maximum number of days to iterate.

    • next: boolean

      If true this searches forward, otherwise false is backwards.

    • Default value includeDay: boolean = false

      If the given day should be included in the search.

    • Default value lookup: number = Constants.DAYS_IN_YEAR

      The maximum number of days to look through from the given day for event occurrences.

    Returns Iter<M>

    A new Iterator for the days found in the cast.

iterateIncludeTimes

  • Iterates timed events that were explicitly specified on the given day. Those events could span multiple days so may be tested against another day.

    Parameters

    • day: Day

      The day to look for included timed events.

    • Default value matchAgainst: Day = day

      The day to test against the timed event.

    Returns Iterate<DaySpan, string, ScheduleModifier<boolean>>

    A new Iterator for all the included spans found.

iterateSpans

  • iterateSpans(day: Day, covers?: boolean): Iter<M, DaySpan>
  • Iterates through the spans (event instances) that start on or covers the given day.

    Parameters

    • day: Day

      The day to look for spans on.

    • Default value covers: boolean = false

      If true spans which span multiple days will be looked at to see if they intersect with the given day, otherwise false will only look at the given day for the start of events.

    Returns Iter<M, DaySpan>

    A new Iterator for all the spans found.

matchesDay

  • matchesDay(day: Day): boolean

matchesRange

  • matchesRange(start: Day, end: Day): boolean
  • Determines whether the given range overlaps with the earliest and latest valid days in this schedule (if any).

    see

    Schedule.start

    see

    Schedule.end

    Parameters

    • start: Day

      The first day in the range.

    • end: Day

      The last day in the range.

    Returns boolean

    true if the range intersects with the schedule, otherwise false.

matchesSpan

  • matchesSpan(day: Day): boolean
  • Determines whether the given day lies between the earliest and latest valid day in the schedule.

    see

    Schedule.start

    see

    Schedule.end

    Parameters

    • day: Day

      The day to test.

    Returns boolean

    true if the day lies in the schedule, otherwise false.

matchesTime

  • matchesTime(day: Day): boolean
  • Determines if the given day is on the schedule and the time specified on the day matches one of the times on the schedule.

    Parameters

    • day: Day

      The day to test.

    Returns boolean

    true if the day and time match the schedule, otherwise false.

move

  • move(toTime: Day, fromTime?: Day, meta?: M): boolean
  • Moves the event instance starting at fromTime to toTime optionally placing meta in the schedules metadata for the new time toTime. If this schedule has a single event (Schedule.isSingleEvent) then the only value needed is toTime and not fromTime.

    Parameters

    • toTime: Day

      The timestamp of the new event.

    • Optional fromTime: Day

      The timestamp of the event on the schedule to move if this schedule generates multiple events.

    • Optional meta: M

    Returns boolean

    true if the schedule had the event moved, otherwise false.

moveInstance

  • moveInstance(fromTime: Day, toTime: Day): boolean
  • Moves the event instance starting at fromTime to toTime optionally placing meta in the schedules metadata for the new time toTime. A move is accomplished by excluding the current event and adding an inclusion of the new day & time.

    see

    Schedule.move

    Parameters

    • fromTime: Day

      The timestamp of the event on the schedule to move.

    • toTime: Day

      The timestamp of the new event.

    Returns boolean

    true.

moveSingleEvent

  • moveSingleEvent(toTime: Day, takeTime?: boolean): boolean
  • Moves the single event in this schedule to the given day/time if applicable. If this schedule is not a single event schedule then false is returned. If this schedule is a timed event the time will take the time of the given toTime of takeTime is true.

    see

    Schedule.move

    Parameters

    • toTime: Day

      The time to move the single event to.

    • Default value takeTime: boolean = true

      If this schedule has a single timed event, should the time of the event be changed to the time of the given toTime?

    Returns boolean

    true if the schedule was adjusted, otherwise false.

moveTime

  • moveTime(fromTime: Time, toTime: Time): boolean
  • Moves a time specified in this schedule to the given time, adjusting any cancelled event instances, metadata, and any excluded and included event instances.

    Parameters

    • fromTime: Time

      The time to move.

    • toTime: Time

      The new time in the schedule.

    Returns boolean

    true if time was moved, otherwise false.

nextDay

  • nextDay(day: Day, includeDay?: boolean, lookAhead?: number): Day
  • Finds the next day an event occurs on the schedule given a day to start, optionally including it, and a maximum number of days to look ahead.

    Parameters

    • day: Day

      The day to start to search from.

    • Default value includeDay: boolean = false

      If the given day should be included in the search.

    • Default value lookAhead: number = Constants.DAYS_IN_YEAR

      The maximum number of days to look ahead from the given day for event occurrences.

    Returns Day

    The next day on the schedule or null if none exists.

nextDays

  • nextDays(day: Day, max: number, includeDay?: boolean, lookAhead?: number): Iter<M>
  • Finds the next specified number of days that events occur on the schedule given a day to start, optionally including it, and a maximum number of days to look ahead.

    Parameters

    • day: Day

      The day to start to search from.

    • max: number

      The maximum number of days to return in the result.

    • Default value includeDay: boolean = false

      If the given day should be included in the search.

    • Default value lookAhead: number = Constants.DAYS_IN_YEAR

      The maximum number of days to look ahead from the given day for event occurrences.

    Returns Iter<M>

    An array containing the next days on the schedule that events start or an empty array if there are none.

prevDay

  • prevDay(day: Day, includeDay?: boolean, lookBack?: number): Day
  • Finds the previous day an event occurs on the schedule given a day to start, optionally including it, and a maximum number of days to look behind.

    Parameters

    • day: Day

      The day to start to search from.

    • Default value includeDay: boolean = false

      If the given day should be included in the search.

    • Default value lookBack: number = Constants.DAYS_IN_YEAR

      The maximum number of days to look behind from the given day for event occurrences.

    Returns Day

    The previous day on the schedule or null if none exists.

prevDays

  • prevDays(day: Day, max: number, includeDay?: boolean, lookBack?: number): Iter<M>
  • Finds the previous specified number of days that events occur on the schedule given a day to start, optionally including it, and a maximum number of days to look behind.

    Parameters

    • day: Day

      The day to start to search from.

    • max: number

      The maximum number of days to return in the result.

    • Default value includeDay: boolean = false

      If the given day should be included in the search.

    • Default value lookBack: number = Constants.DAYS_IN_YEAR

    Returns Iter<M>

    An array containing the previous days on the schedule that events start or an empty array if there are none.

removeTime

  • removeTime(time: Time, removeInclude?: boolean): boolean
  • Removes the time from this schedule and all related included, excluded, cancelled instances as well as metadata.

    Parameters

    • time: Time

      The time to remove from the schedule.

    • Default value removeInclude: boolean = true

      If any included instances should be removed as well.

    Returns boolean

    true if the time was removed, otherwise false.

set

  • Sets the schedule with the given input.

    see

    Parse.schedule

    Parameters

    • input: ScheduleInput<M> | Schedule<M>

      The input or schedule which describes the schedule of events.

    • Default value parseMeta: function = (x => x)

      A function to use when parsing meta input into the desired type.

        • (input: any): M
        • Parameters

          • input: any

          Returns M

    Returns this

setCancelled

  • setCancelled(time: Day, cancelled?: boolean): this
  • Changes the cancellation status of the event at the given start time. By default this cancels the event occurrence - but false may be passed to undo a cancellation.

    Parameters

    • time: Day

      The start time of the event occurrence to cancel or uncancel.

    • Default value cancelled: boolean = true

      Whether the event should be cancelled.

    Returns this

setExcluded

  • setExcluded(time: Day, excluded?: boolean): this
  • Changes the exclusion status of the event at the given time. By default this excludes this event - but false may be passed to undo an exclusion.

    Parameters

    • time: Day

      The start time of the event occurrence to exclude or include.

    • Default value excluded: boolean = true

      Whether the event should be excluded.

    Returns this

setFrequency

setFullDay

  • setFullDay(fullDay?: boolean, defaultTime?: TimeInput): this
  • Sets whether this schedule is a full day event if it is not already. If this schedule is a full day event and false is passed to this function a single timed event will be added based on defaultTime. If this schedule has timed events and true is passed to make the schedule full day, the timed events are removed from this schedule. If the durationUnit is not the expected unit based on the new full day flag - the duration is reset to 1 and the duration unit is set to the expected unit.

    Parameters

    • Default value fullDay: boolean = true

      Whether this schedule should represent a full day event or timed events.

    • Default value defaultTime: TimeInput = "08:00"

      If fullDay is false and this schedule is currently a full day event - this time will be used as the time of the first event.

    Returns this

toInput

  • toInput(returnDays?: boolean, returnTimes?: boolean, timeFormat?: string, alwaysDuration?: boolean, alwaysReturnEnd?: boolean): ScheduleInput<M>
  • Converts the schedule instance back into input.

    see

    Time.format

    Parameters

    • Default value returnDays: boolean = false

      When true the start, end, and array of exclusions will have Day instances, otherwise the UTC timestamp and dayIdentifiers will be used when false.

    • Default value returnTimes: boolean = false

      When true the times returned in the input will be instances of Time otherwise the timeFormat is used to convert the times to strings.

    • Default value timeFormat: string = ""

      The time format to use when returning the times as strings.

    • Default value alwaysDuration: boolean = false

      If the duration values (duration and durationUnit) should always be returned in the input.

    • Default value alwaysReturnEnd: boolean = false

      If end should be in the input even if maxOccurrences is specified on the schedule.

    Returns ScheduleInput<M>

    The input that describes this schedule.

updateChecks

  • updateChecks(): this

updateDurationInDays

  • updateDurationInDays(): this

updateEnd

  • updateEnd(): this

Static forDay

  • Generates a schedule for an event which occurs once all day for a given day optionally spanning multiple days starting on the given day.

    Type parameters

    • M

    Parameters

    • input: DayInput

      The day the event starts.

    • Default value days: number = 1

      The number of days the event lasts.

    Returns Schedule<M>

    A new schedule that starts on the given day.

Static forSpan

  • Generates a schedule for an event which occurs once over a given span.

    Type parameters

    • M

    Parameters

    • span: DaySpan

      The span of the event.

    Returns Schedule<M>

    A new schedule that starts and ends at the given timestamps.

Static forTime

  • Generates a schedule for an event which occurs once at a given time on a given day optionally spanning any amount of time (default is 1 hour).

    Type parameters

    • M

    Parameters

    • input: DayInput

      The day the event starts.

    • time: TimeInput

      The time the event starts.

    • Default value duration: number = 1

      The duration of the event.

    • Default value durationUnit: Unit = "hour"

      The unit for the duration of the event.

    Returns Schedule<M>

    A new schedule that starts on the given day and time.

Legend

  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method

Generated using TypeDoc