novo-elements 11.3.1-next.3 → 12.0.0

package/elements/autocomplete/index.d.ts

@@ -1,2 +1,105 @@
-export * from './autocomplete.component';
-export * from './autocomplete.module';
+import * as i0 from '@angular/core';
+import { AfterContentInit, AfterViewInit, OnChanges, OnDestroy, QueryList, EventEmitter, ElementRef, ChangeDetectorRef, SimpleChanges } from '@angular/core';
+import * as i4 from 'novo-elements/elements/common';
+import { HasOverlayCtor, CanDisableCtor, CanDisable, NovoOptgroup, NovoOption, NovoOverlayTemplateComponent } from 'novo-elements/elements/common';
+import * as i5 from 'novo-elements/elements/field';
+import { NovoFieldControl, NovoFieldElement } from 'novo-elements/elements/field';
+import * as i2 from '@angular/common';
+import * as i3 from 'novo-elements/elements/button';
+import * as i6 from 'novo-elements/elements/chips';
+
+/** Event object that is emitted when an autocomplete option is selected. */
+declare class NovoOptionSelectedEvent {
+    /** Reference to the autocomplete panel that emitted the event. */
+    source: NovoAutocompleteElement;
+    /** Option that was selected. */
+    option: NovoOption;
+    constructor(
+    /** Reference to the autocomplete panel that emitted the event. */
+    source: NovoAutocompleteElement, 
+    /** Option that was selected. */
+    option: NovoOption);
+}
+declare class NovoAutocompleteBase {
+    constructor();
+}
+declare const NovoAutocompleteMixins: HasOverlayCtor & CanDisableCtor & typeof NovoAutocompleteBase;
+declare class NovoAutocompleteElement extends NovoAutocompleteMixins implements CanDisable, AfterContentInit, AfterViewInit, OnChanges, OnDestroy {
+    private _elementRef;
+    private cdr;
+    private _formField;
+    private _stateChanges;
+    private _activeOptionChanges;
+    private _selectedOptionChanges;
+    private _keyDownChanges;
+    /** Manages active item in option list based on key events. */
+    private _keyManager;
+    /** Old value of the native input. Used to work around issues with the `input` event on IE. */
+    private _previousValue;
+    optionGroups: QueryList<NovoOptgroup>;
+    options: QueryList<NovoOption>;
+    /** Event that is emitted whenever an option from the list is selected. */
+    readonly optionSelected: EventEmitter<NovoOptionSelectedEvent>;
+    /** Emits whenever an option is activated using the keyboard. */
+    readonly optionActivated: EventEmitter<NovoOptionSelectedEvent>;
+    /** Tabindex for the toggle. */
+    tabIndex: number | null;
+    /** Key to use to trigger autocomplete. used for textarea. */
+    triggerOn: (control: NovoFieldControl<any>) => boolean;
+    /** Function that maps an option's control value to its display value in the trigger. */
+    displayWith: ((value: any) => string) | null;
+    /** Screenreader label for the button. */
+    ariaLabel: string;
+    /** Whether the user should be allowed to select multiple options. */
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    private _multiple;
+    /** Whether the toggle button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    makeFirstItemActive: boolean;
+    /** Element for the panel containing the autocomplete options. */
+    overlay: NovoOverlayTemplateComponent;
+    element: ElementRef;
+    constructor(_elementRef: ElementRef, cdr: ChangeDetectorRef, defaultTabIndex: string, _formField: NovoFieldElement);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    checkPanel(): void;
+    private _setTriggerValue;
+    /**
+     * Clear any previous selected option and emit a selection change event for this option
+     */
+    private _clearPreviousSelectedOption;
+    /** Emits the `select` event. */
+    private _emitSelectEvent;
+    /**
+     * This method closes the panel, and if a value is specified, also sets the associated
+     * control to that value. It will also mark the control as dirty if this interaction
+     * stemmed from the user.
+     */
+    private _setValueAndClose;
+    private _watchSelectionEvents;
+    private _watchStateChanges;
+    /** The currently active option, coerced to MatOption type. */
+    get activeOption(): NovoOption | null;
+    _handleKeydown(event: KeyboardEvent): void;
+    private checkSelectedOptions;
+    /**
+     * Finds and selects and option based on its value.
+     * @returns Option that has the corresponding value.
+     */
+    private _selectValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoAutocompleteElement, [null, null, { attribute: "tabindex"; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoAutocompleteElement, "novo-autocomplete", ["novoAutocomplete"], { "tabIndex": { "alias": "tabIndex"; "required": false; }; "triggerOn": { "alias": "triggerOn"; "required": false; }; "displayWith": { "alias": "displayWith"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "makeFirstItemActive": { "alias": "makeFirstItemActive"; "required": false; }; }, { "optionSelected": "optionSelected"; "optionActivated": "optionActivated"; }, ["optionGroups", "options"], ["*"], false, never>;
+}
+
+declare class NovoAutoCompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoAutoCompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoAutoCompleteModule, [typeof NovoAutocompleteElement], [typeof i2.CommonModule, typeof i3.NovoButtonModule, typeof i4.NovoOverlayModule, typeof i4.NovoOptionModule, typeof i4.NovoCommonModule, typeof i5.NovoFieldModule, typeof i6.NovoChipsModule], [typeof NovoAutocompleteElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoAutoCompleteModule>;
+}
+
+export { NovoAutoCompleteModule, NovoAutocompleteElement, NovoOptionSelectedEvent };

package/elements/avatar/index.d.ts

@@ -1,3 +1,42 @@
-export * from './Avatar';
-export * from './Avatar.module';
-export * from './AvatarStack';
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, QueryList } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i3 from '@angular/common';
+
+declare class NovoAvatarElement implements OnInit {
+    private sanitizer;
+    source: any;
+    label: string;
+    theme: string;
+    image: string;
+    size: string;
+    shape: string;
+    color: string;
+    get hb_classBinding(): string[];
+    get background(): string;
+    src: any;
+    constructor(sanitizer: DomSanitizer);
+    ngOnInit(): any;
+    setPrefixedValue(elm: any, prop: any, value: any): any;
+    private _isValidURL;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoAvatarElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoAvatarElement, "novo-avatar", never, { "source": { "alias": "source"; "required": false; }; "label": { "alias": "label"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "image": { "alias": "image"; "required": false; }; "size": { "alias": "size"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NovoAvatarStackElement implements AfterViewInit {
+    total: number;
+    viewChildren: QueryList<NovoAvatarElement>;
+    showTotal: boolean;
+    remainingCount: number;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoAvatarStackElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoAvatarStackElement, "novo-avatar-stack", never, { "total": { "alias": "total"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class NovoAvatarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoAvatarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoAvatarModule, [typeof NovoAvatarElement, typeof NovoAvatarStackElement], [typeof i3.CommonModule], [typeof NovoAvatarElement, typeof NovoAvatarStackElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoAvatarModule>;
+}
+
+export { NovoAvatarElement, NovoAvatarModule, NovoAvatarStackElement };

package/elements/breadcrumbs/index.d.ts

@@ -1,6 +1,87 @@
-export * from './Breadcrumb';
-export * from './breadcrumb-item';
-export * from './Breadcrumb.module';
-export * from './Breadcrumb.service';
-export * from './Breadcrumb.tokens';
-export * from './Breadcrumb.types';
+import * as i0 from '@angular/core';
+import { TemplateRef, InjectionToken, OnInit, EventEmitter } from '@angular/core';
+import * as i4 from '@angular/router';
+import { Router } from '@angular/router';
+import * as i3 from '@angular/common';
+import * as i5 from 'novo-elements/elements/dropdown';
+import * as i6 from 'novo-elements/elements/search';
+import * as i7 from 'novo-elements/elements/button';
+import * as i8 from 'novo-elements/elements/icon';
+import * as i9 from 'novo-elements/elements/common';
+
+declare class BreadcrumbService {
+    private router;
+    constructor(router: Router);
+    navigateTo($event: any, item: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbService>;
+}
+
+interface MenuConfig {
+    name: string;
+    link: string;
+    linkType?: 'hrefLink' | 'routerLink';
+    target?: string;
+}
+interface SourceConfig {
+    title: string;
+    link?: string;
+    showMenu?: boolean;
+    isSearch?: boolean;
+    target?: string;
+    menuList?: Array<MenuConfig>;
+    customMenuTemplate?: TemplateRef<any>;
+    noNavigation?: boolean;
+    linkType?: 'hrefLink' | 'routerLink';
+}
+
+declare class BreadcrumbElement {
+    private breadcrumbService;
+    separatorIcon: TemplateRef<any>;
+    source: Array<SourceConfig>;
+    constructor(breadcrumbService: BreadcrumbService);
+    navigateTo($event: any, item: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbElement, "novo-breadcrumb", never, { "separatorIcon": { "alias": "separatorIcon"; "required": false; }; "source": { "alias": "source"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+/**
+ * Describes a parent component that manages a list of options.
+ * Contains properties that the options can inherit.
+ * @docs-private
+ */
+interface NovoBreadcrumbRef<T = any> {
+    separatorIcon: string;
+}
+/**
+ * Injection token used to provide the parent component to options.
+ */
+declare const NOVO_BREADCRUMB_REF: InjectionToken<NovoBreadcrumbRef<any>>;
+
+declare class BreadcrumbItemElement implements OnInit {
+    private breadcrumbService;
+    breadcrumbComponent: NovoBreadcrumbRef;
+    showMenu: boolean;
+    customMenuTemplate: TemplateRef<any>;
+    menuList: Array<MenuConfig>;
+    isSearch: boolean;
+    toggleEvent: EventEmitter<any>;
+    menuListDisplay: Array<MenuConfig>;
+    isOpen: boolean;
+    constructor(breadcrumbService: BreadcrumbService, breadcrumbComponent: NovoBreadcrumbRef);
+    ngOnInit(): void;
+    onToggle($event: any): void;
+    searchEvent($event: any): void;
+    navigateTo($event: any, item: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbItemElement, "novo-breadcrumb-item", never, { "showMenu": { "alias": "showMenu"; "required": false; }; "customMenuTemplate": { "alias": "customMenuTemplate"; "required": false; }; "menuList": { "alias": "menuList"; "required": false; }; "isSearch": { "alias": "isSearch"; "required": false; }; }, { "toggleEvent": "toggleEvent"; }, never, ["*"], false, never>;
+}
+
+declare class NovoBreadcrumbModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoBreadcrumbModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoBreadcrumbModule, [typeof BreadcrumbElement, typeof BreadcrumbItemElement], [typeof i3.CommonModule, typeof i4.RouterModule, typeof i5.NovoDropdownModule, typeof i6.NovoSearchBoxModule, typeof i7.NovoButtonModule, typeof i8.NovoIconModule, typeof i9.NovoOptionModule], [typeof BreadcrumbElement, typeof BreadcrumbItemElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoBreadcrumbModule>;
+}
+
+export { BreadcrumbElement, BreadcrumbItemElement, BreadcrumbService, NOVO_BREADCRUMB_REF, NovoBreadcrumbModule };
+export type { MenuConfig, NovoBreadcrumbRef, SourceConfig };

package/elements/button/index.d.ts

@@ -1,2 +1,65 @@
-export * from './Button';
-export * from './Button.module';
+import * as i0 from '@angular/core';
+import { OnChanges, ElementRef, Signal, SimpleChanges } from '@angular/core';
+import * as i2 from '@angular/common';
+
+declare class NovoButtonElement implements OnChanges {
+    element: ElementRef;
+    /**
+     * The text color of the button. Should be used for Icon buttons. see theme.
+     */
+    color: string;
+    /**
+     * The side of the button to display the icon.
+     */
+    side: string;
+    /**
+     * If a second icon is specified it will default to the opposite side as the primary icon.
+     */
+    secondSide: Signal<string>;
+    /**
+     * 	Sets the size of the button. One of: sm, lg
+     */
+    size: string;
+    /**
+     * The base styling to apply to the button.
+     */
+    theme: string;
+    /**
+     * Conditionally show a spinner over the top of a button.
+     */
+    loading: boolean;
+    /**
+     * Optionally display `bullhorn-icon` with the button along with the text.
+     */
+    set icon(icon: string);
+    get icon(): string;
+    /**
+     * A second icon can be specified, and it will take the opposite side of the primary icon.
+     */
+    set secondIcon(icon: string);
+    get secondIcon(): string;
+    leftSideIconClass: Signal<string>;
+    rightSideIconClass: Signal<string>;
+    /**
+     * Make the button non-interactive.
+     */
+    disabled: boolean;
+    disabledAttr: undefined | '';
+    private _icon;
+    private _secondIcon;
+    constructor(element: ElementRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    handleKeydown(event: KeyboardEvent): void;
+    /** Focuses the input. */
+    focus(options?: FocusOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoButtonElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoButtonElement, "novo-button,button[theme]", never, { "color": { "alias": "color"; "required": false; }; "side": { "alias": "side"; "required": false; }; "size": { "alias": "size"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "secondIcon": { "alias": "secondIcon"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class NovoButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoButtonModule, [typeof NovoButtonElement], [typeof i2.CommonModule], [typeof NovoButtonElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoButtonModule>;
+}
+
+export { NovoButtonElement, NovoButtonModule };

package/elements/calendar/index.d.ts

@@ -1,6 +1,200 @@
-export * from './calendar.component';
-export * from './Calendar.module';
-export * from './month-select/month-select.component';
-export * from './month-view/month-view.component';
-export * from './strategies';
-export * from './year-select/year-select.component';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, ElementRef, ChangeDetectorRef, InjectionToken, FactoryProvider } from '@angular/core';
+import { Day } from 'date-fns';
+import { NovoLabelService } from 'novo-elements/services';
+import { OverlayDate, DatePickerSelectModes, NovoDateSelectionStrategy, NovoMonthSelectEvent, NovoYearSelectEvent, NovoDateSelectEvent, DateLike, Day as Day$1 } from 'novo-elements/utils';
+import * as i5 from '@angular/common';
+import * as i6 from '@angular/forms';
+import * as i7 from 'novo-elements/elements/button';
+import * as i8 from 'novo-elements/pipes';
+import * as i9 from 'novo-elements/elements/icon';
+
+declare class NovoCalendarElement implements OnInit {
+    labels: NovoLabelService;
+    private element;
+    private cdr;
+    private _sanitizer;
+    minYear: string | number;
+    maxYear: string | number;
+    minDate: string | number;
+    maxDate: string | number;
+    activeView: string;
+    layout: string;
+    _selected: Date[];
+    get selected(): Date[];
+    set selected(value: Date[]);
+    selectedChange: EventEmitter<Date[]>;
+    preview: Date[];
+    previewChange: EventEmitter<Date[]>;
+    activeDateChange: EventEmitter<Date>;
+    overlays: OverlayDate[];
+    disabledDateMessage: string;
+    _activeDate: Date;
+    _mode: DatePickerSelectModes;
+    _numberOfMonths: number[];
+    _weekStartsOn: Day;
+    _strategy: NovoDateSelectionStrategy<any>;
+    months: any;
+    get activeDate(): Date;
+    set activeDate(value: Date);
+    get weekStartsOn(): Day;
+    set weekStartsOn(value: Day);
+    get numberOfMonths(): number;
+    set numberOfMonths(value: number);
+    get mode(): DatePickerSelectModes;
+    set mode(value: DatePickerSelectModes);
+    get hb_width(): _angular_platform_browser.SafeStyle;
+    get hb_horiztonal(): boolean;
+    get hb_vertical(): boolean;
+    constructor(labels: NovoLabelService, element: ElementRef, cdr: ChangeDetectorRef, _sanitizer: DomSanitizer);
+    ngOnInit(): void;
+    updateView(activeDate: Date): void;
+    setToday(): void;
+    monthSelected({ event, month }: NovoMonthSelectEvent): void;
+    yearSelected({ event, year }: NovoYearSelectEvent): void;
+    dateSelected({ event, day }: NovoDateSelectEvent): void;
+    updatePreview({ event, day }: NovoDateSelectEvent): void;
+    prevMonth(event: Event): void;
+    nextMonth(event: Event): void;
+    openView(event: Event, type: string): void;
+    _isRange(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoCalendarElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoCalendarElement, "novo-calendar", never, { "minYear": { "alias": "minYear"; "required": false; }; "maxYear": { "alias": "maxYear"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "preview": { "alias": "preview"; "required": false; }; "overlays": { "alias": "overlays"; "required": false; }; "disabledDateMessage": { "alias": "disabledDateMessage"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; }; "numberOfMonths": { "alias": "numberOfMonths"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; }, { "selectedChange": "selectedChange"; "previewChange": "previewChange"; "activeDateChange": "activeDateChange"; }, never, never, false, never>;
+}
+
+declare class NovoMonthViewElement implements OnInit {
+    labels: NovoLabelService;
+    private element;
+    private cdr;
+    private _sanitizer;
+    minDate: Date;
+    maxDate: Date;
+    activeDate: Date;
+    selected: DateLike[];
+    preview: DateLike[];
+    overlays: OverlayDate[];
+    disabledDateMessage: string;
+    isRange: boolean;
+    hideOverflowDays: boolean;
+    _weekStartsOn: Day;
+    get weekStartsOn(): Day;
+    set weekStartsOn(value: Day);
+    select: EventEmitter<any>;
+    hover: EventEmitter<any>;
+    weekdays: string[];
+    monthNames: string[];
+    monthLabel: string;
+    weeks: any;
+    constructor(labels: NovoLabelService, element: ElementRef, cdr: ChangeDetectorRef, _sanitizer: DomSanitizer);
+    ngOnInit(): void;
+    updateView(date: Date): void;
+    onSelect(event: Event, day: Day$1): void;
+    onHover(event: Event, day: Day$1): void;
+    buildMonth(month: Date): void;
+    buildWeek(date: Date, month: Date): Array<Object>;
+    isDisabled(day: DateLike): boolean;
+    /** Returns whether a cell should be marked as selected. */
+    _isSelected(value: DateLike): DateLike;
+    /** Returns whether a cell should be marked as preview. */
+    _isPreview(value: DateLike): DateLike;
+    /** Returns whether a cell should be marked as an overlay. */
+    _isOverlay(value: DateLike): OverlayDate;
+    /** Returns whether a cell should be marked as an overlay. */
+    _hasOverlayType(value: DateLike): string;
+    /** Gets whether a value is the start of the main range. */
+    _isRangeStart(value: DateLike): boolean;
+    /** Gets whether a value is the end of the main range. */
+    _isRangeEnd(value: DateLike): boolean;
+    /** Gets whether a value is within the currently-selected range. */
+    _isInRange(value: DateLike): boolean;
+    /** Gets whether a value is the start of the preview range. */
+    _isPreviewStart(value: DateLike): boolean;
+    /** Gets whether a value is the end of the preview range. */
+    _isPreviewEnd(value: DateLike): boolean;
+    /** Gets whether a value is inside the preview range. */
+    _isInPreview(value: DateLike): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoMonthViewElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoMonthViewElement, "novo-month-view", never, { "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "preview": { "alias": "preview"; "required": false; }; "overlays": { "alias": "overlays"; "required": false; }; "disabledDateMessage": { "alias": "disabledDateMessage"; "required": false; }; "isRange": { "alias": "isRange"; "required": false; }; "hideOverflowDays": { "alias": "hideOverflowDays"; "required": false; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; }; }, { "select": "select"; "hover": "hover"; }, never, never, false, never>;
+}
+
+declare class NovoMonthSelectElement implements OnInit {
+    labels: NovoLabelService;
+    activeDate: DateLike;
+    selected: DateLike[];
+    select: EventEmitter<any>;
+    monthNames: string[];
+    constructor(labels: NovoLabelService);
+    ngOnInit(): void;
+    onSelect(event: Event, month: number): void;
+    _isActive(month: number): boolean;
+    _isSelected(month: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoMonthSelectElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoMonthSelectElement, "novo-month-select", never, { "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
+}
+
+declare class NovoYearSelectElement implements OnInit {
+    labels: NovoLabelService;
+    minYear: string | number;
+    maxYear: string | number;
+    activeDate: DateLike;
+    selected: DateLike[];
+    select: EventEmitter<any>;
+    years: Array<any>;
+    constructor(labels: NovoLabelService);
+    ngOnInit(): void;
+    onSelect(event: Event, year: number): void;
+    _isActive(year: number): boolean;
+    _isSelected(year: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoYearSelectElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoYearSelectElement, "novo-year-select", never, { "minYear": { "alias": "minYear"; "required": false; }; "maxYear": { "alias": "maxYear"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
+}
+
+declare class NovoCalendarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoCalendarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoCalendarModule, [typeof NovoMonthViewElement, typeof NovoMonthSelectElement, typeof NovoYearSelectElement, typeof NovoCalendarElement], [typeof i5.CommonModule, typeof i6.FormsModule, typeof i7.NovoButtonModule, typeof i8.NovoPipesModule, typeof i9.NovoIconModule], [typeof NovoMonthViewElement, typeof NovoMonthSelectElement, typeof NovoYearSelectElement, typeof NovoCalendarElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoCalendarModule>;
+}
+
+/** Injection token used to customize the date range selection behavior. */
+declare const NOVO_DATE_SELECTION_STRATEGY: InjectionToken<NovoDateSelectionStrategy<DateLike>>;
+/** Provides the default date selection behavior. Single Date */
+declare class DefaultDateSelectionStrategy implements NovoDateSelectionStrategy<DateLike[]> {
+    selectionFinished(date: DateLike | null, currentValue: DateLike[], event: Event): DateLike[];
+    createPreview(activeDate: DateLike | null, [currentDate]: DateLike[]): DateLike[];
+    isSelected(activeDate: DateLike | null, [currentDate]: DateLike[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultDateSelectionStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultDateSelectionStrategy>;
+}
+/** @docs-private */
+declare function NOVO_DATE_SELECTION_STRATEGY_PROVIDER_FACTORY(parent: NovoDateSelectionStrategy<unknown>): NovoDateSelectionStrategy<unknown>;
+/** @docs-private */
+declare const NOVO_DATE_SELECTION_STRATEGY_PROVIDER: FactoryProvider;
+
+declare class MultiDateSelectionStrategy implements NovoDateSelectionStrategy<DateLike[]> {
+    selectionFinished(dateLike: DateLike | null, currentValue: DateLike[], event: Event): DateLike[];
+    createPreview(activeDate: DateLike | null, currentValue: DateLike[]): DateLike[];
+    isSelected(activeDate: DateLike | null, currentValue: DateLike[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiDateSelectionStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MultiDateSelectionStrategy>;
+}
+
+declare class RangeSelectionStrategy implements NovoDateSelectionStrategy<DateLike[]> {
+    selectionFinished(date: DateLike, currentRange: DateLike[]): DateLike[];
+    createPreview(activeDate: DateLike | null, currentRange: DateLike[]): DateLike[];
+    isSelected(activeDate: DateLike | null, currentRange: DateLike[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeSelectionStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RangeSelectionStrategy>;
+}
+
+declare class WeekSelectionStrategy implements NovoDateSelectionStrategy<DateLike[]> {
+    private weekStartsOn;
+    constructor(weekStartsOn?: Day);
+    selectionFinished(date: DateLike | null): DateLike[];
+    createPreview(activeDate: DateLike | null): DateLike[];
+    private _createWeekRange;
+    isSelected(activeDate: DateLike | null, currentRange: DateLike[]): boolean;
+}
+
+export { DefaultDateSelectionStrategy, MultiDateSelectionStrategy, NOVO_DATE_SELECTION_STRATEGY, NOVO_DATE_SELECTION_STRATEGY_PROVIDER, NOVO_DATE_SELECTION_STRATEGY_PROVIDER_FACTORY, NovoCalendarElement, NovoCalendarModule, NovoMonthSelectElement, NovoMonthViewElement, NovoYearSelectElement, RangeSelectionStrategy, WeekSelectionStrategy };

package/elements/card/index.d.ts

@@ -1,2 +1,69 @@
-export * from './Card';
-export * from './Card.module';
+import * as i0 from '@angular/core';
+import { OnChanges, OnInit, EventEmitter, SimpleChanges } from '@angular/core';
+import { NovoLabelService } from 'novo-elements/services';
+import * as i2 from '@angular/common';
+import * as i3 from 'novo-elements/elements/icon';
+import * as i4 from 'novo-elements/elements/button';
+import * as i5 from 'novo-elements/elements/loading';
+import * as i6 from 'novo-elements/elements/tooltip';
+
+declare class CardActionsElement {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardActionsElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardActionsElement, "novo-card-actions", never, {}, {}, never, ["*"], false, never>;
+}
+/**
+ * Content of a card, needed as it's used as a selector in the API.
+ */
+declare class CardContentElement {
+    condensed: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardContentElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardContentElement, "novo-card-content, [novo-card-content], [novoCardContent]", never, { "condensed": { "alias": "condensed"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+/**
+ * Content of a card, needed as it's used as a selector in the API.
+ */
+declare class CardHeaderElement {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardHeaderElement, "novo-card-header, [novo-card-header], [novoCardHeader]", never, {}, {}, never, ["novo-avatar, [novo-avatar], novo-icon", "novo-title, [novo-title], novo-text, novo-label, novo-caption", "*", "novo-action"], false, never>;
+}
+declare class CardFooterElement {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardFooterElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardFooterElement, "novo-card-footer, [novo-card-footer], [novoCardFooter]", never, {}, {}, never, ["*"], false, never>;
+}
+declare class CardElement implements OnChanges, OnInit {
+    padding: boolean;
+    config: any;
+    title: string;
+    message: string;
+    messageIcon: string;
+    icon: string;
+    iconTooltip: string;
+    refresh: boolean;
+    close: boolean;
+    move: boolean;
+    loading: boolean;
+    inline: boolean;
+    inset: string;
+    get hbInset(): string;
+    onClose: EventEmitter<void>;
+    onRefresh: EventEmitter<void>;
+    cardAutomationId: string;
+    labels: NovoLabelService;
+    iconClass: string | null;
+    messageIconClass: string;
+    constructor(labels: NovoLabelService);
+    ngOnInit(): void;
+    ngOnChanges(changes?: SimpleChanges): void;
+    toggleClose(): void;
+    toggleRefresh(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardElement, "novo-card", never, { "padding": { "alias": "padding"; "required": false; }; "config": { "alias": "config"; "required": false; }; "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "messageIcon": { "alias": "messageIcon"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconTooltip": { "alias": "iconTooltip"; "required": false; }; "refresh": { "alias": "refresh"; "required": false; }; "close": { "alias": "close"; "required": false; }; "move": { "alias": "move"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "inset": { "alias": "inset"; "required": false; }; }, { "onClose": "onClose"; "onRefresh": "onRefresh"; }, never, ["novo-card-actions", "*", "footer,novo-card-footer,[novo-card-footer],[novoCardFooter]"], false, never>;
+}
+
+declare class NovoCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoCardModule, [typeof CardElement, typeof CardActionsElement, typeof CardContentElement, typeof CardHeaderElement, typeof CardFooterElement], [typeof i2.CommonModule, typeof i3.NovoIconModule, typeof i4.NovoButtonModule, typeof i5.NovoLoadingModule, typeof i6.NovoTooltipModule], [typeof CardElement, typeof CardActionsElement, typeof CardContentElement, typeof CardHeaderElement, typeof CardFooterElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoCardModule>;
+}
+
+export { CardActionsElement, CardContentElement, CardElement, CardFooterElement, CardHeaderElement, NovoCardModule };

package/elements/category-dropdown/index.d.ts

@@ -1,2 +1,44 @@
-export * from './CategoryDropdown';
-export * from './CategoryDropdown.module';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, ElementRef } from '@angular/core';
+import { NovoLabelService } from 'novo-elements/services';
+import { OutsideClick } from 'novo-elements/utils';
+import * as i2 from '@angular/common';
+import * as i3 from 'novo-elements/elements/tabs';
+import * as i4 from 'novo-elements/elements/list';
+
+declare class NovoCategoryDropdownElement extends OutsideClick implements OnInit, OnDestroy {
+    labels: NovoLabelService;
+    _query: string;
+    _categoryMap: any;
+    _categories: string[];
+    clickHandler: Function;
+    _masterCategoryMap: any;
+    _queryTimeout: any;
+    persistSelection: boolean;
+    closeOnSelect: boolean;
+    search: any;
+    footer: any;
+    _select: EventEmitter<any>;
+    categorySelected: EventEmitter<any>;
+    set categories(categories: any);
+    constructor(element: ElementRef, labels: NovoLabelService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onKeyDown(event: any): void;
+    clearSelection(): void;
+    select(event: any, item: any): void;
+    onCategorySelected(category: any): void;
+    clearQuery(event: any): void;
+    queryCategories(query: any): void;
+    executeClickCallback(event: any, link: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoCategoryDropdownElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoCategoryDropdownElement, "novo-category-dropdown", never, { "persistSelection": { "alias": "persistSelection"; "required": false; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; }; "search": { "alias": "search"; "required": false; }; "footer": { "alias": "footer"; "required": false; }; "categories": { "alias": "categories"; "required": false; }; }, { "_select": "itemSelected"; "categorySelected": "categorySelected"; }, never, ["button"], false, never>;
+}
+
+declare class NovoCategoryDropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoCategoryDropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoCategoryDropdownModule, [typeof NovoCategoryDropdownElement], [typeof i2.CommonModule, typeof i3.NovoTabModule, typeof i4.NovoListModule], [typeof NovoCategoryDropdownElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoCategoryDropdownModule>;
+}
+
+export { NovoCategoryDropdownElement, NovoCategoryDropdownModule };