@nebular/theme

  • Version 8.0.0
  • Published
  • 7.52 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_DEFAULT_TIMEPICKER_LOCALIZATION_CONFIG

                            const NB_DEFAULT_TIMEPICKER_LOCALIZATION_CONFIG: NbTimepickerLocalizationConfig;

                              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;

                                                                  variable NB_WINDOW_DEFAULT_BUTTONS_CONFIG

                                                                  const NB_WINDOW_DEFAULT_BUTTONS_CONFIG: NbWindowControlButtonsConfig;

                                                                    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