@nebular/theme

  • Version 7.0.0
  • Published
  • 7.39 MB
  • 1 dependency
  • MIT license

Install

npm i @nebular/theme
yarn add @nebular/theme
pnpm add @nebular/theme

Overview

@nebular/theme

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable BUILT_IN_THEMES

const BUILT_IN_THEMES: NbJSThemeOptions[];

    variable CORPORATE_THEME

    const CORPORATE_THEME: NbJSThemeOptions;

      variable COSMIC_THEME

      const COSMIC_THEME: NbJSThemeOptions;

        variable DARK_THEME

        const DARK_THEME: NbJSThemeOptions;

          variable DEFAULT_MEDIA_BREAKPOINTS

          const DEFAULT_MEDIA_BREAKPOINTS: { name: string; width: number }[];

            variable DEFAULT_THEME

            const DEFAULT_THEME: NbJSThemeOptions;

              variable MONTHS_IN_COLUMN

              const MONTHS_IN_COLUMN: number;

                variable MONTHS_IN_VIEW

                const MONTHS_IN_VIEW: number;

                  variable NB_BUILT_IN_JS_THEMES

                  const NB_BUILT_IN_JS_THEMES: any;

                    variable NB_COALESCED_STYLE_SCHEDULER

                    const NB_COALESCED_STYLE_SCHEDULER: any;

                      variable NB_DATE_ADAPTER

                      const NB_DATE_ADAPTER: any;

                        variable NB_DATE_SERVICE_OPTIONS

                        const NB_DATE_SERVICE_OPTIONS: any;

                          variable NB_DEFAULT_ROW_LEVEL

                          const NB_DEFAULT_ROW_LEVEL: number;

                            variable NB_DIALOG_CONFIG

                            const NB_DIALOG_CONFIG: any;

                              variable NB_DOCUMENT

                              const NB_DOCUMENT: any;

                                variable NB_JS_THEMES

                                const NB_JS_THEMES: any;

                                  variable NB_LAYOUT_DIRECTION

                                  const NB_LAYOUT_DIRECTION: any;
                                  • Layout direction setting injection token.

                                  variable NB_MEDIA_BREAKPOINTS

                                  const NB_MEDIA_BREAKPOINTS: any;

                                    variable NB_ROW_DOUBLE_CLICK_DELAY

                                    const NB_ROW_DOUBLE_CLICK_DELAY: number;

                                      variable NB_SELECT_INJECTION_TOKEN

                                      const NB_SELECT_INJECTION_TOKEN: any;

                                        variable NB_SORT_HEADER_COLUMN_DEF

                                        const NB_SORT_HEADER_COLUMN_DEF: any;

                                          variable NB_STEPPER

                                          const NB_STEPPER: any;

                                            variable NB_TABLE_PROVIDERS

                                            const NB_TABLE_PROVIDERS: any[];

                                              variable NB_TABLE_TEMPLATE

                                              const NB_TABLE_TEMPLATE: string;

                                                variable NB_THEME_OPTIONS

                                                const NB_THEME_OPTIONS: any;

                                                  variable NB_TIME_PICKER_CONFIG

                                                  const NB_TIME_PICKER_CONFIG: any;

                                                    variable NB_TOASTR_CONFIG

                                                    const NB_TOASTR_CONFIG: any;

                                                      variable NB_TREE_GRID

                                                      const NB_TREE_GRID: any;

                                                        variable NB_VIEW_REPEATER_STRATEGY

                                                        const NB_VIEW_REPEATER_STRATEGY: any;

                                                          variable NB_WINDOW

                                                          const NB_WINDOW: any;
                                                          • We're providing browser apis with tokens to improve testing capabilities.

                                                          variable NB_WINDOW_CONFIG

                                                          const NB_WINDOW_CONFIG: any;

                                                            variable NB_WINDOW_CONTENT

                                                            const NB_WINDOW_CONTENT: any;

                                                              variable NB_WINDOW_CONTEXT

                                                              const NB_WINDOW_CONTEXT: any;

                                                                Functions

                                                                function createContainer

                                                                createContainer: <T>(
                                                                ref: any,
                                                                container: any,
                                                                context: Object,
                                                                componentFactoryResolver?: any
                                                                ) => any;

                                                                  function nbSelectFormFieldControlConfigFactory

                                                                  nbSelectFormFieldControlConfigFactory: () => NbFormFieldControlConfig;

                                                                    function patch

                                                                    patch: <T>(container: any, containerContext: Object) => any;

                                                                      function windowFactory

                                                                      windowFactory: (platformId: Object) => Window | undefined;

                                                                        Classes

                                                                        class NbA11yModule

                                                                        class NbA11yModule {}

                                                                          method forRoot

                                                                          static forRoot: () => any;

                                                                            class NbAccordionComponent

                                                                            class NbAccordionComponent {}
                                                                            • An accordion allows to toggle the display of sections of content

                                                                              Basic example @stacked-example(Showcase, accordion/accordion-showcase.component)

                                                                              <nb-accordion>
                                                                              <nb-accordion-item>
                                                                              <nb-accordion-item-header>Product Details</nb-accordion-item-header>
                                                                              <nb-accordion-item-body>
                                                                              Item Content
                                                                              </nb-accordion-item-body>
                                                                              </nb-accordion-item>
                                                                              </nb-accordion>

                                                                              ### Installation

                                                                              Import NbAccordionModule to your feature module.

                                                                              @NgModule({
                                                                              imports: [
                                                                              // ...
                                                                              NbAccordionModule,
                                                                              ],
                                                                              })
                                                                              export class PageModule { }

                                                                              ### Usage

                                                                              With multi mode accordion can have multiple items expanded: @stacked-example(Multiple expanded items, accordion/accordion-multi.component)

                                                                              NbAccordionItemComponent has several methods, for example it is possible to trigger item click/toggle: @stacked-example(Expand API, accordion/accordion-toggle.component)

                                                                              accordion-border-radius: accordion-padding: accordion-shadow: accordion-header-text-color: accordion-header-text-font-family: accordion-header-text-font-size: accordion-header-text-font-weight: accordion-header-text-line-height: accordion-header-disabled-text-color: accordion-header-border-color: accordion-header-border-style: accordion-header-border-width: accordion-item-background-color: accordion-item-text-color: accordion-item-text-font-family: accordion-item-text-font-size: accordion-item-text-font-weight: accordion-item-text-line-height:

                                                                            property multi

                                                                            multi: boolean;
                                                                            • Allow multiple items to be expanded at the same time. {boolean}

                                                                            property ngAcceptInputType_multi

                                                                            static ngAcceptInputType_multi: NbBooleanInput;

                                                                              property openCloseItems

                                                                              openCloseItems: any;

                                                                                method closeAll

                                                                                closeAll: () => void;
                                                                                • Closes all enabled accordion items.

                                                                                method openAll

                                                                                openAll: () => void;
                                                                                • Opens all enabled accordion items.

                                                                                class NbAccordionItemBodyComponent

                                                                                class NbAccordionItemBodyComponent implements OnInit, OnDestroy {}
                                                                                • Component intended to be used within <nb-accordion-item> component

                                                                                constructor

                                                                                constructor(accordionItem: NbAccordionItemComponent, cd: any);

                                                                                  property state

                                                                                  readonly state: string;

                                                                                    method ngOnDestroy

                                                                                    ngOnDestroy: () => void;

                                                                                      method ngOnInit

                                                                                      ngOnInit: () => void;

                                                                                        class NbAccordionItemComponent

                                                                                        class NbAccordionItemComponent implements OnInit, OnChanges, OnDestroy {}
                                                                                        • Component intended to be used within <nb-accordion> component

                                                                                        constructor

                                                                                        constructor(accordion: NbAccordionComponent, cd: any);

                                                                                          property accordionItemInvalidate

                                                                                          accordionItemInvalidate: any;

                                                                                            property collapsed

                                                                                            collapsed: boolean;
                                                                                            • Item is collapse (true by default) {boolean}

                                                                                            property collapsedChange

                                                                                            collapsedChange: any;
                                                                                            • Emits whenever the expanded state of the accordion changes. Primarily used to facilitate two-way binding.

                                                                                            property disabled

                                                                                            disabled: boolean;
                                                                                            • Item is disabled and cannot be opened. {boolean}

                                                                                            property expanded

                                                                                            expanded: boolean;
                                                                                            • Item is expanded (false by default) {boolean}

                                                                                            property ngAcceptInputType_collapsed

                                                                                            static ngAcceptInputType_collapsed: NbBooleanInput;

                                                                                              property ngAcceptInputType_disabled

                                                                                              static ngAcceptInputType_disabled: NbBooleanInput;

                                                                                                property ngAcceptInputType_expanded

                                                                                                static ngAcceptInputType_expanded: NbBooleanInput;

                                                                                                  method close

                                                                                                  close: () => void;
                                                                                                  • Collapse the item.

                                                                                                  method ngOnChanges

                                                                                                  ngOnChanges: (changes: any) => void;

                                                                                                    method ngOnDestroy

                                                                                                    ngOnDestroy: () => void;

                                                                                                      method ngOnInit

                                                                                                      ngOnInit: () => void;

                                                                                                        method open

                                                                                                        open: () => void;
                                                                                                        • Open the item.

                                                                                                        method toggle

                                                                                                        toggle: () => void;
                                                                                                        • Open/close the item

                                                                                                        class NbAccordionItemHeaderComponent

                                                                                                        class NbAccordionItemHeaderComponent implements OnInit, OnDestroy {}
                                                                                                        • Component intended to be used within <nb-accordion-item> component

                                                                                                        constructor

                                                                                                        constructor(accordionItem: NbAccordionItemComponent, cd: any);

                                                                                                          property disabled

                                                                                                          readonly disabled: boolean;

                                                                                                            property expanded

                                                                                                            readonly expanded: boolean;

                                                                                                              property isCollapsed

                                                                                                              readonly isCollapsed: boolean;

                                                                                                                property state

                                                                                                                readonly state: string;

                                                                                                                  property tabbable

                                                                                                                  readonly tabbable: string;

                                                                                                                    method ngOnDestroy

                                                                                                                    ngOnDestroy: () => void;

                                                                                                                      method ngOnInit

                                                                                                                      ngOnInit: () => void;

                                                                                                                        method toggle

                                                                                                                        toggle: () => void;

                                                                                                                          class NbAccordionModule

                                                                                                                          class NbAccordionModule {}
                                                                                                                          • Copyright Akveo. All Rights Reserved. Licensed under the MIT License. See License.txt in the project root for license information.

                                                                                                                          class NbActionComponent

                                                                                                                          class NbActionComponent {}
                                                                                                                          • Action item, display a link with an icon, or any other content provided instead.

                                                                                                                          property badgeDot

                                                                                                                          badgeDot: boolean;
                                                                                                                          • Use badge dot mode boolean

                                                                                                                          property badgePosition

                                                                                                                          badgePosition: NbBadgePosition;
                                                                                                                          • Badge position. Can be set to any class or to one of predefined positions: 'top left', 'top right', 'bottom left', 'bottom right', 'top start', 'top end', 'bottom start', 'bottom end' string

                                                                                                                          property badgeStatus

                                                                                                                          badgeStatus: string;
                                                                                                                          • Badge status (adds specific styles): 'basic', 'primary', 'info', 'success', 'warning', 'danger', 'control'

                                                                                                                            Parameter val

                                                                                                                          property badgeText

                                                                                                                          badgeText: string;
                                                                                                                          • Badge text to display string

                                                                                                                          property disabled

                                                                                                                          disabled: boolean;
                                                                                                                          • Visually disables the item boolean

                                                                                                                          property href

                                                                                                                          href: string;
                                                                                                                          • Regular HREF link @type: string

                                                                                                                          property icon

                                                                                                                          icon: string | NbIconConfig;
                                                                                                                          • Icon name or config object {string | NbIconConfig}

                                                                                                                          link: string;
                                                                                                                          • Router link to use string

                                                                                                                          property ngAcceptInputType_badgeDot

                                                                                                                          static ngAcceptInputType_badgeDot: NbBooleanInput;

                                                                                                                            property ngAcceptInputType_disabled

                                                                                                                            static ngAcceptInputType_disabled: NbBooleanInput;

                                                                                                                              property title

                                                                                                                              title: string;
                                                                                                                              • Optional title for mouseover string

                                                                                                                              class NbActionsComponent

                                                                                                                              class NbActionsComponent {}
                                                                                                                              • Shows a horizontal list of actions, available in multiple sizes. Aligns items vertically.

                                                                                                                                @stacked-example(Showcase, action/action-showcase.component)

                                                                                                                                Basic actions setup:

                                                                                                                                <nb-actions size="small">
                                                                                                                                <nb-action icon="nb-search"></nb-action>
                                                                                                                                <nb-action icon="nb-power-circled"></nb-action>
                                                                                                                                <nb-action icon="nb-person"></nb-action>
                                                                                                                                </nb-actions>

                                                                                                                                ### Installation

                                                                                                                                Import NbActionsModule to your feature module.

                                                                                                                                @NgModule({
                                                                                                                                imports: [
                                                                                                                                // ...
                                                                                                                                NbActionsModule,
                                                                                                                                ],
                                                                                                                                })
                                                                                                                                export class PageModule { }

                                                                                                                                ### Usage

                                                                                                                                Multiple sizes example: @stacked-example(Multiple Sizes, action/action-sizes.component)

                                                                                                                                It is also possible to specify a badge value:

                                                                                                                                @stacked-example(Action Badge, action/action-badge.component)

                                                                                                                                and we can set it to full a width of a parent component @stacked-example(Full Width, action/action-width.component)

                                                                                                                                Action dot mode @stacked-example(Action badge in dot mode, action/action-dot-mode.component)

                                                                                                                                actions-background-color: actions-divider-color: actions-divider-style: actions-divider-width: actions-icon-color: actions-text-color: actions-text-font-family: actions-text-font-weight: actions-text-line-height: actions-disabled-icon-color: actions-disabled-text-color: actions-tiny-height: actions-tiny-icon-height: actions-tiny-padding: actions-tiny-text-font-size: actions-small-height: actions-small-icon-height: actions-small-padding: actions-small-text-font-size: actions-medium-height: actions-medium-icon-height: actions-medium-padding: actions-medium-text-font-size: actions-large-height: actions-large-icon-height: actions-large-padding: actions-large-text-font-size: actions-giant-height: actions-giant-icon-height: actions-giant-padding: actions-giant-text-font-size:

                                                                                                                              property fullWidth

                                                                                                                              fullWidth: boolean;
                                                                                                                              • Component will fill full width of the container

                                                                                                                              property giant

                                                                                                                              readonly giant: boolean;

                                                                                                                                property large

                                                                                                                                readonly large: boolean;

                                                                                                                                  property medium

                                                                                                                                  readonly medium: boolean;

                                                                                                                                    property ngAcceptInputType_fullWidth

                                                                                                                                    static ngAcceptInputType_fullWidth: NbBooleanInput;

                                                                                                                                      property size

                                                                                                                                      size: NbComponentSize;
                                                                                                                                      • Size of the component: 'tiny', 'small' (default), 'medium', 'large', 'giant'

                                                                                                                                      property small

                                                                                                                                      readonly small: boolean;

                                                                                                                                        property tiny

                                                                                                                                        readonly tiny: boolean;

                                                                                                                                          class NbActionsModule

                                                                                                                                          class NbActionsModule {}
                                                                                                                                          • Copyright Akveo. All Rights Reserved. Licensed under the MIT License. See License.txt in the project root for license information.

                                                                                                                                          class NbAdjustableConnectedPositionStrategy

                                                                                                                                          class NbAdjustableConnectedPositionStrategy
                                                                                                                                          extends NbFlexibleConnectedPositionStrategy
                                                                                                                                          implements NbPositionStrategy {}
                                                                                                                                          • The main idea of the adjustable connected strategy is to provide predefined set of positions for your overlay. You have to provide adjustment and appropriate strategy will be chosen in runtime.

                                                                                                                                          property appliedPositions

                                                                                                                                          protected appliedPositions: { key: NbPosition; connectedPosition: any }[];

                                                                                                                                            property positionChange

                                                                                                                                            readonly positionChange: any;

                                                                                                                                              method adjustment

                                                                                                                                              adjustment: (adjustment: NbAdjustment) => this;

                                                                                                                                                method apply

                                                                                                                                                apply: () => void;

                                                                                                                                                  method applyPositions

                                                                                                                                                  protected applyPositions: () => void;

                                                                                                                                                    method attach

                                                                                                                                                    attach: (overlayRef: any) => void;

                                                                                                                                                      method createPositions

                                                                                                                                                      protected createPositions: () => NbPosition[];

                                                                                                                                                        method mapToLogicalPosition

                                                                                                                                                        protected mapToLogicalPosition: (position: NbPosition) => NbPosition;

                                                                                                                                                          method offset

                                                                                                                                                          offset: (offset: number) => this;

                                                                                                                                                            method persistChosenPositions

                                                                                                                                                            protected persistChosenPositions: (positions: NbPosition[]) => void;

                                                                                                                                                              method position

                                                                                                                                                              position: (position: NbPosition) => this;

                                                                                                                                                                method reorderPreferredPositions

                                                                                                                                                                protected reorderPreferredPositions: (positions: NbPosition[]) => NbPosition[];

                                                                                                                                                                  class NbAlertComponent

                                                                                                                                                                  class NbAlertComponent {}
                                                                                                                                                                  • Alert component.

                                                                                                                                                                    Basic alert example: @stacked-example(Showcase, alert/alert-showcase.component)

                                                                                                                                                                    Alert configuration:

                                                                                                                                                                    <nb-alert status="success">
                                                                                                                                                                    You have been successfully authenticated!
                                                                                                                                                                    </nb-alert>

                                                                                                                                                                    ### Installation

                                                                                                                                                                    Import NbAlertModule to your feature module.

                                                                                                                                                                    @NgModule({
                                                                                                                                                                    imports: [
                                                                                                                                                                    // ...
                                                                                                                                                                    NbAlertModule,
                                                                                                                                                                    ],
                                                                                                                                                                    })
                                                                                                                                                                    export class PageModule { }

                                                                                                                                                                    ### Usage

                                                                                                                                                                    Alert could additionally have a close button when closable property is set:

                                                                                                                                                                    <nb-alert status="success" closable (close)="onClose()">
                                                                                                                                                                    You have been successfully authenticated!
                                                                                                                                                                    </nb-alert>

                                                                                                                                                                    Colored alerts could be simply configured by providing a status property: @stacked-example(Alert status, alert/alert-colors.component)

                                                                                                                                                                    It is also possible to assign an accent property for a slight alert highlight as well as combine it with status: @stacked-example(Alert accent, alert/alert-accents.component)

                                                                                                                                                                    And outline property: @stacked-example(Outline Alert, alert/alert-outline.component)

                                                                                                                                                                    @additional-example(Multiple Sizes, alert/alert-sizes.component)

                                                                                                                                                                    alert-border-radius: alert-bottom-margin: alert-padding: alert-scrollbar-color: alert-scrollbar-background-color: alert-scrollbar-width: alert-shadow: alert-text-font-family: alert-text-font-size: alert-text-font-weight: alert-text-line-height: alert-closable-start-padding: alert-tiny-height: alert-small-height: alert-medium-height: alert-medium-padding: alert-large-height: alert-giant-height: alert-basic-background-color: alert-basic-text-color: alert-primary-background-color: alert-primary-text-color: alert-success-background-color: alert-success-text-color: alert-info-background-color: alert-info-text-color: alert-warning-background-color: alert-warning-text-color: alert-danger-background-color: alert-danger-text-color: alert-control-background-color: alert-control-text-color: alert-accent-basic-color: alert-accent-primary-color: alert-accent-info-color: alert-accent-success-color: alert-accent-warning-color: alert-accent-danger-color: alert-accent-control-color: alert-outline-width: alert-outline-basic-color: alert-outline-primary-color: alert-outline-info-color: alert-outline-success-color: alert-outline-warning-color: alert-outline-danger-color: alert-outline-control-color:

                                                                                                                                                                  constructor

                                                                                                                                                                  constructor(statusService: NbStatusService);

                                                                                                                                                                    property accent

                                                                                                                                                                    accent: '' | NbComponentStatus;
                                                                                                                                                                    • Alert accent (color of the top border): basic, primary, success, info, warning, danger, control. Unset by default.

                                                                                                                                                                    property additionalClasses

                                                                                                                                                                    readonly additionalClasses: string[];

                                                                                                                                                                      property basic

                                                                                                                                                                      readonly basic: boolean;

                                                                                                                                                                        property basicAccent

                                                                                                                                                                        readonly basicAccent: boolean;

                                                                                                                                                                          property basicOutline

                                                                                                                                                                          readonly basicOutline: boolean;

                                                                                                                                                                            property closable

                                                                                                                                                                            closable: boolean;
                                                                                                                                                                            • Shows close icon

                                                                                                                                                                            property close

                                                                                                                                                                            close: any;
                                                                                                                                                                            • Emits when chip is removed EventEmitter

                                                                                                                                                                            property control

                                                                                                                                                                            readonly control: boolean;

                                                                                                                                                                              property controlAccent

                                                                                                                                                                              readonly controlAccent: boolean;

                                                                                                                                                                                property controlOutline

                                                                                                                                                                                readonly controlOutline: boolean;

                                                                                                                                                                                  property danger

                                                                                                                                                                                  readonly danger: boolean;

                                                                                                                                                                                    property dangerAccent

                                                                                                                                                                                    readonly dangerAccent: boolean;

                                                                                                                                                                                      property dangerOutline

                                                                                                                                                                                      readonly dangerOutline: boolean;

                                                                                                                                                                                        property giant

                                                                                                                                                                                        readonly giant: boolean;

                                                                                                                                                                                          property info

                                                                                                                                                                                          readonly info: boolean;

                                                                                                                                                                                            property infoAccent

                                                                                                                                                                                            readonly infoAccent: boolean;

                                                                                                                                                                                              property infoOutline

                                                                                                                                                                                              readonly infoOutline: boolean;

                                                                                                                                                                                                property large

                                                                                                                                                                                                readonly large: boolean;

                                                                                                                                                                                                  property medium

                                                                                                                                                                                                  readonly medium: boolean;

                                                                                                                                                                                                    property ngAcceptInputType_closable

                                                                                                                                                                                                    static ngAcceptInputType_closable: NbBooleanInput;

                                                                                                                                                                                                      property outline

                                                                                                                                                                                                      outline: '' | NbComponentStatus;
                                                                                                                                                                                                      • Alert outline (color of the border): basic, primary, success, info, warning, danger, control. Unset by default.

                                                                                                                                                                                                      property primary

                                                                                                                                                                                                      readonly primary: boolean;

                                                                                                                                                                                                        property primaryAccent

                                                                                                                                                                                                        readonly primaryAccent: boolean;

                                                                                                                                                                                                          property primaryOutline

                                                                                                                                                                                                          readonly primaryOutline: boolean;

                                                                                                                                                                                                            property size

                                                                                                                                                                                                            size: '' | NbComponentSize;
                                                                                                                                                                                                            • Alert size, available sizes: tiny, small, medium, large, giant Unset by default.

                                                                                                                                                                                                            property small

                                                                                                                                                                                                            readonly small: boolean;

                                                                                                                                                                                                              property status

                                                                                                                                                                                                              status: string;
                                                                                                                                                                                                              • Alert status (adds specific styles): basic (default), primary, success, info, warning, danger, control.

                                                                                                                                                                                                              property statusService

                                                                                                                                                                                                              protected statusService: NbStatusService;

                                                                                                                                                                                                                property success

                                                                                                                                                                                                                readonly success: boolean;

                                                                                                                                                                                                                  property successAccent

                                                                                                                                                                                                                  readonly successAccent: boolean;

                                                                                                                                                                                                                    property successOutline

                                                                                                                                                                                                                    readonly successOutline: boolean;

                                                                                                                                                                                                                      property tiny

                                                                                                                                                                                                                      readonly tiny: boolean;

                                                                                                                                                                                                                        property warning

                                                                                                                                                                                                                        readonly warning: boolean;

                                                                                                                                                                                                                          property warningAccent

                                                                                                                                                                                                                          readonly warningAccent: boolean;

                                                                                                                                                                                                                            property warningOutline

                                                                                                                                                                                                                            readonly warningOutline: boolean;

                                                                                                                                                                                                                              method onClose

                                                                                                                                                                                                                              onClose: () => void;
                                                                                                                                                                                                                              • Emits the removed chip event

                                                                                                                                                                                                                              class NbAlertModule

                                                                                                                                                                                                                              class NbAlertModule {}
                                                                                                                                                                                                                              • Copyright Akveo. All Rights Reserved. Licensed under the MIT License. See License.txt in the project root for license information.

                                                                                                                                                                                                                              class NbAutocompleteComponent

                                                                                                                                                                                                                              class NbAutocompleteComponent<T> implements AfterContentInit, OnDestroy {}
                                                                                                                                                                                                                              • The NbAutocompleteComponent overlay component. Provides an NbOptionList overlay component.

                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                              constructor(cd: any);

                                                                                                                                                                                                                                property activeFirst

                                                                                                                                                                                                                                activeFirst: boolean;
                                                                                                                                                                                                                                • Flag passed as input to always make first option active.

                                                                                                                                                                                                                                property cd

                                                                                                                                                                                                                                protected cd: any;

                                                                                                                                                                                                                                  property destroy$

                                                                                                                                                                                                                                  protected destroy$: any;

                                                                                                                                                                                                                                    property giant

                                                                                                                                                                                                                                    readonly giant: boolean;

                                                                                                                                                                                                                                      property handleDisplayFn

                                                                                                                                                                                                                                      handleDisplayFn: (value: any) => string;
                                                                                                                                                                                                                                      • Function passed as input to process each string option value before render.

                                                                                                                                                                                                                                      property hostRef

                                                                                                                                                                                                                                      hostRef: any;
                                                                                                                                                                                                                                      • HTML input reference to which autocomplete connected.

                                                                                                                                                                                                                                      property hostWidth

                                                                                                                                                                                                                                      readonly hostWidth: number;
                                                                                                                                                                                                                                      • Returns width of the input.

                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                      id: string;
                                                                                                                                                                                                                                      • Component scoped id for aria attributes.

                                                                                                                                                                                                                                      property large

                                                                                                                                                                                                                                      readonly large: boolean;

                                                                                                                                                                                                                                        property medium

                                                                                                                                                                                                                                        readonly medium: boolean;

                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                          options: any;
                                                                                                                                                                                                                                          • List of NbOptionComponent's components passed as content.

                                                                                                                                                                                                                                          property optionsListClass

                                                                                                                                                                                                                                          optionsListClass: any;
                                                                                                                                                                                                                                          • Specifies class to be set on nb-options container (nb-option-list)

                                                                                                                                                                                                                                          property optionsPanelClass

                                                                                                                                                                                                                                          optionsPanelClass: string | string[];
                                                                                                                                                                                                                                          • Specifies class for the overlay panel with options

                                                                                                                                                                                                                                          property overlayPosition

                                                                                                                                                                                                                                          overlayPosition: NbPosition;

                                                                                                                                                                                                                                            property portal

                                                                                                                                                                                                                                            portal: NbPortalDirective;
                                                                                                                                                                                                                                            • NbOptionList with options content.

                                                                                                                                                                                                                                            property selectedChange

                                                                                                                                                                                                                                            selectedChange: any;
                                                                                                                                                                                                                                            • Will be emitted when selected value changes.

                                                                                                                                                                                                                                            property size

                                                                                                                                                                                                                                            size: NbComponentSize;
                                                                                                                                                                                                                                            • Autocomplete size, available sizes: tiny, small, medium (default), large, giant

                                                                                                                                                                                                                                            property small

                                                                                                                                                                                                                                            readonly small: boolean;

                                                                                                                                                                                                                                              property tiny

                                                                                                                                                                                                                                              readonly tiny: boolean;

                                                                                                                                                                                                                                                method emitSelected

                                                                                                                                                                                                                                                emitSelected: (selected: T) => void;
                                                                                                                                                                                                                                                • Propagate selected value.

                                                                                                                                                                                                                                                method ngAfterContentInit

                                                                                                                                                                                                                                                ngAfterContentInit: () => void;

                                                                                                                                                                                                                                                  method ngOnDestroy

                                                                                                                                                                                                                                                  ngOnDestroy: () => void;

                                                                                                                                                                                                                                                    method setHost

                                                                                                                                                                                                                                                    setHost: (hostRef: any) => void;
                                                                                                                                                                                                                                                    • Autocomplete knows nothing about host html input element. So, attach method set input hostRef for styling.

                                                                                                                                                                                                                                                    class NbAutocompleteDirective

                                                                                                                                                                                                                                                    class NbAutocompleteDirective<T>
                                                                                                                                                                                                                                                    implements OnDestroy, AfterViewInit, ControlValueAccessor {}
                                                                                                                                                                                                                                                    • The NbAutocompleteDirective provides a capability to expand input with NbAutocompleteComponent overlay containing options to select and fill input with.

                                                                                                                                                                                                                                                      @stacked-example(Showcase, autocomplete/autocomplete-showcase.component)

                                                                                                                                                                                                                                                      ### Installation

                                                                                                                                                                                                                                                      Import NbAutocompleteModule to your feature module.

                                                                                                                                                                                                                                                      @NgModule({
                                                                                                                                                                                                                                                      imports: [
                                                                                                                                                                                                                                                      // ...
                                                                                                                                                                                                                                                      NbAutocompleteModule,
                                                                                                                                                                                                                                                      ],
                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                      export class PageModule { }

                                                                                                                                                                                                                                                      ### Usage

                                                                                                                                                                                                                                                      You can bind control with form controls or ngModel.

                                                                                                                                                                                                                                                      @stacked-example(Autocomplete form binding, autocomplete/autocomplete-form.component)

                                                                                                                                                                                                                                                      Options in the autocomplete may be grouped using nb-option-group component.

                                                                                                                                                                                                                                                      @stacked-example(Grouping, autocomplete/autocomplete-group.component)

                                                                                                                                                                                                                                                      Autocomplete may change selected option value via provided function.

                                                                                                                                                                                                                                                      @stacked-example(Custom display, autocomplete/autocomplete-custom-display.component)

                                                                                                                                                                                                                                                      Also, autocomplete may make first option in option list active automatically.

                                                                                                                                                                                                                                                      @stacked-example(Active first, autocomplete/autocomplete-active-first.component)

                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                    hostRef: any,
                                                                                                                                                                                                                                                    overlay: NbOverlayService,
                                                                                                                                                                                                                                                    cd: any,
                                                                                                                                                                                                                                                    triggerStrategyBuilder: NbTriggerStrategyBuilderService,
                                                                                                                                                                                                                                                    positionBuilder: NbPositionBuilderService,
                                                                                                                                                                                                                                                    activeDescendantKeyManagerFactory: NbActiveDescendantKeyManagerFactoryService<
                                                                                                                                                                                                                                                    NbOptionComponent<T>
                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                    renderer: any
                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                      property activeDescendantKeyManagerFactory

                                                                                                                                                                                                                                                      protected activeDescendantKeyManagerFactory: NbActiveDescendantKeyManagerFactoryService<
                                                                                                                                                                                                                                                      NbOptionComponent<T>
                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                        property ariaActiveDescendant

                                                                                                                                                                                                                                                        readonly ariaActiveDescendant: string;

                                                                                                                                                                                                                                                          property ariaAutocomplete

                                                                                                                                                                                                                                                          ariaAutocomplete: string;

                                                                                                                                                                                                                                                            property ariaExpanded

                                                                                                                                                                                                                                                            readonly ariaExpanded: string;

                                                                                                                                                                                                                                                              property ariaOwns

                                                                                                                                                                                                                                                              readonly ariaOwns: string;

                                                                                                                                                                                                                                                                property autocomplete

                                                                                                                                                                                                                                                                autocomplete: NbAutocompleteComponent<T>;
                                                                                                                                                                                                                                                                • Provides autocomplete component.

                                                                                                                                                                                                                                                                property bottom

                                                                                                                                                                                                                                                                readonly bottom: boolean;

                                                                                                                                                                                                                                                                  property cd

                                                                                                                                                                                                                                                                  protected cd: any;

                                                                                                                                                                                                                                                                    property customOverlayHost

                                                                                                                                                                                                                                                                    customOverlayHost: any;

                                                                                                                                                                                                                                                                      property destroy$

                                                                                                                                                                                                                                                                      protected destroy$: any;

                                                                                                                                                                                                                                                                        property focusInputOnValueChange

                                                                                                                                                                                                                                                                        focusInputOnValueChange: boolean;
                                                                                                                                                                                                                                                                        • Determines if the input will be focused when the control value is changed

                                                                                                                                                                                                                                                                        property hasPopup

                                                                                                                                                                                                                                                                        hasPopup: string;

                                                                                                                                                                                                                                                                          property hostRef

                                                                                                                                                                                                                                                                          protected hostRef: any;

                                                                                                                                                                                                                                                                            property isClosed

                                                                                                                                                                                                                                                                            readonly isClosed: boolean;
                                                                                                                                                                                                                                                                            • Determines is autocomplete overlay closed.

                                                                                                                                                                                                                                                                            property isOpen

                                                                                                                                                                                                                                                                            readonly isOpen: boolean;
                                                                                                                                                                                                                                                                            • Determines is autocomplete overlay opened.

                                                                                                                                                                                                                                                                            property keyManager

                                                                                                                                                                                                                                                                            protected keyManager: NbActiveDescendantKeyManager<NbOptionComponent<T>>;

                                                                                                                                                                                                                                                                              property overlay

                                                                                                                                                                                                                                                                              protected overlay: NbOverlayService;

                                                                                                                                                                                                                                                                                property overlayOffset

                                                                                                                                                                                                                                                                                overlayOffset: number;
                                                                                                                                                                                                                                                                                • Determines options overlay offset (in pixels).

                                                                                                                                                                                                                                                                                property overlayRef

                                                                                                                                                                                                                                                                                protected overlayRef: any;

                                                                                                                                                                                                                                                                                  property positionBuilder

                                                                                                                                                                                                                                                                                  protected positionBuilder: NbPositionBuilderService;

                                                                                                                                                                                                                                                                                    property positionStrategy

                                                                                                                                                                                                                                                                                    protected positionStrategy: NbAdjustableConnectedPositionStrategy;

                                                                                                                                                                                                                                                                                      property renderer

                                                                                                                                                                                                                                                                                      protected renderer: any;

                                                                                                                                                                                                                                                                                        property role

                                                                                                                                                                                                                                                                                        role: string;

                                                                                                                                                                                                                                                                                          property scrollStrategy

                                                                                                                                                                                                                                                                                          scrollStrategy: 'noop' | 'close' | 'block' | 'reposition';
                                                                                                                                                                                                                                                                                          • Determines options overlay scroll strategy.

                                                                                                                                                                                                                                                                                          property top

                                                                                                                                                                                                                                                                                          readonly top: boolean;

                                                                                                                                                                                                                                                                                            property triggerStrategy

                                                                                                                                                                                                                                                                                            protected triggerStrategy: NbTriggerStrategy;
                                                                                                                                                                                                                                                                                            • Trigger strategy used by overlay. @docs-private

                                                                                                                                                                                                                                                                                            property triggerStrategyBuilder

                                                                                                                                                                                                                                                                                            protected triggerStrategyBuilder: NbTriggerStrategyBuilderService;

                                                                                                                                                                                                                                                                                              method attachToOverlay

                                                                                                                                                                                                                                                                                              protected attachToOverlay: () => void;

                                                                                                                                                                                                                                                                                                method checkOverlayVisibility

                                                                                                                                                                                                                                                                                                protected checkOverlayVisibility: () => void;

                                                                                                                                                                                                                                                                                                  method createKeyManager

                                                                                                                                                                                                                                                                                                  protected createKeyManager: () => void;

                                                                                                                                                                                                                                                                                                    method createOverlay

                                                                                                                                                                                                                                                                                                    protected createOverlay: () => void;

                                                                                                                                                                                                                                                                                                      method createPositionStrategy

                                                                                                                                                                                                                                                                                                      protected createPositionStrategy: () => NbAdjustableConnectedPositionStrategy;

                                                                                                                                                                                                                                                                                                        method createScrollStrategy

                                                                                                                                                                                                                                                                                                        protected createScrollStrategy: () => any;

                                                                                                                                                                                                                                                                                                          method createTriggerStrategy

                                                                                                                                                                                                                                                                                                          protected createTriggerStrategy: () => NbTriggerStrategy;

                                                                                                                                                                                                                                                                                                            method getActiveItem

                                                                                                                                                                                                                                                                                                            protected getActiveItem: () => NbOptionComponent<T>;

                                                                                                                                                                                                                                                                                                              method getContainer

                                                                                                                                                                                                                                                                                                              protected getContainer: () => any;

                                                                                                                                                                                                                                                                                                                method getDisplayValue

                                                                                                                                                                                                                                                                                                                protected getDisplayValue: (value: string) => string;

                                                                                                                                                                                                                                                                                                                  method handleBlur

                                                                                                                                                                                                                                                                                                                  handleBlur: () => void;

                                                                                                                                                                                                                                                                                                                    method handleInput

                                                                                                                                                                                                                                                                                                                    handleInput: () => void;

                                                                                                                                                                                                                                                                                                                      method handleInputValueUpdate

                                                                                                                                                                                                                                                                                                                      protected handleInputValueUpdate: (value: T) => void;

                                                                                                                                                                                                                                                                                                                        method handleKeydown

                                                                                                                                                                                                                                                                                                                        handleKeydown: () => void;

                                                                                                                                                                                                                                                                                                                          method hide

                                                                                                                                                                                                                                                                                                                          hide: () => void;

                                                                                                                                                                                                                                                                                                                            method initOverlay

                                                                                                                                                                                                                                                                                                                            protected initOverlay: () => void;

                                                                                                                                                                                                                                                                                                                              method ngAfterViewInit

                                                                                                                                                                                                                                                                                                                              ngAfterViewInit: () => void;

                                                                                                                                                                                                                                                                                                                                method ngOnDestroy

                                                                                                                                                                                                                                                                                                                                ngOnDestroy: () => void;

                                                                                                                                                                                                                                                                                                                                  method registerOnChange

                                                                                                                                                                                                                                                                                                                                  registerOnChange: (fn: (value: any) => {}) => void;

                                                                                                                                                                                                                                                                                                                                    method registerOnTouched

                                                                                                                                                                                                                                                                                                                                    registerOnTouched: (fn: any) => void;

                                                                                                                                                                                                                                                                                                                                      method setActiveItem

                                                                                                                                                                                                                                                                                                                                      protected setActiveItem: () => void;

                                                                                                                                                                                                                                                                                                                                        method setDisabledState

                                                                                                                                                                                                                                                                                                                                        setDisabledState: (disabled: boolean) => void;

                                                                                                                                                                                                                                                                                                                                          method setHostInputValue

                                                                                                                                                                                                                                                                                                                                          protected setHostInputValue: (value: any) => void;

                                                                                                                                                                                                                                                                                                                                            method setupAutocomplete

                                                                                                                                                                                                                                                                                                                                            protected setupAutocomplete: () => void;

                                                                                                                                                                                                                                                                                                                                              method show

                                                                                                                                                                                                                                                                                                                                              show: () => void;

                                                                                                                                                                                                                                                                                                                                                method subscribeOnOptionClick

                                                                                                                                                                                                                                                                                                                                                protected subscribeOnOptionClick: () => void;

                                                                                                                                                                                                                                                                                                                                                  method subscribeOnOverlayKeys

                                                                                                                                                                                                                                                                                                                                                  protected subscribeOnOverlayKeys: () => void;

                                                                                                                                                                                                                                                                                                                                                    method subscribeOnPositionChange

                                                                                                                                                                                                                                                                                                                                                    protected subscribeOnPositionChange: () => void;

                                                                                                                                                                                                                                                                                                                                                      method subscribeOnTriggers

                                                                                                                                                                                                                                                                                                                                                      protected subscribeOnTriggers: () => void;

                                                                                                                                                                                                                                                                                                                                                        method writeValue

                                                                                                                                                                                                                                                                                                                                                        writeValue: (value: T) => void;

                                                                                                                                                                                                                                                                                                                                                          class NbAutocompleteModule

                                                                                                                                                                                                                                                                                                                                                          class NbAutocompleteModule {}
                                                                                                                                                                                                                                                                                                                                                          • Copyright Akveo. All Rights Reserved. Licensed under the MIT License. See License.txt in the project root for license information.

                                                                                                                                                                                                                                                                                                                                                          class NbBadgeComponent

                                                                                                                                                                                                                                                                                                                                                          class NbBadgeComponent implements NbBadge {}
                                                                                                                                                                                                                                                                                                                                                          • Badge is a simple labeling component. It can be used to add additional information to any content or highlight unread items.

                                                                                                                                                                                                                                                                                                                                                            Element is absolute positioned, so parent should be [positioned element](https://developer.mozilla.org/en-US/docs/Web/CSS/position). It means parent position should be set to anything except static, e.g. relative, absolute, fixed, or sticky.

                                                                                                                                                                                                                                                                                                                                                            ### Installation

                                                                                                                                                                                                                                                                                                                                                            Import NbBadgeModule to your feature module.

                                                                                                                                                                                                                                                                                                                                                            @NgModule({
                                                                                                                                                                                                                                                                                                                                                            imports: [
                                                                                                                                                                                                                                                                                                                                                            // ...
                                                                                                                                                                                                                                                                                                                                                            NbBadgeModule,
                                                                                                                                                                                                                                                                                                                                                            ],
                                                                                                                                                                                                                                                                                                                                                            })
                                                                                                                                                                                                                                                                                                                                                            export class PageModule { }

                                                                                                                                                                                                                                                                                                                                                            ### Usage

                                                                                                                                                                                                                                                                                                                                                            Badge with default position and status(color):

                                                                                                                                                                                                                                                                                                                                                            <nb-badge text="badgeText"></nb-badge>

                                                                                                                                                                                                                                                                                                                                                            For example, badge can be placed into nb-card header: @stacked-example(Showcase, badge/badge-showcase.component)

                                                                                                                                                                                                                                                                                                                                                            Badge located on the bottom right with warning status:

                                                                                                                                                                                                                                                                                                                                                            <nb-badge text="badgeText" status="warning" position="bottom right">
                                                                                                                                                                                                                                                                                                                                                            </nb-badge>

                                                                                                                                                                                                                                                                                                                                                            badge-border-radius: badge-text-font-family: badge-text-font-size: badge-text-font-weight: badge-text-line-height: badge-padding: badge-basic-background-color: badge-basic-text-color: badge-primary-background-color: badge-primary-text-color: badge-success-background-color: badge-success-text-color: badge-info-background-color: badge-info-text-color: badge-warning-background-color: badge-warning-text-color: badge-danger-background-color: badge-danger-text-color: badge-control-background-color: badge-control-text-color:

                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                          constructor(statusService: NbStatusService);

                                                                                                                                                                                                                                                                                                                                                            property additionalClasses

                                                                                                                                                                                                                                                                                                                                                            readonly additionalClasses: string[];

                                                                                                                                                                                                                                                                                                                                                              property basic

                                                                                                                                                                                                                                                                                                                                                              readonly basic: boolean;

                                                                                                                                                                                                                                                                                                                                                                property bottom

                                                                                                                                                                                                                                                                                                                                                                readonly bottom: boolean;

                                                                                                                                                                                                                                                                                                                                                                  property center

                                                                                                                                                                                                                                                                                                                                                                  readonly center: boolean;

                                                                                                                                                                                                                                                                                                                                                                    property control

                                                                                                                                                                                                                                                                                                                                                                    readonly control: boolean;

                                                                                                                                                                                                                                                                                                                                                                      property danger

                                                                                                                                                                                                                                                                                                                                                                      readonly danger: boolean;

                                                                                                                                                                                                                                                                                                                                                                        property dotMode

                                                                                                                                                                                                                                                                                                                                                                        dotMode: boolean;
                                                                                                                                                                                                                                                                                                                                                                        • Shows badge as a dot. No text is shown. boolean

                                                                                                                                                                                                                                                                                                                                                                        property end

                                                                                                                                                                                                                                                                                                                                                                        readonly end: boolean;

                                                                                                                                                                                                                                                                                                                                                                          property info

                                                                                                                                                                                                                                                                                                                                                                          readonly info: boolean;

                                                                                                                                                                                                                                                                                                                                                                            property left

                                                                                                                                                                                                                                                                                                                                                                            readonly left: boolean;

                                                                                                                                                                                                                                                                                                                                                                              property position

                                                                                                                                                                                                                                                                                                                                                                              position: NbBadgePosition;
                                                                                                                                                                                                                                                                                                                                                                              • Badge position

                                                                                                                                                                                                                                                                                                                                                                                Can be set to any class or to one of predefined positions: 'top left', 'top right', 'bottom left', 'bottom right', 'top start', 'top end', 'bottom start', 'bottom end' string

                                                                                                                                                                                                                                                                                                                                                                              property primary

                                                                                                                                                                                                                                                                                                                                                                              readonly primary: boolean;

                                                                                                                                                                                                                                                                                                                                                                                property right

                                                                                                                                                                                                                                                                                                                                                                                readonly right: boolean;

                                                                                                                                                                                                                                                                                                                                                                                  property start

                                                                                                                                                                                                                                                                                                                                                                                  readonly start: boolean;

                                                                                                                                                                                                                                                                                                                                                                                    property status

                                                                                                                                                                                                                                                                                                                                                                                    status: string;
                                                                                                                                                                                                                                                                                                                                                                                    • Badge status (adds specific styles): 'basic', 'primary', 'info', 'success', 'warning', 'danger', 'control'

                                                                                                                                                                                                                                                                                                                                                                                    property statusService

                                                                                                                                                                                                                                                                                                                                                                                    protected statusService: NbStatusService;

                                                                                                                                                                                                                                                                                                                                                                                      property success

                                                                                                                                                                                                                                                                                                                                                                                      readonly success: boolean;

                                                                                                                                                                                                                                                                                                                                                                                        property text

                                                                                                                                                                                                                                                                                                                                                                                        text: string;
                                                                                                                                                                                                                                                                                                                                                                                        • Text to display string

                                                                                                                                                                                                                                                                                                                                                                                        property top

                                                                                                                                                                                                                                                                                                                                                                                        readonly top: boolean;

                                                                                                                                                                                                                                                                                                                                                                                          property warning

                                                                                                                                                                                                                                                                                                                                                                                          readonly warning: boolean;

                                                                                                                                                                                                                                                                                                                                                                                            class NbBadgeModule

                                                                                                                                                                                                                                                                                                                                                                                            class NbBadgeModule {}
                                                                                                                                                                                                                                                                                                                                                                                            • Copyright Akveo. All Rights Reserved. Licensed under the MIT License. See License.txt in the project root for license information.

                                                                                                                                                                                                                                                                                                                                                                                            class NbBaseCalendarComponent

                                                                                                                                                                                                                                                                                                                                                                                            class NbBaseCalendarComponent<D, T> implements OnInit {}
                                                                                                                                                                                                                                                                                                                                                                                            • The basis for calendar and range calendar components. Encapsulates common behavior - store calendar state and perform navigation between pickers.

                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                            dateService: NbDateService<D>,
                                                                                                                                                                                                                                                                                                                                                                                            yearModelService: NbCalendarYearModelService<D>
                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                              property activeViewMode

                                                                                                                                                                                                                                                                                                                                                                                              activeViewMode: NbCalendarViewMode;
                                                                                                                                                                                                                                                                                                                                                                                              • Defines active view for calendar.

                                                                                                                                                                                                                                                                                                                                                                                              property boundingMonth

                                                                                                                                                                                                                                                                                                                                                                                              boundingMonth: boolean;
                                                                                                                                                                                                                                                                                                                                                                                              • Defines if we should render previous and next months in the current month view.

                                                                                                                                                                                                                                                                                                                                                                                              property date

                                                                                                                                                                                                                                                                                                                                                                                              date: {};
                                                                                                                                                                                                                                                                                                                                                                                              • Value which will be rendered as selected.

                                                                                                                                                                                                                                                                                                                                                                                              property dateChange

                                                                                                                                                                                                                                                                                                                                                                                              dateChange: any;
                                                                                                                                                                                                                                                                                                                                                                                              • Emits date when selected.

                                                                                                                                                                                                                                                                                                                                                                                              property dateService

                                                                                                                                                                                                                                                                                                                                                                                              protected dateService: NbDateService<D>;

                                                                                                                                                                                                                                                                                                                                                                                                property dayCellComponent

                                                                                                                                                                                                                                                                                                                                                                                                dayCellComponent: any;
                                                                                                                                                                                                                                                                                                                                                                                                • Custom day cell component. Have to implement NbCalendarCell interface.

                                                                                                                                                                                                                                                                                                                                                                                                property filter

                                                                                                                                                                                                                                                                                                                                                                                                filter: (D: any) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                • Predicate that decides which cells will be disabled.

                                                                                                                                                                                                                                                                                                                                                                                                property large

                                                                                                                                                                                                                                                                                                                                                                                                readonly large: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                  property max

                                                                                                                                                                                                                                                                                                                                                                                                  max: {};
                                                                                                                                                                                                                                                                                                                                                                                                  • Maximum available date for selection.

                                                                                                                                                                                                                                                                                                                                                                                                  property min

                                                                                                                                                                                                                                                                                                                                                                                                  min: {};
                                                                                                                                                                                                                                                                                                                                                                                                  • Minimum available date for selection.

                                                                                                                                                                                                                                                                                                                                                                                                  property monthCellComponent

                                                                                                                                                                                                                                                                                                                                                                                                  monthCellComponent: any;
                                                                                                                                                                                                                                                                                                                                                                                                  • Custom month cell component. Have to implement NbCalendarCell interface.

                                                                                                                                                                                                                                                                                                                                                                                                  property ngAcceptInputType_activeViewMode

                                                                                                                                                                                                                                                                                                                                                                                                  static ngAcceptInputType_activeViewMode: NbCalendarViewModeValues;

                                                                                                                                                                                                                                                                                                                                                                                                    property ngAcceptInputType_showWeekNumber

                                                                                                                                                                                                                                                                                                                                                                                                    static ngAcceptInputType_showWeekNumber: NbBooleanInput;

                                                                                                                                                                                                                                                                                                                                                                                                      property ngAcceptInputType_size

                                                                                                                                                                                                                                                                                                                                                                                                      static ngAcceptInputType_size: NbCalendarSizeValues;

                                                                                                                                                                                                                                                                                                                                                                                                        property showNavigation

                                                                                                                                                                                                                                                                                                                                                                                                        showNavigation: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                        • Determines whether we should show calendar navigation or not.

                                                                                                                                                                                                                                                                                                                                                                                                        property showWeekNumber

                                                                                                                                                                                                                                                                                                                                                                                                        showWeekNumber: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                        • Determines should we show week numbers column. False by default.

                                                                                                                                                                                                                                                                                                                                                                                                        property size

                                                                                                                                                                                                                                                                                                                                                                                                        size: NbCalendarSize;
                                                                                                                                                                                                                                                                                                                                                                                                        • Size of the calendar and entire components. Can be 'medium' which is default or 'large'.

                                                                                                                                                                                                                                                                                                                                                                                                        property ViewMode

                                                                                                                                                                                                                                                                                                                                                                                                        ViewMode: typeof NbCalendarViewMode;

                                                                                                                                                                                                                                                                                                                                                                                                          property visibleDate

                                                                                                                                                                                                                                                                                                                                                                                                          visibleDate: {};

                                                                                                                                                                                                                                                                                                                                                                                                            property weekNumberSymbol

                                                                                                                                                                                                                                                                                                                                                                                                            weekNumberSymbol: string;
                                                                                                                                                                                                                                                                                                                                                                                                            • Sets symbol used as a header for week numbers column

                                                                                                                                                                                                                                                                                                                                                                                                            property yearCellComponent

                                                                                                                                                                                                                                                                                                                                                                                                            yearCellComponent: any;
                                                                                                                                                                                                                                                                                                                                                                                                            • Custom year cell component. Have to implement NbCalendarCell interface.

                                                                                                                                                                                                                                                                                                                                                                                                            • <