@rossigee/clarity-angular 18.2.1-fixed → 18.2.1

package/types/clr-angular-data-stack-view.d.ts

@@ -0,0 +1,87 @@
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, Type } from '@angular/core';
+import * as i9 from '@clr/angular/utils';
+import { HeadingLevel, ClrCommonStringsService } from '@clr/angular/utils';
+import * as i6 from '@angular/common';
+import * as i7 from '@angular/forms';
+import * as i8 from '@clr/angular/icon';
+
+declare class ClrStackView {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStackView, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStackView, "clr-stack-view", never, {}, {}, never, ["clr-stack-header", "*"], false, never>;
+}
+
+declare class ClrStackHeader {
+    stackView: ClrStackView;
+    /**
+     * Depth of the stack view header starting from 1 for first level
+     */
+    ariaLevel: HeadingLevel;
+    constructor(stackView: ClrStackView);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStackHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStackHeader, "clr-stack-header", never, { "ariaLevel": { "alias": "clrStackHeaderLevel"; "required": false; }; }, {}, never, ["*", ".stack-action"], false, never>;
+}
+
+declare class ClrStackBlock implements OnInit {
+    private parent;
+    commonStrings: ClrCommonStringsService;
+    expanded: boolean;
+    expandable: boolean;
+    /**
+     * Depth of the stack view starting from 1 for first level
+     */
+    ariaLevel: HeadingLevel;
+    expandedChange: EventEmitter<boolean>;
+    stackBlockTitle: any;
+    focused: boolean;
+    uniqueId: string;
+    private _changedChildren;
+    private _fullyInitialized;
+    private _changed;
+    constructor(parent: ClrStackBlock, commonStrings: ClrCommonStringsService);
+    set setChangedValue(value: boolean);
+    get getChangedValue(): boolean;
+    get onStackLabelFocus(): boolean;
+    get labelledById(): any;
+    get caretDirection(): string;
+    get role(): string;
+    get tabIndex(): string;
+    get ariaExpanded(): string;
+    ngOnInit(): void;
+    addChild(): void;
+    toggleExpand(event?: Event): void;
+    getStackChildrenId(): string;
+    protected preventDefaultIfNotInputEvent(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStackBlock, [{ optional: true; skipSelf: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStackBlock, "clr-stack-block", never, { "expanded": { "alias": "clrSbExpanded"; "required": false; }; "expandable": { "alias": "clrSbExpandable"; "required": false; }; "ariaLevel": { "alias": "clrStackViewLevel"; "required": false; }; "setChangedValue": { "alias": "clrSbNotifyChange"; "required": false; }; }, { "expandedChange": "clrSbExpandedChange"; }, ["stackBlockTitle"], ["clr-stack-label", "*", "clr-stack-block"], false, never>;
+}
+
+declare class ClrStackContentInput {
+    uniqueId: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStackContentInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrStackContentInput, "[clrStackInput]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrStackViewCustomTags {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStackViewCustomTags, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrStackViewCustomTags, "clr-stack-content", never, {}, {}, never, never, false, never>;
+}
+declare class ClrStackViewLabel implements OnInit {
+    private _generatedId;
+    private _id;
+    get id(): string;
+    set id(val: string);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStackViewLabel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStackViewLabel, "clr-stack-label", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare const CLR_STACK_VIEW_DIRECTIVES: Type<any>[];
+declare class ClrStackViewModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStackViewModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrStackViewModule, [typeof ClrStackView, typeof ClrStackHeader, typeof ClrStackBlock, typeof ClrStackContentInput, typeof ClrStackViewLabel, typeof ClrStackViewCustomTags], [typeof i6.CommonModule, typeof i7.FormsModule, typeof i8.ClrIcon, typeof i9.ClrExpandableAnimationModule], [typeof ClrStackView, typeof ClrStackHeader, typeof ClrStackBlock, typeof ClrStackContentInput, typeof ClrStackViewLabel, typeof ClrStackViewCustomTags]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrStackViewModule>;
+}
+
+export { CLR_STACK_VIEW_DIRECTIVES, ClrStackBlock, ClrStackContentInput, ClrStackHeader, ClrStackView, ClrStackViewCustomTags, ClrStackViewLabel, ClrStackViewModule };

package/types/clr-angular-data-tree-view.d.ts

@@ -0,0 +1,229 @@
+import * as i0 from '@angular/core';
+import { OnChanges, OnDestroy, TemplateRef, ChangeDetectorRef, AfterContentInit, Renderer2, ElementRef, NgZone, OnInit, AfterViewInit, EventEmitter, Injector, Type } from '@angular/core';
+import { Observable, BehaviorSubject, Subject, Subscription } from 'rxjs';
+import * as i8 from '@clr/angular/utils';
+import { IfExpandService, ClrCommonStringsService } from '@clr/angular/utils';
+import * as i6 from '@angular/common';
+import * as i7 from '@clr/angular/icon';
+
+declare enum ClrSelectedState {
+    UNSELECTED = 0,
+    SELECTED = 1,
+    INDETERMINATE = 2
+}
+
+type AsyncArray<T> = T[] | null | undefined | Promise<T[] | null | undefined> | Observable<T[] | null | undefined>;
+
+declare abstract class TreeNodeModel<T> {
+    nodeId: string;
+    expanded: boolean;
+    model: T | null;
+    textContent: string;
+    loading$: BehaviorSubject<boolean>;
+    selected: BehaviorSubject<ClrSelectedState>;
+    private _loading;
+    private _disabled;
+    abstract parent: TreeNodeModel<T> | null;
+    abstract children: TreeNodeModel<T>[];
+    get loading(): boolean;
+    set loading(isLoading: boolean);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    destroy(): void;
+    setSelected(state: ClrSelectedState, propagateUp: boolean, propagateDown: boolean): void;
+    toggleSelection(propagate: boolean): void;
+    _updateSelectionFromChildren(): void;
+    private computeSelectionStateFromChildren;
+}
+
+declare class RecursiveTreeNodeModel<T> extends TreeNodeModel<T> {
+    private getChildren;
+    private featuresService;
+    parent: RecursiveTreeNodeModel<T> | null;
+    private subscription;
+    private childrenFetched;
+    private _children;
+    constructor(model: T, parent: RecursiveTreeNodeModel<T> | null, getChildren: (node: T) => AsyncArray<T> | undefined, featuresService: TreeFeaturesService<T> | undefined);
+    get children(): RecursiveTreeNodeModel<T>[];
+    set children(value: RecursiveTreeNodeModel<T>[]);
+    destroy(): void;
+    clearChildren(): void;
+    fetchChildren(): void;
+    private wrapChildren;
+}
+
+interface ClrRecursiveForOfContext<T> {
+    $implicit: T;
+    clrModel: TreeNodeModel<T>;
+}
+declare class ClrRecursiveForOf<T> implements OnChanges, OnDestroy {
+    private template;
+    private featuresService;
+    private cdr;
+    nodes: T | T[];
+    getChildren: (node: T) => AsyncArray<T>;
+    private childrenFetchSubscription;
+    constructor(template: TemplateRef<ClrRecursiveForOfContext<T>>, featuresService: TreeFeaturesService<T>, cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrRecursiveForOf<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrRecursiveForOf<any>, "[clrRecursiveFor][clrRecursiveForOf]", never, { "nodes": { "alias": "clrRecursiveForOf"; "required": false; }; "getChildren": { "alias": "clrRecursiveForGetChildren"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TreeFeaturesService<T> {
+    selectable: boolean;
+    eager: boolean;
+    recursion: {
+        template: TemplateRef<ClrRecursiveForOfContext<T>>;
+        root: RecursiveTreeNodeModel<T>[];
+    };
+    childrenFetched: Subject<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeFeaturesService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeFeaturesService<any>>;
+}
+
+declare class TreeFocusManagerService<T> {
+    rootNodeModels: TreeNodeModel<T>[];
+    private focusedNodeId;
+    private _focusRequest;
+    private _focusChange;
+    get focusRequest(): Observable<string>;
+    get focusChange(): Observable<string>;
+    focusNode(model: TreeNodeModel<T>): void;
+    broadcastFocusedNode(nodeId: string): void;
+    focusParent(model: TreeNodeModel<T>): void;
+    focusFirstVisibleNode(): void;
+    focusLastVisibleNode(): void;
+    focusNodeAbove(model: TreeNodeModel<T>): void;
+    focusNodeBelow(model: TreeNodeModel<T>): void;
+    focusNodeStartsWith(searchString: string, model: TreeNodeModel<T>): void;
+    private findSiblings;
+    private findLastVisibleInNode;
+    private findNextFocusable;
+    private findLastVisibleInTree;
+    private findNodeAbove;
+    private findNodeBelow;
+    private findDescendentNodeStartsWith;
+    private findSiblingNodeStartsWith;
+    private findRootNodeStartsWith;
+    private findNodeStartsWith;
+    private findClosestNodeStartsWith;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeFocusManagerService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeFocusManagerService<any>>;
+}
+
+declare class ClrTree<T> implements AfterContentInit, OnDestroy {
+    featuresService: TreeFeaturesService<T>;
+    private focusManagerService;
+    private renderer;
+    private el;
+    private rootNodes;
+    private subscriptions;
+    private _isMultiSelectable;
+    constructor(featuresService: TreeFeaturesService<T>, focusManagerService: TreeFocusManagerService<T>, renderer: Renderer2, el: ElementRef<HTMLElement>, ngZone: NgZone);
+    set lazy(value: boolean);
+    get isMultiSelectable(): boolean;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private setMultiSelectable;
+    private setRootNodes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTree<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTree<any>, "clr-tree", never, { "lazy": { "alias": "clrLazy"; "required": false; }; }, {}, ["rootNodes"], ["*"], false, never>;
+}
+
+declare class ClrTreeNodeLink {
+    private el;
+    constructor(el: ElementRef<HTMLElement>);
+    get active(): boolean;
+    activate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreeNodeLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrTreeNodeLink, ".clr-treenode-link", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrTreeNode<T> implements OnInit, AfterContentInit, AfterViewInit, OnDestroy {
+    private platformId;
+    featuresService: TreeFeaturesService<T>;
+    expandService: IfExpandService;
+    commonStrings: ClrCommonStringsService;
+    private focusManager;
+    private elementRef;
+    expandable: boolean | undefined;
+    selectedChange: EventEmitter<ClrSelectedState>;
+    expandedChange: EventEmitter<boolean>;
+    STATES: typeof ClrSelectedState;
+    isModelLoading: boolean;
+    nodeId: string;
+    contentContainerTabindex: number;
+    _model: TreeNodeModel<T>;
+    private skipEmitChange;
+    private typeAheadKeyBuffer;
+    private typeAheadKeyEvent;
+    private subscriptions;
+    private contentContainer;
+    private treeNodeLinkList;
+    constructor(platformId: any, parent: ClrTreeNode<T>, featuresService: TreeFeaturesService<T>, expandService: IfExpandService, commonStrings: ClrCommonStringsService, focusManager: TreeFocusManagerService<T>, elementRef: ElementRef<HTMLElement>, injector: Injector);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get selected(): ClrSelectedState | boolean;
+    set selected(value: ClrSelectedState | boolean);
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    set clrForTypeAhead(value: string);
+    get ariaSelected(): boolean;
+    get treeNodeLink(): ClrTreeNodeLink;
+    private get isParent();
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    isExpandable(): boolean;
+    isSelectable(): boolean;
+    focusTreeNode(): void;
+    broadcastFocusOnContainer(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private setTabIndex;
+    private checkTabIndex;
+    private toggleExpandOrTriggerDefault;
+    private expandOrFocusFirstChild;
+    private collapseOrFocusParent;
+    private triggerDefaultAction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreeNode<any>, [null, { optional: true; skipSelf: true; }, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreeNode<any>, "clr-tree-node", never, { "expandable": { "alias": "clrExpandable"; "required": false; }; "disabled": { "alias": "clrDisabled"; "required": false; }; "selected": { "alias": "clrSelected"; "required": false; }; "expanded": { "alias": "clrExpanded"; "required": false; }; "clrForTypeAhead": { "alias": "clrForTypeAhead"; "required": false; }; }, { "selectedChange": "clrSelectedChange"; "expandedChange": "clrExpandedChange"; }, ["treeNodeLinkList"], ["*", "clr-tree-node", "[clrIfExpanded]"], false, never>;
+}
+
+declare class RecursiveChildren<T> {
+    featuresService: TreeFeaturesService<T>;
+    private expandService;
+    parent: TreeNodeModel<T>;
+    children: TreeNodeModel<T>[];
+    subscription: Subscription;
+    role: string;
+    constructor(featuresService: TreeFeaturesService<T>, expandService: IfExpandService);
+    ngAfterContentInit(): void;
+    shouldRender(): boolean;
+    getContext(node: TreeNodeModel<T>): ClrRecursiveForOfContext<T>;
+    ngOnDestroy(): void;
+    private setAriaRoles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecursiveChildren<any>, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RecursiveChildren<any>, "clr-recursive-children", never, { "parent": { "alias": "parent"; "required": false; }; "children": { "alias": "children"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const CLR_TREE_VIEW_DIRECTIVES: Type<any>[];
+declare class ClrTreeViewModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreeViewModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrTreeViewModule, [typeof ClrTree, typeof ClrTreeNode, typeof ClrRecursiveForOf, typeof ClrTreeNodeLink, typeof RecursiveChildren], [typeof i6.CommonModule, typeof i7.ClrIcon, typeof i8.ClrLoadingModule], [typeof ClrTree, typeof ClrTreeNode, typeof ClrRecursiveForOf, typeof ClrTreeNodeLink]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrTreeViewModule>;
+}
+
+declare class DeclarativeTreeNodeModel<T> extends TreeNodeModel<T> {
+    parent: DeclarativeTreeNodeModel<T> | null;
+    children: DeclarativeTreeNodeModel<T>[];
+    constructor(parent: DeclarativeTreeNodeModel<T> | null);
+    destroy(): void;
+    _addChild(child: DeclarativeTreeNodeModel<T>): void;
+    _removeChild(child: DeclarativeTreeNodeModel<T>): void;
+}
+
+export { CLR_TREE_VIEW_DIRECTIVES, ClrRecursiveForOf, ClrSelectedState, ClrTree, ClrTreeNode, ClrTreeNodeLink, ClrTreeViewModule, DeclarativeTreeNodeModel, RecursiveTreeNodeModel, TreeNodeModel };
+export type { ClrRecursiveForOfContext };

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

@@ -0,0 +1,15 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@clr/angular/data/datagrid';
+export * from '@clr/angular/data/datagrid';
+import * as i2 from '@clr/angular/data/stack-view';
+export * from '@clr/angular/data/stack-view';
+import * as i3 from '@clr/angular/data/tree-view';
+export * from '@clr/angular/data/tree-view';
+
+declare class ClrDataModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDataModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrDataModule, never, never, [typeof i1.ClrDatagridModule, typeof i2.ClrStackViewModule, typeof i3.ClrTreeViewModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrDataModule>;
+}
+
+export { ClrDataModule };

package/types/clr-angular-emphasis-alert.d.ts

@@ -0,0 +1,175 @@
+import * as i0 from '@angular/core';
+import { QueryList, OnInit, OnDestroy, EventEmitter, ChangeDetectorRef, Renderer2, ElementRef, AfterContentInit, Type } from '@angular/core';
+import { ClrCommonStringsService } from '@clr/angular/utils';
+import { Observable } from 'rxjs';
+import * as i6 from '@angular/common';
+import * as i7 from '@clr/angular/icon';
+import * as i8 from '@clr/angular/popover/dropdown';
+import * as i9 from '@clr/angular/progress/spinner';
+
+interface AlertInfoObject {
+    shape: string;
+    cssClass: string;
+    title: string;
+}
+
+declare class AlertIconAndTypesService {
+    private commonStrings;
+    private defaultIconShape;
+    private _alertIconShape;
+    private _alertType;
+    constructor(commonStrings: ClrCommonStringsService);
+    get alertType(): string;
+    set alertType(val: string);
+    get alertIconShape(): string;
+    set alertIconShape(val: string);
+    get alertIconTitle(): string;
+    iconInfoFromType(type: string): AlertInfoObject;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertIconAndTypesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertIconAndTypesService>;
+}
+
+declare class MultiAlertService {
+    private subscription;
+    private allAlerts;
+    private _change;
+    private _current;
+    /**
+     * The Observable that lets other classes subscribe to changes
+     */
+    get changes(): Observable<number>;
+    get current(): number;
+    set current(index: number);
+    get activeAlerts(): ClrAlert[];
+    get currentAlert(): ClrAlert;
+    set currentAlert(alert: ClrAlert);
+    get count(): number;
+    manage(alerts: QueryList<ClrAlert>): void;
+    next(): void;
+    previous(): void;
+    open(): void;
+    close(isCurrentAlert: boolean): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiAlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MultiAlertService>;
+}
+
+declare class ClrAlert implements OnInit, OnDestroy {
+    private iconService;
+    private cdr;
+    private multiAlertService;
+    private commonStrings;
+    private renderer;
+    private hostElement;
+    isSmall: boolean;
+    closable: boolean;
+    isAppLevel: boolean;
+    clrCloseButtonAriaLabel: string;
+    _closedChanged: EventEmitter<boolean>;
+    _closed: boolean;
+    private _hidden;
+    private subscriptions;
+    private _isLightweight;
+    private _origAlertType;
+    constructor(iconService: AlertIconAndTypesService, cdr: ChangeDetectorRef, multiAlertService: MultiAlertService, commonStrings: ClrCommonStringsService, renderer: Renderer2, hostElement: ElementRef<HTMLElement>);
+    get isLightweight(): boolean;
+    set isLightweight(val: boolean);
+    get alertType(): string;
+    set alertType(val: string);
+    set alertIconShape(value: string);
+    set closed(value: boolean);
+    get alertClass(): string;
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    configAlertType(val: string): void;
+    open(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrAlert, [null, null, { optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrAlert, "clr-alert", never, { "isSmall": { "alias": "clrAlertSizeSmall"; "required": false; }; "closable": { "alias": "clrAlertClosable"; "required": false; }; "isAppLevel": { "alias": "clrAlertAppLevel"; "required": false; }; "clrCloseButtonAriaLabel": { "alias": "clrCloseButtonAriaLabel"; "required": false; }; "isLightweight": { "alias": "clrAlertLightweight"; "required": false; }; "alertType": { "alias": "clrAlertType"; "required": false; }; "alertIconShape": { "alias": "clrAlertIcon"; "required": false; }; "closed": { "alias": "clrAlertClosed"; "required": false; }; }, { "_closedChanged": "clrAlertClosedChange"; }, never, ["*"], false, never>;
+}
+
+declare class ClrAlertItem {
+    iconService: AlertIconAndTypesService;
+    constructor(iconService: AlertIconAndTypesService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrAlertItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrAlertItem, "clr-alert-item", never, {}, {}, never, ["*"], false, never>;
+}
+
+/**
+ * @remark
+ * This directive is used only of selectin alert text.
+ */
+declare class ClrAlertText {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrAlertText, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrAlertText, ".alert-text", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrAlerts implements AfterContentInit, OnDestroy {
+    multiAlertService: MultiAlertService;
+    currentAlertChange: EventEmitter<ClrAlert>;
+    currentAlertIndexChange: EventEmitter<number>;
+    private subscriptions;
+    constructor(multiAlertService: MultiAlertService);
+    set allAlerts(value: QueryList<ClrAlert>);
+    /**
+     * Input/Output to support two way binding on current alert index
+     */
+    set _inputCurrentIndex(index: number);
+    get currentAlertIndex(): number;
+    set currentAlertIndex(index: number);
+    /**
+     * Input/Output to support two way binding on current alert instance
+     */
+    get currentAlert(): ClrAlert;
+    set currentAlert(alert: ClrAlert);
+    /**
+     * Ensure we are only dealing with alerts that have not been closed yet
+     */
+    get alerts(): ClrAlert[];
+    get currentAlertType(): string;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrAlerts, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrAlerts, "clr-alerts", never, { "_inputCurrentIndex": { "alias": "clrCurrentAlertIndex"; "required": false; }; "currentAlert": { "alias": "clrCurrentAlert"; "required": false; }; }, { "currentAlertChange": "clrCurrentAlertChange"; "currentAlertIndexChange": "clrCurrentAlertIndexChange"; }, ["allAlerts"], ["clr-alert"], false, never>;
+}
+
+declare class ClrAlertsPager implements OnInit, OnDestroy {
+    multiAlertService: MultiAlertService;
+    commonStrings: ClrCommonStringsService;
+    currentAlertChange: EventEmitter<ClrAlert>;
+    currentAlertIndexChange: EventEmitter<number>;
+    private multiAlertServiceChanges;
+    constructor(multiAlertService: MultiAlertService, commonStrings: ClrCommonStringsService);
+    /**
+     * Input/Output to support two way binding on current alert instance
+     */
+    get currentAlert(): ClrAlert;
+    set currentAlert(alert: ClrAlert);
+    /**
+     * Input/Output to support two way binding on current alert index
+     */
+    get currentAlertIndex(): number;
+    set currentAlertIndex(index: number);
+    protected get previousAlertAriaLabel(): string;
+    protected get nextAlertAriaLabel(): string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    pageUp(): void;
+    pageDown(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrAlertsPager, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrAlertsPager, "clr-alerts-pager", never, { "currentAlert": { "alias": "clrCurrentAlert"; "required": false; }; "currentAlertIndex": { "alias": "clrCurrentAlertIndex"; "required": false; }; }, { "currentAlertChange": "clrCurrentAlertChange"; "currentAlertIndexChange": "clrCurrentAlertIndexChange"; }, never, never, false, never>;
+}
+
+declare const CLR_ALERT_DIRECTIVES: Type<any>[];
+declare class ClrAlertModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrAlertModule, [typeof ClrAlert, typeof ClrAlertItem, typeof ClrAlerts, typeof ClrAlertsPager, typeof ClrAlertText], [typeof i6.CommonModule, typeof i7.ClrIcon, typeof i8.ClrDropdownModule, typeof i9.ClrSpinnerModule], [typeof ClrAlert, typeof ClrAlertItem, typeof ClrAlerts, typeof ClrAlertsPager, typeof ClrAlertText]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrAlertModule>;
+}
+
+declare const ALERT_TYPES: string[];
+
+export { ALERT_TYPES, CLR_ALERT_DIRECTIVES, ClrAlert, ClrAlertItem, ClrAlertModule, ClrAlertText, ClrAlerts, ClrAlertsPager };

package/types/clr-angular-emphasis-badge.d.ts

@@ -0,0 +1,25 @@
+import { Type } from '@clr/angular/emphasis/common';
+import * as i0 from '@angular/core';
+
+declare enum ClrBadgeColors {
+    None = "",
+    Info = "info",
+    Warning = "warning",
+    Danger = "danger",
+    Success = "success",
+    Gray = "gray",
+    Blue = "blue",
+    LightBlue = "light-blue",
+    Orange = "orange",
+    Purple = "purple"
+}
+declare class ClrBadge {
+    color: ClrBadgeColors | string;
+    type: Type | string;
+    get isOutlined(): boolean;
+    get colorClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrBadge, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrBadge, "clr-badge", never, { "color": { "alias": "clrColor"; "required": false; }; "type": { "alias": "clrType"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+export { ClrBadge, ClrBadgeColors };

package/types/clr-angular-emphasis-common.d.ts

@@ -0,0 +1,6 @@
+declare enum Type {
+    Solid = "solid",
+    Outlined = "outlined"
+}
+
+export { Type };

package/types/clr-angular-emphasis-label.d.ts

@@ -0,0 +1,29 @@
+import { Type } from '@clr/angular/emphasis/common';
+import * as i0 from '@angular/core';
+
+declare enum ClrLabelColors {
+    None = "",
+    Info = "info",
+    Warning = "warning",
+    Danger = "danger",
+    Success = "success",
+    Gray = "gray",
+    Blue = "blue",
+    LightBlue = "light-blue",
+    Orange = "orange",
+    Purple = "purple"
+}
+declare class ClrLabel {
+    color: ClrLabelColors | string;
+    badgeText: string;
+    textContent: string;
+    clickable: boolean;
+    disabled: boolean;
+    type: Type | string;
+    get isSolid(): boolean;
+    get colorClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrLabel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrLabel, "clr-label", never, { "color": { "alias": "clrColor"; "required": false; }; "badgeText": { "alias": "clrBadgeText"; "required": false; }; "textContent": { "alias": "clrText"; "required": false; }; "clickable": { "alias": "clrClickable"; "required": false; }; "disabled": { "alias": "clrDisabled"; "required": false; }; "type": { "alias": "clrType"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+export { ClrLabel, ClrLabelColors };

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

@@ -0,0 +1,15 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@clr/angular/emphasis/badge';
+export * from '@clr/angular/emphasis/badge';
+import * as i2 from '@clr/angular/emphasis/label';
+export * from '@clr/angular/emphasis/label';
+import * as i3 from '@clr/angular/emphasis/alert';
+export * from '@clr/angular/emphasis/alert';
+
+declare class ClrEmphasisModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrEmphasisModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrEmphasisModule, never, [typeof i1.ClrBadge, typeof i2.ClrLabel], [typeof i3.ClrAlertModule, typeof i1.ClrBadge, typeof i2.ClrLabel]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrEmphasisModule>;
+}
+
+export { ClrEmphasisModule };

package/types/clr-angular-forms-checkbox.d.ts

@@ -0,0 +1,69 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, InjectionToken, ViewContainerRef, Injector, Renderer2, ElementRef, AfterContentInit, QueryList } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import * as i6 from '@clr/angular/forms/common';
+import { ClrControlLabel, WrappedFormControl, ClrAbstractContainer, LayoutService, ControlClassService, NgControlService } from '@clr/angular/forms/common';
+import { BehaviorSubject } from 'rxjs';
+import * as i4 from '@angular/common';
+import * as i5 from '@clr/angular/icon';
+import * as i7 from '@clr/angular/utils';
+
+declare const IS_TOGGLE: InjectionToken<BehaviorSubject<boolean>>;
+declare function isToggleFactory(): BehaviorSubject<boolean>;
+declare const IS_TOGGLE_PROVIDER: {
+    provide: InjectionToken<BehaviorSubject<boolean>>;
+    useFactory: typeof isToggleFactory;
+};
+declare class ClrCheckboxWrapper implements OnInit, OnDestroy {
+    label: ClrControlLabel;
+    checkbox: ClrCheckbox;
+    toggle: boolean;
+    private subscriptions;
+    constructor(toggleService: BehaviorSubject<boolean>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrCheckboxWrapper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrCheckboxWrapper, "clr-checkbox-wrapper,clr-toggle-wrapper", never, {}, {}, ["label", "checkbox"], ["[clrCheckbox],[clrToggle]", "label"], false, never>;
+}
+
+/**
+ * This implements both the clrCheckbox and clrToggle functionality, since they are both just checkboxes with different
+ * visual styling. The challenge is that the container needs to know which selector was used, which the @Attribute
+ * decorator gets for us to determine if the toggle is used, and emits a value to the wrapper container to tell it
+ * there is a toggle switch instead.
+ */
+declare class ClrCheckbox extends WrappedFormControl<ClrCheckboxWrapper> {
+    private control;
+    protected toggle: string;
+    constructor(vcr: ViewContainerRef, injector: Injector, control: NgControl, renderer: Renderer2, el: ElementRef<HTMLInputElement>, toggle: string);
+    get controlDisabled(): boolean;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrCheckbox, [null, null, { optional: true; self: true; }, null, null, { attribute: "clrToggle"; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrCheckbox, "[clrCheckbox],[clrToggle]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrCheckboxContainer extends ClrAbstractContainer implements AfterContentInit {
+    protected layoutService: LayoutService;
+    protected controlClassService: ControlClassService;
+    protected ngControlService: NgControlService;
+    role: string;
+    checkboxes: QueryList<ClrCheckbox>;
+    private inline;
+    constructor(layoutService: LayoutService, controlClassService: ControlClassService, ngControlService: NgControlService);
+    get clrInline(): boolean | string;
+    set clrInline(value: boolean | string);
+    protected get allCheckboxesDisabled(): boolean;
+    ngAfterContentInit(): void;
+    private setAriaRoles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrCheckboxContainer, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrCheckboxContainer, "clr-checkbox-container,clr-toggle-container", never, { "clrInline": { "alias": "clrInline"; "required": false; }; }, {}, ["checkboxes"], ["label", "clr-checkbox-wrapper,clr-toggle-wrapper", "clr-control-helper", "clr-control-error", "clr-control-success"], false, never>;
+}
+
+declare class ClrCheckboxModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrCheckboxModule, [typeof ClrCheckbox, typeof ClrCheckboxContainer, typeof ClrCheckboxWrapper], [typeof i4.CommonModule, typeof i5.ClrIcon, typeof i6.ClrCommonFormsModule, typeof i7.ClrHostWrappingModule], [typeof i6.ClrCommonFormsModule, typeof ClrCheckbox, typeof ClrCheckboxContainer, typeof ClrCheckboxWrapper]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrCheckboxModule>;
+}
+
+export { ClrCheckbox, ClrCheckboxContainer, ClrCheckboxModule, ClrCheckboxWrapper, IS_TOGGLE, IS_TOGGLE_PROVIDER, isToggleFactory };