@ng-select/ng-select

  • Version 8.1.1
  • Published
  • 1.13 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

Classes

Interfaces

Type Aliases

Variables

variable SELECTION_MODEL_FACTORY

const SELECTION_MODEL_FACTORY: any;

    Classes

    class NgFooterTemplateDirective

    class NgFooterTemplateDirective {}

      constructor

      constructor(template: any);

        property ɵdir

        static ɵdir: any;

          property ɵfac

          static ɵfac: any;

            property template

            template: any;

              class NgHeaderTemplateDirective

              class NgHeaderTemplateDirective {}

                constructor

                constructor(template: any);

                  property ɵdir

                  static ɵdir: any;

                    property ɵfac

                    static ɵfac: any;

                      property template

                      template: any;

                        class NgItemLabelDirective

                        class NgItemLabelDirective implements OnChanges {}

                          constructor

                          constructor(element: any);

                            property escape

                            escape: boolean;

                              property ngItemLabel

                              ngItemLabel: string;

                                property ɵdir

                                static ɵdir: any;

                                  property ɵfac

                                  static ɵfac: any;

                                    method ngOnChanges

                                    ngOnChanges: (changes: any) => void;

                                      class NgLabelTemplateDirective

                                      class NgLabelTemplateDirective {}

                                        constructor

                                        constructor(template: any);

                                          property ɵdir

                                          static ɵdir: any;

                                            property ɵfac

                                            static ɵfac: any;

                                              property template

                                              template: any;

                                                class NgLoadingSpinnerTemplateDirective

                                                class NgLoadingSpinnerTemplateDirective {}

                                                  constructor

                                                  constructor(template: any);

                                                    property ɵdir

                                                    static ɵdir: any;

                                                      property ɵfac

                                                      static ɵfac: any;

                                                        property template

                                                        template: any;

                                                          class NgLoadingTextTemplateDirective

                                                          class NgLoadingTextTemplateDirective {}

                                                            constructor

                                                            constructor(template: any);

                                                              property ɵdir

                                                              static ɵdir: any;

                                                                property ɵfac

                                                                static ɵfac: any;

                                                                  property template

                                                                  template: any;

                                                                    class NgMultiLabelTemplateDirective

                                                                    class NgMultiLabelTemplateDirective {}

                                                                      constructor

                                                                      constructor(template: any);

                                                                        property ɵdir

                                                                        static ɵdir: any;

                                                                          property ɵfac

                                                                          static ɵfac: any;

                                                                            property template

                                                                            template: any;

                                                                              class NgNotFoundTemplateDirective

                                                                              class NgNotFoundTemplateDirective {}

                                                                                constructor

                                                                                constructor(template: any);

                                                                                  property ɵdir

                                                                                  static ɵdir: any;

                                                                                    property ɵfac

                                                                                    static ɵfac: any;

                                                                                      property template

                                                                                      template: any;

                                                                                        class NgOptgroupTemplateDirective

                                                                                        class NgOptgroupTemplateDirective {}

                                                                                          constructor

                                                                                          constructor(template: any);

                                                                                            property ɵdir

                                                                                            static ɵdir: any;

                                                                                              property ɵfac

                                                                                              static ɵfac: any;

                                                                                                property template

                                                                                                template: any;

                                                                                                  class NgOptionComponent

                                                                                                  class NgOptionComponent implements OnChanges, AfterViewChecked, OnDestroy {}

                                                                                                    constructor

                                                                                                    constructor(elementRef: any);

                                                                                                      property disabled

                                                                                                      disabled: any;

                                                                                                        property elementRef

                                                                                                        elementRef: any;

                                                                                                          property label

                                                                                                          readonly label: string;

                                                                                                            property ɵcmp

                                                                                                            static ɵcmp: any;

                                                                                                              property ɵfac

                                                                                                              static ɵfac: any;

                                                                                                                property stateChange$

                                                                                                                readonly stateChange$: any;

                                                                                                                  property value

                                                                                                                  value: any;

                                                                                                                    method ngAfterViewChecked

                                                                                                                    ngAfterViewChecked: () => void;

                                                                                                                      method ngOnChanges

                                                                                                                      ngOnChanges: (changes: any) => void;

                                                                                                                        method ngOnDestroy

                                                                                                                        ngOnDestroy: () => void;

                                                                                                                          class NgOptionTemplateDirective

                                                                                                                          class NgOptionTemplateDirective {}

                                                                                                                            constructor

                                                                                                                            constructor(template: any);

                                                                                                                              property ɵdir

                                                                                                                              static ɵdir: any;

                                                                                                                                property ɵfac

                                                                                                                                static ɵfac: any;

                                                                                                                                  property template

                                                                                                                                  template: any;

                                                                                                                                    class NgSelectComponent

                                                                                                                                    class NgSelectComponent
                                                                                                                                    implements OnDestroy, OnChanges, OnInit, 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 config

                                                                                                                                                                                config: NgSelectConfig;

                                                                                                                                                                                  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 | ((value: any) => any);

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

                                                                                                                                                                                                                                                                  static ɵcmp: any;

                                                                                                                                                                                                                                                                    property ɵfac

                                                                                                                                                                                                                                                                    static ɵfac: 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: any[];

                                                                                                                                                                                                                                                                                                    property selectOnTab

                                                                                                                                                                                                                                                                                                    selectOnTab: boolean;

                                                                                                                                                                                                                                                                                                      property showAddTag

                                                                                                                                                                                                                                                                                                      readonly showAddTag: boolean;

                                                                                                                                                                                                                                                                                                        property single

                                                                                                                                                                                                                                                                                                        readonly single: 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 clearSearchOnAdd

                                                                                                                                                                                                                                                                                                                                                                                                              clearSearchOnAdd: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                property disableVirtualScroll

                                                                                                                                                                                                                                                                                                                                                                                                                disableVirtualScroll: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                  property loadingText

                                                                                                                                                                                                                                                                                                                                                                                                                  loadingText: string;

                                                                                                                                                                                                                                                                                                                                                                                                                    property notFoundText

                                                                                                                                                                                                                                                                                                                                                                                                                    notFoundText: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property openOnEnter

                                                                                                                                                                                                                                                                                                                                                                                                                      openOnEnter: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        property ɵfac

                                                                                                                                                                                                                                                                                                                                                                                                                        static ɵfac: any;

                                                                                                                                                                                                                                                                                                                                                                                                                          property ɵprov

                                                                                                                                                                                                                                                                                                                                                                                                                          static ɵprov: any;

                                                                                                                                                                                                                                                                                                                                                                                                                            property placeholder

                                                                                                                                                                                                                                                                                                                                                                                                                            placeholder: string;

                                                                                                                                                                                                                                                                                                                                                                                                                              property typeToSearchText

                                                                                                                                                                                                                                                                                                                                                                                                                              typeToSearchText: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                class NgSelectModule

                                                                                                                                                                                                                                                                                                                                                                                                                                class NgSelectModule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  property ɵfac

                                                                                                                                                                                                                                                                                                                                                                                                                                  static ɵfac: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property ɵinj

                                                                                                                                                                                                                                                                                                                                                                                                                                    static ɵinj: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property ɵmod

                                                                                                                                                                                                                                                                                                                                                                                                                                      static ɵmod: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                        class NgTagTemplateDirective

                                                                                                                                                                                                                                                                                                                                                                                                                                        class NgTagTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(template: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                            property ɵdir

                                                                                                                                                                                                                                                                                                                                                                                                                                            static ɵdir: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property ɵfac

                                                                                                                                                                                                                                                                                                                                                                                                                                              static ɵfac: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property template

                                                                                                                                                                                                                                                                                                                                                                                                                                                template: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  class NgTypeToSearchTemplateDirective

                                                                                                                                                                                                                                                                                                                                                                                                                                                  class NgTypeToSearchTemplateDirective {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(template: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ɵdir

                                                                                                                                                                                                                                                                                                                                                                                                                                                      static ɵdir: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ɵfac

                                                                                                                                                                                                                                                                                                                                                                                                                                                        static ɵfac: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property template

                                                                                                                                                                                                                                                                                                                                                                                                                                                          template: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 | any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 = 'top' | 'right' | 'bottom' | 'left' | 'auto';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (8)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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>