@hermes-ui/angular 0.1.4

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

@@ -0,0 +1,298 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, AfterViewInit, AfterContentInit, EventEmitter, ChangeDetectorRef, QueryList } from '@angular/core';
+import * as i7 from '@angular/forms';
+import { UntypedFormGroup, UntypedFormBuilder } from '@angular/forms';
+import * as i4 from '@hermes-ui/angular/addons/var';
+import { Step, StepInternal, ModelChange, WorkflowModelManager, RelevanceService, WorkflowModel } from '@hermes-ui/angular/addons/var';
+import { WorkflowStrings } from '@hermes-ui/angular/addons/workflow/strings';
+import * as i5 from '@hermes-ui/angular/stepper';
+import { HermesStepButton, HermesStepper } from '@hermes-ui/angular/stepper';
+import { HermesCommonStrings } from '@hermes-ui/angular/utils';
+import { Observable } from 'rxjs';
+import * as i2 from '@hermes-ui/angular/addons/property-view';
+import { PropertyViewModel } from '@hermes-ui/angular/addons/property-view';
+import * as i3 from '@hermes-ui/angular/addons/a11y';
+import * as i6 from '@angular/common';
+
+/**
+ * SummaryService provides methods to build data required to display Step summary using appfx-property-view.
+ */
+declare class SummaryService {
+    /**
+     * Builds {@link PropertyViewModel} for the Step passed using Step#description field.
+     */
+    getDescription(step: Step): PropertyViewModel | undefined;
+    /**
+     * Builds {@link PropertyViewModel} for the Step passed using Step#summary method.
+     */
+    getSummary(step: StepInternal): PropertyViewModel | undefined;
+    private getPropertyViewModelFromMessage;
+    private getPropertyViewModelFromPropertyViewSectionModel;
+    private getPropertyViewSectionBuilder;
+    private getPropertyViewCategoryBuilder;
+    private getPropertyViewBuilder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SummaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SummaryService>;
+}
+
+/**
+ * HermesStepper component has very limited API. It does not provide public information
+ * about the expanded state of the step panels. Also it does not provide straight forward
+ * API for notification when a panel get expanded.
+ * This class is responsible for exposing the state of Clarity stepper component.
+ * It monitors the current state of all panels. When a panel is expanded,
+ * {@link onStepActivated$} observable emits.
+ */
+declare class StepperStateService {
+    private summaryService;
+    /**
+     * Observable that emits when the user expands a HermesStepper panel.
+     */
+    onStepActivated$: Observable<StepState>;
+    /**
+     * Current state of all panels.
+     */
+    private panelState$;
+    /**
+     * Panel state on the previous user interaction.
+     */
+    private lastExpandedState;
+    constructor(summaryService: SummaryService);
+    /**
+     * Must be invoked when {@link HermesAccordionPanel#panelOpenChange} EventEmitter emits.
+     * `panelOpenChange` emits when a panel changes its opened state.
+     * One would expect this listener to be invoked once per panel transition (current panel
+     * is closed and the next is opened). Unfortunately this is not the case. The listener
+     * is invoked every time for all panels on every transition and sometimes even multiple times
+     * for one and the same panel just for a single transition.
+     * The panels states are pushed to {@link panelState$} subject, that is debounced.
+     *
+     * @param step Step, rendered by the Clarity stepper
+     * @param expanded Expanded state of the step
+     * @param index Step index (different than the panel index, as some steps might be skipped)
+     */
+    stepActivated(step: Step, expanded: boolean, index: number): void;
+    /**
+     * Marks a step as valid or not depending on the passed state.
+     * @param {Step} step Step, which has be marked as valid
+     * @param {boolean} isValid The valid state of the step
+     */
+    markStepValid(step: Step, isValid: boolean): void;
+    /**
+     * Reset the valid states of the next steps
+     * @param {Step} step Step after which all next steps to be reset
+     */
+    resetNextStepsValidStates(step: Step): void;
+    /**
+     * Finds the index of the first step in the list which is not skipped and not-valid/incomplete.
+     * This method always considers the last not skipped step in the stepper as incomplete.
+     * @returns {number} The index of the first incomplete step or the index of the last step if all are completed.
+     */
+    getIndexOfFirstIncompleteStep(): number;
+    /**
+     * Finds the index of the first visible step container which is not-valid/incomplete.
+     * This method always considers the last visible step in the stepper as incomplete.
+     *
+     * Note that since skipped steps are not rendered there are no step containers for those.
+     * E.g if we have the following steps:
+     * 0 - step 1, valid
+     * 1 - step 2, valid & skipped,
+     * 2 - step 3, invalid
+     * The method will return 1 because step 2 will not be rendered at all and we will have only
+     * two step containers.
+     *
+     * @returns {number} The index of the first incomplete step container or the index of the
+     * last one if all are completed.
+     */
+    getFirstIncompleteStepContainerIndex(): number;
+    /**
+     * Checks if all steps are in completed state.
+     * @returns {boolean} True if all steps are completed, False otherwise.
+     */
+    areAllStepsCompleted(): boolean;
+    /**
+     * Method to find out if the step at a given index is expanded or not.
+     * List of step states are retrieved and based on the index; 'expanded'
+     * property lets us know if the step is currently open or not.
+     * @param {number} index of the step
+     * @returns {boolean}
+     */
+    isStepActivated(index: number): boolean;
+    /**
+     * Determines if a step at a specific index is the first visible step in the provided list.
+     * @param index The index to check.
+     * @param steps The list of internal steps to evaluate for skipped status.
+     * @returns True if the index is the first non-skipped step, false otherwise.
+     */
+    isFirstVisibleStep(index: number, steps: StepInternal[]): boolean;
+    private initOnStepActivated$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepperStateService>;
+}
+interface StepState {
+    step: Step;
+    expanded: boolean;
+    index: number;
+    valid?: boolean;
+}
+
+/**
+ * Component used to render the composition of step components as inline wizard
+ * (using Clarity stepper component). Workflow of the steps is handled by the
+ * {@link WorkflowModelManager} - the same responsible for the {@link AppfxWizardComponent} workflow.
+ * This guarantees the same API and UX for the inline and dialog wizards.
+ */
+declare class StepperComponent implements OnDestroy, AfterViewInit, AfterContentInit {
+    #private;
+    readonly stateService: StepperStateService;
+    readonly workflowStrings: WorkflowStrings;
+    private readonly modelMgr;
+    private readonly relevanceService;
+    private readonly formBuilder;
+    private readonly cdr;
+    private readonly summaryService;
+    /**
+     * Display loading indicator.
+     */
+    loading: boolean;
+    /**
+     * If set to true, the Next button will use the primary (solid) button style.
+     * Defaults to false to maintain backward compatibility for existing consumers.
+     */
+    usePrimaryNextButton: boolean;
+    /**
+     * If set to true, a "Back" button is displayed in every step except the first visible one.
+     * This allows users to navigate to the previous non-skipped step.
+     */
+    showBackButton: boolean;
+    /**
+     * If set to true, a "Cancel" button is displayed in all steps.
+     * This allows users to terminate the workflow before completion.
+     */
+    showCancelButton: boolean;
+    /**
+     * Dispatches when any of the workflow state's variables changes.
+     */
+    readonly onModelChange: EventEmitter<ModelChange[]>;
+    /**
+     * Dispatched when the workflow is finished via the Finish button.
+     * You can perform the actions you want there (i.e modify or create something)
+     */
+    readonly onFinish: EventEmitter<void>;
+    /**
+     * Dispatched when the user clicks the "Cancel" button.
+     * Use this to handle navigation away from the stepper or closing the containing view.
+     */
+    readonly onCancel: EventEmitter<void>;
+    form: UntypedFormGroup;
+    initialStep: string;
+    stepPanelOverriddenStrings: Partial<HermesCommonStrings>;
+    private pagesContainers;
+    private stepperPanels;
+    private activeStep;
+    private activePage;
+    private awaitingWizardPageOnLoad$;
+    private componentAfterViewInit$;
+    private readonly subscriptions;
+    private retrySubscription;
+    private stepperService;
+    private errorActivatingStep;
+    constructor(stateService: StepperStateService, workflowStrings: WorkflowStrings, modelMgr: WorkflowModelManager, relevanceService: RelevanceService, formBuilder: UntypedFormBuilder, cdr: ChangeDetectorRef, summaryService: SummaryService);
+    /**
+     * The descriptions of the pages that are visualized.
+     */
+    get steps(): Step[];
+    set steps(value: Step[]);
+    get stepsInternal(): StepInternal[];
+    /**
+     * You can supply here any structure you like. As long as it has the
+     * needed properties to inject to the page models and eject back from
+     * the page models.
+     */
+    get wizardModel(): WorkflowModel;
+    set wizardModel(value: WorkflowModel);
+    set hermesStepButtons(hermesStepButtons: QueryList<HermesStepButton>);
+    set stepper(value: HermesStepper);
+    get isLoading(): boolean;
+    get pageProgressDetails(): string;
+    get showProgressCancelButton(): boolean;
+    get cancelValidationButtonLabel(): string;
+    cancelPageValidation(): void;
+    isNextButtonDisabled(step: Step): boolean;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    onStepActivated(step: Step): void;
+    /**
+     * Wrapper function which to wrap the handler of the "Next/Finish" button of every step and
+     * to add additional validation and data extraction logic.
+     */
+    onHermesStepButtonClickedWrapperFn(callbackFn: () => void): () => void;
+    /**
+     * Handler invoked when the form is submitted. This happens when
+     * all steps are in completed state.
+     */
+    onFormSubmit(): void;
+    /**
+     * Checks if the given step index corresponds to the first visible (non-skipped) step in the workflow.
+     * Used to conditionally hide the Back button on the initial page.
+     * @param stepIndex The index of the step in the stepsInternal array.
+     */
+    protected isFirstVisibleStep(stepIndex: number): boolean;
+    /**
+     * When user clicks on already completed steps, Stepper should call validate method of current step before navigation.
+     * Patches stepperService.togglePanel method which calls this.commitActiveStep before calling the original togglePanel method.
+     */
+    private patchStepperService;
+    private commitActiveStep;
+    private activatePendingContainer;
+    private retryStepTransition;
+    private invalidateNextSteps;
+    /**
+     * Marks steps that come before the provided source index as complete, internally
+     * in the Clarity panel component.
+     * It will mark all panels as closed, except the one that is being expanded,
+     * passed in as the target index.
+     *
+     * DOM order of steps is assumed with regard to indices.
+     *
+     * @param sourceIndex indices that come before this will be marked as complete.
+     * @param openPanelIndex index of the panel set to be opened.
+     */
+    private completePreviousSteps;
+    private unsubscribeRetry;
+    /**
+     * HermesStepper requires a child FormGroup for every step. This method creates one dummy
+     * FormGroup for every step. In future these form groups must be used to indicate
+     * the error state of each step.
+     */
+    private initForm;
+    /**
+     * In Clarity 4.x the implementation was:
+     * <code>
+     *     <hermes-stepper-panel (hermesAccordionPanelOpenChange)="stateService.stepActivated(step, $event, i)"
+     * </code>
+     * In Clarity 5.x "hermesAccordionPanelOpenChange" was regressed:
+     * https://github.com/vmware/clarity/issues/5957
+     * This is temporary fix until the above issue gets fixed.
+     *
+     * In future this logic can be changed. Instead of listening for all panels states
+     * (that triggers too many times), we can use combination of:
+     * - StepperService.activeStep (invoked on Next) AND
+     * - StepperService.togglePanel (invoked on previous panel click)
+     */
+    private subscribeForPanelChanges;
+    private getFormGroupNameForStep;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepperComponent, "appfx-stepper", never, { "loading": { "alias": "loading"; "required": false; }; "usePrimaryNextButton": { "alias": "usePrimaryNextButton"; "required": false; }; "showBackButton": { "alias": "showBackButton"; "required": false; }; "showCancelButton": { "alias": "showCancelButton"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; "wizardModel": { "alias": "wizardModel"; "required": false; }; }, { "onModelChange": "onModelChange"; "onFinish": "onFinish"; "onCancel": "onCancel"; }, never, never, false, never>;
+}
+
+declare class AppfxStepperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppfxStepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppfxStepperModule, [typeof StepperComponent], [typeof i2.AppfxPropertyViewModule, typeof i3.AppfxA11yModule, typeof i4.AppfxWorkflowCoreModule, typeof i5.HermesStepperModule, typeof i6.CommonModule, typeof i7.FormsModule, typeof i7.ReactiveFormsModule], [typeof StepperComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppfxStepperModule>;
+}
+
+export { AppfxStepperModule, StepperComponent as Stepper, StepperComponent, StepperStateService, SummaryService };
+export type { StepState };
+//# sourceMappingURL=hermes-ui-angular-addons-stepper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-addons-stepper.d.ts","sources":["../../../addons/stepper/summary/summary.service.ts","../../../addons/stepper/state/stepper-state.service.ts","../../../addons/stepper/stepper.component.ts","../../../addons/stepper/stepper.module.ts"],"mappings":";;;;;;;;;;;;;;;;AAiBA;;AAEG;AACH,cACa,cAAc;AACzB;;AAEG;AACH,yBAAqB,IAAI,GAAG,iBAAiB;AAO7C;;AAEG;AACH,qBAAiB,YAAY,GAAG,iBAAiB;AAQjD;AAOA;AASA;AAIA;AAIA;yCA9CW,cAAc;6CAAd,cAAc;AAiD1B;;ACxDD;;;;;;;AAOG;AACH,cACa,mBAAmB;AAgBlB;AAfZ;;AAEG;AACH,sBAAkB,UAAU,CAAC,SAAS;AAEtC;;AAEG;;AAGH;;AAEG;;AAGiB,gCAAgB,cAAc;AAIlD;;;;;;;;;;;;AAYG;AACH,wBAAoB,IAAI;AAkBxB;;;;AAIG;wBACiB,IAAI;AAOxB;;;AAGG;AACH,oCAAgC,IAAI;AAcpC;;;;AAIG;AACH;AAeA;;;;;;;;;;;;;;AAcG;AACH;AAcA;;;AAGG;AACH;AAMA;;;;;;AAMG;AACH;AASA;;;;;AAKG;6CACsC,YAAY;AAKrD;yCAvKW,mBAAmB;6CAAnB,mBAAmB;AA4L/B;UAEgB,SAAS;UAClB,IAAI;;;;AAIX;;ACjLD;;;;;AAKG;AACH,cAOa,gBAAiB,YAAW,SAAS,EAAE,aAAa,EAAE,gBAAgB;;2BA8DxD,mBAAmB;8BAChB,eAAe;;;;;;AA9D3C;;AAEG;AACM;AAET;;;AAGG;AACM;AAET;;;AAGG;AACM;AAET;;;AAGG;AACM;AAET;;AAEG;4BAC+B,YAAY,CAAC,WAAW;AAE1D;;;AAGG;AACO,uBAAmB,YAAY;AAEzC;;;AAGG;AACO,uBAAmB,YAAY;UAEnC,gBAAgB;;AAEtB,gCAA4B,OAAO,CAAC,mBAAmB;;;;;;;AAUvD;;;;8BASyB,mBAAmB,mBAChB,eAAe,YACd,oBAAoB,oBACZ,gBAAgB,eACrB,kBAAkB,OAC1B,iBAAiB,kBACN,cAAc;AAoDjD;;AAEG;AACH,iBAAa,IAAI;AAIjB,qBACiB,IAAI;AAarB,yBAAqB,YAAY;AAIjC;;;;AAIG;uBACgB,aAAa;AAIhC,2BACuB,aAAa;6CAMK,SAAS,CAAC,gBAAgB;AAWnE,uBACmB,aAAa;;;;;AA+BhC;+BAM2B,IAAI;;;;AAwC/B,0BAAsB,IAAI;AAI1B;;;AAGG;AACH;AAUA;;;AAGG;AACH;AAMA;;;;AAIG;AACH;AAIA;;;AAGG;AACH;AAwBA;AAqCA;AAsBA;AAIA;AASA;;;;;;;;;;AAUG;AACH;AAqBA;AAMA;;;;AAIG;AACH;AAYA;;;;;;;;;;;;;AAaG;AACH;AAcA;yCAtdW,gBAAgB;2CAAhB,gBAAgB;AAyd5B;;ACzfD,cAMa,kBAAkB;yCAAlB,kBAAkB;0CAAlB,kBAAkB,UAAAA,gBAAA,WAAA,EAAA,CAAA,uBAAA,SAAA,EAAA,CAAA,eAAA,SAAA,EAAA,CAAA,uBAAA,SAAA,EAAA,CAAA,mBAAA,SAAA,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,WAAA,SAAA,EAAA,CAAA,mBAAA,WAAAA,gBAAA;0CAAlB,kBAAkB;AAAG;;","names":["i1.StepperComponent"]}

package/types/hermes-ui-angular-addons-tabs.d.ts

@@ -0,0 +1,173 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, Renderer2, ChangeDetectorRef, OnChanges, AfterViewInit, AfterContentInit, SimpleChanges, ElementRef } from '@angular/core';
+import * as i7 from '@hermes-ui/angular/layout/tabs';
+import { HermesTab, HermesTabLink } from '@hermes-ui/angular/layout/tabs';
+import * as i6 from '@hermes-ui/angular/addons/a11y';
+import { ZoomLevel, ZoomLevelService } from '@hermes-ui/angular/addons/a11y';
+import { WorkflowStrings } from '@hermes-ui/angular/addons/workflow/strings';
+import * as i5 from '@hermes-ui/angular/addons/var';
+import { WorkflowModelManager, WorkflowConfigurationService, TabLayout, ModelChange, Step, RelevanceService, WorkflowModel, StepInternal } from '@hermes-ui/angular/addons/var';
+import { Observable } from 'rxjs';
+import * as i8 from '@hermes-ui/angular/icon';
+import * as i9 from '@angular/common';
+import * as i10 from '@angular/forms';
+
+/**
+ * Detects when an active tab changes and emits a notification.
+ * Optionally applies a CSS class to the active tab link element.
+ *
+ * Note: this directive peers into Clarity tab internals and requires maintenance
+ * if Clarity changes its internal structure.
+ */
+declare class IfTabActiveDirective implements OnInit, OnDestroy {
+    tab: HermesTab;
+    private renderer;
+    appfxIfTabActiveChange: EventEmitter<boolean>;
+    activeClass: string;
+    private subscription;
+    constructor(tab: HermesTab, renderer: Renderer2);
+    /** Programmatically activate the tab when set to true. */
+    set activateTab(value: boolean);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Accesses the underlying tab link element via Clarity internals. */
+    private getTabLinkElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IfTabActiveDirective, [{ host: true; self: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IfTabActiveDirective, "[appfxIfTabActive]", never, { "activeClass": { "alias": "activeClass"; "required": false; }; "activateTab": { "alias": "activateTab"; "required": false; }; }, { "appfxIfTabActiveChange": "appfxIfTabActiveChange"; }, never, never, false, never>;
+}
+
+declare class TabLinksComponent {
+    workflowStrings: WorkflowStrings;
+    private cdr;
+    opened: boolean;
+    title?: string;
+    openedChange: EventEmitter<boolean>;
+    currentZoomLevel: ZoomLevel;
+    constructor(workflowStrings: WorkflowStrings, cdr: ChangeDetectorRef);
+    changeOpened(opened: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabLinksComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabLinksComponent, "appfx-tab-links", never, { "opened": { "alias": "opened"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, { "openedChange": "openedChange"; }, never, never, false, never>;
+}
+
+/**
+ * Component used to render the composition of step components as tabs
+ * (using Clarity tabs component). Workflow of the steps is handled by the
+ * {@link WorkflowModelManager} - the same responsible for the {@link Wizard} workflow.
+ * This guarantees the same API and UX for the inline and dialog wizards.
+ *
+ * @example
+ * <appfx-tabs
+ *             [loading]="loading"
+ *             [tabs]="tabs"
+ *             [disableTabsContent]="false"
+ *             [tabLayout]="TabLayout.horizontal"
+ *             [model]="tabsModel">
+ * </appfx-tabs>
+ */
+declare class TabsComponent implements OnInit, OnChanges, AfterViewInit, AfterContentInit, OnDestroy {
+    modelMgr: WorkflowModelManager;
+    private relevanceService;
+    private cdr;
+    workflowStrings: WorkflowStrings;
+    configService: WorkflowConfigurationService;
+    private zoomLevelService?;
+    /** Disable the content of the tabs. */
+    disableTabsContent: boolean;
+    /** Display loading indicator. */
+    loading: boolean;
+    /** The tabs layout. Defaults to horizontal. */
+    tabLayout: TabLayout;
+    /** Set to false to suppress the loading indicator; check {@link isLoading} instead. */
+    showLoadingIndicator: boolean;
+    /** Set to false to disable auto-collapsible tab links. */
+    autoCollapseTabLinks: boolean;
+    /** Set to false to hide the tab links (useful when there is only one step). */
+    showTabLinks: boolean;
+    /** Emits when the workflow model changes. */
+    readonly onModelChange: EventEmitter<ModelChange[]>;
+    tabLinksOpenedChange: EventEmitter<boolean>;
+    /** Emits with the activated step when the active tab changes. */
+    activeTabChange: EventEmitter<Step>;
+    errorIconVisibleList: boolean[];
+    hermesTabsLayout: TabLayout;
+    TabLayout: typeof TabLayout;
+    currentZoomLevel: ZoomLevel;
+    ZoomLevel: typeof ZoomLevel;
+    tabLinksOpened: boolean;
+    activeTabStep: Step;
+    isVerticalLayout: boolean;
+    isSecondaryLayout: boolean;
+    private pagesContainers;
+    private tabLinks;
+    private steps;
+    private tabsModel;
+    private awaitingActivePageOnLoad$;
+    private componentAfterViewInit$;
+    private subscriptions;
+    private errorActivatingStep;
+    private retrySubscription;
+    private stepsValidationMap;
+    constructor(modelMgr: WorkflowModelManager, relevanceService: RelevanceService, cdr: ChangeDetectorRef, workflowStrings: WorkflowStrings, configService: WorkflowConfigurationService, zoomLevelService?: ZoomLevelService);
+    get tabs(): Step[];
+    set tabs(steps: Step[]);
+    /**
+     * Supply any structure that has the needed properties to inject to / eject from step models.
+     * If not specified the steps will stay disconnected from each other.
+     */
+    get model(): WorkflowModel;
+    set model(tabsModel: WorkflowModel);
+    get tabsInternal(): StepInternal[];
+    get isLoading(): boolean;
+    get showTabNav(): boolean;
+    get showTabContent(): boolean;
+    get showAppfxTabLinks(): boolean;
+    get isReady(): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Checks if the tab is currently active. */
+    isTabActive(step: StepInternal): boolean;
+    /** Triggered when the tab page is changed. */
+    onStepActiveChange(step: StepInternal, isStepActive: boolean): void;
+    /** Validates only the active tab. */
+    validateActiveTab$(): Observable<boolean>;
+    /** Validates all tabs. Navigates to the first invalid tab if any fail. */
+    validate$(): Observable<boolean>;
+    private activateFirstTab;
+    private navigateToTabWithErrors;
+    private activateStep;
+    private validateStep;
+    private onStepsOrModelChange;
+    private unsubscribeRetry;
+    private retryStepTransition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, [null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "appfx-tabs", never, { "disableTabsContent": { "alias": "disableTabsContent"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "tabLayout": { "alias": "tabLayout"; "required": false; }; "showLoadingIndicator": { "alias": "showLoadingIndicator"; "required": false; }; "autoCollapseTabLinks": { "alias": "autoCollapseTabLinks"; "required": false; }; "showTabLinks": { "alias": "showTabLinks"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; "model": { "alias": "model"; "required": false; }; }, { "onModelChange": "onModelChange"; "tabLinksOpenedChange": "tabLinksOpenedChange"; "activeTabChange": "activeTabChange"; }, never, never, false, never>;
+}
+
+/**
+ * Toggles CSS classes on a HermesTabLink to switch between default tab style and
+ * a button-like appearance, enabling more versatile use of hermes-tabs.
+ */
+declare class RenderAsButtonDirective implements OnChanges, AfterViewInit {
+    private hermesTabLink;
+    private renderer;
+    private el;
+    renderAsButton: boolean;
+    constructor(hermesTabLink: HermesTabLink, renderer: Renderer2, el: ElementRef);
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    private patchClarityStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderAsButtonDirective, [{ host: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderAsButtonDirective, "[renderAsButton]", never, { "renderAsButton": { "alias": "renderAsButton"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class AppfxTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppfxTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppfxTabsModule, [typeof TabsComponent, typeof TabLinksComponent, typeof IfTabActiveDirective, typeof RenderAsButtonDirective], [typeof i5.AppfxWorkflowCoreModule, typeof i6.AppfxA11yModule, typeof i7.HermesTabsModule, typeof i8.HermesIcon, typeof i9.CommonModule, typeof i10.FormsModule, typeof i10.ReactiveFormsModule], [typeof TabsComponent, typeof TabLinksComponent, typeof IfTabActiveDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppfxTabsModule>;
+}
+
+export { TabsComponent as AppfxTabsComponent, AppfxTabsModule, IfTabActiveDirective as IfTabActive, IfTabActiveDirective, TabLinksComponent as TabLinks, TabLinksComponent, TabsComponent as Tabs, TabsComponent };
+//# sourceMappingURL=hermes-ui-angular-addons-tabs.d.ts.map

package/types/hermes-ui-angular-addons-tabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-addons-tabs.d.ts","sources":["../../../addons/tabs/if-tab-active/if-tab-active.directive.ts","../../../addons/tabs/tab-links/tab-links.component.ts","../../../addons/tabs/tabs.component.ts","../../../addons/tabs/render-as-button/render-as-button.directive.ts","../../../addons/tabs/tabs.module.ts"],"mappings":";;;;;;;;;;;;;;AAsBA;;;;;;AAMG;AACH,cAIa,oBAAqB,YAAW,MAAM,EAAE,SAAS;AAQnC,SAAK,SAAS;AACrC;AARQ,4BAAwB,YAAY;;;AAOrB,qBAAK,SAAS,YACnB,SAAS;;AAI7B;;;;AAgCA;yCA7CW,oBAAoB;2CAApB,oBAAoB;AAgDhC;;ACtED,cAMa,iBAAiB;AAYnB,qBAAiB,eAAe;AACvC;AAVF;;AAIU,kBAAY,YAAA;AAEtB,sBAAgB,SAAA;AAGP,iCAAiB,eAAe,OAC1B,iBAAiB;;yCAbrB,iBAAiB;2CAAjB,iBAAiB;AAqB7B;;ACID;;;;;;;;;;;;;;AAcG;AACH,cAOa,aAAc,YAAW,MAAM,EAAE,SAAS,EAAE,aAAa,EAAE,gBAAgB,EAAE,SAAS;AAoDxF,cAAU,oBAAoB;AACrC;AACA;AACO,qBAAiB,eAAe;AAChC,mBAAe,4BAA4B;;;;;AAjDpD;;eAGoB,SAAS;;AAGpB;;AAGA;;AAGA;;4BAGyB,YAAY,CAAC,WAAW;AAEhD,0BAAoB,YAAA;;AAGpB,qBAAe,YAAA,CAAA,IAAA;;sBAGP,SAAS;AAC3B,sBAAS,SAAA;AACT,sBAAgB,SAAA;AAChB,sBAAS,SAAA;AACT;mBACe,IAAI;;;;;;;;;;;;;0BAiBA,oBAAoB,oBACX,gBAAgB,OAC7B,iBAAiB,mBACN,eAAe,iBACjB,4BAA4B,qBACX,gBAAgB;AAUzD,gBAAY,IAAI;AAIhB,oBACgB,IAAI;AAapB;;;AAGG;iBACU,aAAa;AAI1B,yBACqB,aAAa;AAMlC,wBAAoB,YAAY;;;;;;AAwChC;AAWA,yBAAqB,aAAa;;;;;AAyClC,sBAAkB,YAAY;;6BAKL,YAAY;;AAoBrC,0BAAsB,UAAU;;AAUhC,iBAAa,UAAU;AA0BvB;AAWA;AAuBA;AAcA;AAsBA;AAOA;AAMA;yCAhVW,aAAa;2CAAb,aAAa;AAmVzB;;ACnYD;;;AAGG;AACH,cAIa,uBAAwB,YAAW,SAAS,EAAE,aAAa;AAI5D;AACR;AACA;;+BAF+B,aAAa,YAC1B,SAAS,MACf,UAAU;AAGxB;AAIA;AAIA;yCAjBW,uBAAuB;2CAAvB,uBAAuB;AAgCnC;;AChCD,cAKa,eAAe;yCAAf,eAAe;0CAAf,eAAe,UAAAA,aAAA,SAAAC,iBAAA,SAAAC,oBAAA,SAAAC,uBAAA,WAAA,EAAA,CAAA,uBAAA,SAAA,EAAA,CAAA,eAAA,SAAA,EAAA,CAAA,gBAAA,SAAA,EAAA,CAAA,UAAA,SAAA,EAAA,CAAA,YAAA,SAAA,GAAA,CAAA,WAAA,SAAA,GAAA,CAAA,mBAAA,WAAAH,aAAA,SAAAC,iBAAA,SAAAC,oBAAA;0CAAf,eAAe;AAAG;;","names":["i1.TabsComponent","i2.TabLinksComponent","i3.IfTabActiveDirective","i4.RenderAsButtonDirective"]}