angular-calendar

  • Version 0.28.28
  • Published
  • 2.62 MB
  • 6 dependencies
  • MIT license

Install

npm i angular-calendar
yarn add angular-calendar
pnpm add angular-calendar

Overview

A calendar component for angular 6.0+ that can display events on a month, week or day view

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable collapseAnimation

const collapseAnimation: any;

    variable MOMENT

    const MOMENT: any;

      Functions

      function getWeekViewPeriod

      getWeekViewPeriod: (
      dateAdapter: DateAdapter,
      viewDate: Date,
      weekStartsOn: number,
      excluded?: number[],
      daysInWeek?: number
      ) => { viewStart: Date; viewEnd: Date };

        Classes

        class CalendarA11y

        class CalendarA11y {}
        • This class is responsible for adding accessibility to the calendar. You may override any of its methods via angulars DI to suit your requirements. For example:

          import { A11yParams, CalendarA11y } from 'angular-calendar';
          import { formatDate, I18nPluralPipe } from '@angular/common';
          import { Injectable } from '@angular/core';
          // adding your own a11y params
          export interface CustomA11yParams extends A11yParams {
          isDrSuess?: boolean;
          }
          @Injectable()
          export class CustomCalendarA11y extends CalendarA11y {
          constructor(protected i18nPlural: I18nPluralPipe) {
          super(i18nPlural);
          }
          // overriding a function
          public openDayEventsLandmark({ date, locale, isDrSuess }: CustomA11yParams): string {
          if (isDrSuess) {
          return `
          ${formatDate(date, 'EEEE MMMM d', locale)}
          Today you are you! That is truer than true! There is no one alive
          who is you-er than you!
          `;
          }
          }
          }
          // in your component that uses the calendar
          providers: [{
          provide: CalendarA11y,
          useClass: CustomCalendarA11y
          }]

        constructor

        constructor(i18nPlural: any);

          property i18nPlural

          protected i18nPlural: any;

            method actionButtonLabel

            actionButtonLabel: ({ action }: A11yParams) => string;
            • Aria label for the calendar event actions icons

              Returns

              'Edit' for fa-pencil icons, and 'Delete' for fa-times icons

            method allDayEventDescription

            allDayEventDescription: ({ event, locale }: A11yParams) => string;
            • Descriptive aria label for an all day event @example: Scott's Party, event spans multiple days: start time October 19 5:00pm, no stop time

            method eventDescription

            eventDescription: ({ event, locale }: A11yParams) => string;
            • Descriptive aria label for an event @example: Saturday October 19th, Scott's Pizza Party, from 11:00am to 5:00pm

            method hideDayHourSegment

            hideDayHourSegment: () => boolean;
            • Returns

              true if hour segments in the day view should be aria-hidden

            method hideEventTitle

            hideEventTitle: () => boolean;
            • Returns

              true if event titles should be aria-hidden (global)

            method hideMonthCellEvents

            hideMonthCellEvents: () => boolean;
            • Returns

              true if the events inside the month cell should be aria-hidden

            method hideWeekHourSegment

            hideWeekHourSegment: () => boolean;
            • Returns

              true if hour segments in the week view should be aria-hidden

            method monthCell

            monthCell: ({ day, locale }: A11yParams) => string;
            • Aria label for the badges/date of a cell @example: Saturday October 19 1 event click to expand

            method monthCellTabIndex

            monthCellTabIndex: () => number;
            • Returns

              {number} Tab index to be given to month cells

            method openDayEventsAlert

            openDayEventsAlert: ({ date, locale }: A11yParams) => string;
            • Aria label for alert that a day in the month view was expanded @example: Saturday October 19 expanded

            method openDayEventsLandmark

            openDayEventsLandmark: ({ date, locale }: A11yParams) => string;
            • Aria label for the open day events start landmark @example: Saturday October 19 expanded view

            class CalendarAngularDateFormatter

            class CalendarAngularDateFormatter implements CalendarDateFormatterInterface {}
            • This will use the angular date pipe to do all date formatting. It is the default date formatter used by the calendar.

            constructor

            constructor(dateAdapter: DateAdapter);

              property dateAdapter

              protected dateAdapter: DateAdapter;

                method dayViewHour

                dayViewHour: ({ date, locale }: DateFormatterParams) => string;
                • The time formatting down the left hand side of the day view

                method dayViewTitle

                dayViewTitle: ({ date, locale }: DateFormatterParams) => string;
                • The day view title

                method monthViewColumnHeader

                monthViewColumnHeader: ({ date, locale }: DateFormatterParams) => string;
                • The month view header week day labels

                method monthViewDayNumber

                monthViewDayNumber: ({ date, locale }: DateFormatterParams) => string;
                • The month view cell day number

                method monthViewTitle

                monthViewTitle: ({ date, locale }: DateFormatterParams) => string;
                • The month view title

                method weekViewColumnHeader

                weekViewColumnHeader: ({ date, locale }: DateFormatterParams) => string;
                • The week view header week day labels

                method weekViewColumnSubHeader

                weekViewColumnSubHeader: ({ date, locale }: DateFormatterParams) => string;
                • The week view sub header day and month labels

                method weekViewHour

                weekViewHour: ({ date, locale }: DateFormatterParams) => string;
                • The time formatting down the left hand side of the week view

                method weekViewTitle

                weekViewTitle: ({
                date,
                locale,
                weekStartsOn,
                excludeDays,
                daysInWeek,
                }: DateFormatterParams) => string;
                • The week view title

                class CalendarCommonModule

                class CalendarCommonModule {}
                • Import this module to if you're just using a singular view and want to save on bundle size. Example usage:

                  import { CalendarCommonModule, CalendarMonthModule } from 'angular-calendar';
                  @NgModule({
                  imports: [
                  CalendarCommonModule.forRoot(),
                  CalendarMonthModule
                  ]
                  })
                  class MyModule {}

                method forRoot

                static forRoot: (dateAdapter: any, config?: CalendarModuleConfig) => any;

                  class CalendarDateFormatter

                  class CalendarDateFormatter extends CalendarAngularDateFormatter {}
                  • This class is responsible for all formatting of dates. There are 3 implementations available, the CalendarAngularDateFormatter (default) which uses the angular date pipe to format dates, the CalendarNativeDateFormatter which will use the Intl API to format dates, or there is the CalendarMomentDateFormatter which uses moment.

                    If you wish, you may override any of the defaults via angulars DI. For example:

                    import { CalendarDateFormatter, DateFormatterParams } from 'angular-calendar';
                    import { formatDate } from '@angular/common';
                    import { Injectable } from '@angular/core';
                    @Injectable()
                    class CustomDateFormatter extends CalendarDateFormatter {
                    public monthViewColumnHeader({date, locale}: DateFormatterParams): string {
                    return formatDate(date, 'EEE', locale); // use short week days
                    }
                    }
                    // in your component that uses the calendar
                    providers: [{
                    provide: CalendarDateFormatter,
                    useClass: CustomDateFormatter
                    }]

                  class CalendarDayModule

                  class CalendarDayModule {}

                    class CalendarDayViewComponent

                    class CalendarDayViewComponent {}
                    • Shows all events on a given day. Example usage:

                      <mwl-calendar-day-view
                      [viewDate]="viewDate"
                      [events]="events">
                      </mwl-calendar-day-view>

                    property allDayEventsLabelTemplate

                    allDayEventsLabelTemplate: any;
                    • A custom template to use for the all day events label text

                    property beforeViewRender

                    beforeViewRender: any;
                    • An output that will be called before the view is rendered for the current day. If you add the cssClass property to an hour grid segment it will add that class to the hour segment in the template

                    property currentTimeMarkerTemplate

                    currentTimeMarkerTemplate: any;
                    • A custom template to use for the current time marker

                    property dayEndHour

                    dayEndHour: number;
                    • The day end hours in 24 hour time. Must be 0-23

                    property dayEndMinute

                    dayEndMinute: number;
                    • The day end minutes. Must be 0-59

                    property dayStartHour

                    dayStartHour: number;
                    • The day start hours in 24 hour time. Must be 0-23

                    property dayStartMinute

                    dayStartMinute: number;
                    • The day start minutes. Must be 0-59

                    property eventActionsTemplate

                    eventActionsTemplate: any;
                    • A custom template to use for event actions

                    property eventClicked

                    eventClicked: any;
                    • Called when an event title is clicked

                    property events

                    events: any[];
                    • An array of events to display on view The schema is available here: https://github.com/mattlewis92/calendar-utils/blob/c51689985f59a271940e30bc4e2c4e1fee3fcb5c/src/calendarUtils.ts#L49-L63

                    property eventSnapSize

                    eventSnapSize: number;
                    • The grid size to snap resizing and dragging of events to

                    property eventTemplate

                    eventTemplate: any;
                    • A custom template to use for day view events

                    property eventTimesChanged

                    eventTimesChanged: any;
                    • Called when an event is resized or dragged and dropped

                    property eventTitleTemplate

                    eventTitleTemplate: any;
                    • A custom template to use for event titles

                    property hourSegmentClicked

                    hourSegmentClicked: any;
                    • Called when an hour segment is clicked

                    property hourSegmentHeight

                    hourSegmentHeight: number;
                    • The height in pixels of each hour segment

                    property hourSegments

                    hourSegments: number;
                    • The number of segments in an hour. Must divide equally into 60.

                    property hourSegmentTemplate

                    hourSegmentTemplate: any;
                    • A custom template to use to replace the hour segment

                    property locale

                    locale: string;
                    • The locale used to format dates

                    property refresh

                    refresh: any;
                    • An observable that when emitted on will re-render the current view

                    property snapDraggedEvents

                    snapDraggedEvents: boolean;
                    • Whether to snap events to a grid when dragging

                    property tooltipAppendToBody

                    tooltipAppendToBody: boolean;
                    • Whether to append tooltips to the body or next to the trigger element

                    property tooltipDelay

                    tooltipDelay: number;
                    • The delay in milliseconds before the tooltip should be displayed. If not provided the tooltip will be displayed immediately.

                    property tooltipPlacement

                    tooltipPlacement: any;
                    • The placement of the event tooltip

                    property tooltipTemplate

                    tooltipTemplate: any;
                    • A custom template to use for the event tooltips

                    property viewDate

                    viewDate: Date;
                    • The current view date

                    class CalendarEventTitleFormatter

                    class CalendarEventTitleFormatter {}
                    • This class is responsible for displaying all event titles within the calendar. You may override any of its methods via angulars DI to suit your requirements. For example:

                      import { Injectable } from '@angular/core';
                      import { CalendarEventTitleFormatter, CalendarEvent } from 'angular-calendar';
                      @Injectable()
                      class CustomEventTitleFormatter extends CalendarEventTitleFormatter {
                      month(event: CalendarEvent): string {
                      return `Custom prefix: ${event.title}`;
                      }
                      }
                      // in your component
                      providers: [{
                      provide: CalendarEventTitleFormatter,
                      useClass: CustomEventTitleFormatter
                      }]

                    method day

                    day: (event: any, title: string) => string;
                    • The day view event title.

                    method dayTooltip

                    dayTooltip: (event: any, title: string) => string;
                    • The day view event tooltip. Return a falsey value from this to disable the tooltip.

                    method month

                    month: (event: any, title: string) => string;
                    • The month view event title.

                    method monthTooltip

                    monthTooltip: (event: any, title: string) => string;
                    • The month view event tooltip. Return a falsey value from this to disable the tooltip.

                    method week

                    week: (event: any, title: string) => string;
                    • The week view event title.

                    method weekTooltip

                    weekTooltip: (event: any, title: string) => string;
                    • The week view event tooltip. Return a falsey value from this to disable the tooltip.

                    class CalendarModule

                    class CalendarModule {}
                    • The main module of this library. Example usage:

                      import { CalenderModule } from 'angular-calendar';
                      @NgModule({
                      imports: [
                      CalenderModule.forRoot()
                      ]
                      })
                      class MyModule {}

                    method forRoot

                    static forRoot: (dateAdapter: any, config?: CalendarModuleConfig) => any;

                      class CalendarMomentDateFormatter

                      class CalendarMomentDateFormatter implements CalendarDateFormatterInterface {}
                      • This will use moment to do all date formatting. To use this class:

                        import { CalendarDateFormatter, CalendarMomentDateFormatter, MOMENT } from 'angular-calendar';
                        import moment from 'moment';
                        // in your component
                        provide: [{
                        provide: MOMENT, useValue: moment
                        }, {
                        provide: CalendarDateFormatter, useClass: CalendarMomentDateFormatter
                        }]

                      constructor

                      constructor(moment: any, dateAdapter: DateAdapter);

                      property dateAdapter

                      protected dateAdapter: DateAdapter;

                        property moment

                        protected moment: any;

                          method dayViewHour

                          dayViewHour: ({ date, locale }: DateFormatterParams) => string;
                          • The time formatting down the left hand side of the day view

                          method dayViewTitle

                          dayViewTitle: ({ date, locale }: DateFormatterParams) => string;
                          • The day view title

                          method monthViewColumnHeader

                          monthViewColumnHeader: ({ date, locale }: DateFormatterParams) => string;
                          • The month view header week day labels

                          method monthViewDayNumber

                          monthViewDayNumber: ({ date, locale }: DateFormatterParams) => string;
                          • The month view cell day number

                          method monthViewTitle

                          monthViewTitle: ({ date, locale }: DateFormatterParams) => string;
                          • The month view title

                          method weekViewColumnHeader

                          weekViewColumnHeader: ({ date, locale }: DateFormatterParams) => string;
                          • The week view header week day labels

                          method weekViewColumnSubHeader

                          weekViewColumnSubHeader: ({ date, locale }: DateFormatterParams) => string;
                          • The week view sub header day and month labels

                          method weekViewHour

                          weekViewHour: ({ date, locale }: DateFormatterParams) => string;
                          • The time formatting down the left hand side of the week view

                          method weekViewTitle

                          weekViewTitle: ({
                          date,
                          locale,
                          weekStartsOn,
                          excludeDays,
                          daysInWeek,
                          }: DateFormatterParams) => string;
                          • The week view title

                          class CalendarMonthModule

                          class CalendarMonthModule {}

                            class CalendarMonthViewComponent

                            class CalendarMonthViewComponent implements OnChanges, OnInit, OnDestroy {}
                            • Shows all events on a given month. Example usage:

                              <mwl-calendar-month-view
                              [viewDate]="viewDate"
                              [events]="events">
                              </mwl-calendar-month-view>

                            constructor

                            constructor(
                            cdr: any,
                            utils: CalendarUtils,
                            locale: string,
                            dateAdapter: DateAdapter
                            );

                            property activeDay

                            activeDay: Date;
                            • If set will be used to determine the day that should be open. If not set, the viewDate is used

                            property activeDayIsOpen

                            activeDayIsOpen: boolean;
                            • Whether the events list for the day of the viewDate option is visible or not

                            property beforeViewRender

                            beforeViewRender: any;
                            • An output that will be called before the view is rendered for the current month. If you add the cssClass property to a day in the body it will add that class to the cell element in the template

                            property cdr

                            protected cdr: any;

                              property cellTemplate

                              cellTemplate: any;
                              • A custom template to use to replace the day cell

                              property columnHeaderClicked

                              columnHeaderClicked: any;
                              • Called when a header week day is clicked. Returns ISO day number.

                              property columnHeaders

                              columnHeaders: any[];

                              property dateAdapter

                              protected dateAdapter: DateAdapter;

                                property dayClicked

                                dayClicked: any;
                                • Called when the day cell is clicked

                                property eventActionsTemplate

                                eventActionsTemplate: any;
                                • A custom template to use for event actions

                                property eventClicked

                                eventClicked: any;
                                • Called when the event title is clicked

                                property events

                                events: any[];
                                • An array of events to display on view. The schema is available here: https://github.com/mattlewis92/calendar-utils/blob/c51689985f59a271940e30bc4e2c4e1fee3fcb5c/src/calendarUtils.ts#L49-L63

                                property eventTimesChanged

                                eventTimesChanged: any;
                                • Called when an event is dragged and dropped

                                property eventTitleTemplate

                                eventTitleTemplate: any;
                                • A custom template to use for event titles

                                property excludeDays

                                excludeDays: number[];
                                • An array of day indexes (0 = sunday, 1 = monday etc) that will be hidden on the view

                                property headerTemplate

                                headerTemplate: any;
                                • A custom template to use to replace the header

                                property locale

                                locale: string;
                                • The locale used to format dates

                                property openDay

                                openDay: any;

                                property openDayEventsTemplate

                                openDayEventsTemplate: any;
                                • A custom template to use for the slide down box of events for the active day

                                property openRowIndex

                                openRowIndex: number;

                                property refresh

                                refresh: any;
                                • An observable that when emitted on will re-render the current view

                                property refreshSubscription

                                refreshSubscription: any;

                                property tooltipAppendToBody

                                tooltipAppendToBody: boolean;
                                • Whether to append tooltips to the body or next to the trigger element

                                property tooltipDelay

                                tooltipDelay: number;
                                • The delay in milliseconds before the tooltip should be displayed. If not provided the tooltip will be displayed immediately.

                                property tooltipPlacement

                                tooltipPlacement: any;
                                • The placement of the event tooltip

                                property tooltipTemplate

                                tooltipTemplate: any;
                                • A custom template to use for the event tooltips

                                property trackByDate

                                trackByDate: (index: number, day: any) => string;

                                property trackByRowOffset

                                trackByRowOffset: (index: number, offset: number) => string;

                                property utils

                                protected utils: CalendarUtils;

                                  property view

                                  view: any;

                                  property viewDate

                                  viewDate: Date;
                                  • The current view date

                                  property weekendDays

                                  weekendDays: number[];
                                  • An array of day indexes (0 = sunday, 1 = monday etc) that indicate which days are weekends

                                  property weekStartsOn

                                  weekStartsOn: number;
                                  • The start number of the week. If using the moment date adapter this option won't do anything and you'll need to set it globally like so:

                                    moment.updateLocale('en', {
                                    week: {
                                    dow: 1, // set start of week to monday instead
                                    doy: 0,
                                    },
                                    });

                                  method checkActiveDayIsOpen

                                  protected checkActiveDayIsOpen: () => void;

                                    method emitBeforeViewRender

                                    protected emitBeforeViewRender: () => void;

                                      method eventDropped

                                      eventDropped: (droppedOn: any, event: any, draggedFrom?: any) => void;

                                      method ngOnChanges

                                      ngOnChanges: (changes: any) => void;

                                      method ngOnDestroy

                                      ngOnDestroy: () => void;

                                      method ngOnInit

                                      ngOnInit: () => void;

                                      method refreshAll

                                      protected refreshAll: () => void;

                                        method refreshBody

                                        protected refreshBody: () => void;

                                          method refreshHeader

                                          protected refreshHeader: () => void;

                                            method toggleDayHighlight

                                            toggleDayHighlight: (event: any, isHighlighted: boolean) => void;

                                            class CalendarNativeDateFormatter

                                            class CalendarNativeDateFormatter implements CalendarDateFormatterInterface {}
                                            • This will use Intl API to do all date formatting.

                                              You will need to include a polyfill for older browsers.

                                            constructor

                                            constructor(dateAdapter: DateAdapter);

                                              property dateAdapter

                                              protected dateAdapter: DateAdapter;

                                                method dayViewHour

                                                dayViewHour: ({ date, locale }: DateFormatterParams) => string;
                                                • The time formatting down the left hand side of the day view

                                                method dayViewTitle

                                                dayViewTitle: ({ date, locale }: DateFormatterParams) => string;
                                                • The day view title

                                                method monthViewColumnHeader

                                                monthViewColumnHeader: ({ date, locale }: DateFormatterParams) => string;
                                                • The month view header week day labels

                                                method monthViewDayNumber

                                                monthViewDayNumber: ({ date, locale }: DateFormatterParams) => string;
                                                • The month view cell day number

                                                method monthViewTitle

                                                monthViewTitle: ({ date, locale }: DateFormatterParams) => string;
                                                • The month view title

                                                method weekViewColumnHeader

                                                weekViewColumnHeader: ({ date, locale }: DateFormatterParams) => string;
                                                • The week view header week day labels

                                                method weekViewColumnSubHeader

                                                weekViewColumnSubHeader: ({ date, locale }: DateFormatterParams) => string;
                                                • The week view sub header day and month labels

                                                method weekViewHour

                                                weekViewHour: ({ date, locale }: DateFormatterParams) => string;
                                                • The time formatting down the left hand side of the week view

                                                method weekViewTitle

                                                weekViewTitle: ({
                                                date,
                                                locale,
                                                weekStartsOn,
                                                excludeDays,
                                                daysInWeek,
                                                }: DateFormatterParams) => string;
                                                • The week view title

                                                class CalendarUtils

                                                class CalendarUtils {}

                                                  constructor

                                                  constructor(dateAdapter: DateAdapter);

                                                    property dateAdapter

                                                    protected dateAdapter: DateAdapter;

                                                      method getMonthView

                                                      getMonthView: (args: any) => any;

                                                        method getWeekView

                                                        getWeekView: (args: any) => any;

                                                          method getWeekViewHeader

                                                          getWeekViewHeader: (args: any) => WeekDay[];

                                                            class CalendarWeekModule

                                                            class CalendarWeekModule {}

                                                              class CalendarWeekViewComponent

                                                              class CalendarWeekViewComponent implements OnChanges, OnInit, OnDestroy {}
                                                              • Shows all events on a given week. Example usage:

                                                                <mwl-calendar-week-view
                                                                [viewDate]="viewDate"
                                                                [events]="events">
                                                                </mwl-calendar-week-view>

                                                              constructor

                                                              constructor(
                                                              cdr: any,
                                                              utils: CalendarUtils,
                                                              locale: string,
                                                              dateAdapter: DateAdapter
                                                              );

                                                              property allDayEventResizes

                                                              allDayEventResizes: Map<any, WeekViewAllDayEventResize>;

                                                              property allDayEventsLabelTemplate

                                                              allDayEventsLabelTemplate: any;
                                                              • A custom template to use for the all day events label text

                                                              property beforeViewRender

                                                              beforeViewRender: any;
                                                              • An output that will be called before the view is rendered for the current week. If you add the cssClass property to a day in the header it will add that class to the cell element in the template

                                                              property calendarId

                                                              calendarId: Symbol;

                                                              property cdr

                                                              protected cdr: any;

                                                                property currentTimeMarkerTemplate

                                                                currentTimeMarkerTemplate: any;
                                                                • A custom template to use for the current time marker

                                                                property dateAdapter

                                                                protected dateAdapter: DateAdapter;

                                                                  property dayColumnWidth

                                                                  dayColumnWidth: number;

                                                                  property dayEndHour

                                                                  dayEndHour: number;
                                                                  • The day end hours in 24 hour time. Must be 0-23

                                                                  property dayEndMinute

                                                                  dayEndMinute: number;
                                                                  • The day end minutes. Must be 0-59

                                                                  property dayHeaderClicked

                                                                  dayHeaderClicked: any;
                                                                  • Called when a header week day is clicked. Adding a cssClass property on $event.day will add that class to the header element

                                                                  property days

                                                                  days: any[];

                                                                  property daysInWeek

                                                                  daysInWeek: number;
                                                                  • The number of days in a week. Can be used to create a shorter or longer week view. The first day of the week will always be the viewDate and weekStartsOn if set will be ignored

                                                                  property dayStartHour

                                                                  dayStartHour: number;
                                                                  • The day start hours in 24 hour time. Must be 0-23

                                                                  property dayStartMinute

                                                                  dayStartMinute: number;
                                                                  • The day start minutes. Must be 0-59

                                                                  property dragActive

                                                                  dragActive: boolean;

                                                                  property dragAlreadyMoved

                                                                  dragAlreadyMoved: boolean;

                                                                  property eventActionsTemplate

                                                                  eventActionsTemplate: any;
                                                                  • A custom template to use for event actions

                                                                  property eventClicked

                                                                  eventClicked: any;
                                                                  • Called when the event title is clicked

                                                                  property eventDragEnterByType

                                                                  eventDragEnterByType: { allDay: number; time: number };

                                                                  property events

                                                                  events: any[];
                                                                  • An array of events to display on view The schema is available here: https://github.com/mattlewis92/calendar-utils/blob/c51689985f59a271940e30bc4e2c4e1fee3fcb5c/src/calendarUtils.ts#L49-L63

                                                                  property eventSnapSize

                                                                  eventSnapSize: number;
                                                                  • The grid size to snap resizing and dragging of hourly events to

                                                                  property eventTemplate

                                                                  eventTemplate: any;
                                                                  • A custom template to use for week view events

                                                                  property eventTimesChanged

                                                                  eventTimesChanged: any;
                                                                  • Called when an event is resized or dragged and dropped

                                                                  property eventTitleTemplate

                                                                  eventTitleTemplate: any;
                                                                  • A custom template to use for event titles

                                                                  property excludeDays

                                                                  excludeDays: number[];
                                                                  • An array of day indexes (0 = sunday, 1 = monday etc) that will be hidden on the view

                                                                  property headerTemplate

                                                                  headerTemplate: any;
                                                                  • A custom template to use to replace the header

                                                                  property hourSegmentClicked

                                                                  hourSegmentClicked: any;
                                                                  • Called when an hour segment is clicked

                                                                  property hourSegmentHeight

                                                                  hourSegmentHeight: number;
                                                                  • The height in pixels of each hour segment

                                                                  property hourSegments

                                                                  hourSegments: number;
                                                                  • The number of segments in an hour. Must divide equally into 60.

                                                                  property hourSegmentTemplate

                                                                  hourSegmentTemplate: any;
                                                                  • A custom template to use to replace the hour segment

                                                                  property lastDraggedEvent

                                                                  lastDraggedEvent: any;

                                                                  property locale

                                                                  locale: string;
                                                                  • The locale used to format dates

                                                                  property precision

                                                                  precision: 'days' | 'minutes';
                                                                  • The precision to display events. days will round event start and end dates to the nearest day and minutes will not do this rounding

                                                                  property refresh

                                                                  refresh: any;
                                                                  • An observable that when emitted on will re-render the current view

                                                                  property refreshSubscription

                                                                  refreshSubscription: any;

                                                                  property snapDraggedEvents

                                                                  snapDraggedEvents: boolean;
                                                                  • Whether to snap events to a grid when dragging

                                                                  property timeEventResizes

                                                                  timeEventResizes: Map<any, any>;

                                                                  property tooltipAppendToBody

                                                                  tooltipAppendToBody: boolean;
                                                                  • Whether to append tooltips to the body or next to the trigger element

                                                                  property tooltipDelay

                                                                  tooltipDelay: number;
                                                                  • The delay in milliseconds before the tooltip should be displayed. If not provided the tooltip will be displayed immediately.

                                                                  property tooltipPlacement

                                                                  tooltipPlacement: any;
                                                                  • The placement of the event tooltip

                                                                  property tooltipTemplate

                                                                  tooltipTemplate: any;
                                                                  • A custom template to use for the event tooltips

                                                                  property trackByHour

                                                                  trackByHour: (index: number, hour: any) => string;

                                                                  property trackByHourColumn

                                                                  trackByHourColumn: (index: number, column: any) => string | WeekViewHourColumn;

                                                                  property trackByHourSegment

                                                                  trackByHourSegment: (index: number, segment: any) => string;

                                                                  property trackById

                                                                  trackById: (index: number, row: any) => string;

                                                                  property trackByWeekAllDayEvent

                                                                  trackByWeekAllDayEvent: (
                                                                  index: number,
                                                                  weekEvent: any
                                                                  ) => string | number | CalendarEvent<any>;

                                                                  property trackByWeekDayHeaderDate

                                                                  trackByWeekDayHeaderDate: (index: number, day: any) => string;

                                                                  property trackByWeekTimeEvent

                                                                  trackByWeekTimeEvent: (
                                                                  index: number,
                                                                  weekEvent: any
                                                                  ) => string | number | CalendarEvent<any>;

                                                                  property utils

                                                                  protected utils: CalendarUtils;

                                                                    property validateDrag

                                                                    validateDrag: any;

                                                                    property validateResize

                                                                    validateResize: (args: any) => boolean;

                                                                    property view

                                                                    view: any;

                                                                    property viewDate

                                                                    viewDate: Date;
                                                                    • The current view date

                                                                    property weekendDays

                                                                    weekendDays: number[];
                                                                    • An array of day indexes (0 = sunday, 1 = monday etc) that indicate which days are weekends

                                                                    property weekStartsOn

                                                                    weekStartsOn: number;
                                                                    • The start number of the week. This is ignored when the daysInWeek input is also set as the viewDate will be used as the start of the week instead. Note, you should also pass this to the calendar title pipe so it shows the same days: {{ viewDate | calendarDate:(view + 'ViewTitle'):locale:weekStartsOn }} If using the moment date adapter this option won't do anything and you'll need to set it globally like so:

                                                                      moment.updateLocale('en', {
                                                                      week: {
                                                                      dow: 1, // set start of week to monday instead
                                                                      doy: 0,
                                                                      },
                                                                      });

                                                                    method allDayEventDragMove

                                                                    allDayEventDragMove: () => void;

                                                                    method allDayEventResizeEnded

                                                                    allDayEventResizeEnded: (allDayEvent: any) => void;

                                                                    method allDayEventResizeStarted

                                                                    allDayEventResizeStarted: (
                                                                    allDayEventsContainer: HTMLElement,
                                                                    allDayEvent: any,
                                                                    resizeEvent: any
                                                                    ) => void;

                                                                    method allDayEventResizing

                                                                    allDayEventResizing: (
                                                                    allDayEvent: any,
                                                                    resizeEvent: any,
                                                                    dayWidth: number
                                                                    ) => void;

                                                                    method dateDragEnter

                                                                    dateDragEnter: (date: Date) => void;

                                                                    method dragEnded

                                                                    dragEnded: (
                                                                    weekEvent: WeekViewAllDayEvent | WeekViewTimeEvent,
                                                                    dragEndEvent: any,
                                                                    dayWidth: number,
                                                                    useY?: boolean
                                                                    ) => void;

                                                                    method dragEnter

                                                                    dragEnter: (type: 'allDay' | 'time') => void;

                                                                    method dragLeave

                                                                    dragLeave: (type: 'allDay' | 'time') => void;

                                                                    method dragMove

                                                                    dragMove: (dayEvent: any, dragEvent: any) => void;

                                                                    method dragStarted

                                                                    dragStarted: (
                                                                    eventsContainer: HTMLElement,
                                                                    event: HTMLElement,
                                                                    dayEvent?: any
                                                                    ) => void;

                                                                    method emitBeforeViewRender

                                                                    protected emitBeforeViewRender: () => void;

                                                                      method eventDropped

                                                                      eventDropped: (dropEvent: any, date: Date, allDay: boolean) => void;

                                                                      method getDayColumnWidth

                                                                      getDayColumnWidth: (eventRowContainer: HTMLElement) => number;

                                                                      method getDragMovedEventTimes

                                                                      protected getDragMovedEventTimes: (
                                                                      weekEvent: WeekViewAllDayEvent | WeekViewTimeEvent,
                                                                      dragEndEvent: DragEndEvent | DragMoveEvent,
                                                                      dayWidth: number,
                                                                      useY: boolean
                                                                      ) => { start: Date; end: Date };

                                                                        method getTimeEventResizedDates

                                                                        protected getTimeEventResizedDates: (
                                                                        calendarEvent: any,
                                                                        resizeEvent: any
                                                                        ) => { start: Date; end: Date };

                                                                          method getWeekView

                                                                          protected getWeekView: (events: CalendarEvent[]) => any;

                                                                            method ngOnChanges

                                                                            ngOnChanges: (changes: any) => void;

                                                                            method ngOnDestroy

                                                                            ngOnDestroy: () => void;

                                                                            method ngOnInit

                                                                            ngOnInit: () => void;

                                                                            method refreshAll

                                                                            protected refreshAll: () => void;

                                                                              method refreshBody

                                                                              protected refreshBody: () => void;

                                                                                method refreshHeader

                                                                                protected refreshHeader: () => void;

                                                                                  method resizeStarted

                                                                                  protected resizeStarted: (
                                                                                  eventsContainer: HTMLElement,
                                                                                  minWidth?: number
                                                                                  ) => void;

                                                                                    method restoreOriginalEvents

                                                                                    protected restoreOriginalEvents: (
                                                                                    tempEvents: CalendarEvent[],
                                                                                    adjustedEvents: Map<CalendarEvent, CalendarEvent>,
                                                                                    snapDraggedEvents?: boolean
                                                                                    ) => void;

                                                                                      method timeEventResizeEnded

                                                                                      timeEventResizeEnded: (timeEvent: any) => void;

                                                                                      method timeEventResizeStarted

                                                                                      timeEventResizeStarted: (
                                                                                      eventsContainer: HTMLElement,
                                                                                      timeEvent: any,
                                                                                      resizeEvent: any
                                                                                      ) => void;

                                                                                      method timeEventResizing

                                                                                      timeEventResizing: (timeEvent: any, resizeEvent: any) => void;

                                                                                      class DateAdapter

                                                                                      abstract class DateAdapter implements BaseDateAdapter {}

                                                                                        method addDays

                                                                                        abstract addDays: (date: Date | number, amount: number) => Date;

                                                                                          method addHours

                                                                                          abstract addHours: (date: Date | number, amount: number) => Date;

                                                                                            method addMinutes

                                                                                            abstract addMinutes: (date: Date | number, amount: number) => Date;

                                                                                              method addMonths

                                                                                              abstract addMonths: (date: Date | number, amount: number) => Date;

                                                                                                method addSeconds

                                                                                                abstract addSeconds: (date: Date | number, amount: number) => Date;

                                                                                                  method addWeeks

                                                                                                  abstract addWeeks: (date: Date | number, amount: number) => Date;

                                                                                                    method differenceInDays

                                                                                                    abstract differenceInDays: (
                                                                                                    dateLeft: Date | number,
                                                                                                    dateRight: Date | number
                                                                                                    ) => number;

                                                                                                      method differenceInMinutes

                                                                                                      abstract differenceInMinutes: (
                                                                                                      dateLeft: Date | number,
                                                                                                      dateRight: Date | number
                                                                                                      ) => number;

                                                                                                        method differenceInSeconds

                                                                                                        abstract differenceInSeconds: (
                                                                                                        dateLeft: Date | number,
                                                                                                        dateRight: Date | number
                                                                                                        ) => number;

                                                                                                          method endOfDay

                                                                                                          abstract endOfDay: (date: Date | number) => Date;

                                                                                                            method endOfMonth

                                                                                                            abstract endOfMonth: (date: Date | number) => Date;

                                                                                                              method endOfWeek

                                                                                                              abstract endOfWeek: (
                                                                                                              date: Date | number,
                                                                                                              options?: { weekStartsOn?: number }
                                                                                                              ) => Date;

                                                                                                                method getDate

                                                                                                                abstract getDate: (date: Date | number) => number;

                                                                                                                  method getDay

                                                                                                                  abstract getDay: (date: Date | number) => number;

                                                                                                                    method getHours

                                                                                                                    abstract getHours: (date: Date | number) => number;

                                                                                                                      method getISOWeek

                                                                                                                      abstract getISOWeek: (date: Date | number) => number;

                                                                                                                        method getMinutes

                                                                                                                        abstract getMinutes: (date: Date | number) => number;

                                                                                                                          method getMonth

                                                                                                                          abstract getMonth: (date: Date | number) => number;

                                                                                                                            method getYear

                                                                                                                            abstract getYear: (date: Date | number) => number;

                                                                                                                              method isSameDay

                                                                                                                              abstract isSameDay: (
                                                                                                                              dateLeft: Date | number,
                                                                                                                              dateRight: Date | number
                                                                                                                              ) => boolean;

                                                                                                                                method isSameMonth

                                                                                                                                abstract isSameMonth: (
                                                                                                                                dateLeft: Date | number,
                                                                                                                                dateRight: Date | number
                                                                                                                                ) => boolean;

                                                                                                                                  method isSameSecond

                                                                                                                                  abstract isSameSecond: (
                                                                                                                                  dateLeft: Date | number,
                                                                                                                                  dateRight: Date | number
                                                                                                                                  ) => boolean;

                                                                                                                                    method max

                                                                                                                                    abstract max: (dates: (Date | number)[]) => Date;

                                                                                                                                      method setDate

                                                                                                                                      abstract setDate: (date: Date | number, dayOfMonth: number) => Date;

                                                                                                                                        method setHours

                                                                                                                                        abstract setHours: (date: Date | number, hours: number) => Date;

                                                                                                                                          method setMinutes

                                                                                                                                          abstract setMinutes: (date: Date | number, minutes: number) => Date;

                                                                                                                                            method setMonth

                                                                                                                                            abstract setMonth: (date: Date | number, month: number) => Date;

                                                                                                                                              method setYear

                                                                                                                                              abstract setYear: (date: Date | number, year: number) => Date;

                                                                                                                                                method startOfDay

                                                                                                                                                abstract startOfDay: (date: Date | number) => Date;

                                                                                                                                                  method startOfMinute

                                                                                                                                                  abstract startOfMinute: (date: Date | number) => Date;

                                                                                                                                                    method startOfMonth

                                                                                                                                                    abstract startOfMonth: (date: Date | number) => Date;

                                                                                                                                                      method startOfWeek

                                                                                                                                                      abstract startOfWeek: (
                                                                                                                                                      date: Date | number,
                                                                                                                                                      options?: { weekStartsOn?: number }
                                                                                                                                                      ) => Date;

                                                                                                                                                        method subDays

                                                                                                                                                        abstract subDays: (date: Date | number, amount: number) => Date;

                                                                                                                                                          method subMonths

                                                                                                                                                          abstract subMonths: (date: Date | number, amount: number) => Date;

                                                                                                                                                            method subWeeks

                                                                                                                                                            abstract subWeeks: (date: Date | number, amount: number) => Date;

                                                                                                                                                              class ɵa

                                                                                                                                                              class CalendarOpenDayEventsComponent {}

                                                                                                                                                                property customTemplate

                                                                                                                                                                customTemplate: any;

                                                                                                                                                                  property date

                                                                                                                                                                  date: Date;

                                                                                                                                                                    property eventActionsTemplate

                                                                                                                                                                    eventActionsTemplate: any;

                                                                                                                                                                      property eventClicked

                                                                                                                                                                      eventClicked: any;

                                                                                                                                                                        property events

                                                                                                                                                                        events: any[];

                                                                                                                                                                          property eventTitleTemplate

                                                                                                                                                                          eventTitleTemplate: any;

                                                                                                                                                                            property isOpen

                                                                                                                                                                            isOpen: boolean;

                                                                                                                                                                              property locale

                                                                                                                                                                              locale: string;

                                                                                                                                                                                property trackByEventId

                                                                                                                                                                                trackByEventId: (
                                                                                                                                                                                index: number,
                                                                                                                                                                                event: any
                                                                                                                                                                                ) => string | number | CalendarEvent<any>;

                                                                                                                                                                                  property validateDrag

                                                                                                                                                                                  validateDrag: ({ x, y }: { x: number; y: number }) => boolean;

                                                                                                                                                                                    class ɵb

                                                                                                                                                                                    class CalendarEventActionsComponent {}

                                                                                                                                                                                      property customTemplate

                                                                                                                                                                                      customTemplate: any;

                                                                                                                                                                                        property event

                                                                                                                                                                                        event: any;

                                                                                                                                                                                          property trackByActionId

                                                                                                                                                                                          trackByActionId: (index: number, action: any) => string | number | EventAction;

                                                                                                                                                                                            class ɵc

                                                                                                                                                                                            class CalendarEventTitleComponent {}

                                                                                                                                                                                              property customTemplate

                                                                                                                                                                                              customTemplate: any;

                                                                                                                                                                                                property event

                                                                                                                                                                                                event: any;

                                                                                                                                                                                                  property view

                                                                                                                                                                                                  view: string;

                                                                                                                                                                                                    class ɵd

                                                                                                                                                                                                    class CalendarTooltipWindowComponent {}

                                                                                                                                                                                                      property contents

                                                                                                                                                                                                      contents: string;

                                                                                                                                                                                                        property customTemplate

                                                                                                                                                                                                        customTemplate: any;

                                                                                                                                                                                                          property event

                                                                                                                                                                                                          event: any;

                                                                                                                                                                                                            property placement

                                                                                                                                                                                                            placement: string;

                                                                                                                                                                                                              class ɵe

                                                                                                                                                                                                              class CalendarTooltipDirective implements OnDestroy, OnChanges {}

                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                elementRef: any,
                                                                                                                                                                                                                injector: any,
                                                                                                                                                                                                                renderer: any,
                                                                                                                                                                                                                componentFactoryResolver: any,
                                                                                                                                                                                                                viewContainerRef: any,
                                                                                                                                                                                                                document: any
                                                                                                                                                                                                                );

                                                                                                                                                                                                                  property appendToBody

                                                                                                                                                                                                                  appendToBody: boolean;

                                                                                                                                                                                                                    property contents

                                                                                                                                                                                                                    contents: string;

                                                                                                                                                                                                                      property customTemplate

                                                                                                                                                                                                                      customTemplate: any;

                                                                                                                                                                                                                        property delay

                                                                                                                                                                                                                        delay: number;

                                                                                                                                                                                                                          property event

                                                                                                                                                                                                                          event: any;

                                                                                                                                                                                                                            property placement

                                                                                                                                                                                                                            placement: any;

                                                                                                                                                                                                                              method ngOnChanges

                                                                                                                                                                                                                              ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                                method ngOnDestroy

                                                                                                                                                                                                                                ngOnDestroy: () => void;

                                                                                                                                                                                                                                  method onMouseOut

                                                                                                                                                                                                                                  onMouseOut: () => void;

                                                                                                                                                                                                                                    method onMouseOver

                                                                                                                                                                                                                                    onMouseOver: () => void;

                                                                                                                                                                                                                                      class ɵf

                                                                                                                                                                                                                                      class CalendarPreviousViewDirective {}
                                                                                                                                                                                                                                      • Change the view date to the previous view. For example:

                                                                                                                                                                                                                                        <button
                                                                                                                                                                                                                                        mwlCalendarPreviousView
                                                                                                                                                                                                                                        [(viewDate)]="viewDate"
                                                                                                                                                                                                                                        [view]="view">
                                                                                                                                                                                                                                        Previous
                                                                                                                                                                                                                                        </button>

                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                      constructor(dateAdapter: DateAdapter);

                                                                                                                                                                                                                                        property daysInWeek

                                                                                                                                                                                                                                        daysInWeek: number;
                                                                                                                                                                                                                                        • The number of days in a week. If set will subtract this amount of days instead of 1 week

                                                                                                                                                                                                                                        property excludeDays

                                                                                                                                                                                                                                        excludeDays: number[];
                                                                                                                                                                                                                                        • Days to skip when going back by 1 day

                                                                                                                                                                                                                                        property view

                                                                                                                                                                                                                                        view: CalendarView | 'month' | 'week' | 'day';
                                                                                                                                                                                                                                        • The current view

                                                                                                                                                                                                                                        property viewDate

                                                                                                                                                                                                                                        viewDate: Date;
                                                                                                                                                                                                                                        • The current view date

                                                                                                                                                                                                                                        property viewDateChange

                                                                                                                                                                                                                                        viewDateChange: any;
                                                                                                                                                                                                                                        • Called when the view date is changed

                                                                                                                                                                                                                                        method onClick

                                                                                                                                                                                                                                        onClick: () => void;

                                                                                                                                                                                                                                        class ɵg

                                                                                                                                                                                                                                        class CalendarNextViewDirective {}
                                                                                                                                                                                                                                        • Change the view date to the next view. For example:

                                                                                                                                                                                                                                          <button
                                                                                                                                                                                                                                          mwlCalendarNextView
                                                                                                                                                                                                                                          [(viewDate)]="viewDate"
                                                                                                                                                                                                                                          [view]="view">
                                                                                                                                                                                                                                          Next
                                                                                                                                                                                                                                          </button>

                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                        constructor(dateAdapter: DateAdapter);

                                                                                                                                                                                                                                          property daysInWeek

                                                                                                                                                                                                                                          daysInWeek: number;
                                                                                                                                                                                                                                          • The number of days in a week. If set will add this amount of days instead of 1 week

                                                                                                                                                                                                                                          property excludeDays

                                                                                                                                                                                                                                          excludeDays: number[];
                                                                                                                                                                                                                                          • Days to skip when going forward by 1 day

                                                                                                                                                                                                                                          property view

                                                                                                                                                                                                                                          view: CalendarView | 'month' | 'week' | 'day';
                                                                                                                                                                                                                                          • The current view

                                                                                                                                                                                                                                          property viewDate

                                                                                                                                                                                                                                          viewDate: Date;
                                                                                                                                                                                                                                          • The current view date

                                                                                                                                                                                                                                          property viewDateChange

                                                                                                                                                                                                                                          viewDateChange: any;
                                                                                                                                                                                                                                          • Called when the view date is changed

                                                                                                                                                                                                                                          method onClick

                                                                                                                                                                                                                                          onClick: () => void;

                                                                                                                                                                                                                                          class ɵh

                                                                                                                                                                                                                                          class CalendarTodayDirective {}
                                                                                                                                                                                                                                          • Change the view date to the current day. For example:

                                                                                                                                                                                                                                            <button
                                                                                                                                                                                                                                            mwlCalendarToday
                                                                                                                                                                                                                                            [(viewDate)]="viewDate">
                                                                                                                                                                                                                                            Today
                                                                                                                                                                                                                                            </button>

                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                          constructor(dateAdapter: DateAdapter);

                                                                                                                                                                                                                                            property viewDate

                                                                                                                                                                                                                                            viewDate: Date;
                                                                                                                                                                                                                                            • The current view date

                                                                                                                                                                                                                                            property viewDateChange

                                                                                                                                                                                                                                            viewDateChange: any;
                                                                                                                                                                                                                                            • Called when the view date is changed

                                                                                                                                                                                                                                            method onClick

                                                                                                                                                                                                                                            onClick: () => void;

                                                                                                                                                                                                                                            class ɵi

                                                                                                                                                                                                                                            class CalendarDatePipe implements PipeTransform {}
                                                                                                                                                                                                                                            • This pipe is primarily for rendering the current view title. Example usage:

                                                                                                                                                                                                                                              // where `viewDate` is a `Date` and view is `'month' | 'week' | 'day'`
                                                                                                                                                                                                                                              {{ viewDate | calendarDate:(view + 'ViewTitle'):'en' }}

                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                            constructor(dateFormatter: CalendarDateFormatter, locale: string);

                                                                                                                                                                                                                                              method transform

                                                                                                                                                                                                                                              transform: (
                                                                                                                                                                                                                                              date: Date,
                                                                                                                                                                                                                                              method: string,
                                                                                                                                                                                                                                              locale?: string,
                                                                                                                                                                                                                                              weekStartsOn?: number,
                                                                                                                                                                                                                                              excludeDays?: number[],
                                                                                                                                                                                                                                              daysInWeek?: number
                                                                                                                                                                                                                                              ) => string;

                                                                                                                                                                                                                                                class ɵj

                                                                                                                                                                                                                                                class CalendarEventTitlePipe implements PipeTransform {}

                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                  constructor(calendarEventTitle: CalendarEventTitleFormatter);

                                                                                                                                                                                                                                                    method transform

                                                                                                                                                                                                                                                    transform: (title: string, titleType: string, event: any) => string;

                                                                                                                                                                                                                                                      class ɵk

                                                                                                                                                                                                                                                      class CalendarA11yPipe implements PipeTransform {}
                                                                                                                                                                                                                                                      • This pipe is primarily for rendering aria labels. Example usage:

                                                                                                                                                                                                                                                        // where `myEvent` is a `CalendarEvent` and myLocale is a locale identifier
                                                                                                                                                                                                                                                        {{ { event: myEvent, locale: myLocale } | calendarA11y: 'eventDescription' }}

                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                      constructor(calendarA11y: CalendarA11y, locale: string);

                                                                                                                                                                                                                                                        method transform

                                                                                                                                                                                                                                                        transform: (a11yParams: A11yParams, method: string) => string;

                                                                                                                                                                                                                                                          class ɵl

                                                                                                                                                                                                                                                          class ClickDirective implements OnInit, OnDestroy {}

                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                            constructor(renderer: any, elm: any, document: any);

                                                                                                                                                                                                                                                              property click

                                                                                                                                                                                                                                                              click: any;

                                                                                                                                                                                                                                                                property clickListenerDisabled

                                                                                                                                                                                                                                                                clickListenerDisabled: boolean;

                                                                                                                                                                                                                                                                  method ngOnDestroy

                                                                                                                                                                                                                                                                  ngOnDestroy: () => void;

                                                                                                                                                                                                                                                                    method ngOnInit

                                                                                                                                                                                                                                                                    ngOnInit: () => void;

                                                                                                                                                                                                                                                                      class ɵm

                                                                                                                                                                                                                                                                      class KeydownEnterDirective implements OnInit, OnDestroy {}

                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                        constructor(host: any, ngZone: any, renderer: any);

                                                                                                                                                                                                                                                                          property keydown

                                                                                                                                                                                                                                                                          keydown: any;

                                                                                                                                                                                                                                                                            method ngOnDestroy

                                                                                                                                                                                                                                                                            ngOnDestroy: () => void;

                                                                                                                                                                                                                                                                              method ngOnInit

                                                                                                                                                                                                                                                                              ngOnInit: () => void;

                                                                                                                                                                                                                                                                                class ɵn

                                                                                                                                                                                                                                                                                class CalendarMonthCellComponent {}

                                                                                                                                                                                                                                                                                  property customTemplate

                                                                                                                                                                                                                                                                                  customTemplate: any;

                                                                                                                                                                                                                                                                                    property day

                                                                                                                                                                                                                                                                                    day: any;

                                                                                                                                                                                                                                                                                      property eventClicked

                                                                                                                                                                                                                                                                                      eventClicked: any;

                                                                                                                                                                                                                                                                                        property highlightDay

                                                                                                                                                                                                                                                                                        highlightDay: any;

                                                                                                                                                                                                                                                                                          property locale

                                                                                                                                                                                                                                                                                          locale: string;

                                                                                                                                                                                                                                                                                            property openDay

                                                                                                                                                                                                                                                                                            openDay: any;

                                                                                                                                                                                                                                                                                              property tooltipAppendToBody

                                                                                                                                                                                                                                                                                              tooltipAppendToBody: boolean;

                                                                                                                                                                                                                                                                                                property tooltipDelay

                                                                                                                                                                                                                                                                                                tooltipDelay: number;

                                                                                                                                                                                                                                                                                                  property tooltipPlacement

                                                                                                                                                                                                                                                                                                  tooltipPlacement: any;

                                                                                                                                                                                                                                                                                                    property tooltipTemplate

                                                                                                                                                                                                                                                                                                    tooltipTemplate: any;

                                                                                                                                                                                                                                                                                                      property trackByEventId

                                                                                                                                                                                                                                                                                                      trackByEventId: (
                                                                                                                                                                                                                                                                                                      index: number,
                                                                                                                                                                                                                                                                                                      event: any
                                                                                                                                                                                                                                                                                                      ) => string | number | CalendarEvent<any>;

                                                                                                                                                                                                                                                                                                        property unhighlightDay

                                                                                                                                                                                                                                                                                                        unhighlightDay: any;

                                                                                                                                                                                                                                                                                                          property validateDrag

                                                                                                                                                                                                                                                                                                          validateDrag: ({ x, y }: { x: number; y: number }) => boolean;

                                                                                                                                                                                                                                                                                                            class ɵo

                                                                                                                                                                                                                                                                                                            class CalendarMonthViewHeaderComponent {}

                                                                                                                                                                                                                                                                                                              property columnHeaderClicked

                                                                                                                                                                                                                                                                                                              columnHeaderClicked: any;

                                                                                                                                                                                                                                                                                                                property customTemplate

                                                                                                                                                                                                                                                                                                                customTemplate: any;

                                                                                                                                                                                                                                                                                                                  property days

                                                                                                                                                                                                                                                                                                                  days: any[];

                                                                                                                                                                                                                                                                                                                    property locale

                                                                                                                                                                                                                                                                                                                    locale: string;

                                                                                                                                                                                                                                                                                                                      property trackByWeekDayHeaderDate

                                                                                                                                                                                                                                                                                                                      trackByWeekDayHeaderDate: (index: number, day: any) => string;

                                                                                                                                                                                                                                                                                                                        class ɵp

                                                                                                                                                                                                                                                                                                                        class CalendarWeekViewHeaderComponent {}

                                                                                                                                                                                                                                                                                                                          property customTemplate

                                                                                                                                                                                                                                                                                                                          customTemplate: any;

                                                                                                                                                                                                                                                                                                                            property dayHeaderClicked

                                                                                                                                                                                                                                                                                                                            dayHeaderClicked: any;

                                                                                                                                                                                                                                                                                                                              property days

                                                                                                                                                                                                                                                                                                                              days: any[];

                                                                                                                                                                                                                                                                                                                                property dragEnter

                                                                                                                                                                                                                                                                                                                                dragEnter: any;

                                                                                                                                                                                                                                                                                                                                  property eventDropped

                                                                                                                                                                                                                                                                                                                                  eventDropped: any;

                                                                                                                                                                                                                                                                                                                                    property locale

                                                                                                                                                                                                                                                                                                                                    locale: string;

                                                                                                                                                                                                                                                                                                                                      property trackByWeekDayHeaderDate

                                                                                                                                                                                                                                                                                                                                      trackByWeekDayHeaderDate: (index: number, day: any) => string;

                                                                                                                                                                                                                                                                                                                                        class ɵq

                                                                                                                                                                                                                                                                                                                                        class CalendarWeekViewEventComponent {}

                                                                                                                                                                                                                                                                                                                                          property column

                                                                                                                                                                                                                                                                                                                                          column: any;

                                                                                                                                                                                                                                                                                                                                            property customTemplate

                                                                                                                                                                                                                                                                                                                                            customTemplate: any;

                                                                                                                                                                                                                                                                                                                                              property daysInWeek

                                                                                                                                                                                                                                                                                                                                              daysInWeek: number;

                                                                                                                                                                                                                                                                                                                                                property eventActionsTemplate

                                                                                                                                                                                                                                                                                                                                                eventActionsTemplate: any;

                                                                                                                                                                                                                                                                                                                                                  property eventClicked

                                                                                                                                                                                                                                                                                                                                                  eventClicked: any;

                                                                                                                                                                                                                                                                                                                                                    property eventTitleTemplate

                                                                                                                                                                                                                                                                                                                                                    eventTitleTemplate: any;

                                                                                                                                                                                                                                                                                                                                                      property locale

                                                                                                                                                                                                                                                                                                                                                      locale: string;

                                                                                                                                                                                                                                                                                                                                                        property tooltipAppendToBody

                                                                                                                                                                                                                                                                                                                                                        tooltipAppendToBody: boolean;

                                                                                                                                                                                                                                                                                                                                                          property tooltipDelay

                                                                                                                                                                                                                                                                                                                                                          tooltipDelay: number;

                                                                                                                                                                                                                                                                                                                                                            property tooltipDisabled

                                                                                                                                                                                                                                                                                                                                                            tooltipDisabled: boolean;

                                                                                                                                                                                                                                                                                                                                                              property tooltipPlacement

                                                                                                                                                                                                                                                                                                                                                              tooltipPlacement: any;

                                                                                                                                                                                                                                                                                                                                                                property tooltipTemplate

                                                                                                                                                                                                                                                                                                                                                                tooltipTemplate: any;

                                                                                                                                                                                                                                                                                                                                                                  property weekEvent

                                                                                                                                                                                                                                                                                                                                                                  weekEvent: any;

                                                                                                                                                                                                                                                                                                                                                                    class ɵr

                                                                                                                                                                                                                                                                                                                                                                    class CalendarWeekViewHourSegmentComponent {}

                                                                                                                                                                                                                                                                                                                                                                      property customTemplate

                                                                                                                                                                                                                                                                                                                                                                      customTemplate: any;

                                                                                                                                                                                                                                                                                                                                                                        property daysInWeek

                                                                                                                                                                                                                                                                                                                                                                        daysInWeek: number;

                                                                                                                                                                                                                                                                                                                                                                          property isTimeLabel

                                                                                                                                                                                                                                                                                                                                                                          isTimeLabel: boolean;

                                                                                                                                                                                                                                                                                                                                                                            property locale

                                                                                                                                                                                                                                                                                                                                                                            locale: string;

                                                                                                                                                                                                                                                                                                                                                                              property segment

                                                                                                                                                                                                                                                                                                                                                                              segment: any;

                                                                                                                                                                                                                                                                                                                                                                                property segmentHeight

                                                                                                                                                                                                                                                                                                                                                                                segmentHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                  class ɵs

                                                                                                                                                                                                                                                                                                                                                                                  class CalendarWeekViewCurrentTimeMarkerComponent implements OnChanges {}

                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                    constructor(dateAdapter: DateAdapter, zone: any);

                                                                                                                                                                                                                                                                                                                                                                                      property columnDate

                                                                                                                                                                                                                                                                                                                                                                                      columnDate: Date;

                                                                                                                                                                                                                                                                                                                                                                                        property columnDate$

                                                                                                                                                                                                                                                                                                                                                                                        columnDate$: any;

                                                                                                                                                                                                                                                                                                                                                                                          property customTemplate

                                                                                                                                                                                                                                                                                                                                                                                          customTemplate: any;

                                                                                                                                                                                                                                                                                                                                                                                            property dayEndHour

                                                                                                                                                                                                                                                                                                                                                                                            dayEndHour: number;

                                                                                                                                                                                                                                                                                                                                                                                              property dayEndMinute

                                                                                                                                                                                                                                                                                                                                                                                              dayEndMinute: number;

                                                                                                                                                                                                                                                                                                                                                                                                property dayStartHour

                                                                                                                                                                                                                                                                                                                                                                                                dayStartHour: number;

                                                                                                                                                                                                                                                                                                                                                                                                  property dayStartMinute

                                                                                                                                                                                                                                                                                                                                                                                                  dayStartMinute: number;

                                                                                                                                                                                                                                                                                                                                                                                                    property hourSegmentHeight

                                                                                                                                                                                                                                                                                                                                                                                                    hourSegmentHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                      property hourSegments

                                                                                                                                                                                                                                                                                                                                                                                                      hourSegments: number;

                                                                                                                                                                                                                                                                                                                                                                                                        property marker$

                                                                                                                                                                                                                                                                                                                                                                                                        marker$: any;

                                                                                                                                                                                                                                                                                                                                                                                                          method ngOnChanges

                                                                                                                                                                                                                                                                                                                                                                                                          ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                            interface A11yParams

                                                                                                                                                                                                                                                                                                                                                                                                            interface A11yParams {}
                                                                                                                                                                                                                                                                                                                                                                                                            • The parameters passed to the a11y methods.

                                                                                                                                                                                                                                                                                                                                                                                                            property action

                                                                                                                                                                                                                                                                                                                                                                                                            action?: EventAction;
                                                                                                                                                                                                                                                                                                                                                                                                            • Action button label e.g. 'Edit'

                                                                                                                                                                                                                                                                                                                                                                                                            property date

                                                                                                                                                                                                                                                                                                                                                                                                            date?: Date;
                                                                                                                                                                                                                                                                                                                                                                                                            • A date

                                                                                                                                                                                                                                                                                                                                                                                                            property day

                                                                                                                                                                                                                                                                                                                                                                                                            day?: MonthViewDay;
                                                                                                                                                                                                                                                                                                                                                                                                            • A day in the month view

                                                                                                                                                                                                                                                                                                                                                                                                            property event

                                                                                                                                                                                                                                                                                                                                                                                                            event?: CalendarEvent;
                                                                                                                                                                                                                                                                                                                                                                                                            • A calendar event

                                                                                                                                                                                                                                                                                                                                                                                                            property locale

                                                                                                                                                                                                                                                                                                                                                                                                            locale?: string;
                                                                                                                                                                                                                                                                                                                                                                                                            • Users preferred locale

                                                                                                                                                                                                                                                                                                                                                                                                            interface CalendarDateFormatterInterface

                                                                                                                                                                                                                                                                                                                                                                                                            interface CalendarDateFormatterInterface {}
                                                                                                                                                                                                                                                                                                                                                                                                            • If using a completely custom date formatter then it should implement this interface.

                                                                                                                                                                                                                                                                                                                                                                                                            method dayViewHour

                                                                                                                                                                                                                                                                                                                                                                                                            dayViewHour: ({ date: Date }: DateFormatterParams) => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • The time formatting down the left hand side of the day view

                                                                                                                                                                                                                                                                                                                                                                                                            method dayViewTitle

                                                                                                                                                                                                                                                                                                                                                                                                            dayViewTitle: ({ date: Date }: DateFormatterParams) => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • The day view title

                                                                                                                                                                                                                                                                                                                                                                                                            method monthViewColumnHeader

                                                                                                                                                                                                                                                                                                                                                                                                            monthViewColumnHeader: ({ date: Date }: DateFormatterParams) => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • The month view header week day labels

                                                                                                                                                                                                                                                                                                                                                                                                            method monthViewDayNumber

                                                                                                                                                                                                                                                                                                                                                                                                            monthViewDayNumber: ({ date: Date }: DateFormatterParams) => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • The month view cell day number

                                                                                                                                                                                                                                                                                                                                                                                                            method monthViewTitle

                                                                                                                                                                                                                                                                                                                                                                                                            monthViewTitle: ({ date: Date }: DateFormatterParams) => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • The month view title

                                                                                                                                                                                                                                                                                                                                                                                                            method weekViewColumnHeader

                                                                                                                                                                                                                                                                                                                                                                                                            weekViewColumnHeader: ({ date: Date }: DateFormatterParams) => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • The week view header week day labels

                                                                                                                                                                                                                                                                                                                                                                                                            method weekViewColumnSubHeader

                                                                                                                                                                                                                                                                                                                                                                                                            weekViewColumnSubHeader: ({ date: Date }: DateFormatterParams) => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • The week view sub header day and month labels

                                                                                                                                                                                                                                                                                                                                                                                                            method weekViewHour

                                                                                                                                                                                                                                                                                                                                                                                                            weekViewHour: ({ date: Date }: DateFormatterParams) => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • The time formatting down the left hand side of the day view

                                                                                                                                                                                                                                                                                                                                                                                                            method weekViewTitle

                                                                                                                                                                                                                                                                                                                                                                                                            weekViewTitle: ({ date: Date }: DateFormatterParams) => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • The week view title

                                                                                                                                                                                                                                                                                                                                                                                                            interface CalendarEventTimesChangedEvent

                                                                                                                                                                                                                                                                                                                                                                                                            interface CalendarEventTimesChangedEvent<MetaType = any> {}
                                                                                                                                                                                                                                                                                                                                                                                                            • The output $event type when an event is resized or dragged and dropped.

                                                                                                                                                                                                                                                                                                                                                                                                            property allDay

                                                                                                                                                                                                                                                                                                                                                                                                            allDay?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                              property event

                                                                                                                                                                                                                                                                                                                                                                                                              event: CalendarEvent<MetaType>;

                                                                                                                                                                                                                                                                                                                                                                                                                property newEnd

                                                                                                                                                                                                                                                                                                                                                                                                                newEnd?: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                  property newStart

                                                                                                                                                                                                                                                                                                                                                                                                                  newStart: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                    type: CalendarEventTimesChangedEventType;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CalendarModuleConfig

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CalendarModuleConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property a11y

                                                                                                                                                                                                                                                                                                                                                                                                                        a11y?: Provider;

                                                                                                                                                                                                                                                                                                                                                                                                                          property dateFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                          dateFormatter?: Provider;

                                                                                                                                                                                                                                                                                                                                                                                                                            property eventTitleFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                            eventTitleFormatter?: Provider;

                                                                                                                                                                                                                                                                                                                                                                                                                              property utils

                                                                                                                                                                                                                                                                                                                                                                                                                              utils?: Provider;

                                                                                                                                                                                                                                                                                                                                                                                                                                interface CalendarMonthViewBeforeRenderEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                interface CalendarMonthViewBeforeRenderEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  property body

                                                                                                                                                                                                                                                                                                                                                                                                                                  body: MonthViewDay[];

                                                                                                                                                                                                                                                                                                                                                                                                                                    property header

                                                                                                                                                                                                                                                                                                                                                                                                                                    header: WeekDay[];

                                                                                                                                                                                                                                                                                                                                                                                                                                      property period

                                                                                                                                                                                                                                                                                                                                                                                                                                      period: ViewPeriod;

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CalendarMonthViewEventTimesChangedEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CalendarMonthViewEventTimesChangedEvent<
                                                                                                                                                                                                                                                                                                                                                                                                                                        EventMetaType = any,
                                                                                                                                                                                                                                                                                                                                                                                                                                        DayMetaType = any
                                                                                                                                                                                                                                                                                                                                                                                                                                        > extends CalendarEventTimesChangedEvent<EventMetaType> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property day

                                                                                                                                                                                                                                                                                                                                                                                                                                          day: MonthViewDay<DayMetaType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CalendarWeekViewBeforeRenderEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CalendarWeekViewBeforeRenderEvent extends WeekView {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              property header

                                                                                                                                                                                                                                                                                                                                                                                                                                              header: WeekDay[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DateFormatterParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DateFormatterParams {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                • The parameter type passed to the date formatter methods.

                                                                                                                                                                                                                                                                                                                                                                                                                                                property date

                                                                                                                                                                                                                                                                                                                                                                                                                                                date: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                • The date to format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                property daysInWeek

                                                                                                                                                                                                                                                                                                                                                                                                                                                daysInWeek?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                • The number of days in a week. Can be used to create a shorter or longer week view. The first day of the week will always be the viewDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                property excludeDays

                                                                                                                                                                                                                                                                                                                                                                                                                                                excludeDays?: number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                • An array of day indexes (0 = sunday, 1 = monday etc) that will be hidden on the view

                                                                                                                                                                                                                                                                                                                                                                                                                                                property locale

                                                                                                                                                                                                                                                                                                                                                                                                                                                locale?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                • The users preferred locale.

                                                                                                                                                                                                                                                                                                                                                                                                                                                property weekStartsOn

                                                                                                                                                                                                                                                                                                                                                                                                                                                weekStartsOn?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                • The start day number of the week

                                                                                                                                                                                                                                                                                                                                                                                                                                                Enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                enum CalendarEventTimesChangedEventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                enum CalendarEventTimesChangedEventType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                Drag = 'drag',
                                                                                                                                                                                                                                                                                                                                                                                                                                                Drop = 'drop',
                                                                                                                                                                                                                                                                                                                                                                                                                                                Resize = 'resize',
                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Drag

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Drag = 'drag'

                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Drop

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Drop = 'drop'

                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Resize

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Resize = 'resize'

                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum CalendarView

                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum CalendarView {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Month = 'month',
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Week = 'week',
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Day = 'day',
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Day

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Day = 'day'

                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Month

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Month = 'month'

                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Week

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Week = 'week'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CalendarDayViewBeforeRenderEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CalendarDayViewBeforeRenderEvent = CalendarWeekViewBeforeRenderEvent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Package Files (40)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dependencies (6)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Peer Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/angular-calendar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/angular-calendar)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <a href="https://www.jsdocs.io/package/angular-calendar"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>