@ng-select/ng-select

  • Version 7.2.0
  • Published
  • 1.11 MB
  • 1 dependency
  • MIT license

Install

npm i @ng-select/ng-select
yarn add @ng-select/ng-select
pnpm add @ng-select/ng-select

Overview

Angular ng-select - All in One UI Select, Multiselect and Autocomplete

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable SELECTION_MODEL_FACTORY

const SELECTION_MODEL_FACTORY: any;

    Functions

    function ɵb

    ɵb: () => DefaultSelectionModel;

      Classes

      class NgSelectComponent

      class NgSelectComponent
      implements OnDestroy, OnChanges, AfterViewInit, ControlValueAccessor {}

        constructor

        constructor(
        classes: string,
        autoFocus: any,
        config: NgSelectConfig,
        newSelectionModel: SelectionModelFactory,
        _elementRef: any,
        _cd: any,
        _console: ConsoleService
        );

          property addEvent

          addEvent: any;

            property addTag

            addTag: boolean | AddTagFn;

              property addTagText

              addTagText: string;

                property appearance

                appearance: string;

                  property appendTo

                  appendTo: string;

                    property bindLabel

                    bindLabel: string;

                      property bindValue

                      bindValue: string;

                        property blurEvent

                        blurEvent: any;

                          property bufferAmount

                          bufferAmount: number;

                            property changeEvent

                            changeEvent: any;

                              property classes

                              classes: string;

                                property clearable

                                clearable: boolean;

                                  property clearAllText

                                  clearAllText: string;

                                    property clearEvent

                                    clearEvent: any;

                                      property clearItem

                                      clearItem: (item: any) => void;

                                        property clearOnBackspace

                                        clearOnBackspace: boolean;

                                          property clearSearchOnAdd

                                          clearSearchOnAdd: boolean;

                                            property closeEvent

                                            closeEvent: any;

                                              property closeOnSelect

                                              closeOnSelect: boolean;

                                                property compareWith

                                                compareWith: CompareWithFn;

                                                  property currentPanelPosition

                                                  readonly currentPanelPosition: DropdownPosition;

                                                    property disabled

                                                    readonly disabled: boolean;

                                                      property dropdownId

                                                      dropdownId: string;

                                                        property dropdownPanel

                                                        dropdownPanel: NgDropdownPanelComponent;

                                                          property dropdownPosition

                                                          dropdownPosition: DropdownPosition;

                                                            property editableSearchTerm

                                                            editableSearchTerm: boolean;

                                                              property element

                                                              element: HTMLElement;

                                                                property escapeHTML

                                                                escapeHTML: boolean;

                                                                  property filtered

                                                                  readonly filtered: boolean;

                                                                    property focused

                                                                    focused: boolean;

                                                                      property focusEvent

                                                                      focusEvent: any;

                                                                        property footerTemplate

                                                                        footerTemplate: any;

                                                                          property groupBy

                                                                          groupBy: string | Function;

                                                                            property groupValue

                                                                            groupValue: GroupValueFn;

                                                                              property hasValue

                                                                              readonly hasValue: boolean;

                                                                                property headerTemplate

                                                                                headerTemplate: any;

                                                                                  property hideSelected

                                                                                  hideSelected: boolean;

                                                                                    property inputAttrs

                                                                                    inputAttrs: { [key: string]: string };

                                                                                      property isOpen

                                                                                      isOpen: boolean;

                                                                                        property items

                                                                                        items: any[];

                                                                                          property itemsList

                                                                                          itemsList: ItemsList;

                                                                                            property keyDownFn

                                                                                            keyDownFn: (_: KeyboardEvent) => boolean;

                                                                                              property labelForId

                                                                                              labelForId: any;

                                                                                                property labelTemplate

                                                                                                labelTemplate: any;

                                                                                                  property loading

                                                                                                  loading: boolean;

                                                                                                    property loadingSpinnerTemplate

                                                                                                    loadingSpinnerTemplate: any;

                                                                                                      property loadingText

                                                                                                      loadingText: string;

                                                                                                        property loadingTextTemplate

                                                                                                        loadingTextTemplate: any;

                                                                                                          property markFirst

                                                                                                          markFirst: boolean;

                                                                                                            property maxSelectedItems

                                                                                                            maxSelectedItems: number;

                                                                                                              property minTermLength

                                                                                                              minTermLength: number;

                                                                                                                property multiLabelTemplate

                                                                                                                multiLabelTemplate: any;

                                                                                                                  property multiple

                                                                                                                  multiple: boolean;

                                                                                                                    property ngOptions

                                                                                                                    ngOptions: any;

                                                                                                                      property notFoundTemplate

                                                                                                                      notFoundTemplate: any;

                                                                                                                        property notFoundText

                                                                                                                        notFoundText: string;

                                                                                                                          property openEvent

                                                                                                                          openEvent: any;

                                                                                                                            property openOnEnter

                                                                                                                            openOnEnter: boolean;

                                                                                                                              property optgroupTemplate

                                                                                                                              optgroupTemplate: any;

                                                                                                                                property optionTemplate

                                                                                                                                optionTemplate: any;

                                                                                                                                  property placeholder

                                                                                                                                  placeholder: string;

                                                                                                                                    property readonly

                                                                                                                                    readonly: boolean;

                                                                                                                                      property removeEvent

                                                                                                                                      removeEvent: any;

                                                                                                                                        property scroll

                                                                                                                                        scroll: any;

                                                                                                                                          property scrollToEnd

                                                                                                                                          scrollToEnd: any;

                                                                                                                                            property searchable

                                                                                                                                            searchable: boolean;

                                                                                                                                              property searchEvent

                                                                                                                                              searchEvent: any;

                                                                                                                                                property searchFn

                                                                                                                                                searchFn: any;

                                                                                                                                                  property searchInput

                                                                                                                                                  searchInput: any;

                                                                                                                                                    property searchTerm

                                                                                                                                                    searchTerm: string;

                                                                                                                                                      property searchWhileComposing

                                                                                                                                                      searchWhileComposing: boolean;

                                                                                                                                                        property selectableGroup

                                                                                                                                                        selectableGroup: boolean;

                                                                                                                                                          property selectableGroupAsModel

                                                                                                                                                          selectableGroupAsModel: boolean;

                                                                                                                                                            property selectedItems

                                                                                                                                                            readonly selectedItems: NgOption[];

                                                                                                                                                              property selectedValues

                                                                                                                                                              readonly selectedValues: (string | Object)[];

                                                                                                                                                                property selectOnTab

                                                                                                                                                                selectOnTab: boolean;

                                                                                                                                                                  property showAddTag

                                                                                                                                                                  readonly showAddTag: boolean;

                                                                                                                                                                    property tabIndex

                                                                                                                                                                    tabIndex: number;

                                                                                                                                                                      property tagTemplate

                                                                                                                                                                      tagTemplate: any;

                                                                                                                                                                        property trackByFn

                                                                                                                                                                        trackByFn: any;

                                                                                                                                                                          property trackByOption

                                                                                                                                                                          trackByOption: (_: number, item: NgOption) => any;

                                                                                                                                                                            property typeahead

                                                                                                                                                                            typeahead: any;

                                                                                                                                                                              property typeToSearchTemplate

                                                                                                                                                                              typeToSearchTemplate: any;

                                                                                                                                                                                property typeToSearchText

                                                                                                                                                                                typeToSearchText: string;

                                                                                                                                                                                  property useDefaultClass

                                                                                                                                                                                  useDefaultClass: boolean;

                                                                                                                                                                                    property viewPortItems

                                                                                                                                                                                    viewPortItems: NgOption[];

                                                                                                                                                                                      property virtualScroll

                                                                                                                                                                                      virtualScroll: boolean;

                                                                                                                                                                                        method blur

                                                                                                                                                                                        blur: () => void;

                                                                                                                                                                                          method clearModel

                                                                                                                                                                                          clearModel: () => void;

                                                                                                                                                                                            method close

                                                                                                                                                                                            close: () => void;

                                                                                                                                                                                              method detectChanges

                                                                                                                                                                                              detectChanges: () => void;

                                                                                                                                                                                                method filter

                                                                                                                                                                                                filter: (term: string) => void;

                                                                                                                                                                                                  method focus

                                                                                                                                                                                                  focus: () => void;

                                                                                                                                                                                                    method handleArrowClick

                                                                                                                                                                                                    handleArrowClick: () => void;

                                                                                                                                                                                                      method handleClearClick

                                                                                                                                                                                                      handleClearClick: () => void;

                                                                                                                                                                                                        method handleKeyCode

                                                                                                                                                                                                        handleKeyCode: ($event: KeyboardEvent) => void;

                                                                                                                                                                                                          method handleKeyDown

                                                                                                                                                                                                          handleKeyDown: ($event: KeyboardEvent) => void;

                                                                                                                                                                                                            method handleMousedown

                                                                                                                                                                                                            handleMousedown: ($event: MouseEvent) => void;

                                                                                                                                                                                                              method ngAfterViewInit

                                                                                                                                                                                                              ngAfterViewInit: () => void;

                                                                                                                                                                                                                method ngOnChanges

                                                                                                                                                                                                                ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                  method ngOnDestroy

                                                                                                                                                                                                                  ngOnDestroy: () => void;

                                                                                                                                                                                                                    method ngOnInit

                                                                                                                                                                                                                    ngOnInit: () => void;

                                                                                                                                                                                                                      method onCompositionEnd

                                                                                                                                                                                                                      onCompositionEnd: (term: string) => void;

                                                                                                                                                                                                                        method onCompositionStart

                                                                                                                                                                                                                        onCompositionStart: () => void;

                                                                                                                                                                                                                          method onInputBlur

                                                                                                                                                                                                                          onInputBlur: ($event: any) => void;

                                                                                                                                                                                                                            method onInputFocus

                                                                                                                                                                                                                            onInputFocus: ($event: any) => void;

                                                                                                                                                                                                                              method onItemHover

                                                                                                                                                                                                                              onItemHover: (item: NgOption) => void;

                                                                                                                                                                                                                                method open

                                                                                                                                                                                                                                open: () => void;

                                                                                                                                                                                                                                  method registerOnChange

                                                                                                                                                                                                                                  registerOnChange: (fn: any) => void;

                                                                                                                                                                                                                                    method registerOnTouched

                                                                                                                                                                                                                                    registerOnTouched: (fn: any) => void;

                                                                                                                                                                                                                                      method select

                                                                                                                                                                                                                                      select: (item: NgOption) => void;

                                                                                                                                                                                                                                        method selectTag

                                                                                                                                                                                                                                        selectTag: () => void;

                                                                                                                                                                                                                                          method setDisabledState

                                                                                                                                                                                                                                          setDisabledState: (state: boolean) => void;

                                                                                                                                                                                                                                            method showClear

                                                                                                                                                                                                                                            showClear: () => boolean;

                                                                                                                                                                                                                                              method showNoItemsFound

                                                                                                                                                                                                                                              showNoItemsFound: () => boolean;

                                                                                                                                                                                                                                                method showTypeToSearch

                                                                                                                                                                                                                                                showTypeToSearch: () => boolean;

                                                                                                                                                                                                                                                  method toggle

                                                                                                                                                                                                                                                  toggle: () => void;

                                                                                                                                                                                                                                                    method toggleItem

                                                                                                                                                                                                                                                    toggleItem: (item: NgOption) => void;

                                                                                                                                                                                                                                                      method unselect

                                                                                                                                                                                                                                                      unselect: (item: NgOption) => void;

                                                                                                                                                                                                                                                        method writeValue

                                                                                                                                                                                                                                                        writeValue: (value: any | any[]) => void;

                                                                                                                                                                                                                                                          class NgSelectConfig

                                                                                                                                                                                                                                                          class NgSelectConfig {}

                                                                                                                                                                                                                                                            property addTagText

                                                                                                                                                                                                                                                            addTagText: string;

                                                                                                                                                                                                                                                              property appearance

                                                                                                                                                                                                                                                              appearance: string;

                                                                                                                                                                                                                                                                property appendTo

                                                                                                                                                                                                                                                                appendTo: string;

                                                                                                                                                                                                                                                                  property bindLabel

                                                                                                                                                                                                                                                                  bindLabel: string;

                                                                                                                                                                                                                                                                    property bindValue

                                                                                                                                                                                                                                                                    bindValue: string;

                                                                                                                                                                                                                                                                      property clearAllText

                                                                                                                                                                                                                                                                      clearAllText: string;

                                                                                                                                                                                                                                                                        property disableVirtualScroll

                                                                                                                                                                                                                                                                        disableVirtualScroll: boolean;

                                                                                                                                                                                                                                                                          property loadingText

                                                                                                                                                                                                                                                                          loadingText: string;

                                                                                                                                                                                                                                                                            property notFoundText

                                                                                                                                                                                                                                                                            notFoundText: string;

                                                                                                                                                                                                                                                                              property openOnEnter

                                                                                                                                                                                                                                                                              openOnEnter: boolean;

                                                                                                                                                                                                                                                                                property placeholder

                                                                                                                                                                                                                                                                                placeholder: string;

                                                                                                                                                                                                                                                                                  property typeToSearchText

                                                                                                                                                                                                                                                                                  typeToSearchText: string;

                                                                                                                                                                                                                                                                                    class NgSelectModule

                                                                                                                                                                                                                                                                                    class NgSelectModule {}

                                                                                                                                                                                                                                                                                      class ɵc

                                                                                                                                                                                                                                                                                      class DefaultSelectionModel implements SelectionModel {}

                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                        readonly value: NgOption[];

                                                                                                                                                                                                                                                                                          method clear

                                                                                                                                                                                                                                                                                          clear: (keepDisabled: boolean) => void;

                                                                                                                                                                                                                                                                                            method select

                                                                                                                                                                                                                                                                                            select: (item: NgOption, multiple: boolean, groupAsModel: boolean) => void;

                                                                                                                                                                                                                                                                                              method unselect

                                                                                                                                                                                                                                                                                              unselect: (item: NgOption, multiple: boolean) => void;

                                                                                                                                                                                                                                                                                                class ɵd

                                                                                                                                                                                                                                                                                                class NgDropdownPanelService {}

                                                                                                                                                                                                                                                                                                  property dimensions

                                                                                                                                                                                                                                                                                                  readonly dimensions: PanelDimensions;

                                                                                                                                                                                                                                                                                                    method calculateItems

                                                                                                                                                                                                                                                                                                    calculateItems: (
                                                                                                                                                                                                                                                                                                    scrollPos: number,
                                                                                                                                                                                                                                                                                                    itemsLength: number,
                                                                                                                                                                                                                                                                                                    buffer: number
                                                                                                                                                                                                                                                                                                    ) => ItemsRangeResult;

                                                                                                                                                                                                                                                                                                      method getScrollTo

                                                                                                                                                                                                                                                                                                      getScrollTo: (itemTop: number, itemHeight: number, lastScroll: number) => number;

                                                                                                                                                                                                                                                                                                        method setDimensions

                                                                                                                                                                                                                                                                                                        setDimensions: (itemHeight: number, panelHeight: number) => void;

                                                                                                                                                                                                                                                                                                          class ɵe

                                                                                                                                                                                                                                                                                                          class NgItemLabelDirective implements OnChanges {}

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor(element: any);

                                                                                                                                                                                                                                                                                                              property escape

                                                                                                                                                                                                                                                                                                              escape: boolean;

                                                                                                                                                                                                                                                                                                                property ngItemLabel

                                                                                                                                                                                                                                                                                                                ngItemLabel: string;

                                                                                                                                                                                                                                                                                                                  method ngOnChanges

                                                                                                                                                                                                                                                                                                                  ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                                                                                                                    class ɵf

                                                                                                                                                                                                                                                                                                                    class NgOptionTemplateDirective {}

                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                      constructor(template: any);

                                                                                                                                                                                                                                                                                                                        property template

                                                                                                                                                                                                                                                                                                                        template: any;

                                                                                                                                                                                                                                                                                                                          class ɵg

                                                                                                                                                                                                                                                                                                                          class NgOptgroupTemplateDirective {}

                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                            constructor(template: any);

                                                                                                                                                                                                                                                                                                                              property template

                                                                                                                                                                                                                                                                                                                              template: any;

                                                                                                                                                                                                                                                                                                                                class ɵh

                                                                                                                                                                                                                                                                                                                                class NgLabelTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                  constructor(template: any);

                                                                                                                                                                                                                                                                                                                                    property template

                                                                                                                                                                                                                                                                                                                                    template: any;

                                                                                                                                                                                                                                                                                                                                      class ɵi

                                                                                                                                                                                                                                                                                                                                      class NgMultiLabelTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                        constructor(template: any);

                                                                                                                                                                                                                                                                                                                                          property template

                                                                                                                                                                                                                                                                                                                                          template: any;

                                                                                                                                                                                                                                                                                                                                            class ɵj

                                                                                                                                                                                                                                                                                                                                            class NgHeaderTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                              constructor(template: any);

                                                                                                                                                                                                                                                                                                                                                property template

                                                                                                                                                                                                                                                                                                                                                template: any;

                                                                                                                                                                                                                                                                                                                                                  class ɵk

                                                                                                                                                                                                                                                                                                                                                  class NgFooterTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                    constructor(template: any);

                                                                                                                                                                                                                                                                                                                                                      property template

                                                                                                                                                                                                                                                                                                                                                      template: any;

                                                                                                                                                                                                                                                                                                                                                        class ɵl

                                                                                                                                                                                                                                                                                                                                                        class NgNotFoundTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                          constructor(template: any);

                                                                                                                                                                                                                                                                                                                                                            property template

                                                                                                                                                                                                                                                                                                                                                            template: any;

                                                                                                                                                                                                                                                                                                                                                              class ɵm

                                                                                                                                                                                                                                                                                                                                                              class NgTypeToSearchTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                constructor(template: any);

                                                                                                                                                                                                                                                                                                                                                                  property template

                                                                                                                                                                                                                                                                                                                                                                  template: any;

                                                                                                                                                                                                                                                                                                                                                                    class ɵn

                                                                                                                                                                                                                                                                                                                                                                    class NgLoadingTextTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                      constructor(template: any);

                                                                                                                                                                                                                                                                                                                                                                        property template

                                                                                                                                                                                                                                                                                                                                                                        template: any;

                                                                                                                                                                                                                                                                                                                                                                          class ɵo

                                                                                                                                                                                                                                                                                                                                                                          class NgTagTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                            constructor(template: any);

                                                                                                                                                                                                                                                                                                                                                                              property template

                                                                                                                                                                                                                                                                                                                                                                              template: any;

                                                                                                                                                                                                                                                                                                                                                                                class ɵp

                                                                                                                                                                                                                                                                                                                                                                                class NgLoadingSpinnerTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                  constructor(template: any);

                                                                                                                                                                                                                                                                                                                                                                                    property template

                                                                                                                                                                                                                                                                                                                                                                                    template: any;

                                                                                                                                                                                                                                                                                                                                                                                      class ɵq

                                                                                                                                                                                                                                                                                                                                                                                      class NgDropdownPanelComponent implements OnInit, OnChanges, OnDestroy {}

                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                                                        _renderer: any,
                                                                                                                                                                                                                                                                                                                                                                                        _zone: any,
                                                                                                                                                                                                                                                                                                                                                                                        _panelService: NgDropdownPanelService,
                                                                                                                                                                                                                                                                                                                                                                                        _elementRef: any,
                                                                                                                                                                                                                                                                                                                                                                                        _document: any
                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                          property appendTo

                                                                                                                                                                                                                                                                                                                                                                                          appendTo: string;

                                                                                                                                                                                                                                                                                                                                                                                            property bufferAmount

                                                                                                                                                                                                                                                                                                                                                                                            bufferAmount: any;

                                                                                                                                                                                                                                                                                                                                                                                              property contentElementRef

                                                                                                                                                                                                                                                                                                                                                                                              contentElementRef: any;

                                                                                                                                                                                                                                                                                                                                                                                                property currentPosition

                                                                                                                                                                                                                                                                                                                                                                                                readonly currentPosition: DropdownPosition;

                                                                                                                                                                                                                                                                                                                                                                                                  property filterValue

                                                                                                                                                                                                                                                                                                                                                                                                  filterValue: string;

                                                                                                                                                                                                                                                                                                                                                                                                    property footerTemplate

                                                                                                                                                                                                                                                                                                                                                                                                    footerTemplate: any;

                                                                                                                                                                                                                                                                                                                                                                                                      property headerTemplate

                                                                                                                                                                                                                                                                                                                                                                                                      headerTemplate: any;

                                                                                                                                                                                                                                                                                                                                                                                                        property items

                                                                                                                                                                                                                                                                                                                                                                                                        items: NgOption[];

                                                                                                                                                                                                                                                                                                                                                                                                          property markedItem

                                                                                                                                                                                                                                                                                                                                                                                                          markedItem: NgOption;

                                                                                                                                                                                                                                                                                                                                                                                                            property outsideClick

                                                                                                                                                                                                                                                                                                                                                                                                            outsideClick: any;

                                                                                                                                                                                                                                                                                                                                                                                                              property paddingElementRef

                                                                                                                                                                                                                                                                                                                                                                                                              paddingElementRef: any;

                                                                                                                                                                                                                                                                                                                                                                                                                property position

                                                                                                                                                                                                                                                                                                                                                                                                                position: DropdownPosition;

                                                                                                                                                                                                                                                                                                                                                                                                                  property scroll

                                                                                                                                                                                                                                                                                                                                                                                                                  scroll: any;

                                                                                                                                                                                                                                                                                                                                                                                                                    property scrollElementRef

                                                                                                                                                                                                                                                                                                                                                                                                                    scrollElementRef: any;

                                                                                                                                                                                                                                                                                                                                                                                                                      property scrollToEnd

                                                                                                                                                                                                                                                                                                                                                                                                                      scrollToEnd: any;

                                                                                                                                                                                                                                                                                                                                                                                                                        property update

                                                                                                                                                                                                                                                                                                                                                                                                                        update: any;

                                                                                                                                                                                                                                                                                                                                                                                                                          property virtualScroll

                                                                                                                                                                                                                                                                                                                                                                                                                          virtualScroll: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                            method adjustPosition

                                                                                                                                                                                                                                                                                                                                                                                                                            adjustPosition: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              method ngOnChanges

                                                                                                                                                                                                                                                                                                                                                                                                                              ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                method ngOnDestroy

                                                                                                                                                                                                                                                                                                                                                                                                                                ngOnDestroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method ngOnInit

                                                                                                                                                                                                                                                                                                                                                                                                                                  ngOnInit: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method scrollTo

                                                                                                                                                                                                                                                                                                                                                                                                                                    scrollTo: (option: NgOption, startFromOption?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method scrollToTag

                                                                                                                                                                                                                                                                                                                                                                                                                                      scrollToTag: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        class ɵr

                                                                                                                                                                                                                                                                                                                                                                                                                                        class NgOptionComponent implements OnChanges, AfterViewChecked, OnDestroy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(elementRef: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                            property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                            disabled: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property elementRef

                                                                                                                                                                                                                                                                                                                                                                                                                                              elementRef: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly label: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property stateChange$

                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly stateChange$: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ngAfterViewChecked

                                                                                                                                                                                                                                                                                                                                                                                                                                                      ngAfterViewChecked: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method ngOnChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                        ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ngOnDestroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                          ngOnDestroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ɵs

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ConsoleService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method warn

                                                                                                                                                                                                                                                                                                                                                                                                                                                              warn: (message: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NgOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NgOption {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  children?: NgOption[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property htmlId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      htmlId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property marked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            marked?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parent?: NgOption;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property selected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selected?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value?: string | Object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [name: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SelectionModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SelectionModel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: NgOption[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          clear: (keepDisabled: boolean) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            select: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            item: NgOption,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            multiple: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            selectableGroupAsModel: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method unselect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unselect: (item: NgOption, multiple: boolean) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DropdownPosition = 'bottom' | 'top' | 'auto';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ɵa

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SelectionModelFactory = () => SelectionModel;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package Files (11)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Peer Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Badge

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

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

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