@clr/angular 13.17.0 → 13.18.1

package/utils/drag-and-drop/draggable/draggable.d.ts

@@ -15,22 +15,22 @@ export declare class ClrDraggable<T> implements AfterContentInit, OnDestroy {
     private injector;
     private draggableSnapshot;
     private globalDragMode;
+    dragStartEmitter: EventEmitter<ClrDragEvent<T>>;
+    dragMoveEmitter: EventEmitter<ClrDragEvent<T>>;
+    dragEndEmitter: EventEmitter<ClrDragEvent<T>>;
+    customGhost: ClrIfDragged<T>;
+    dragOn: boolean;
     private draggableEl;
     private subscriptions;
     private componentFactory;
-    dragOn: boolean;
     constructor(el: ElementRef, dragEventListener: DragEventListenerService<T>, dragHandleRegistrar: DragHandleRegistrarService<T>, viewContainerRef: ViewContainerRef, cfr: ComponentFactoryResolver, injector: Injector, draggableSnapshot: DraggableSnapshotService<T>, globalDragMode: GlobalDragModeService);
-    customGhost: ClrIfDragged<T>;
     set dataTransfer(value: T);
     set group(value: string | string[]);
     set dragStartDelay(value: number);
-    private createDefaultGhost;
-    private destroyDefaultGhost;
-    dragStartEmitter: EventEmitter<ClrDragEvent<T>>;
-    dragMoveEmitter: EventEmitter<ClrDragEvent<T>>;
-    dragEndEmitter: EventEmitter<ClrDragEvent<T>>;
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
+    private createDefaultGhost;
+    private destroyDefaultGhost;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrDraggable<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ClrDraggable<any>, "[clrDraggable]", never, { "dataTransfer": "clrDraggable"; "group": "clrGroup"; "dragStartDelay": "clrDragStartDelay"; }, { "dragStartEmitter": "clrDragStart"; "dragMoveEmitter": "clrDragMove"; "dragEndEmitter": "clrDragEnd"; }, ["customGhost"]>;
 }

package/utils/drag-and-drop/draggable-ghost.d.ts

