@hermes-ui/angular 0.1.4

package/types/hermes-ui-angular-stepper.d.ts

@@ -0,0 +1,180 @@
+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 '@hermes-ui/angular/collapsible-panel';
+import { HermesCommonStringsService, IfExpandService, WillyWonka, OompaLoompa } from '@hermes-ui/angular/utils';
+import { Observable } from 'rxjs';
+import * as i9 from '@angular/common';
+import * as i10 from '@hermes-ui/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 HermesStepDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesStepDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesStepDescription, "hermes-step-description", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class HermesStepperPanel extends CollapsiblePanel implements OnInit {
+    private platformId;
+    commonStrings: HermesCommonStringsService;
+    private formGroupName;
+    private ngModelGroup;
+    private stepperService;
+    headerButton: ElementRef<HTMLButtonElement>;
+    stepDescription: QueryList<HermesStepDescription>;
+    disabled: boolean;
+    readonly PanelStatus: typeof StepperPanelStatus;
+    panel: Observable<StepperPanelModel>;
+    private subscriptions;
+    constructor(platformId: any, commonStrings: HermesCommonStringsService, 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<HermesStepperPanel, [null, null, { optional: true; }, { optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesStepperPanel, "hermes-stepper-panel", never, {}, {}, ["stepDescription"], ["hermes-step-title", "hermes-step-description", "*"], false, never>;
+}
+
+declare class HermesStepper implements OnInit, OnChanges, AfterViewInit, OnDestroy {
+    private formGroup;
+    private ngForm;
+    private stepperService;
+    initialPanel: string;
+    panels: QueryList<HermesStepperPanel>;
+    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<HermesStepper, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesStepper, "form[hermesStepper]", never, { "initialPanel": { "alias": "hermesInitialStep"; "required": false; }; }, {}, ["panels"], ["*"], false, never>;
+}
+
+declare enum HermesStepButtonType {
+    Next = "next",
+    Previous = "previous",
+    Submit = "submit"
+}
+declare class HermesStepButton implements OnInit {
+    private hermesStep;
+    private stepperService;
+    type: HermesStepButtonType | string;
+    submitButton: boolean;
+    previousButton: boolean;
+    constructor(hermesStep: HermesStepperPanel, stepperService: StepperService);
+    ngOnInit(): void;
+    navigateToNextPanel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesStepButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesStepButton, "[hermesStepButton]", never, { "type": { "alias": "hermesStepButton"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HermesStepTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesStepTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesStepTitle, "hermes-step-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class HermesStepContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesStepContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesStepContent, "hermes-step-content", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class StepperWillyWonka extends WillyWonka {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperWillyWonka, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StepperWillyWonka, "form[hermesStepper]", 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, "hermes-stepper-panel, [hermesStepButton]", never, {}, {}, never, never, false, never>;
+}
+
+declare class HermesStepperModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesStepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesStepperModule, [typeof HermesStepper, typeof HermesStepButton, typeof HermesStepTitle, typeof HermesStepDescription, typeof HermesStepContent, typeof HermesStepperPanel, typeof StepperOompaLoompa, typeof StepperWillyWonka], [typeof i9.CommonModule, typeof i10.HermesIcon], [typeof HermesStepper, typeof HermesStepButton, typeof HermesStepTitle, typeof HermesStepDescription, typeof HermesStepContent, typeof HermesStepperPanel, typeof StepperOompaLoompa, typeof StepperWillyWonka, typeof i10.HermesIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesStepperModule>;
+}
+
+export { HermesStepButton, HermesStepButtonType, HermesStepContent, HermesStepDescription, HermesStepTitle, HermesStepper, HermesStepperModule, HermesStepperPanel, StepperOompaLoompa, StepperPanelModel, StepperPanelStatus, StepperService, StepperWillyWonka };
+//# sourceMappingURL=hermes-ui-angular-stepper.d.ts.map

package/types/hermes-ui-angular-stepper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-stepper.d.ts","sources":["../../../stepper/enums/stepper-panel-status.enum.ts","../../../stepper/models/stepper-panel.model.ts","../../../stepper/models/stepper.model.ts","../../../stepper/providers/stepper.service.ts","../../../stepper/step-description.ts","../../../stepper/stepper-panel.ts","../../../stepper/stepper.ts","../../../stepper/step-button.ts","../../../stepper/step-title.ts","../../../stepper/step-content.ts","../../../stepper/chocolate/stepper-willy-wonka.ts","../../../stepper/chocolate/stepper-oompa-loompa.ts","../../../stepper/stepper.module.ts"],"mappings":";;;;;;;;;;AAOA,aAAY,kBAAkB;AAC5B;AACA;AACA;AACD;;ACAD,cAAa,iBAAkB,SAAQ,qBAAqB;AAC1D,YAAM,kBAAA;AACP;;ACDD,cAAa,YAAa,SAAQ,0BAA0B;AAC1D;AAA8B,sBAAc,iBAAiB;;;;AAK7D,kBAAuB,iBAAiB;;AAQxC;AAIS;AAOA;;;AAiBT;;;;AAgCA;;0CAUmC,iBAAA;8CAII,iBAAA;AAIvC;AAIA;AAMA;AAcA;AAMA;AAUA;AAYA;AAMA;AAIA;AAIA;AAGD;;AC/JD,cACa,cAAe,SAAQ,uBAAuB;AACzD,yBAAqB,UAAU;8BACP,UAAA;AAExB,0BAA6B,YAAA;;;;;;AAyB7B;;AAWA;;AAWA;AAUA;AAQA;yCArEW,cAAc;6CAAd,cAAc;AA2E1B;;ACjFD,cAOa,qBAAqB;yCAArB,qBAAqB;2CAArB,qBAAqB;AAAG;;ACiBrC,cASa,kBAAmB,SAAQ,gBAAiB,YAAW,MAAM;AAUjD;AACd,mBAAe,0BAA0B;AACpC;AACA;AACZ;AAbyB,kBAAc,UAAU,CAAC,iBAAiB;AAC7B,qBAAiB,SAAS,CAAC,qBAAqB;AACpC;iCAChC,kBAAA;AACX,WAAO,UAAU,CAAC,iBAAiB;;gDAMpB,0BAA0B,iBACb,aAAa,gBACd,YAAY,kBACtB,cAAc,mBACrB,eAAe,OAC3B,iBAAiB;;AAQxB;AAIA;AAIA,qBAAa,cAAA,CAAA,SAAA;AAIb,0BAAsB,iBAAiB,GAAG,kBAAkB;gCAIhC,iBAAiB;;;AAYpC;;AAyCT;AAIA;AAIA;AAUA;yCA/GW,kBAAkB;2CAAlB,kBAAkB;AAoH9B;;AClID,cAUa,aAAc,YAAW,MAAM,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS;AAOjE;AACA;AACZ;;AAPmC,YAAQ,SAAS,CAAC,kBAAkB;AACzE,UAAM,kBAAkB,GAAG,MAAM;;2BAIA,kBAAkB,UACrB,MAAM,kBACV,cAAc;;yBAanB,aAAa;;;AAkBlC;AAIA;AAUA;AAKA;yCA3DW,aAAa;2CAAb,aAAa;AAoEzB;;AC9FD,aAAY,oBAAoB;AAC9B;AACA;AACA;AACD;AAED,cASa,gBAAiB,YAAW,MAAM;AAM3C;AACA;AANyB,UAAM,oBAAoB;AACnB;AACH;AAGrB,4BAAY,kBAAkB,kBACd,cAAc;;;yCAP7B,gBAAgB;2CAAhB,gBAAgB;AAwB5B;;AC1CD,cAOa,eAAe;yCAAf,eAAe;2CAAf,eAAe;AAAG;;ACP/B,cAMa,iBAAiB;yCAAjB,iBAAiB;2CAAjB,iBAAiB;AAAG;;ACLjC,cAIa,iBAAkB,SAAQ,UAAU;yCAApC,iBAAiB;2CAAjB,iBAAiB;AAAsB;;ACFpD,cAIa,kBAAmB,SAAQ,WAAW;;qBAGhC,iBAAiB,cAA0B,iBAAiB,mBAAmB,eAAe;AAQ/G;yCAXW,kBAAkB;2CAAlB,kBAAkB;AAc9B;;ACCD,cAKa,mBAAmB;;yCAAnB,mBAAmB;0CAAnB,mBAAmB,UAAAA,aAAA,SAAAC,gBAAA,SAAAC,eAAA,SAAAC,qBAAA,SAAAC,iBAAA,SAAAC,kBAAA,SAAAC,kBAAA,SAAAC,iBAAA,WAAA,EAAA,CAAA,YAAA,SAAA,GAAA,CAAA,UAAA,WAAAP,aAAA,SAAAC,gBAAA,SAAAC,eAAA,SAAAC,qBAAA,SAAAC,iBAAA,SAAAC,kBAAA,SAAAC,kBAAA,SAAAC,iBAAA,SAAA,GAAA,CAAA,UAAA;0CAAnB,mBAAmB;AAI/B;;","names":["i1.HermesStepper","i2.HermesStepButton","i3.HermesStepTitle","i4.HermesStepDescription","i5.HermesStepContent","i6.HermesStepperPanel","i7.StepperOompaLoompa","i8.StepperWillyWonka"]}

package/types/hermes-ui-angular-timeline.d.ts

@@ -0,0 +1,87 @@
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { HermesCommonStringsService } from '@hermes-ui/angular/utils';
+import * as i6 from '@angular/common';
+import * as i7 from '@hermes-ui/angular/icon';
+import * as i8 from '@hermes-ui/angular/progress/spinner';
+
+declare enum HermesTimelineLayout {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+
+declare class HermesTimeline {
+    layout: HermesTimelineLayout;
+    get isVertical(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesTimeline, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesTimeline, "hermes-timeline", never, { "layout": { "alias": "hermesLayout"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare enum HermesTimelineStepState {
+    NOT_STARTED = "not-started",
+    CURRENT = "current",
+    PROCESSING = "processing",
+    SUCCESS = "success",
+    ERROR = "error"
+}
+
+declare class TimelineIconAttributeService {
+    private attributeMap;
+    constructor(commonStrings: HermesCommonStringsService);
+    getAriaLabel(step: HermesTimelineStepState): string;
+    getIconShape(step: HermesTimelineStepState): string;
+    getIconStatus(step: HermesTimelineStepState): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineIconAttributeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimelineIconAttributeService>;
+}
+
+declare class HermesTimelineStep {
+    private iconAttributeService;
+    private platformId;
+    state: HermesTimelineStepState;
+    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<HermesTimelineStep, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesTimelineStep, "hermes-timeline-step", never, { "state": { "alias": "hermesState"; "required": false; }; }, {}, ["stepTitle"], ["hermes-timeline-step-header", "hermes-timeline-step-title", "hermes-timeline-step-description"], false, never>;
+}
+
+declare class HermesTimelineStepDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesTimelineStepDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesTimelineStepDescription, "hermes-timeline-step-description", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class HermesTimelineStepHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesTimelineStepHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesTimelineStepHeader, "hermes-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, HermesTimeLine step has a ContentChild that queries for the HermesTimelineStepTitle and
+ * then adds the projected text into a .hermes-sr-only element that is a sibling element to the icon. See the
+ * HermesTimlineStep template for the DOM structure.
+ */
+declare class HermesTimelineStepTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesTimelineStepTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesTimelineStepTitle, "hermes-timeline-step-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class HermesTimelineModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesTimelineModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesTimelineModule, [typeof HermesTimeline, typeof HermesTimelineStep, typeof HermesTimelineStepDescription, typeof HermesTimelineStepHeader, typeof HermesTimelineStepTitle], [typeof i6.CommonModule, typeof i7.HermesIcon, typeof i8.HermesSpinnerModule], [typeof HermesTimeline, typeof HermesTimelineStep, typeof HermesTimelineStepDescription, typeof HermesTimelineStepHeader, typeof HermesTimelineStepTitle, typeof i7.HermesIcon, typeof i8.HermesSpinnerModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesTimelineModule>;
+}
+
+export { HermesTimeline, HermesTimelineLayout, HermesTimelineModule, HermesTimelineStep, HermesTimelineStepDescription, HermesTimelineStepHeader, HermesTimelineStepState, HermesTimelineStepTitle };
+//# sourceMappingURL=hermes-ui-angular-timeline.d.ts.map

package/types/hermes-ui-angular-timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-timeline.d.ts","sources":["../../../timeline/enums/timeline-layout.enum.ts","../../../timeline/timeline.ts","../../../timeline/enums/timeline-step-state.enum.ts","../../../timeline/providers/timeline-icon-attribute.service.ts","../../../timeline/timeline-step.ts","../../../timeline/timeline-step-description.ts","../../../timeline/timeline-step-header.ts","../../../timeline/timeline-step-title.ts","../../../timeline/timeline.module.ts"],"mappings":";;;;;;;AAOA,aAAY,oBAAoB;AAC9B;AACA;AACD;;ACED,cAOa,cAAc;YACM,oBAAoB;;yCADxC,cAAc;2CAAd,cAAc;AAO1B;;ACnBD,aAAY,uBAAuB;AACjC;AACA;AACA;AACA;AACA;AACD;;ACAD,cACa,4BAA4B;;AAG3B,+BAAe,0BAA0B;AA4BrD,uBAAmB,uBAAuB;AAI1C,uBAAmB,uBAAuB;AAI1C,wBAAoB,uBAAuB;yCAvChC,4BAA4B;6CAA5B,4BAA4B;AA0CxC;;AC1CD,cAkBa,kBAAkB;AAQ3B;AACqB;WARM,uBAAuB;AAES,eAAW,UAAU,CAAC,WAAW;;AAKpF,sCAAsB,4BAA4B;;;;;;yCARjD,kBAAkB;2CAAlB,kBAAkB;AAiC9B;;ACxDD,cAMa,6BAA6B;yCAA7B,6BAA6B;2CAA7B,6BAA6B;AAAG;;ACN7C,cAMa,wBAAwB;yCAAxB,wBAAwB;2CAAxB,wBAAwB;AAAG;;ACNxC;;;;;;;;;AASG;AACH,cAMa,uBAAuB;yCAAvB,uBAAuB;2CAAvB,uBAAuB;AAAG;;ACQvC,cAKa,oBAAoB;;yCAApB,oBAAoB;0CAApB,oBAAoB,UAAAA,cAAA,SAAAC,kBAAA,SAAAC,6BAAA,SAAAC,wBAAA,SAAAC,uBAAA,WAAA,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,UAAA,SAAA,EAAA,CAAA,mBAAA,WAAAJ,cAAA,SAAAC,kBAAA,SAAAC,6BAAA,SAAAC,wBAAA,SAAAC,uBAAA,SAAA,EAAA,CAAA,UAAA,SAAA,EAAA,CAAA,mBAAA;0CAApB,oBAAoB;AAIhC;;","names":["i1.HermesTimeline","i2.HermesTimelineStep","i3.HermesTimelineStepDescription","i4.HermesTimelineStepHeader","i5.HermesTimelineStepTitle"]}

package/types/hermes-ui-angular-toast.d.ts

@@ -0,0 +1,131 @@
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { OnDestroy, EventEmitter, ElementRef, Type } from '@angular/core';
+import { HermesCommonStringsService } from '@hermes-ui/angular/utils';
+import * as i3 from '@angular/common';
+import * as i4 from '@hermes-ui/angular/icon';
+import * as i5 from '@hermes-ui/angular/progress/spinner';
+
+type HermesToastType = 'default' | 'info' | 'success' | 'warning' | 'danger' | 'loading';
+interface HermesToastAction {
+    label: string;
+    onClick: (toast: HermesToastRef) => void;
+}
+interface HermesToastConfig {
+    id?: string;
+    title?: string;
+    description?: string;
+    type?: HermesToastType;
+    /** Milliseconds before auto-dismiss. 0 or Infinity disables auto-dismiss. */
+    duration?: number;
+    closable?: boolean;
+    action?: HermesToastAction;
+}
+interface HermesToastRef extends HermesToastConfig {
+    id: string;
+    type: HermesToastType;
+    duration: number;
+    closable: boolean;
+    createdAt: number;
+}
+interface HermesToastPromiseMessages<T> {
+    loading?: string | HermesToastConfig;
+    success: string | HermesToastConfig | ((value: T) => string | HermesToastConfig);
+    error: string | HermesToastConfig | ((error: unknown) => string | HermesToastConfig);
+}
+type HermesToasterPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+
+/**
+ * Global, imperative toast queue. A single `hermes-toaster` placed once in the app
+ * (typically next to the root component) renders whatever this service holds - call
+ * `show`/`success`/`error`/etc. from anywhere, no injected view reference needed.
+ */
+declare class HermesToastService {
+    private readonly _toasts;
+    private readonly timers;
+    get toasts$(): Observable<HermesToastRef[]>;
+    get snapshot(): HermesToastRef[];
+    show(config: HermesToastConfig): string;
+    private shorthand;
+    default: (message: string, config?: Omit<HermesToastConfig, "type">) => string;
+    info: (message: string, config?: Omit<HermesToastConfig, "type">) => string;
+    success: (message: string, config?: Omit<HermesToastConfig, "type">) => string;
+    warning: (message: string, config?: Omit<HermesToastConfig, "type">) => string;
+    danger: (message: string, config?: Omit<HermesToastConfig, "type">) => string;
+    loading(message: string, config?: Omit<HermesToastConfig, 'type'>): string;
+    update(id: string, config: Partial<HermesToastConfig>): void;
+    dismiss(id: string): void;
+    dismissAll(): void;
+    /** Pauses every running auto-dismiss timer, e.g. while the pointer is over the toaster. */
+    pauseAll(): void;
+    /** Resumes every paused auto-dismiss timer with its remaining time. */
+    resumeAll(): void;
+    /** Ties a toast to a promise: shows a loading toast, then resolves it into success/error. */
+    promise<T>(promise: Promise<T>, messages: HermesToastPromiseMessages<T>): Promise<T>;
+    private resolveMessageText;
+    private resolveMessageConfig;
+    private restartTimer;
+    private clearTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HermesToastService>;
+}
+
+interface ToastIconInfo {
+    shape: string;
+    cssClass: string;
+}
+declare class HermesToastItem implements OnDestroy {
+    private hostElement;
+    commonStrings: HermesCommonStringsService;
+    toast: HermesToastRef;
+    index: number;
+    dismissed: EventEmitter<string>;
+    readonly hostClass = true;
+    readonly role = "status";
+    readonly ariaLive = "polite";
+    private resizeObserver?;
+    constructor(hostElement: ElementRef<HTMLElement>, commonStrings: HermesCommonStringsService);
+    get icon(): ToastIconInfo | undefined;
+    get isLoading(): boolean;
+    dismiss(): void;
+    actionClick(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesToastItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesToastItem, "hermes-toast-item", never, { "toast": { "alias": "toast"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, { "dismissed": "hermesDismissed"; }, never, never, false, never>;
+}
+
+/**
+ * Renders the queue kept by `HermesToastService` as a stack of toasts anchored to a
+ * corner of the viewport. Place a single `<hermes-toaster>` once near the app root -
+ * every `HermesToastService.show()`/`success()`/`error()` call anywhere in the app will
+ * render into it.
+ */
+declare class HermesToaster {
+    private toastService;
+    position: HermesToasterPosition;
+    maxVisible: number;
+    readonly hostClass = true;
+    expanded: boolean;
+    readonly toasts$: Observable<HermesToastRef[]>;
+    constructor(toastService: HermesToastService);
+    trackById(_index: number, toast: HermesToastRef): string;
+    isLimited(index: number): boolean;
+    onEnter(): void;
+    onLeave(): void;
+    onEscape(): void;
+    dismiss(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesToaster, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesToaster, "hermes-toaster", never, { "position": { "alias": "hermesToasterPosition"; "required": false; }; "maxVisible": { "alias": "hermesToasterMaxVisible"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const HERMES_TOAST_DIRECTIVES: Type<any>[];
+declare class HermesToastModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesToastModule, [typeof HermesToaster, typeof HermesToastItem], [typeof i3.CommonModule, typeof i4.HermesIcon, typeof i5.HermesSpinnerModule], [typeof HermesToaster, typeof HermesToastItem]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesToastModule>;
+}
+
+export { HERMES_TOAST_DIRECTIVES, HermesToastItem, HermesToastModule, HermesToastService, HermesToaster };
+export type { HermesToastAction, HermesToastConfig, HermesToastPromiseMessages, HermesToastRef, HermesToastType, HermesToasterPosition };
+//# sourceMappingURL=hermes-ui-angular-toast.d.ts.map

package/types/hermes-ui-angular-toast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-toast.d.ts","sources":["../../../toast/toast.interfaces.ts","../../../toast/toast.service.ts","../../../toast/toast-item.ts","../../../toast/toaster.ts","../../../toast/toast.module.ts"],"mappings":";;;;;;;;AAOM,KAAM,eAAe;UAEV,iBAAiB;;AAEhC,qBAAiB,cAAc;AAChC;UAEgB,iBAAiB;;;;WAIzB,eAAe;;;;aAIb,iBAAiB;AAC3B;AAEK,UAAW,cAAe,SAAQ,iBAAiB;;UAEjD,eAAe;;;;AAItB;AAEK,UAAW,0BAA0B;AACzC,uBAAmB,iBAAiB;AACpC,sBAAkB,iBAAiB,2BAA2B,iBAAiB;AAC/E,oBAAgB,iBAAiB,iCAAiC,iBAAiB;AACpF;AAEK,KAAM,qBAAqB;;ACjBjC;;;;AAIG;AACH,cACa,kBAAkB;AAC7B;AACA;AAEA,mBAAe,UAAU,CAAC,cAAc;AAIxC,oBAAgB,cAAc;AAI9B,iBAAa,iBAAiB;AA2B9B;wCACmC,IAAI,CAAC,iBAAiB;qCAAtB,IAAI,CAAC,iBAAiB;wCAAtB,IAAI,CAAC,iBAAiB;wCAAtB,IAAI,CAAC,iBAAiB;uCAAtB,IAAI,CAAC,iBAAiB;AAUzD,sCAAiC,IAAI,CAAC,iBAAiB;AAIvD,+BAA2B,OAAO,CAAC,iBAAiB;AAQpD;AAKA;;AAMA;;AASA;;wBAYoB,OAAO,eAAe,0BAA0B,MAAM,OAAO;AAiBjF;AAOA;AAIA;AAcA;yCAxIW,kBAAkB;6CAAlB,kBAAkB;AA+I9B;;AC/JD,UAAU,aAAa;;;AAGtB;AASD,cAKa,eAAgB,YAAW,SAAS;AAenC;AAAqD,mBAAe,0BAA0B;WAd1F,cAAc;AAI9B;AAE2B,eAAS,YAAA;;;;;6BAQH,UAAU,CAAC,WAAW,kBAAyB,0BAA0B;AAS1G,gBAAY,aAAa;;AAQzB;AAIA;AAIA;yCAxCW,eAAe;2CAAf,eAAe;AA2C3B;;ACpDD;;;;;AAKG;AACH,cAgBa,aAAa;AAYZ;cATF,qBAAqB;AAEG;;AAGH;sBAEb,UAAU,CAAC,cAAc;AAEvB,8BAAc,kBAAkB;qCAEnB,cAAc;AAI/C;AAMA;AAOA;AAMA;AAOA;yCA5CW,aAAa;2CAAb,aAAa;AA+CzB;;AClED,cAAa,uBAAuB,EAAE,IAAI;AAE1C,cAKa,iBAAiB;;yCAAjB,iBAAiB;0CAAjB,iBAAiB,UAAAA,aAAA,SAAAC,eAAA,WAAA,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,UAAA,SAAA,EAAA,CAAA,mBAAA,WAAAD,aAAA,SAAAC,eAAA;0CAAjB,iBAAiB;AAI7B;;","names":["i1.HermesToaster","i2.HermesToastItem"]}

package/types/hermes-ui-angular-utils-conditional.d.ts

@@ -0,0 +1,133 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, EventEmitter, TemplateRef, ViewContainerRef, OnInit, ElementRef, Renderer2, Type } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { LoadingListener, HermesLoadingState } from '@hermes-ui/angular/utils/loading';
+import * as i1 from '@angular/common';
+
+declare const IF_ACTIVE_ID: InjectionToken<number>;
+declare function tokenFactory(): number;
+declare const IF_ACTIVE_ID_PROVIDER: {
+    provide: InjectionToken<number>;
+    useFactory: typeof tokenFactory;
+};
+declare class IfActiveService {
+    /********
+     * @property _currentChange
+     *
+     * @description
+     * A RXJS Subject that updates and provides subscriptions to for the current current state of a component template
+     * implemting the IfActive structural directive.
+     *
+     */
+    private _currentChange;
+    /*********
+     * @property _current
+     *
+     * @description
+     * A property holding the current value for current/closed state of an IfActive structural directive.
+     */
+    private _current;
+    /*********
+     *
+     * @description
+     * A getter function that provides an observable for the _current Subject.
+     *
+     */
+    get currentChange(): Observable<number>;
+    /*********
+     *
+     * @description
+     * A property that gets/sets the current state of _current for this instance of IfActive structural directive.
+     * And, broadcasts the new value to all subscribers.
+     *
+     */
+    get current(): number;
+    set current(value: number);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IfActiveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IfActiveService>;
+}
+
+declare class HermesIfActive implements OnDestroy {
+    private ifActiveService;
+    private id;
+    private template;
+    private container;
+    /**********
+     * @property activeChange
+     *
+     * @description
+     * An event emitter that emits when the active property is set to allow for 2way binding when the directive is
+     * used with de-structured / de-sugared syntax.
+     *
+     */
+    activeChange: EventEmitter<boolean>;
+    private subscription;
+    private wasActive;
+    constructor(ifActiveService: IfActiveService, id: number, template: TemplateRef<any>, container: ViewContainerRef);
+    /**
+     * @description
+     * A property that gets/sets IfActiveService.active with value.
+     *
+     */
+    get active(): boolean | string;
+    set active(value: boolean | string);
+    ngOnDestroy(): void;
+    /**
+     * @description
+     * Function that takes a any value and either created an embedded view for the associated ViewContainerRef or,
+     * Clears all views from the ViewContainerRef
+     */
+    updateView(value: boolean): void;
+    private checkAndUpdateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesIfActive, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesIfActive, "[hermesIfActive]", never, { "active": { "alias": "hermesIfActive"; "required": false; }; }, { "activeChange": "hermesIfActiveChange"; }, never, never, true, never>;
+}
+
+declare class IfExpandService implements LoadingListener {
+    expandable: number;
+    hasExpandTemplate: boolean;
+    protected _loading: boolean;
+    protected _expanded: boolean;
+    protected _expandChange: Subject<boolean>;
+    get loading(): boolean;
+    set loading(value: boolean);
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    get expandChange(): Observable<boolean>;
+    toggle(): void;
+    loadingStateChange(state: HermesLoadingState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IfExpandService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IfExpandService>;
+}
+
+declare class HermesIfExpanded implements OnInit, OnDestroy {
+    private template;
+    private container;
+    private el;
+    private renderer;
+    private expand;
+    expandedChange: EventEmitter<boolean>;
+    private _expanded;
+    /**
+     * Subscriptions to all the services and queries changes
+     */
+    private _subscriptions;
+    constructor(template: TemplateRef<any>, container: ViewContainerRef, el: ElementRef<HTMLElement>, renderer: Renderer2, expand: IfExpandService);
+    get expanded(): boolean | string;
+    set expanded(value: boolean | string);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private updateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesIfExpanded, [{ optional: true; }, null, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesIfExpanded, "[hermesIfExpanded]", never, { "expanded": { "alias": "hermesIfExpanded"; "required": false; }; }, { "expandedChange": "hermesIfExpandedChange"; }, never, never, true, never>;
+}
+
+declare const CONDITIONAL_DIRECTIVES: Type<any>[];
+declare class HermesConditionalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesConditionalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesConditionalModule, never, [typeof i1.CommonModule, typeof HermesIfActive, typeof HermesIfExpanded], [typeof HermesIfActive, typeof HermesIfExpanded]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesConditionalModule>;
+}
+
+export { CONDITIONAL_DIRECTIVES, HermesConditionalModule, HermesIfActive, HermesIfExpanded, IF_ACTIVE_ID, IF_ACTIVE_ID_PROVIDER, IfActiveService, IfExpandService, tokenFactory };
+//# sourceMappingURL=hermes-ui-angular-utils-conditional.d.ts.map

package/types/hermes-ui-angular-utils-conditional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-utils-conditional.d.ts","sources":["../../../utils/conditional/if-active.service.ts","../../../utils/conditional/if-active.directive.ts","../../../utils/conditional/if-expanded.service.ts","../../../utils/conditional/if-expanded.directive.ts","../../../utils/conditional/conditional.module.ts"],"mappings":";;;;;;AAYA,cAAa,YAAY,EAAA,cAAA;AAEzB,iBAAgB,YAAY;AAI5B,cAAa,qBAAqB;;;;AAKlC,cAWa,eAAe;AAC1B;;;;;;;AAOG;;AAGH;;;;;AAKG;;AAGH;;;;;AAKG;AACH,yBAAqB,UAAU;AAI/B;;;;;;AAMG;;AAIH;yCAvCW,eAAe;6CAAf,eAAe;AA6C3B;;AC1DD,cAca,cAAe,YAAW,SAAS;AAe5C;AACsB;AACtB;AACA;AAjBF;;;;;;;AAOG;AAC6B,kBAAY,YAAA;;;AAMlC,iCAAiB,eAAe,wBAEtB,WAAW,kBACV,gBAAgB;AASrC;;;;AAIG;AACH;AAIA;;AAUA;;;;AAIG;;AASH;yCA3DW,cAAc;2CAAd,cAAc;AAoE1B;;AC5FD,cACa,eAAgB,YAAW,eAAe;AACrD;AACA;;;6BAIuB,OAAA;;AAKvB;;AAUA;AAQA,wBAAoB,UAAU;;AAQ9B,8BAA0B,kBAAkB;yCArCjC,eAAe;6CAAf,eAAe;AA+C3B;;ACnCD,cAGa,gBAAiB,YAAW,MAAM,EAAE,SAAS;AAW1C;AACZ;AACA;AACA;AACA;AAdgC,oBAAc,YAAA;;AAIhD;;AAEG;;0BAI6B,WAAW,kBACtB,gBAAgB,MACvB,UAAU,CAAC,WAAW,aAChB,SAAS,UACX,eAAe;AAYjC;AAIA;;;AAiBA;yCAhDW,gBAAgB;2CAAhB,gBAAgB;AA8E5B;;AC5FD,cAAa,sBAAsB,EAAE,IAAI;AAEzC,cAIa,uBAAuB;yCAAvB,uBAAuB;0CAAvB,uBAAuB,iBAAA,EAAA,CAAA,YAAA,SAAAA,cAAA,SAAAC,gBAAA,WAAAD,cAAA,SAAAC,gBAAA;0CAAvB,uBAAuB;AAAG;;","names":["i2.HermesIfActive","i3.HermesIfExpanded"]}

package/types/hermes-ui-angular-utils-loading.d.ts

@@ -0,0 +1,39 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, Type } from '@angular/core';
+import * as i2 from '@angular/common';
+
+/**
+ * This is an abstract class because we need it to still be a valid token for dependency injection after transpiling.
+ * This does not mean you should extend it, simply implementing it is fine.
+ */
+declare abstract class LoadingListener {
+    abstract loadingStateChange(state: HermesLoadingState | string): void;
+}
+
+declare enum HermesLoadingState {
+    DEFAULT = 0,
+    LOADING = 1,
+    SUCCESS = 2,
+    ERROR = 3
+}
+declare class HermesLoading implements OnDestroy {
+    private listener;
+    static ngAcceptInputType_loadingState: boolean | HermesLoadingState | null | string;
+    private _loadingState;
+    constructor(listener: LoadingListener);
+    get loadingState(): boolean | string | HermesLoadingState;
+    set loadingState(value: boolean | string | HermesLoadingState);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesLoading, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesLoading, "[hermesLoading]", never, { "loadingState": { "alias": "hermesLoading"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const HERMES_LOADING_DIRECTIVES: Type<any>[];
+declare class HermesLoadingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesLoadingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesLoadingModule, [typeof HermesLoading], [typeof i2.CommonModule], [typeof HermesLoading]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesLoadingModule>;
+}
+
+export { HERMES_LOADING_DIRECTIVES, HermesLoading, HermesLoadingModule, HermesLoadingState, LoadingListener };
+//# sourceMappingURL=hermes-ui-angular-utils-loading.d.ts.map

package/types/hermes-ui-angular-utils-loading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-utils-loading.d.ts","sources":["../../../utils/loading/loading-listener.ts","../../../utils/loading/loading.ts","../../../utils/loading/loading.module.ts"],"mappings":";;;;AASA;;;AAGG;AACH,uBAAsB,eAAe;uCACA,kBAAkB;AACtD;;ACJD,aAAY,kBAAkB;AAC5B;AACA;AACA;AACA;AACD;AAED,cAIa,aAAc,YAAW,SAAS;AAMrB;qDALyB,kBAAkB;;AAKnC,0BAAU,eAAe;AAEzD,2CAI2C,kBAAkB;+CAAlB,kBAAkB;;yCAZlD,aAAa;2CAAb,aAAa;AAgCzB;;AC1CD,cAAa,yBAAyB,EAAE,IAAI;AAE5C,cAKa,mBAAmB;yCAAnB,mBAAmB;0CAAnB,mBAAmB,UAAAA,aAAA,WAAA,EAAA,CAAA,YAAA,WAAAA,aAAA;0CAAnB,mBAAmB;AAAG;;","names":["i1.HermesLoading"]}