@rossigee/clarity-angular 18.2.1-fixed.1 → 18.2.1

package/types/clr-angular-popover-signpost.d.ts

@@ -0,0 +1,157 @@
+import * as i8 from '@clr/angular/popover/common';
+import { ClrPopoverService, ClrPopoverPoint, ClrPopoverContent, ClrPopoverPosition } from '@clr/angular/popover/common';
+import * as i7 from '@clr/angular/utils';
+import { ClrCommonStringsService } from '@clr/angular/utils';
+import * as i0 from '@angular/core';
+import { OnDestroy, ElementRef, AfterViewInit, Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i5 from '@angular/common';
+import * as i6 from '@clr/angular/icon';
+
+declare class SignpostFocusManager {
+    private _triggerEl;
+    set triggerEl(value: HTMLElement);
+    focusTrigger(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignpostFocusManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignpostFocusManager>;
+}
+
+declare class SignpostIdService {
+    private _id;
+    get id(): Observable<string>;
+    setId(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignpostIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignpostIdService>;
+}
+
+declare class ClrSignpostTrigger implements OnDestroy {
+    private popoverService;
+    private el;
+    private signpostIdService;
+    private signpostFocusManager;
+    private platformId;
+    ariaExpanded: boolean;
+    ariaControl: string;
+    isOpen: boolean;
+    private document;
+    private subscriptions;
+    constructor(popoverService: ClrPopoverService, el: ElementRef<HTMLElement>, signpostIdService: SignpostIdService, signpostFocusManager: SignpostFocusManager, document: any, platformId: any);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**********
+     *
+     * @description
+     * click handler for the ClrSignpost trigger button used to hide/show ClrSignpostContent.
+     */
+    onSignpostTriggerClick(event: Event): void;
+    private focusOnClose;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrSignpostTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrSignpostTrigger, "[clrSignpostTrigger]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrSignpost {
+    commonStrings: ClrCommonStringsService;
+    private popoverService;
+    /**********
+     * @property useCustomTrigger
+     *
+     * @description
+     * Flag used to determine if we need to use the default trigger or a user supplied trigger element.
+     *
+     */
+    useCustomTrigger: boolean;
+    signpostTriggerAriaLabel: string;
+    /**
+     * Hides the default trigger button. Use when the signpost is opened
+     * programmatically via `openAtPoint()` and no trigger icon is needed.
+     */
+    hideTrigger: boolean;
+    constructor(commonStrings: ClrCommonStringsService, popoverService: ClrPopoverService);
+    /**********
+     * @property signPostTrigger
+     *
+     * @description
+     * Uses ContentChild to check for a user supplied element with the ClrSignpostTrigger on it.
+     *
+     */
+    set customTrigger(trigger: ClrSignpostTrigger);
+    get showDefaultTrigger(): boolean;
+    openAtPoint(point: ClrPopoverPoint, targetElement?: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrSignpost, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrSignpost, "clr-signpost", never, { "signpostTriggerAriaLabel": { "alias": "clrSignpostTriggerAriaLabel"; "required": false; }; "hideTrigger": { "alias": "clrSignpostHideTrigger"; "required": false; }; }, {}, ["customTrigger"], ["*"], false, [{ directive: typeof i8.ClrPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ClrSignpostContent implements OnDestroy, AfterViewInit {
+    private element;
+    commonStrings: ClrCommonStringsService;
+    private signpostFocusManager;
+    private platformId;
+    private document;
+    private popoverService;
+    private popoverContent;
+    signpostCloseAriaLabel: string;
+    closeButton: ElementRef<HTMLButtonElement>;
+    signpostContentId: string;
+    private _position;
+    constructor(parentHost: ElementRef<HTMLElement>, element: ElementRef, commonStrings: ClrCommonStringsService, signpostIdService: SignpostIdService, signpostFocusManager: SignpostFocusManager, platformId: any, document: Document, popoverService: ClrPopoverService, popoverContent: ClrPopoverContent);
+    /*********
+     *
+     * @description
+     * A setter for the position of the ClrSignpostContent popover. This is a combination of the following:
+     * - originPoint - where on the trigger to position the content
+     * - popoverPoint - where on the content container to align with the origin
+     * - offsetY - where on the Y axis to align the ClrSignpostContent so it meets specs
+     * - offsetX - where on the X axis to align the ClrSignpostContent so it meets specs
+     * There are 12 possible positions to place a ClrSignpostContent container:
+     * - top-left
+     * - top-middle
+     * - top-right
+     * - right-top
+     * - right-middle
+     * - right-bottom
+     * - bottom-right
+     * - bottom-middle
+     * - bottom-left
+     * - left-bottom
+     * - left-middle
+     * - left-top
+     *
+     * I think of it as follows for 'top-left' -> CONTAINER_SIDE-SIDE_POSITION. In this case CONTAINER_SIDE is 'top'
+     * meaning the top of the trigger icon (above the icon that hides/shows) the ClrSignpostContent. And, SIDE_POSITION
+     * is 'left' meaning two things: 1) the ClrSignpostContent container extends to the left and 2) the 'arrow/pointer'
+     * linking the SignpostContent to the trigger points down at the horizontal center of the trigger icon.
+     *
+     * @param newPosition
+     */
+    get position(): string | ClrPopoverPosition;
+    set position(position: string | ClrPopoverPosition);
+    get isOffScreen(): boolean;
+    /**********
+     *
+     * @description
+     * Close function that uses the signpost instance to toggle the state of the content popover.
+     *
+     */
+    close(): void;
+    ngAfterViewInit(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    ngOnDestroy(): void;
+    private getFocusableElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrSignpostContent, [{ optional: true; }, null, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrSignpostContent, "clr-signpost-content", never, { "signpostCloseAriaLabel": { "alias": "clrSignpostCloseAriaLabel"; "required": false; }; "position": { "alias": "clrPosition"; "required": false; }; }, {}, never, ["clr-signpost-title", "*"], false, [{ directive: typeof i8.ClrPopoverContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ClrSignpostTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrSignpostTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrSignpostTitle, "clr-signpost-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare const CLR_SIGNPOST_DIRECTIVES: Type<any>[];
+declare class ClrSignpostModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrSignpostModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrSignpostModule, [typeof ClrSignpost, typeof ClrSignpostContent, typeof ClrSignpostTrigger, typeof ClrSignpostTitle], [typeof i5.CommonModule, typeof i6.ClrIcon, typeof i7.ClrFocusOnViewInitModule, typeof i8.ClrPopoverModuleNext, typeof i8.ClrIfOpen], [typeof ClrSignpost, typeof ClrSignpostContent, typeof ClrSignpostTrigger, typeof ClrSignpostTitle, typeof i8.ClrIfOpen]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrSignpostModule>;
+}
+
+export { CLR_SIGNPOST_DIRECTIVES, ClrSignpost, ClrSignpostContent, ClrSignpostModule, ClrSignpostTitle, ClrSignpostTrigger };

package/types/clr-angular-popover-tooltip.d.ts

@@ -0,0 +1,83 @@
+import * as i0 from '@angular/core';
+import { ElementRef, OnInit, Renderer2, Type } from '@angular/core';
+import * as i1 from '@clr/angular/popover/common';
+import { ClrPopoverService, ClrPopoverContent, ClrPopoverPosition } from '@clr/angular/popover/common';
+import { Observable } from 'rxjs';
+import * as i4 from '@angular/common';
+import * as i5 from '@clr/angular/icon';
+
+declare class ClrTooltip {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTooltip, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTooltip, "clr-tooltip", never, {}, {}, never, ["*"], false, [{ directive: typeof i1.ClrPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TooltipIdService {
+    private _id;
+    get id(): Observable<string>;
+    updateId(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipIdService>;
+}
+
+declare class TooltipMouseService {
+    private readonly popoverService;
+    private mouseOutDelay;
+    private mouseOverTrigger;
+    private mouseOverContent;
+    constructor(popoverService: ClrPopoverService);
+    onMouseEnterTrigger(): void;
+    onMouseLeaveTrigger(): void;
+    onMouseEnterContent(): void;
+    onMouseLeaveContent(): void;
+    private hideIfMouseOut;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipMouseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipMouseService>;
+}
+
+declare class ClrTooltipTrigger {
+    private popoverService;
+    private tooltipMouseService;
+    ariaDescribedBy: string;
+    private subs;
+    constructor(popoverService: ClrPopoverService, tooltipIdService: TooltipIdService, tooltipMouseService: TooltipMouseService, element: ElementRef);
+    ngOnDestroy(): void;
+    showTooltip(): void;
+    hideTooltip(): void;
+    private onMouseEnter;
+    private onMouseLeave;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTooltipTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrTooltipTrigger, "[clrTooltipTrigger]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrTooltipContent implements OnInit {
+    private tooltipIdService;
+    el: ElementRef;
+    private renderer;
+    private tooltipMouseService;
+    private popoverContent;
+    private _id;
+    private _position;
+    private _size;
+    constructor(parentHost: ElementRef<HTMLElement>, tooltipIdService: TooltipIdService, el: ElementRef, renderer: Renderer2, popoverService: ClrPopoverService, tooltipMouseService: TooltipMouseService, popoverContent: ClrPopoverContent);
+    get id(): string;
+    set id(value: string);
+    get position(): string | ClrPopoverPosition;
+    set position(value: string | ClrPopoverPosition);
+    get size(): string;
+    set size(value: string);
+    ngOnInit(): void;
+    private onMouseEnter;
+    private onMouseLeave;
+    private updateCssClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTooltipContent, [{ optional: true; }, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTooltipContent, "clr-tooltip-content", never, { "id": { "alias": "id"; "required": false; }; "position": { "alias": "clrPosition"; "required": false; }; "size": { "alias": "clrSize"; "required": false; }; }, {}, never, ["*"], false, [{ directive: typeof i1.ClrPopoverContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare const CLR_TOOLTIP_DIRECTIVES: Type<any>[];
+declare class ClrTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrTooltipModule, [typeof ClrTooltip, typeof ClrTooltipTrigger, typeof ClrTooltipContent], [typeof i4.CommonModule, typeof i5.ClrIcon, typeof i1.ClrPopoverModuleNext], [typeof ClrTooltip, typeof ClrTooltipTrigger, typeof ClrTooltipContent, typeof i1.ClrIfOpen, typeof i5.ClrIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrTooltipModule>;
+}
+
+export { CLR_TOOLTIP_DIRECTIVES, ClrTooltip, ClrTooltipContent, ClrTooltipModule, ClrTooltipTrigger };

package/types/clr-angular-popover.d.ts

@@ -0,0 +1,16 @@
+import * as i1 from '@clr/angular/popover/dropdown';
+export * from '@clr/angular/popover/dropdown';
+export * from '@clr/angular/popover/common';
+import * as i0 from '@angular/core';
+import * as i2 from '@clr/angular/popover/signpost';
+export * from '@clr/angular/popover/signpost';
+import * as i3 from '@clr/angular/popover/tooltip';
+export * from '@clr/angular/popover/tooltip';
+
+declare class ClrPopoverModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrPopoverModule, never, never, [typeof i1.ClrDropdownModule, typeof i2.ClrSignpostModule, typeof i3.ClrTooltipModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrPopoverModule>;
+}
+
+export { ClrPopoverModule };

package/types/clr-angular-progress-progress-bars.d.ts

@@ -0,0 +1,57 @@
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i2 from '@angular/common';
+
+declare class ClrProgressBar {
+    max: number | string;
+    displayval: string;
+    color: string;
+    value: number | string;
+    externalId: string;
+    private _ID;
+    private _labeled;
+    private _fade;
+    private _loop;
+    private _flash;
+    private _flashDanger;
+    private _compact;
+    get id(): string;
+    set id(value: string);
+    get progressClass(): boolean;
+    set clrCompact(value: boolean | string);
+    get compactClass(): boolean;
+    set clrLabeled(value: boolean | string);
+    get labeledClass(): boolean;
+    set clrFade(value: boolean | string);
+    get fadeClass(): boolean;
+    set clrLoop(value: boolean | string);
+    get loopClass(): boolean;
+    get warningClass(): boolean;
+    get successClass(): boolean;
+    get dangerClass(): boolean;
+    set clrFlash(value: boolean | string);
+    get flashClass(): boolean;
+    /** @deprecated since 2.0, remove in 4.0 */
+    set clrFlashDanger(value: boolean | string);
+    get flashDangerClass(): boolean;
+    /**
+     * Make sure that we always will have something that is readable
+     * for the screen reader
+     */
+    get displayValue(): string;
+    /**
+     * Display optional text only when labeled is eneabled
+     */
+    displayStringValue(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrProgressBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrProgressBar, "clr-progress-bar", never, { "max": { "alias": "clrMax"; "required": false; }; "displayval": { "alias": "clrDisplayval"; "required": false; }; "color": { "alias": "clrColor"; "required": false; }; "value": { "alias": "clrValue"; "required": false; }; "id": { "alias": "id"; "required": false; }; "clrCompact": { "alias": "clrCompact"; "required": false; }; "clrLabeled": { "alias": "clrLabeled"; "required": false; }; "clrFade": { "alias": "clrFade"; "required": false; }; "clrLoop": { "alias": "clrLoop"; "required": false; }; "clrFlash": { "alias": "clrFlash"; "required": false; }; "clrFlashDanger": { "alias": "clrFlashDanger"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const CLR_PROGRESS_BAR_DIRECTIVES: Type<any>[];
+declare class ClrProgressBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrProgressBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrProgressBarModule, [typeof ClrProgressBar], [typeof i2.CommonModule], [typeof ClrProgressBar]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrProgressBarModule>;
+}
+
+export { CLR_PROGRESS_BAR_DIRECTIVES, ClrProgressBar, ClrProgressBarModule };

package/types/clr-angular-progress-spinner.d.ts

@@ -0,0 +1,44 @@
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i2 from '@angular/common';
+
+declare class ClrSpinner {
+    private _inline;
+    private _inverse;
+    private _small;
+    private _medium;
+    /**
+     * Default class for all spinners. This class is always true
+     */
+    get spinnerClass(): boolean;
+    get inlineClass(): boolean;
+    set clrInline(value: boolean | string);
+    get inverseClass(): boolean;
+    set clrInverse(value: boolean | string);
+    get smallClass(): boolean;
+    set clrSmall(value: boolean | string);
+    /**
+     * When clrSmall & clrMedium are set both to true.
+     * The CSS with high priority will be small - so medium size will be ignored.
+     *
+     * For this reason if clrSmall is set we won't add clrMedium class.
+     *
+     * NOTE: This is dictated by the CSS rules.
+     * DON'T USE clrSmall & clrMedium to toggle classes. This could change without notice.
+     *
+     * Also there is no logical need to have both of them set to TRUE or FALSE.
+     */
+    get mediumClass(): boolean;
+    set clrMedium(value: boolean | string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrSpinner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrSpinner, "clr-spinner", never, { "clrInline": { "alias": "clrInline"; "required": false; }; "clrInverse": { "alias": "clrInverse"; "required": false; }; "clrSmall": { "alias": "clrSmall"; "required": false; }; "clrMedium": { "alias": "clrMedium"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare const CLR_SPINNER_DIRECTIVES: Type<any>[];
+declare class ClrSpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrSpinnerModule, [typeof ClrSpinner], [typeof i2.CommonModule], [typeof ClrSpinner]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrSpinnerModule>;
+}
+
+export { CLR_SPINNER_DIRECTIVES, ClrSpinner, ClrSpinnerModule };

package/types/clr-angular-stepper.d.ts

@@ -0,0 +1,179 @@
+import * as _angular_forms from '@angular/forms';
+import { FormGroupName, NgModelGroup, FormGroupDirective, NgForm } from '@angular/forms';
+import * as i0 from '@angular/core';
+import { OnInit, ElementRef, QueryList, ChangeDetectorRef, OnChanges, AfterViewInit, OnDestroy, SimpleChanges } from '@angular/core';
+import { CollapsiblePanelModel, CollapsiblePanelGroupModel, CollapsiblePanelService, CollapsiblePanel } from '@clr/angular/collapsible-panel';
+import { ClrCommonStringsService, IfExpandService, WillyWonka, OompaLoompa } from '@clr/angular/utils';
+import { Observable } from 'rxjs';
+import * as i9 from '@angular/common';
+import * as i10 from '@clr/angular/icon';
+
+declare enum StepperPanelStatus {
+    Inactive = "inactive",
+    Error = "error",
+    Complete = "complete"
+}
+
+declare class StepperPanelModel extends CollapsiblePanelModel {
+    status: StepperPanelStatus;
+}
+
+declare class StepperModel extends CollapsiblePanelGroupModel {
+    protected _panels: {
+        [id: string]: StepperPanelModel;
+    };
+    private stepperModelInitialize;
+    private initialPanel;
+    get panels(): StepperPanelModel[];
+    get allPanelsCompleted(): boolean;
+    get shouldOpenFirstPanel(): boolean;
+    addPanel(id: string, open?: boolean): void;
+    updatePanelOrder(ids: string[]): void;
+    togglePanel(panelId: string): void;
+    navigateToPreviousPanel(currentPanelId: string): void;
+    navigateToNextPanel(currentPanelId: string, currentPanelValid?: boolean): void;
+    overrideInitialPanel(panelId: string): void;
+    setPanelValid(panelId: string): void;
+    setPanelInvalid(panelId: string): void;
+    setPanelsWithErrors(ids: string[]): void;
+    resetPanels(): void;
+    getNextPanel(currentPanelId: string): StepperPanelModel;
+    getPreviousPanel(currentPanelId: string): StepperPanelModel;
+    private resetAllFuturePanels;
+    private resetPanel;
+    private openFirstPanel;
+    private completePanel;
+    private openNextPanel;
+    private openPreviousPanel;
+    private setPanelError;
+    private getFirstPanel;
+    private getNumberOfIncompletePanels;
+    private getNumberOfOpenPanels;
+}
+
+declare class StepperService extends CollapsiblePanelService {
+    readonly activeStep: Observable<string>;
+    readonly panelsCompleted: Observable<boolean>;
+    protected panelGroup: StepperModel;
+    private _activeStepChanges;
+    constructor();
+    resetPanels(): void;
+    setPanelValid(panelId: string): void;
+    setPanelInvalid(panelId: string): void;
+    setPanelsWithErrors(ids: string[]): void;
+    navigateToPreviousPanel(currentPanelId: string): void;
+    navigateToNextPanel(currentPanelId: string, currentPanelValid?: boolean): void;
+    overrideInitialPanel(panelId: string): void;
+    private updateNextStep;
+    private updatePreviousStep;
+    private getAllCompletedPanelChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepperService>;
+}
+
+declare class ClrStepDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStepDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStepDescription, "clr-step-description", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class ClrStepperPanel extends CollapsiblePanel implements OnInit {
+    private platformId;
+    commonStrings: ClrCommonStringsService;
+    private formGroupName;
+    private ngModelGroup;
+    private stepperService;
+    headerButton: ElementRef<HTMLButtonElement>;
+    stepDescription: QueryList<ClrStepDescription>;
+    disabled: boolean;
+    readonly PanelStatus: typeof StepperPanelStatus;
+    panel: Observable<StepperPanelModel>;
+    private subscriptions;
+    constructor(platformId: any, commonStrings: ClrCommonStringsService, formGroupName: FormGroupName, ngModelGroup: NgModelGroup, stepperService: StepperService, ifExpandService: IfExpandService, cdr: ChangeDetectorRef);
+    get id(): string;
+    set id(_value: string);
+    get panelNumber(): number;
+    get formGroup(): _angular_forms.FormGroup<any>;
+    getPanelStatus(panel: StepperPanelModel): StepperPanelStatus;
+    getPanelStateClasses(panel: StepperPanelModel): string;
+    getContentId(id: string): string;
+    getHeaderId(id: string): string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected stepCompleteText(panelNumber: number): string;
+    protected stepErrorText(panelNumber: number): string;
+    private listenToFocusChanges;
+    private triggerAllFormControlValidationIfError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStepperPanel, [null, null, { optional: true; }, { optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStepperPanel, "clr-stepper-panel", never, {}, {}, ["stepDescription"], ["clr-step-title", "clr-step-description", "*"], false, never>;
+}
+
+declare class ClrStepper implements OnInit, OnChanges, AfterViewInit, OnDestroy {
+    private formGroup;
+    private ngForm;
+    private stepperService;
+    initialPanel: string;
+    panels: QueryList<ClrStepperPanel>;
+    form: FormGroupDirective | NgForm;
+    private subscriptions;
+    constructor(formGroup: FormGroupDirective, ngForm: NgForm, stepperService: StepperService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private listenForFormResetChanges;
+    private listenForPanelsCompleted;
+    private setPanelsWithFormErrors;
+    private listenForDOMChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStepper, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStepper, "form[clrStepper]", never, { "initialPanel": { "alias": "clrInitialStep"; "required": false; }; }, {}, ["panels"], ["*"], false, never>;
+}
+
+declare enum ClrStepButtonType {
+    Next = "next",
+    Previous = "previous",
+    Submit = "submit"
+}
+declare class ClrStepButton implements OnInit {
+    private clrStep;
+    private stepperService;
+    type: ClrStepButtonType | string;
+    submitButton: boolean;
+    previousButton: boolean;
+    constructor(clrStep: ClrStepperPanel, stepperService: StepperService);
+    ngOnInit(): void;
+    navigateToNextPanel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStepButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrStepButton, "[clrStepButton]", never, { "type": { "alias": "clrStepButton"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ClrStepTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStepTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStepTitle, "clr-step-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class ClrStepContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStepContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStepContent, "clr-step-content", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class StepperWillyWonka extends WillyWonka {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperWillyWonka, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StepperWillyWonka, "form[clrStepper]", never, {}, {}, never, never, false, never>;
+}
+
+declare class StepperOompaLoompa extends OompaLoompa {
+    private expand;
+    constructor(cdr: ChangeDetectorRef, willyWonka: StepperWillyWonka, ifExpandService: IfExpandService);
+    get flavor(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperOompaLoompa, [null, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StepperOompaLoompa, "clr-stepper-panel, [clrStepButton]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrStepperModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrStepperModule, [typeof ClrStepper, typeof ClrStepButton, typeof ClrStepTitle, typeof ClrStepDescription, typeof ClrStepContent, typeof ClrStepperPanel, typeof StepperOompaLoompa, typeof StepperWillyWonka], [typeof i9.CommonModule, typeof i10.ClrIcon], [typeof ClrStepper, typeof ClrStepButton, typeof ClrStepTitle, typeof ClrStepDescription, typeof ClrStepContent, typeof ClrStepperPanel, typeof StepperOompaLoompa, typeof StepperWillyWonka, typeof i10.ClrIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrStepperModule>;
+}
+
+export { ClrStepButton, ClrStepButtonType, ClrStepContent, ClrStepDescription, ClrStepTitle, ClrStepper, ClrStepperModule, ClrStepperPanel, StepperOompaLoompa, StepperPanelModel, StepperPanelStatus, StepperService, StepperWillyWonka };

package/types/clr-angular-timeline.d.ts

@@ -0,0 +1,86 @@
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { ClrCommonStringsService } from '@clr/angular/utils';
+import * as i6 from '@angular/common';
+import * as i7 from '@clr/angular/icon';
+import * as i8 from '@clr/angular/progress/spinner';
+
+declare enum ClrTimelineLayout {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+
+declare class ClrTimeline {
+    layout: ClrTimelineLayout;
+    get isVertical(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTimeline, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTimeline, "clr-timeline", never, { "layout": { "alias": "clrLayout"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare enum ClrTimelineStepState {
+    NOT_STARTED = "not-started",
+    CURRENT = "current",
+    PROCESSING = "processing",
+    SUCCESS = "success",
+    ERROR = "error"
+}
+
+declare class TimelineIconAttributeService {
+    private attributeMap;
+    constructor(commonStrings: ClrCommonStringsService);
+    getAriaLabel(step: ClrTimelineStepState): string;
+    getIconShape(step: ClrTimelineStepState): string;
+    getIconStatus(step: ClrTimelineStepState): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineIconAttributeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimelineIconAttributeService>;
+}
+
+declare class ClrTimelineStep {
+    private iconAttributeService;
+    private platformId;
+    state: ClrTimelineStepState;
+    stepTitle: ElementRef<HTMLElement>;
+    stepTitleText: string;
+    constructor(iconAttributeService: TimelineIconAttributeService, platformId: any);
+    get iconAriaLabel(): string;
+    get iconShape(): string;
+    get iconStatus(): string;
+    get isProcessing(): boolean;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTimelineStep, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTimelineStep, "clr-timeline-step", never, { "state": { "alias": "clrState"; "required": false; }; }, {}, ["stepTitle"], ["clr-timeline-step-header", "clr-timeline-step-title", "clr-timeline-step-description"], false, never>;
+}
+
+declare class ClrTimelineStepDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTimelineStepDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTimelineStepDescription, "clr-timeline-step-description", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class ClrTimelineStepHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTimelineStepHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTimelineStepHeader, "clr-timeline-step-header", never, {}, {}, never, ["*"], false, never>;
+}
+
+/**
+ * Note: Why does this component have aria-hidden attribute?
+ *
+ * tl;dr: we want screen readers to ignore this element when its reading out to blind users.
+ *
+ * In order to make a timeline step accessible to screen readers we need the title read out before the
+ * icon. In order to do this, ClrTimeLine step has a ContentChild that queries for the ClrTimelineStepTitle and
+ * then adds the projected text into a .clr-sr-only element that is a sibling element to the icon. See the
+ * ClrTimlineStep template for the DOM structure.
+ */
+declare class ClrTimelineStepTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTimelineStepTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTimelineStepTitle, "clr-timeline-step-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class ClrTimelineModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTimelineModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrTimelineModule, [typeof ClrTimeline, typeof ClrTimelineStep, typeof ClrTimelineStepDescription, typeof ClrTimelineStepHeader, typeof ClrTimelineStepTitle], [typeof i6.CommonModule, typeof i7.ClrIcon, typeof i8.ClrSpinnerModule], [typeof ClrTimeline, typeof ClrTimelineStep, typeof ClrTimelineStepDescription, typeof ClrTimelineStepHeader, typeof ClrTimelineStepTitle, typeof i7.ClrIcon, typeof i8.ClrSpinnerModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrTimelineModule>;
+}
+
+export { ClrTimeline, ClrTimelineLayout, ClrTimelineModule, ClrTimelineStep, ClrTimelineStepDescription, ClrTimelineStepHeader, ClrTimelineStepState, ClrTimelineStepTitle };