novo-elements 11.4.0 → 12.0.0

package/elements/stepper/index.d.ts

@@ -1,7 +1,134 @@
-export * from './step-header.component';
-export * from './step-label.component';
-export * from './step-status.component';
-export * from './stepper-buttons.component';
-export * from './stepper.animations';
-export * from './stepper.component';
-export * from './stepper.module';
+import * as i11 from '@angular/cdk/a11y';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import * as i9 from '@angular/cdk/stepper';
+import { CdkStepLabel, CdkStepHeader, CdkStepperNext, CdkStepperPrevious, CdkStepper, CdkStep } from '@angular/cdk/stepper';
+import * as i0 from '@angular/core';
+import { TemplateRef, OnDestroy, ElementRef, AfterContentInit, QueryList, ChangeDetectorRef } from '@angular/core';
+import { AnimationTriggerMetadata } from '@angular/animations';
+import { Directionality } from '@angular/cdk/bidi';
+import * as i10 from 'novo-elements/elements/icon';
+import { NovoIconComponent } from 'novo-elements/elements/icon';
+import * as i6 from '@angular/common';
+import * as i7 from '@angular/cdk/portal';
+import * as i8 from 'novo-elements/elements/button';
+
+declare class NovoStepLabel extends CdkStepLabel {
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoStepLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoStepLabel, "[novoStepLabel]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NovoStepHeader extends CdkStepHeader implements OnDestroy {
+    private _focusMonitor;
+    private _element;
+    theme: string;
+    color: string;
+    icon: string;
+    /** State of the given step. */
+    state: string;
+    /** Label of the given step. */
+    label: NovoStepLabel | string;
+    /** Overrides for the header icons, passed in via the stepper. */
+    iconOverrides: {
+        [key: string]: TemplateRef<any>;
+    };
+    /** Index of the given step. */
+    get index(): number;
+    set index(value: number);
+    private _index;
+    /** Whether the given step is selected. */
+    get selected(): boolean;
+    set selected(value: boolean);
+    private _selected;
+    /** Whether the given step label is active. */
+    get active(): boolean;
+    set active(value: boolean);
+    private _active;
+    /** Whether the given step label is active. */
+    get touched(): boolean;
+    /** Whether the given step is optional. */
+    get optional(): boolean;
+    set optional(value: boolean);
+    private _optional;
+    constructor(_focusMonitor: FocusMonitor, _element: ElementRef);
+    ngOnDestroy(): void;
+    /** Returns string label of given step if it is a text label. */
+    _stringLabel(): string | null;
+    /** Returns NovoStepLabel if the label of given step is a template label. */
+    _templateLabel(): NovoStepLabel | null;
+    /** Returns the host HTML element. */
+    _getHostElement(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoStepHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoStepHeader, "novo-step-header", never, { "theme": { "alias": "theme"; "required": false; }; "color": { "alias": "color"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "state": { "alias": "state"; "required": false; }; "label": { "alias": "label"; "required": false; }; "iconOverrides": { "alias": "iconOverrides"; "required": false; }; "index": { "alias": "index"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "active": { "alias": "active"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NovoStepStatus {
+    state: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoStepStatus, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoStepStatus, "novo-step-status", never, { "state": { "alias": "state"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/** Button that moves to the next step in a stepper workflow. */
+declare class NovoStepperNext extends CdkStepperNext {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoStepperNext, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoStepperNext, "button[novoStepperNext]", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, false, never>;
+}
+/** Button that moves to the previous step in a stepper workflow. */
+declare class NovoStepperPrevious extends CdkStepperPrevious {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoStepperPrevious, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoStepperPrevious, "button[novoStepperPrevious]", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/** Animations used by the Novo steppers. */
+declare const novoStepperAnimations: {
+    readonly horizontalStepTransition: AnimationTriggerMetadata;
+    readonly verticalStepTransition: AnimationTriggerMetadata;
+};
+
+declare class NovoStep extends CdkStep {
+    /** Content for step label given by `<ng-template novoStepLabel>`. */
+    stepLabel: NovoStepLabel;
+    theme: string;
+    color: string;
+    icon: string;
+    constructor(stepper: CdkStepper);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoStep, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoStep, "novo-step", never, { "theme": { "alias": "theme"; "required": false; }; "color": { "alias": "color"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, ["stepLabel"], ["*"], false, never>;
+}
+declare class NovoStepper extends CdkStepper implements AfterContentInit, OnDestroy {
+    /** The list of step headers of the steps in the stepper. */
+    _stepHeader: QueryList<CdkStepHeader>;
+    /** Steps that the stepper holds. */
+    steps: QueryList<NovoStep>;
+    /** Custom icon overrides passed in by the consumer. */
+    _icons: QueryList<NovoIconComponent>;
+    /** Consumer-specified template-refs to be used to override the header icons. */
+    _iconOverrides: {
+        [key: string]: TemplateRef<any>;
+    };
+    get completed(): boolean;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    complete(): void;
+    getIndicatorType(index: number): 'none' | '' | 'edit' | 'done';
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoStepper, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoStepper, "[novoStepper]", never, {}, {}, ["steps", "_icons"], never, false, never>;
+}
+declare class NovoHorizontalStepper extends NovoStepper {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoHorizontalStepper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoHorizontalStepper, "novo-horizontal-stepper", ["novoHorizontalStepper"], {}, {}, never, never, false, never>;
+}
+declare class NovoVerticalStepper extends NovoStepper {
+    constructor(dir: Directionality, changeDetectorRef: ChangeDetectorRef, elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoVerticalStepper, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoVerticalStepper, "novo-vertical-stepper", ["novoVerticalStepper"], {}, {}, never, never, false, never>;
+}
+
+declare class NovoStepperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoStepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoStepperModule, [typeof NovoHorizontalStepper, typeof NovoVerticalStepper, typeof NovoStep, typeof NovoStepLabel, typeof NovoStepper, typeof NovoStepHeader, typeof NovoStepStatus, typeof NovoStepperNext, typeof NovoStepperPrevious], [typeof i6.CommonModule, typeof i7.PortalModule, typeof i8.NovoButtonModule, typeof i9.CdkStepperModule, typeof i10.NovoIconModule, typeof i11.A11yModule], [typeof NovoHorizontalStepper, typeof NovoVerticalStepper, typeof NovoStep, typeof NovoStepLabel, typeof NovoStepper, typeof NovoStepHeader, typeof NovoStepStatus, typeof NovoStepperNext, typeof NovoStepperPrevious]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoStepperModule>;
+}
+
+export { NovoHorizontalStepper, NovoStep, NovoStepHeader, NovoStepLabel, NovoStepStatus, NovoStepper, NovoStepperModule, NovoStepperNext, NovoStepperPrevious, NovoVerticalStepper, novoStepperAnimations };

package/elements/switch/index.d.ts

@@ -1,2 +1,35 @@
-export * from './Switch';
-export * from './Switch.module';
+import * as i0 from '@angular/core';
+import { EventEmitter, ChangeDetectorRef } from '@angular/core';
+import * as i3 from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i2 from '@angular/common';
+import * as i4 from 'novo-elements/elements/icon';
+
+declare class NovoSwitchElement implements ControlValueAccessor {
+    private ref;
+    theme: string;
+    icons: [string, string];
+    disabled: boolean;
+    onChange: EventEmitter<any>;
+    private _value;
+    get value(): boolean;
+    set value(value: boolean);
+    onModelChange: Function;
+    onModelTouched: Function;
+    constructor(ref: ChangeDetectorRef);
+    onKeydown(event: KeyboardEvent): void;
+    toggle(event: any): void;
+    writeValue(model: boolean): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoSwitchElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoSwitchElement, "novo-switch", never, { "theme": { "alias": "theme"; "required": false; }; "icons": { "alias": "icons"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onChange": "onChange"; }, never, ["*"], false, never>;
+}
+
+declare class NovoSwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoSwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoSwitchModule, [typeof NovoSwitchElement], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.NovoIconModule], [typeof NovoSwitchElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoSwitchModule>;
+}
+
+export { NovoSwitchElement, NovoSwitchModule };

package/elements/tabbed-group-picker/index.d.ts

@@ -1,2 +1,147 @@
-export * from './TabbedGroupPicker';
-export * from './TabbedGroupPicker.module';
+import * as i0 from '@angular/core';
+import { OnDestroy, OnInit, EventEmitter, ChangeDetectorRef } from '@angular/core';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { NovoLabelService } from 'novo-elements/services';
+import * as i9 from 'novo-elements/elements/dropdown';
+import { NovoDropdownElement } from 'novo-elements/elements/dropdown';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i4 from '@angular/cdk/scrolling';
+import * as i5 from 'novo-elements/elements/tabs';
+import * as i6 from 'novo-elements/elements/list';
+import * as i7 from 'novo-elements/elements/form';
+import * as i8 from 'novo-elements/elements/button';
+import * as i10 from 'novo-elements/elements/common';
+import * as i11 from 'novo-elements/elements/checkbox';
+
+type TabbedGroupPickerTab = {
+    typeName: string;
+    typeLabel: string;
+    valueField: string;
+    labelField: string;
+    scrollOffset?: number;
+    icon?: string;
+} & (ParentTab | ChildTab);
+type ParentTab = {
+    childTypeName: string;
+    data: Array<ParentOption>;
+};
+type BaseOption = {
+    selected?: boolean;
+    indeterminate?: boolean;
+} & {
+    [key: string]: any;
+};
+type ParentOption = BaseOption & {
+    children: Option[];
+};
+type Option = BaseOption | ParentOption;
+type ChildTab = {
+    data: Array<{
+        selected?: boolean;
+    } & {
+        [key: string]: any;
+    }>;
+};
+type TabbedGroupPickerQuickSelect = {
+    label: string;
+    selected?: boolean;
+    childTypeName?: string;
+    children?: (({
+        selected?: boolean;
+    } & {
+        [key: string]: any;
+    }) | number)[];
+    all?: boolean;
+};
+type QuickSelectConfig = {
+    label: string;
+    items: TabbedGroupPickerQuickSelect[];
+};
+type TabbedGroupPickerButtonConfig = {
+    theme: string;
+    side: string;
+    icon: string;
+    label: string;
+    size?: string;
+};
+declare class NovoTabbedGroupPickerElement implements OnDestroy, OnInit {
+    labelService: NovoLabelService;
+    private ref;
+    private scrollableInstance;
+    private inputElement;
+    dropdown: NovoDropdownElement;
+    multiple: boolean;
+    buttonConfig: TabbedGroupPickerButtonConfig;
+    tabs: TabbedGroupPickerTab[];
+    quickSelectConfig: QuickSelectConfig;
+    showFooter: boolean;
+    selectionEnabled: boolean;
+    activation: EventEmitter<any>;
+    selectionChange: EventEmitter<TabbedGroupPickerTab[]>;
+    applyChange: EventEmitter<any>;
+    cancelChange: EventEmitter<any>;
+    displayTabs: TabbedGroupPickerTab[];
+    displayTabIndex: number;
+    filterText: BehaviorSubject<string>;
+    filterTextSubscription: Subscription;
+    loading: boolean;
+    showClearAll: boolean;
+    appliedState: TabbedGroupPickerTab[];
+    scrollViewportHeight: number;
+    virtualScrollItemSize: number;
+    constructor(labelService: NovoLabelService, ref: ChangeDetectorRef);
+    get displayTab(): TabbedGroupPickerTab;
+    set displayTab(tab: TabbedGroupPickerTab);
+    get minBufferPx(): number;
+    get maxBufferPx(): number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    loadValues(): void;
+    changeTab(tab: TabbedGroupPickerTab): void;
+    getPixelHeight(element: HTMLElement): number;
+    setupDisplayData(): void;
+    createChildrenReferences(): void;
+    makeCompareFunction<T>(key: string): (a: T | {
+        [key: string]: T;
+    }, b: T | {
+        [key: string]: T;
+    }) => 1 | -1 | 0 | undefined;
+    replaceChildrenWithReferences(parent: {
+        children: any[];
+    }, sortedData: ChildTab['data'], compareFunction: (a: any, b: any) => 1 | -1 | 0, warnFunction: (child: any) => void): void;
+    makeWarningFunction(parentLabel: string, childLabel: string, childValueField: any): (child: any) => void;
+    onDropdownToggle(event: any): void;
+    activateItem(item: any, tab?: TabbedGroupPickerTab): void;
+    onItemToggled(item: Option): void;
+    initializeDescendantSelection(): void;
+    updateDescendants(parentIsSelected: boolean, children: Option[]): void;
+    updateClearAll(itemWasJustSelected?: boolean): void;
+    updateParentsAndQuickSelect(): void;
+    getSelectedState: (childArray: Option[]) => "selected" | "indeterminate" | undefined;
+    getSelectedValues(): TabbedGroupPickerTab[];
+    emitSelectedValues(): void;
+    updateAppliedState(): void;
+    apply(): void;
+    cancel(): void;
+    revertState(): void;
+    deselectEverything(event: any): void;
+    onClearFilter(event: any): void;
+    onFilter(event: {
+        target: {
+            value: string;
+        };
+    }): void;
+    filter: (searchTerm: string) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTabbedGroupPickerElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoTabbedGroupPickerElement, "novo-tabbed-group-picker", never, { "buttonConfig": { "alias": "buttonConfig"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; "quickSelectConfig": { "alias": "quickSelectConfig"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "selectionEnabled": { "alias": "selectionEnabled"; "required": false; }; }, { "activation": "activation"; "selectionChange": "selectionChange"; "applyChange": "applyChange"; "cancelChange": "cancelChange"; }, never, ["*"], false, never>;
+}
+
+declare class NovoTabbedGroupPickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTabbedGroupPickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoTabbedGroupPickerModule, [typeof NovoTabbedGroupPickerElement], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.ScrollingModule, typeof i5.NovoTabModule, typeof i6.NovoListModule, typeof i7.NovoFormExtrasModule, typeof i8.NovoButtonModule, typeof i9.NovoDropdownModule, typeof i10.NovoOptionModule, typeof i11.NovoCheckboxModule], [typeof NovoTabbedGroupPickerElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoTabbedGroupPickerModule>;
+}
+
+export { NovoTabbedGroupPickerElement, NovoTabbedGroupPickerModule };
+export type { ChildTab, ParentTab, QuickSelectConfig, TabbedGroupPickerButtonConfig, TabbedGroupPickerQuickSelect, TabbedGroupPickerTab };

package/elements/tabs/index.d.ts

@@ -1,2 +1,105 @@
-export * from './Tabs';
-export * from './Tabs.module';
+import * as i0 from '@angular/core';
+import { AfterContentChecked, EventEmitter, ElementRef, ChangeDetectorRef, OnInit } from '@angular/core';
+import { Router, RouterLink } from '@angular/router';
+import * as i2 from '@angular/common';
+
+declare class NovoNavElement implements AfterContentChecked {
+    theme: string;
+    direction: string;
+    outlet: any;
+    router: string;
+    condensed: boolean;
+    items: Array<any>;
+    /** The index of the active tab. */
+    get selectedIndex(): number | null;
+    set selectedIndex(value: number | null);
+    private _selectedIndex;
+    /** The tab index that should be selected after the content has been checked. */
+    private _indexToSelect;
+    /** Output to enable support for two-way binding on `[(selectedIndex)]` */
+    readonly selectedIndexChange: EventEmitter<number>;
+    ngAfterContentChecked(): void;
+    select(item: any): void;
+    add(item: any): void;
+    private _activateSelectedItem;
+    private _showActiveContent;
+    private _deactivateAllItems;
+    /** Clamps the given index to the bounds of 0 and the tabs length. */
+    private _clampTabIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoNavElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoNavElement, "novo-nav", never, { "theme": { "alias": "theme"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "outlet": { "alias": "outlet"; "required": false; }; "router": { "alias": "router"; "required": false; }; "condensed": { "alias": "condensed"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; }, never, ["*"], false, never>;
+}
+declare class NovoTabElement {
+    private el;
+    private cdr;
+    role: string;
+    active: boolean;
+    color: string;
+    disabled: boolean;
+    activeChange: EventEmitter<boolean>;
+    onlyText: boolean;
+    get hb_textOnly(): boolean;
+    tablink: any;
+    nav: any;
+    constructor(nav: NovoNavElement, el: ElementRef, cdr: ChangeDetectorRef);
+    select(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTabElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoTabElement, "novo-tab", never, { "active": { "alias": "active"; "required": false; }; "color": { "alias": "color"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "activeChange": "activeChange"; }, never, ["*"], false, never>;
+}
+declare class NovoTabButtonElement {
+    role: string;
+    active: boolean;
+    disabled: boolean;
+    nav: any;
+    constructor(nav: NovoNavElement);
+    select(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTabButtonElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoTabButtonElement, "novo-tab-button", never, { "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+declare class NovoTabLinkElement implements OnInit {
+    private router;
+    private cdr;
+    private link?;
+    role: string;
+    active: boolean;
+    disabled: boolean;
+    spy: string;
+    nav: any;
+    constructor(nav: NovoNavElement, router: Router, cdr: ChangeDetectorRef, link?: RouterLink);
+    ngOnInit(): void;
+    select(): void;
+    private isLinkActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTabLinkElement, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoTabLinkElement, "novo-tab-link", never, { "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "spy": { "alias": "spy"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+declare class NovoNavOutletElement {
+    items: Array<any>;
+    show(index: any): void;
+    add(item: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoNavOutletElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoNavOutletElement, "novo-nav-outlet", never, {}, {}, never, ["*"], false, never>;
+}
+declare class NovoNavContentElement {
+    active: boolean;
+    constructor(outlet: NovoNavOutletElement);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoNavContentElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoNavContentElement, "novo-nav-content", never, { "active": { "alias": "active"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+declare class NovoNavHeaderElement {
+    role: string;
+    active: boolean;
+    forElement: any;
+    outlet: any;
+    constructor(outlet: NovoNavOutletElement);
+    show(event?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoNavHeaderElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoNavHeaderElement, "novo-nav-header", never, { "active": { "alias": "active"; "required": false; }; "forElement": { "alias": "for"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class NovoTabModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTabModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoTabModule, [typeof NovoNavElement, typeof NovoTabElement, typeof NovoTabButtonElement, typeof NovoTabLinkElement, typeof NovoNavOutletElement, typeof NovoNavContentElement, typeof NovoNavHeaderElement], [typeof i2.CommonModule], [typeof NovoNavElement, typeof NovoTabElement, typeof NovoTabButtonElement, typeof NovoTabLinkElement, typeof NovoNavOutletElement, typeof NovoNavContentElement, typeof NovoNavHeaderElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoTabModule>;
+}
+
+export { NovoNavContentElement, NovoNavElement, NovoNavHeaderElement, NovoNavOutletElement, NovoTabButtonElement, NovoTabElement, NovoTabLinkElement, NovoTabModule };

package/elements/tiles/index.d.ts

@@ -1,2 +1,45 @@
-export * from './Tiles';
-export * from './Tiles.module';
+import * as i0 from '@angular/core';
+import { AfterContentInit, OnChanges, EventEmitter, ElementRef, ChangeDetectorRef, SimpleChanges } from '@angular/core';
+import * as i4 from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i2 from '@angular/common';
+import * as i3 from 'novo-elements/elements/button';
+
+declare class NovoTilesElement implements ControlValueAccessor, AfterContentInit, OnChanges {
+    private element;
+    private ref;
+    name: string;
+    options: any;
+    required: boolean;
+    disabled: boolean;
+    onChange: EventEmitter<any>;
+    onSelectedOptionClick: EventEmitter<any>;
+    onDisabledOptionClick: EventEmitter<any>;
+    _options: Array<any>;
+    activeTile: any;
+    focused: boolean;
+    model: any;
+    onModelChange: Function;
+    onModelTouched: Function;
+    constructor(element: ElementRef, ref: ChangeDetectorRef);
+    setFocus(focus: boolean): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(change: SimpleChanges): void;
+    setupOptions(): void;
+    select(event: any, item: any): void;
+    setTile(item: any): void;
+    writeValue(model: any): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState(disabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTilesElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoTilesElement, "novo-tiles", never, { "name": { "alias": "name"; "required": false; }; "options": { "alias": "options"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "controlDisabled"; "required": false; }; }, { "onChange": "onChange"; "onSelectedOptionClick": "onSelectedOptionClick"; "onDisabledOptionClick": "onDisabledOptionClick"; }, never, never, false, never>;
+}
+
+declare class NovoTilesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTilesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoTilesModule, [typeof NovoTilesElement], [typeof i2.CommonModule, typeof i3.NovoButtonModule, typeof i4.ReactiveFormsModule], [typeof NovoTilesElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoTilesModule>;
+}
+
+export { NovoTilesElement, NovoTilesModule };

package/elements/time-picker/index.d.ts

@@ -1,3 +1,141 @@
-export * from './TimePicker';
-export * from './TimePicker.module';
-export * from './TimePickerInput';
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, ElementRef, ChangeDetectorRef, EventEmitter, SimpleChanges } from '@angular/core';
+import * as i4 from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+import { NovoLabelService, DateFormatService } from 'novo-elements/services';
+import * as i6 from 'novo-elements/elements/common';
+import { NovoOverlayTemplateComponent } from 'novo-elements/elements/common';
+import * as i3 from '@angular/common';
+import * as i5 from 'angular-imask';
+import * as i7 from 'novo-elements/elements/list';
+import * as i8 from 'novo-elements/elements/button';
+
+declare enum TIME_VALUE_FORMATS {
+    iso8601 = "iso8601",
+    Date = "Date"
+}
+declare class NovoTimePickerElement implements ControlValueAccessor, OnInit, OnChanges {
+    element: ElementRef;
+    labels: NovoLabelService;
+    protected cdr: ChangeDetectorRef;
+    military: boolean;
+    analog: boolean;
+    inline: boolean;
+    step: number;
+    hasButtons: boolean;
+    saveDisabled: boolean;
+    onSelect: EventEmitter<any>;
+    onSave: EventEmitter<any>;
+    onCancel: EventEmitter<any>;
+    hours: number;
+    minutes: number;
+    value: any;
+    meridian: string;
+    inBetween: boolean;
+    hoursClass: string;
+    activeHour: any;
+    minutesClass: string;
+    activeMinute: any;
+    increments: string[];
+    selected: string;
+    MERIDIANS: Array<string>;
+    MINUTES: Array<string>;
+    HOURS: Array<string>;
+    model: any;
+    _onChange: Function;
+    _onTouched: Function;
+    flatten(arr: any): any[];
+    constructor(element: ElementRef, labels: NovoLabelService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnChanges(changes?: SimpleChanges): void;
+    init(value: any, dispatch: any): void;
+    checkBetween(value: any): void;
+    setValue(event: any, value: any): void;
+    setHours(event: any, hours: any, dispatch: any): void;
+    setMinutes(event: any, minutes: any, dispatch: any): void;
+    setPeriod(event: any, period: any, dispatch: any): void;
+    dispatchChange(): void;
+    writeValue(model: any): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    convertTime12to24(time12h: string): string;
+    save(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTimePickerElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoTimePickerElement, "novo-time-picker", never, { "military": { "alias": "military"; "required": false; }; "analog": { "alias": "analog"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "step": { "alias": "step"; "required": false; }; "hasButtons": { "alias": "hasButtons"; "required": false; }; "saveDisabled": { "alias": "saveDisabled"; "required": false; }; }, { "onSelect": "onSelect"; "onSave": "onSave"; "onCancel": "onCancel"; }, never, never, false, never>;
+}
+
+declare class NovoTimePickerInputElement implements OnInit, OnChanges, ControlValueAccessor {
+    element: ElementRef;
+    labels: NovoLabelService;
+    dateFormatService: DateFormatService;
+    protected _changeDetectorRef: ChangeDetectorRef;
+    value: any;
+    /** View -> model callback called when value changes */
+    _onChange: (value: any) => void;
+    /** View -> model callback called when autocomplete has been touched */
+    _onTouched: () => void;
+    name: string;
+    placeholder: string;
+    military: boolean;
+    maskOptions: any;
+    disabled: boolean;
+    hasButtons: boolean;
+    saveDisabled: boolean;
+    overlayOnElement: ElementRef;
+    /**
+     * @deprecated don't use
+     */
+    analog: boolean;
+    blurEvent: EventEmitter<FocusEvent>;
+    focusEvent: EventEmitter<FocusEvent>;
+    changeEvent: EventEmitter<FocusEvent>;
+    onSave: EventEmitter<any>;
+    onCancel: EventEmitter<any>;
+    /** Element for the panel containing the autocomplete options. */
+    overlay: NovoOverlayTemplateComponent;
+    input: HTMLInputElement;
+    constructor(element: ElementRef, labels: NovoLabelService, dateFormatService: DateFormatService, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnChanges(changes?: SimpleChanges): void;
+    initFormatOptions(): void;
+    /** BEGIN: Convenient Panel Methods. */
+    openPanel(): void;
+    closePanel(): void;
+    get panelOpen(): boolean;
+    get overlayElement(): ElementRef;
+    /** END: Convenient Panel Methods. */
+    _handleKeydown(event: KeyboardEvent): void;
+    _handleInput(event: KeyboardEvent): void;
+    _handleChange(event: Event): void;
+    _handleBlur(event: FocusEvent): void;
+    _handleFocus(event: FocusEvent): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => {}): void;
+    registerOnTouched(fn: () => {}): void;
+    setDisabledState(disabled: boolean): void;
+    dispatchOnChange(newValue?: any, skip?: boolean): void;
+    private _setTriggerValue;
+    setValueAndClose(event: any | null): void;
+    setValue(event: any | null): void;
+    /**
+     * Clear any previous selected option and emit a selection change event for this option
+     */
+    clearValue(): void;
+    get hasValue(): boolean;
+    scrollToIndex(index: number): void;
+    hourOneFormatRequired(hourInput: string): boolean;
+    protected formatTime(value: string): void;
+    save(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTimePickerInputElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoTimePickerInputElement, "novo-time-picker-input", never, { "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "military": { "alias": "military"; "required": false; }; "maskOptions": { "alias": "maskOptions"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hasButtons": { "alias": "hasButtons"; "required": false; }; "saveDisabled": { "alias": "saveDisabled"; "required": false; }; "overlayOnElement": { "alias": "overlayOnElement"; "required": false; }; "analog": { "alias": "analog"; "required": false; }; }, { "blurEvent": "blurEvent"; "focusEvent": "focusEvent"; "changeEvent": "changeEvent"; "onSave": "onSave"; "onCancel": "onCancel"; }, never, never, false, never>;
+}
+
+declare class NovoTimePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTimePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoTimePickerModule, [typeof NovoTimePickerElement, typeof NovoTimePickerInputElement], [typeof i3.CommonModule, typeof i4.FormsModule, typeof i5.IMaskModule, typeof i6.NovoOverlayModule, typeof i7.NovoListModule, typeof i8.NovoButtonModule], [typeof NovoTimePickerElement, typeof NovoTimePickerInputElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoTimePickerModule>;
+}
+
+export { NovoTimePickerElement, NovoTimePickerInputElement, NovoTimePickerModule, TIME_VALUE_FORMATS };