@nebular/theme

  • Version 9.0.2
  • Published
  • 12 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: InjectionToken<NbJSThemeOptions[]>;

                    variable NB_BUTTON_GROUP

                    const NB_BUTTON_GROUP: InjectionToken<NbButtonGroupComponent>;

                      variable NB_COALESCED_STYLE_SCHEDULER

                      const NB_COALESCED_STYLE_SCHEDULER: any;

                        variable NB_DATE_ADAPTER

                        const NB_DATE_ADAPTER: InjectionToken<NbDatepickerAdapter<any>>;

                          variable NB_DATE_SERVICE_OPTIONS

                          const NB_DATE_SERVICE_OPTIONS: InjectionToken<unknown>;

                            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: InjectionToken<NbDialogConfig<any>>;

                                  variable NB_DOCUMENT

                                  const NB_DOCUMENT: InjectionToken<Document>;

                                    variable NB_JS_THEMES

                                    const NB_JS_THEMES: InjectionToken<NbJSThemeOptions[]>;

                                      variable NB_LAYOUT_DIRECTION

                                      const NB_LAYOUT_DIRECTION: InjectionToken<NbLayoutDirection>;
                                      • Layout direction setting injection token.

                                      variable NB_MEDIA_BREAKPOINTS

                                      const NB_MEDIA_BREAKPOINTS: InjectionToken<NbMediaBreakpoint[]>;

                                        variable NB_ROW_DOUBLE_CLICK_DELAY

                                        const NB_ROW_DOUBLE_CLICK_DELAY: number;

                                          variable NB_SELECT_INJECTION_TOKEN

                                          const NB_SELECT_INJECTION_TOKEN: InjectionToken<unknown>;

                                            variable NB_SORT_HEADER_COLUMN_DEF

                                            const NB_SORT_HEADER_COLUMN_DEF: InjectionToken<unknown>;

                                              variable NB_STEPPER

                                              const NB_STEPPER: InjectionToken<unknown>;

                                                variable NB_TABLE_PROVIDERS

                                                const NB_TABLE_PROVIDERS: Provider[];

                                                  variable NB_TABLE_TEMPLATE

                                                  const NB_TABLE_TEMPLATE: string;

                                                    variable NB_THEME_OPTIONS

                                                    const NB_THEME_OPTIONS: InjectionToken<NbThemeOptions>;

                                                      variable NB_TIME_PICKER_CONFIG

                                                      const NB_TIME_PICKER_CONFIG: InjectionToken<unknown>;

                                                        variable NB_TOASTR_CONFIG

                                                        const NB_TOASTR_CONFIG: InjectionToken<NbToastrConfig>;

                                                          variable NB_TREE_GRID

                                                          const NB_TREE_GRID: InjectionToken<unknown>;

                                                            variable NB_VIEW_REPEATER_STRATEGY

                                                            const NB_VIEW_REPEATER_STRATEGY: any;

                                                              variable NB_WINDOW

                                                              const NB_WINDOW: InjectionToken<Window>;
                                                              • We're providing browser apis with tokens to improve testing capabilities.

                                                              variable NB_WINDOW_CONFIG

                                                              const NB_WINDOW_CONFIG: InjectionToken<NbWindowConfig>;

                                                                variable NB_WINDOW_CONTENT

                                                                const NB_WINDOW_CONTENT: InjectionToken<any>;

                                                                  variable NB_WINDOW_CONTEXT

                                                                  const NB_WINDOW_CONTEXT: InjectionToken<Object>;

                                                                    variable NB_WINDOW_DEFAULT_BUTTONS_CONFIG

                                                                    const NB_WINDOW_DEFAULT_BUTTONS_CONFIG: NbWindowControlButtonsConfig;

                                                                      Functions

                                                                      function createContainer

                                                                      createContainer: <T>(
                                                                      ref: OverlayRef,
                                                                      container: ComponentType<T>,
                                                                      context: Object,
                                                                      componentFactoryResolver?: ComponentFactoryResolver
                                                                      ) => ComponentRef<T>;

                                                                        function nbSelectFormFieldControlConfigFactory

                                                                        nbSelectFormFieldControlConfigFactory: () => NbFormFieldControlConfig;

                                                                          function patch

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

                                                                            function windowFactory

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

                                                                              Classes

                                                                              class NbA11yModule

                                                                              class NbA11yModule {}

                                                                                property ɵfac

                                                                                static ɵfac: i0.ɵɵFactoryDeclaration<NbA11yModule, never>;

                                                                                  property ɵinj

                                                                                  static ɵinj: i0.ɵɵInjectorDeclaration<NbA11yModule>;

                                                                                    property ɵmod

                                                                                    static ɵmod: i0.ɵɵNgModuleDeclaration<NbA11yModule, never, never, never>;

                                                                                      method forRoot

                                                                                      static forRoot: () => ModuleWithProviders<NbA11yModule>;

                                                                                        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: Subject<boolean>;

                                                                                            property ɵcmp

                                                                                            static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                            NbAccordionComponent,
                                                                                            'nb-accordion',
                                                                                            never,
                                                                                            { multi: 'multi' },
                                                                                            {},
                                                                                            never,
                                                                                            ['nb-accordion-item']
                                                                                            >;

                                                                                              property ɵfac

                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<NbAccordionComponent, never>;

                                                                                                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: ChangeDetectorRef);

                                                                                                  property ɵcmp

                                                                                                  static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                  NbAccordionItemBodyComponent,
                                                                                                  'nb-accordion-item-body',
                                                                                                  never,
                                                                                                  {},
                                                                                                  {},
                                                                                                  never,
                                                                                                  ['*']
                                                                                                  >;

                                                                                                    property ɵfac

                                                                                                    static ɵfac: i0.ɵɵFactoryDeclaration<
                                                                                                    NbAccordionItemBodyComponent,
                                                                                                    [{ host: true }, null]
                                                                                                    >;

                                                                                                      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: ChangeDetectorRef);

                                                                                                              property accordionItemInvalidate

                                                                                                              accordionItemInvalidate: Subject<boolean>;

                                                                                                                property collapsed

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

                                                                                                                property collapsedChange

                                                                                                                collapsedChange: EventEmitter<boolean>;
                                                                                                                • 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;

                                                                                                                      property ɵcmp

                                                                                                                      static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                      NbAccordionItemComponent,
                                                                                                                      'nb-accordion-item',
                                                                                                                      never,
                                                                                                                      { collapsed: 'collapsed'; expanded: 'expanded'; disabled: 'disabled' },
                                                                                                                      { collapsedChange: 'collapsedChange' },
                                                                                                                      never,
                                                                                                                      ['nb-accordion-item-header', 'nb-accordion-item-body']
                                                                                                                      >;

                                                                                                                        property ɵfac

                                                                                                                        static ɵfac: i0.ɵɵFactoryDeclaration<
                                                                                                                        NbAccordionItemComponent,
                                                                                                                        [{ host: true }, null]
                                                                                                                        >;

                                                                                                                          method close

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

                                                                                                                          method ngOnChanges

                                                                                                                          ngOnChanges: (changes: SimpleChanges) => 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: ChangeDetectorRef);

                                                                                                                                  property disabled

                                                                                                                                  readonly disabled: boolean;

                                                                                                                                    property expanded

                                                                                                                                    readonly expanded: boolean;

                                                                                                                                      property isCollapsed

                                                                                                                                      readonly isCollapsed: boolean;

                                                                                                                                        property ɵcmp

                                                                                                                                        static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                        NbAccordionItemHeaderComponent,
                                                                                                                                        'nb-accordion-item-header',
                                                                                                                                        never,
                                                                                                                                        {},
                                                                                                                                        {},
                                                                                                                                        never,
                                                                                                                                        ['nb-accordion-item-title', 'nb-accordion-item-description', '*']
                                                                                                                                        >;

                                                                                                                                          property ɵfac

                                                                                                                                          static ɵfac: i0.ɵɵFactoryDeclaration<
                                                                                                                                          NbAccordionItemHeaderComponent,
                                                                                                                                          [{ host: true }, null]
                                                                                                                                          >;

                                                                                                                                            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 {}

                                                                                                                                                        property ɵfac

                                                                                                                                                        static ɵfac: i0.ɵɵFactoryDeclaration<NbAccordionModule, never>;

                                                                                                                                                          property ɵinj

                                                                                                                                                          static ɵinj: i0.ɵɵInjectorDeclaration<NbAccordionModule>;

                                                                                                                                                            property ɵmod

                                                                                                                                                            static ɵmod: i0.ɵɵNgModuleDeclaration<
                                                                                                                                                            NbAccordionModule,
                                                                                                                                                            [
                                                                                                                                                            typeof i1.NbAccordionComponent,
                                                                                                                                                            typeof i2.NbAccordionItemComponent,
                                                                                                                                                            typeof i3.NbAccordionItemHeaderComponent,
                                                                                                                                                            typeof i4.NbAccordionItemBodyComponent
                                                                                                                                                            ],
                                                                                                                                                            [any, typeof i6.NbIconModule],
                                                                                                                                                            [
                                                                                                                                                            typeof i1.NbAccordionComponent,
                                                                                                                                                            typeof i2.NbAccordionItemComponent,
                                                                                                                                                            typeof i3.NbAccordionItemHeaderComponent,
                                                                                                                                                            typeof i4.NbAccordionItemBodyComponent
                                                                                                                                                            ]
                                                                                                                                                            >;

                                                                                                                                                              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 ɵcmp

                                                                                                                                                                  static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                  NbActionComponent,
                                                                                                                                                                  'nb-action',
                                                                                                                                                                  never,
                                                                                                                                                                  {
                                                                                                                                                                  link: 'link';
                                                                                                                                                                  href: 'href';
                                                                                                                                                                  title: 'title';
                                                                                                                                                                  icon: 'icon';
                                                                                                                                                                  disabled: 'disabled';
                                                                                                                                                                  badgeDot: 'badgeDot';
                                                                                                                                                                  badgeText: 'badgeText';
                                                                                                                                                                  badgeStatus: 'badgeStatus';
                                                                                                                                                                  badgePosition: 'badgePosition';
                                                                                                                                                                  },
                                                                                                                                                                  {},
                                                                                                                                                                  never,
                                                                                                                                                                  ['*']
                                                                                                                                                                  >;

                                                                                                                                                                    property ɵfac

                                                                                                                                                                    static ɵfac: i0.ɵɵFactoryDeclaration<NbActionComponent, never>;

                                                                                                                                                                      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 ɵcmp

                                                                                                                                                                              static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                              NbActionsComponent,
                                                                                                                                                                              'nb-actions',
                                                                                                                                                                              never,
                                                                                                                                                                              { size: 'size'; fullWidth: 'fullWidth' },
                                                                                                                                                                              {},
                                                                                                                                                                              never,
                                                                                                                                                                              ['nb-action']
                                                                                                                                                                              >;

                                                                                                                                                                                property ɵfac

                                                                                                                                                                                static ɵfac: i0.ɵɵFactoryDeclaration<NbActionsComponent, never>;

                                                                                                                                                                                  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 {}

                                                                                                                                                                                        property ɵfac

                                                                                                                                                                                        static ɵfac: i0.ɵɵFactoryDeclaration<NbActionsModule, never>;

                                                                                                                                                                                          property ɵinj

                                                                                                                                                                                          static ɵinj: i0.ɵɵInjectorDeclaration<NbActionsModule>;

                                                                                                                                                                                            property ɵmod

                                                                                                                                                                                            static ɵmod: i0.ɵɵNgModuleDeclaration<
                                                                                                                                                                                            NbActionsModule,
                                                                                                                                                                                            [typeof i1.NbActionComponent, typeof i1.NbActionsComponent],
                                                                                                                                                                                            [typeof i2.NbSharedModule, typeof i3.NbBadgeModule, typeof i4.NbIconModule],
                                                                                                                                                                                            [typeof i1.NbActionComponent, typeof i1.NbActionsComponent]
                                                                                                                                                                                            >;

                                                                                                                                                                                              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: ConnectedPosition;
                                                                                                                                                                                              }[];

                                                                                                                                                                                                property positionChange

                                                                                                                                                                                                readonly positionChange: Observable<NbPosition>;

                                                                                                                                                                                                  method adjustment

                                                                                                                                                                                                  adjustment: (adjustment: NbAdjustment) => this;

                                                                                                                                                                                                    method apply

                                                                                                                                                                                                    apply: () => void;

                                                                                                                                                                                                      method applyPositions

                                                                                                                                                                                                      protected applyPositions: () => void;

                                                                                                                                                                                                        method attach

                                                                                                                                                                                                        attach: (overlayRef: OverlayRef) => void;

                                                                                                                                                                                                          method createPositions

                                                                                                                                                                                                          protected createPositions: () => NbPosition[];

                                                                                                                                                                                                            method direction

                                                                                                                                                                                                            direction: (direction: NbLayoutDirection) => this;

                                                                                                                                                                                                              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: EventEmitter<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 ɵcmp

                                                                                                                                                                                                                                                            static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                                                                                                            NbAlertComponent,
                                                                                                                                                                                                                                                            'nb-alert',
                                                                                                                                                                                                                                                            never,
                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                            size: 'size';
                                                                                                                                                                                                                                                            status: 'status';
                                                                                                                                                                                                                                                            accent: 'accent';
                                                                                                                                                                                                                                                            outline: 'outline';
                                                                                                                                                                                                                                                            closable: 'closable';
                                                                                                                                                                                                                                                            },
                                                                                                                                                                                                                                                            { close: 'close' },
                                                                                                                                                                                                                                                            never,
                                                                                                                                                                                                                                                            ['*']
                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                              property ɵfac

                                                                                                                                                                                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<NbAlertComponent, never>;

                                                                                                                                                                                                                                                                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 {}

                                                                                                                                                                                                                                                                                          property ɵfac

                                                                                                                                                                                                                                                                                          static ɵfac: i0.ɵɵFactoryDeclaration<NbAlertModule, never>;

                                                                                                                                                                                                                                                                                            property ɵinj

                                                                                                                                                                                                                                                                                            static ɵinj: i0.ɵɵInjectorDeclaration<NbAlertModule>;

                                                                                                                                                                                                                                                                                              property ɵmod

                                                                                                                                                                                                                                                                                              static ɵmod: i0.ɵɵNgModuleDeclaration<
                                                                                                                                                                                                                                                                                              NbAlertModule,
                                                                                                                                                                                                                                                                                              [typeof i1.NbAlertComponent],
                                                                                                                                                                                                                                                                                              [typeof i2.NbSharedModule],
                                                                                                                                                                                                                                                                                              [typeof i1.NbAlertComponent]
                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                class NbAutocompleteComponent

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

                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                constructor(cd: ChangeDetectorRef);

                                                                                                                                                                                                                                                                                                  property activeFirst

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

                                                                                                                                                                                                                                                                                                  property cd

                                                                                                                                                                                                                                                                                                  protected cd: ChangeDetectorRef;

                                                                                                                                                                                                                                                                                                    property destroy$

                                                                                                                                                                                                                                                                                                    protected destroy$: Subject<void>;