@@ -8,8 +8,6 @@ export declare class ClrDraggableGhost<T> implements OnDestroy {
     private draggableSnapshot;
     private renderer;
     private ngZone;
-    private draggableGhostEl;
-    private subscriptions;
     leaveAnimConfig: {
         value: number;
         params: {
@@ -17,14 +15,16 @@ export declare class ClrDraggableGhost<T> implements OnDestroy {
             left: string;
         };
     };
+    private draggableGhostEl;
+    private subscriptions;
     constructor(el: ElementRef, dragEventListener: DragEventListenerService<T>, draggableSnapshot: DraggableSnapshotService<T>, renderer: Renderer2, ngZone: NgZone);
+    ngOnDestroy(): void;
     private setDefaultGhostSize;
     private animateToOnLeave;
     private findTopLeftPosition;
     private findDropPointPosition;
     private setSizeStyle;
     private setPositionStyle;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrDraggableGhost<any>, [null, { optional: true; }, { optional: true; }, null, null]>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ClrDraggableGhost<any>, "clr-draggable-ghost", never, {}, {}, never, ["*"]>;
 }

package/utils/drag-and-drop/droppable/droppable.d.ts

@@ -9,34 +9,34 @@ export declare class ClrDroppable<T> implements OnInit, OnDestroy {
     private eventBus;
     private domAdapter;
     private renderer;
-    private dragStartSubscription;
-    private dragMoveSubscription;
-    private dragEndSubscription;
-    private droppableEl;
-    private clientRect;
-    constructor(el: ElementRef, eventBus: DragAndDropEventBusService<T>, domAdapter: DomAdapter, renderer: Renderer2);
-    isDraggableMatch: boolean;
-    private _isDraggableOver;
-    set isDraggableOver(value: boolean);
-    private _group;
-    set group(value: string | string[]);
-    private _dropTolerance;
-    private dropToleranceGenerator;
-    set dropTolerance(value: number | string | ClrDropToleranceInterface);
     dragStartEmitter: EventEmitter<ClrDragEvent<T>>;
     dragMoveEmitter: EventEmitter<ClrDragEvent<T>>;
     dragEndEmitter: EventEmitter<ClrDragEvent<T>>;
     dragLeaveEmitter: EventEmitter<ClrDragEvent<T>>;
     dragEnterEmitter: EventEmitter<ClrDragEvent<T>>;
     dropEmitter: EventEmitter<ClrDragEvent<T>>;
+    isDraggableMatch: boolean;
+    private droppableEl;
+    private clientRect;
+    private _isDraggableOver;
+    private _group;
+    private _dropTolerance;
+    private dragStartSubscription;
+    private dragMoveSubscription;
+    private dragEndSubscription;
+    constructor(el: ElementRef, eventBus: DragAndDropEventBusService<T>, domAdapter: DomAdapter, renderer: Renderer2);
+    set group(value: string | string[]);
+    set dropTolerance(value: number | string | ClrDropToleranceInterface);
+    set isDraggableOver(value: boolean);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private dropToleranceGenerator;
     private unsubscribeFrom;
     private checkGroupMatch;
     private isInDropArea;
     private onDragStart;
     private onDragMove;
     private onDragEnd;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrDroppable<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ClrDroppable<any>, "[clrDroppable]", never, { "group": "clrGroup"; "dropTolerance": "clrDropTolerance"; }, { "dragStartEmitter": "clrDragStart"; "dragMoveEmitter": "clrDragMove"; "dragEndEmitter": "clrDragEnd"; "dragLeaveEmitter": "clrDragLeave"; "dragEnterEmitter": "clrDragEnter"; "dropEmitter": "clrDrop"; }, never>;
 }

package/utils/drag-and-drop/providers/drag-event-listener.service.d.ts

@@ -7,26 +7,26 @@ export declare class DragEventListenerService<T> {
     private ngZone;
     private renderer;
     private eventBus;
+    dragDataTransfer?: T;
+    group?: string | string[];
+    dragStartDelay: number;
+    ghostElement?: any;
+    dropPointPosition?: DragPointPosition;
     private draggableEl;
-    private listeners;
-    private nestedListeners;
-    private checkDragStartBoundaryListener;
+    private hasDragStarted;
+    private initialPosition;
+    private dragStartDelayTimeout;
     private dragStart;
     private dragMove;
     private dragEnd;
-    private hasDragStarted;
-    private dragStartDelayTimeout;
+    private listeners;
+    private nestedListeners;
+    private checkDragStartBoundaryListener;
+    constructor(ngZone: NgZone, renderer: Renderer2, eventBus: DragAndDropEventBusService<T>);
     get dragStarted(): Observable<DragEventInterface<T>>;
     get dragMoved(): Observable<DragEventInterface<T>>;
     get dragEnded(): Observable<DragEventInterface<T>>;
     get dragStartPosition(): DragPointPosition;
-    constructor(ngZone: NgZone, renderer: Renderer2, eventBus: DragAndDropEventBusService<T>);
-    private initialPosition;
-    dragDataTransfer?: T;
-    group?: string | string[];
-    dragStartDelay: number;
-    ghostElement?: any;
-    dropPointPosition?: DragPointPosition;
     attachDragListeners(draggableEl: Node): void;
     detachDragListeners(): void;
     private getNativeEventObject;

package/utils/drag-and-drop/providers/drag-handle-registrar.service.d.ts

@@ -6,13 +6,13 @@ export declare class DragHandleRegistrarService<T> {
     private renderer;
     private _customHandleEl;
     private _defaultHandleEl;
+    constructor(dragEventListener: DragEventListenerService<T>, renderer: Renderer2);
     get defaultHandleEl(): Node;
     set defaultHandleEl(el: Node);
-    constructor(dragEventListener: DragEventListenerService<T>, renderer: Renderer2);
-    private makeElementHandle;
     get customHandleEl(): any;
     registerCustomHandle(el: Node): void;
     unregisterCustomHandle(): void;
+    private makeElementHandle;
     static ɵfac: i0.ɵɵFactoryDeclaration<DragHandleRegistrarService<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DragHandleRegistrarService<any>>;
 }

package/utils/drag-and-drop/providers/draggable-snapshot.service.d.ts

@@ -3,14 +3,14 @@ import { DragEventInterface } from '../interfaces/drag-event.interface';
 import * as i0 from "@angular/core";
 export declare class DraggableSnapshotService<T> {
     private domAdapter;
-    constructor(domAdapter: DomAdapter);
     private draggableElClientRect;
     private snapshotDragEvent;
-    capture(el: Node, event: DragEventInterface<T>): void;
-    discard(): void;
+    constructor(domAdapter: DomAdapter);
     get hasDraggableState(): boolean;
     get clientRect(): ClientRect;
     get dragEvent(): DragEventInterface<T>;
+    capture(el: Node, event: DragEventInterface<T>): void;
+    discard(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DraggableSnapshotService<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DraggableSnapshotService<any>>;
 }

package/utils/focus/focus-on-view-init/focus-on-view-init.d.ts

@@ -5,11 +5,11 @@ export declare class ClrFocusOnViewInit implements AfterViewInit, OnDestroy {
     private platformId;
     private focusOnViewInit;
     private renderer;
-    private destroy$;
-    constructor(el: ElementRef, platformId: any, focusOnViewInit: boolean, document: any, renderer: Renderer2, ngZone: NgZone);
     private document;
     private directFocus;
+    private destroy$;
     private _isEnabled;
+    constructor(el: ElementRef, platformId: any, focusOnViewInit: boolean, document: any, renderer: Renderer2, ngZone: NgZone);
     set isEnabled(value: boolean | string);
     ngAfterViewInit(): void;
     ngOnDestroy(): void;

package/utils/focus/focus.service.d.ts

@@ -4,9 +4,9 @@ import { FocusableItem } from './focusable-item/focusable-item';
 import * as i0 from "@angular/core";
 export declare class FocusService {
     private renderer;
-    constructor(renderer: Renderer2);
-    private _unlistenFuncs;
     private _current;
+    private _unlistenFuncs;
+    constructor(renderer: Renderer2);
     get current(): FocusableItem;
     reset(first: FocusableItem): void;
     listenToArrowKeys(el: HTMLElement): void;

package/utils/focus/focusable-item/basic-focusable-item.service.d.ts

@@ -6,8 +6,8 @@ export declare class BasicFocusableItem implements FocusableItem {
     private renderer;
     private platformId;
     id: string;
-    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2, platformId: any);
     disabled: boolean;
+    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2, platformId: any);
     focus(): void;
     blur(): void;
     activate(): void;

package/utils/focus/focusable-item/focusable-item.d.ts

@@ -2,11 +2,11 @@ import { Observable } from 'rxjs';
 export declare abstract class FocusableItem {
     id: string;
     disabled?: boolean;
-    abstract focus(): void;
-    abstract blur(): void;
-    abstract activate?(): void;
     up?: FocusableItem | Observable<FocusableItem>;
     down?: FocusableItem | Observable<FocusableItem>;
     left?: FocusableItem | Observable<FocusableItem>;
     right?: FocusableItem | Observable<FocusableItem>;
+    abstract focus(): void;
+    abstract blur(): void;
+    abstract activate?(): void;
 }

package/utils/focus/key-focus/key-focus-item.d.ts

@@ -3,8 +3,8 @@ import * as i0 from "@angular/core";
 export declare class ClrKeyFocusItem {
     private elementRef;
     private platformId;
-    get nativeElement(): any;
     constructor(elementRef: ElementRef, platformId: any);
+    get nativeElement(): any;
     focus(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrKeyFocusItem, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ClrKeyFocusItem, "[clrKeyFocusItem]", never, {}, {}, never>;

package/utils/focus/key-focus/key-focus.d.ts

@@ -6,35 +6,39 @@ import { ClrKeyFocusItem } from './key-focus-item';
 import * as i0 from "@angular/core";
 export declare class ClrKeyFocus {
     private elementRef;
-    constructor(elementRef: ElementRef);
     direction: ClrFocusDirection | string;
     focusOnLoad: boolean;
-    private focusChange;
     protected clrKeyFocusItems: QueryList<ClrKeyFocusItem>;
+    protected subscriptions: Subscription[];
+    private focusChange;
+    private _current;
     private _focusableItems;
-    set focusableItems(elements: Array<FocusableItem> | any);
+    constructor(elementRef: ElementRef);
+    /**
+     * Here we use `any` cause any other type require reworking all methods below and a lot of more ifs.
+     * this method will only work with array with FocusableItems anyway so any other value will be ignored.
+     */
     get focusableItems(): Array<FocusableItem> | any;
+    set focusableItems(elements: Array<FocusableItem> | any);
     get nativeElement(): HTMLElement;
-    private _current;
     get current(): number;
     set current(value: number);
     get currentItem(): any;
     get currentItemElement(): HTMLElement;
-    focusCurrent(): void;
-    moveTo(position: number): void;
-    protected subscriptions: Subscription[];
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
     handleKeyboardEvent(event: KeyboardEvent): void;
     setClickedItemCurrent(event: any): void;
-    private getItemPosition;
+    focusCurrent(): void;
+    moveTo(position: number): void;
     protected positionInRange(position: number): boolean;
     protected currentFocusIsNotFirstItem(): boolean;
     protected currentFocusIsNotLastItem(): boolean;
     protected initializeFocus(): void;
-    private listenForItemUpdates;
     protected nextKeyPressed(event: KeyboardEvent): boolean;
     protected prevKeyPressed(event: KeyboardEvent): boolean;
+    private getItemPosition;
+    private listenForItemUpdates;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrKeyFocus, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ClrKeyFocus, "[clrKeyFocus]", never, { "direction": "clrDirection"; "focusOnLoad": "clrFocusOnLoad"; "focusableItems": "clrKeyFocus"; }, { "focusChange": "clrFocusChange"; }, ["clrKeyFocusItems"], ["*"]>;
 }

package/utils/focus/key-focus/roving-tabindex.d.ts

@@ -4,10 +4,10 @@ import { ClrKeyFocus } from './key-focus';
 import * as i0 from "@angular/core";
 export declare class ClrRovingTabindex extends ClrKeyFocus {
     private renderer;
+    private disabled;
     constructor(elementRef: ElementRef, renderer: Renderer2);
-    set rovingIndexItems(elements: Array<FocusableItem> | string);
     get rovingIndexItems(): Array<FocusableItem> | string;
-    private disabled;
+    set rovingIndexItems(elements: Array<FocusableItem> | string);
     set rovingTabindexDisabled(disabled: boolean);
     handleKeyboardEvent(event: KeyboardEvent): void;
     setClickedItemCurrent(event: any): void;

package/utils/focus-trap/focus-trap.d.ts

@@ -12,13 +12,13 @@ export declare function removeReboundElementsFromFocusTrapElement(focusTrapEleme
 export declare function castHtmlElementToFocusTrapElement(el: HTMLElement): FocusTrapElement;
 export declare class FocusTrap {
     protected renderer: Renderer2;
+    active: boolean;
+    firstFocusElement: HTMLElement | FocusTrapElement;
     focusTrapElement: FocusTrapElement;
+    protected _document: Document;
     private previousFocus;
     private onFocusInEvent;
     private unlisten;
-    protected _document: Document;
-    firstFocusElement: HTMLElement | FocusTrapElement;
-    active: boolean;
     constructor(renderer: Renderer2, injector: Injector, platformId: any, hostElement: FocusTrapElement);
     enableFocusTrap(): void;
     removeFocusTrap(): void;

package/utils/focus-trap/focus-trap.directive.d.ts

@@ -17,22 +17,22 @@ export declare class FocusTrapDirective implements OnInit, AfterViewInit, OnDest
     private bottomReboundEl;
     private firstFocusableEl;
     private lastFocusableEl;
-    constructor(el: ElementRef, injector: Injector, focusTrapsTracker: FocusTrapTracker, renderer: Renderer2, platformId: any);
     private _config;
+    constructor(el: ElementRef, injector: Injector, focusTrapsTracker: FocusTrapTracker, renderer: Renderer2, platformId: any);
     set config(config: FocusTrapConfig | string);
+    private get potentiallyFocusableEls();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
     onFocusIn(event: any): void;
+    setPreviousFocus(): void;
     private createFocusableOffScreenEl;
     private addReboundEls;
     private removeReboundEls;
-    setPreviousFocus(): void;
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
-    private get potentiallyFocusableEls();
     private focusFirstFocusable;
     private focusLastFocusable;
     private focusTrapElIfOutside;
     private focusElement;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FocusTrapDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FocusTrapDirective, "[clrFocusTrap]", never, { "config": "clrFocusTrap"; }, {}, never>;
 }

package/utils/for-type-ahead/for-type-ahead.d.ts

@@ -4,12 +4,12 @@ import * as i0 from "@angular/core";
 export declare class ClrForTypeAhead {
     private el;
     private forTypeAheadProvider;
-    constructor(el: ElementRef, forTypeAheadProvider: ForTypeAheadProvider);
-    private trimAndLowerCase;
     private _content;
+    constructor(el: ElementRef, forTypeAheadProvider: ForTypeAheadProvider);
     get content(): string;
     set content(value: string);
     ngOnInit(): void;
+    private trimAndLowerCase;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrForTypeAhead, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ClrForTypeAhead, "[clrForTypeAhead]", never, { "content": "clrForTypeAhead"; }, {}, never>;
 }

package/utils/for-type-ahead/for-type-ahead.service.d.ts

@@ -1,11 +1,11 @@
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class ForTypeAheadProvider {
-    private _textContentChange;
-    get textContentChange(): Observable<string>;
     private _textContent;
+    private _textContentChange;
     get textContent(): string;
     set textContent(value: string);
+    get textContentChange(): Observable<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ForTypeAheadProvider, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ForTypeAheadProvider>;
 }

package/utils/host-wrapping/host-wrapper.d.ts

@@ -6,7 +6,7 @@ import { DynamicWrapper } from './dynamic-wrapper';
  * TODO - make sure these comment annotations do not break ng-packgr.
  */
 export declare class HostWrapper<W extends DynamicWrapper> implements Injector {
-    constructor(containerType: Type<W>, vcr: ViewContainerRef, index?: number);
     private injector;
+    constructor(containerType: Type<W>, vcr: ViewContainerRef, index?: number);
     get<T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T): T;
 }

package/utils/i18n/common-strings.interface.d.ts

@@ -268,6 +268,10 @@ export interface ClrCommonStrings {
      * Wizard: Screen-reader text for step with error.
      */
     wizardStepError: string;
+    /**
+     * Wizard: Aria-label for the stepnav section.
+     */
+    wizardStepnavAriaLabel: string;
     /**
      * Password Input
      * Screen-reader text for the hide/show password field button.

package/utils/i18n/common-strings.service.d.ts

@@ -2,14 +2,14 @@ import { ClrCommonStrings } from '../../utils/i18n/common-strings.interface';
 import * as i0 from "@angular/core";
 export declare class ClrCommonStringsService {
     private _strings;
-    /**
-     * Allows you to pass in new overrides for localization
-     */
-    localize(overrides: Partial<ClrCommonStrings>): void;
     /**
      * Access to all of the keys as strings
      */
     get keys(): Readonly<ClrCommonStrings>;
+    /**
+     * Allows you to pass in new overrides for localization
+     */
+    localize(overrides: Partial<ClrCommonStrings>): void;
     /**
      * Parse a string with a set of tokens to replace
      */

package/utils/loading/loading.d.ts

@@ -10,8 +10,8 @@ export declare enum ClrLoadingState {
 export declare class ClrLoading implements OnDestroy {
     private listener;
     static ngAcceptInputType_loadingState: boolean | ClrLoadingState | null | string;
-    constructor(listener: LoadingListener);
     private _loadingState;
+    constructor(listener: LoadingListener);
     get loadingState(): boolean | string | ClrLoadingState;
     set loadingState(value: boolean | string | ClrLoadingState);
     ngOnDestroy(): void;

package/utils/popover/popover-close-button.d.ts

@@ -6,9 +6,9 @@ export declare class ClrPopoverCloseButton implements OnDestroy, AfterViewInit {
     private elementRef;
     private smartEventsService;
     private smartOpenService;
+    closeChange: EventEmitter<void>;
     private subscriptions;
     constructor(elementRef: ElementRef, smartEventsService: ClrPopoverEventsService, smartOpenService: ClrPopoverToggleService);
-    closeChange: EventEmitter<void>;
     handleClick(event: MouseEvent): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;

package/utils/popover/popover-content.d.ts

@@ -15,15 +15,17 @@ export declare class ClrPopoverContent implements AfterContentChecked, OnDestroy
     private smartOpenService;
     private view;
     private subscriptions;
+    private removeClickListenerFn;
+    private shouldRealign;
+    private checkCollector;
+    constructor(document: Document, container: ViewContainerRef, template: TemplateRef<any>, renderer: Renderer2, smartPositionService: ClrPopoverPositionService, smartEventsService: ClrPopoverEventsService, smartOpenService: ClrPopoverToggleService);
     set open(value: boolean);
     set contentAt(position: ClrPopoverPosition);
     set outsideClickClose(clickToClose: boolean);
     set scrollToClose(scrollToClose: boolean);
-    private removeClickListenerFn;
-    constructor(document: Document, container: ViewContainerRef, template: TemplateRef<any>, renderer: Renderer2, smartPositionService: ClrPopoverPositionService, smartEventsService: ClrPopoverEventsService, smartOpenService: ClrPopoverToggleService);
+    ngAfterContentChecked(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    private removeContent;
     /**
      * TODO(matt): investigate why DebugElement retains a reference to the nodes and causes a memory leak.
      * A note about the use of appendChild/removeChild
@@ -32,9 +34,7 @@ export declare class ClrPopoverContent implements AfterContentChecked, OnDestroy
      * it is a low priority issue for now.
      */
     private addContent;
-    private shouldRealign;
-    private checkCollector;
-    ngAfterContentChecked(): void;
+    private removeContent;
     private alignContent;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverContent, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ClrPopoverContent, "[clrPopoverContent]", never, { "open": "clrPopoverContent"; "contentAt": "clrPopoverContentAt"; "outsideClickClose": "clrPopoverContentOutsideClickToClose"; "scrollToClose": "clrPopoverContentScrollToClose"; }, {}, never>;

package/utils/popover/popover-open-close-button.d.ts

@@ -3,9 +3,9 @@ import { ClrPopoverToggleService } from './providers/popover-toggle.service';
 import * as i0 from "@angular/core";
 export declare class ClrPopoverOpenCloseButton implements OnDestroy {
     private smartOpenService;
+    openCloseChange: EventEmitter<boolean>;
     private subscriptions;
     constructor(smartOpenService: ClrPopoverToggleService);
-    openCloseChange: EventEmitter<boolean>;
     handleClick(event: MouseEvent): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverOpenCloseButton, never>;

package/utils/popover/providers/popover-events.service.d.ts

@@ -8,33 +8,27 @@ export declare class ClrPopoverEventsService implements OnDestroy {
     private document;
     outsideClickClose: boolean;
     scrollToClose: boolean;
-    private documentClickListener;
     ignoredEvent: any;
+    anchorButtonRef: ElementRef;
+    closeButtonRef: ElementRef;
+    contentRef: ElementRef;
+    private documentClickListener;
+    private escapeListener;
+    private scrollSubscription;
     private subscriptions;
+    private documentScroller;
     constructor(renderer: Renderer2, smartOpenService: ClrPopoverToggleService, document: HTMLDocument);
-    private scrollSubscription;
+    ngOnDestroy(): void;
     addScrollListener(): void;
     removeScrollListener(): void;
-    private testForSmartPopoverContentContainer;
     addClickListener(): void;
     removeClickListener(): void;
-    private escapeListener;
     addEscapeListener(): void;
     removeEscapeListener(): void;
-    private _anchorButtonRef;
-    set anchorButtonRef(ref: ElementRef);
-    get anchorButtonRef(): ElementRef;
-    private _closeButtonRef;
-    set closeButtonRef(ref: ElementRef);
-    get closeButtonRef(): ElementRef;
     setCloseFocus(): void;
     setAnchorFocus(): void;
-    private _contentRef;
-    set contentRef(host: ElementRef);
-    get contentRef(): ElementRef;
-    private documentScroller;
+    private testForSmartPopoverContentContainer;
     private removeAllEventListeners;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverEventsService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ClrPopoverEventsService>;
 }

package/utils/popover/providers/popover-position.service.d.ts

@@ -6,16 +6,14 @@ import * as i0 from "@angular/core";
 export declare class ClrPopoverPositionService {
     private eventService;
     platformId: any;
+    position: ClrPopoverPosition;
+    shouldRealign: Observable<void>;
     private currentAnchorCoords;
     private currentContentCoords;
     private contentOffsets;
-    private _position;
     private _shouldRealign;
-    shouldRealign: Observable<void>;
-    realign(): void;
-    set position(position: ClrPopoverPosition);
-    get position(): ClrPopoverPosition;
     constructor(eventService: ClrPopoverEventsService, platformId: any);
+    realign(): void;
     alignContent(content: HTMLElement): ClrPopoverContentOffset;
     private handleVerticalAxisOneViolation;
     private handleVerticalAxisTwoViolations;

package/utils/popover/providers/popover-toggle.service.d.ts

@@ -1,28 +1,24 @@
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class ClrPopoverToggleService {
-    /**
-     *  Popovers might need to ignore click events on an element
-     *  (eg: popover opens on focus on an input field. Clicks should be ignored in this case)
-     */
     private _open;
     private _openChange;
     private _openEvent;
     private _openEventChange;
+    private _popoverAligned;
     get openChange(): Observable<boolean>;
-    set openEvent(event: Event);
     get openEvent(): Event;
-    getEventChange(): Observable<Event>;
-    set open(value: boolean);
+    set openEvent(event: Event);
     get open(): boolean;
+    set open(value: boolean);
     get originalEvent(): Event;
+    get popoverAligned(): Observable<HTMLElement>;
+    getEventChange(): Observable<Event>;
     /**
      * Sometimes, we need to remember the event that triggered the toggling to avoid loops.
      * This is for instance the case of components that open on a click, but close on a click outside.
      */
     toggleWithEvent(event: any): void;
-    private _popoverAligned;
-    get popoverAligned(): Observable<HTMLElement>;
     popoverAlignedEmit(popoverNode: HTMLElement): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverToggleService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ClrPopoverToggleService>;

package/wizard/heading-level.d.ts

@@ -0,0 +1 @@
+export declare type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6 | '1' | '2' | '3' | '4' | '5' | '6';

package/wizard/index.d.ts

@@ -4,9 +4,10 @@ export * from './wizard-stepnav';
 export * from './wizard-stepnav-item';
 export * from './wizard-button';
 export * from './wizard-header-action';
-export * from './wizard-custom-tags';
+export * from './wizard-title';
 export * from './wizard-page-title';
 export * from './wizard-page-navtitle';
 export * from './wizard-page-buttons';
 export * from './wizard-page-header-actions';
 export * from './wizard.module';
+export * from './heading-level';

package/wizard/providers/button-hub.service.d.ts

@@ -3,16 +3,16 @@ import * as i0 from "@angular/core";
 export declare class ButtonHubService {
     buttonsReady: boolean;
     private _previousBtnClicked;
-    get previousBtnClicked(): Observable<any>;
     private _nextBtnClicked;
-    get nextBtnClicked(): Observable<any>;
     private _dangerBtnClicked;
-    get dangerBtnClicked(): Observable<any>;
     private _cancelBtnClicked;
-    get cancelBtnClicked(): Observable<any>;
     private _finishBtnClicked;
-    get finishBtnClicked(): Observable<any>;
     private _customBtnClicked;
+    get previousBtnClicked(): Observable<any>;
+    get nextBtnClicked(): Observable<any>;
+    get dangerBtnClicked(): Observable<any>;
+    get cancelBtnClicked(): Observable<any>;
+    get finishBtnClicked(): Observable<any>;
     get customBtnClicked(): Observable<any>;
     buttonClicked(buttonType: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ButtonHubService, never>;