@skyux/tabs 12.23.0 → 13.0.0-alpha.0

package/index.d.ts

@@ -1,20 +1,835 @@
-export { SkySectionedFormModule } from './lib/modules/sectioned-form/sectioned-form.module';
-export { SkySectionedFormService } from './lib/modules/sectioned-form/sectioned-form.service';
-export { SkyTabIndex } from './lib/modules/tabs/tab-index';
-export { SkyTabLayoutType } from './lib/modules/tabs/tab-layout-type';
-export { SkyTabsModule } from './lib/modules/tabs/tabs.module';
-export { SkyTabsetButtonsDisplayMode } from './lib/modules/tabs/tabset-buttons-display-mode';
-export { SkyTabsetNavButtonType } from './lib/modules/tabs/tabset-nav-button-type';
-export { SkyTabsetStyle } from './lib/modules/tabs/tabset-style';
-export { SkyTabsetTabIndexesChange } from './lib/modules/tabs/tabset-tab-indexes-change';
-export { SkyVerticalTabsetModule } from './lib/modules/vertical-tabset/vertical-tabset.module';
-export { SkySectionedFormComponent } from './lib/modules/sectioned-form/sectioned-form.component';
-export { SkySectionedFormMessage } from './lib/modules/sectioned-form/types/sectioned-form-message';
-export { SkySectionedFormMessageType } from './lib/modules/sectioned-form/types/sectioned-form-message-type';
-export { SkySectionedFormSectionComponent as λ5 } from './lib/modules/sectioned-form/sectioned-form-section.component';
-export { SkyTabComponent as λ1 } from './lib/modules/tabs/tab.component';
-export { SkyTabsetNavButtonComponent as λ3 } from './lib/modules/tabs/tabset-nav-button.component';
-export { SkyTabsetComponent as λ2 } from './lib/modules/tabs/tabset.component';
-export { SkyVerticalTabComponent as λ4 } from './lib/modules/vertical-tabset/vertical-tab.component';
-export { SkyVerticalTabsetGroupComponent as λ7 } from './lib/modules/vertical-tabset/vertical-tabset-group.component';
-export { SkyVerticalTabsetComponent as λ6 } from './lib/modules/vertical-tabset/vertical-tabset.component';
+import * as i0 from '@angular/core';
+import { ElementRef, OnInit, OnDestroy, ChangeDetectorRef, QueryList, AfterViewChecked, EventEmitter, AfterViewInit, OnChanges, SimpleChanges, PipeTransform } from '@angular/core';
+import * as i6 from '@skyux/core';
+import { SkyLogService } from '@skyux/core';
+import { Observable, Subject, BehaviorSubject, ReplaySubject } from 'rxjs';
+import * as i4 from '@angular/common';
+import * as i4$1 from '@skyux/forms';
+import * as i9 from '@skyux/theme';
+import * as i1 from '@skyux/i18n';
+import { SkyLibResourcesService } from '@skyux/i18n';
+import * as i5 from '@skyux/icon';
+import * as i7 from '@skyux/indicators';
+import * as i8 from '@skyux/popovers';
+
+/**
+ * Tracks the element IDs for all tabs within a tablist.
+ * @internal
+ */
+declare class SkyTabIdService {
+    #private;
+    get ids(): Observable<string[]>;
+    constructor();
+    /**
+     * Associates a tab's ID with its parent tablist.
+     * @param {string} id A unique ID for the tab's registration.
+     * @param {string} elementId The ID applied to the tab's element.
+     */
+    register(id: string, elementId: string): void;
+    /**
+     * Disassociates a tab's ID with its parent tablist.
+     * @param {string} id The ID used to register the tab.
+     */
+    unregister(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyTabIdService>;
+}
+
+declare class SkyVerticalTabsetAdapterService {
+    #private;
+    scrollToContentTop(element: ElementRef): void;
+    focusButton(elRef: ElementRef<HTMLElement> | undefined): boolean;
+    focusFirstButton(tabGroups: ElementRef<HTMLElement> | undefined): void;
+    focusNextButton(tabGroups: ElementRef | undefined): void;
+    focusPreviousButton(tabGroups: ElementRef | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyVerticalTabsetAdapterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyVerticalTabsetAdapterService>;
+}
+
+interface SkyVerticalTabsetGroupMessage {
+    messageType: 'focus';
+}
+
+/**
+ * @internal
+ */
+declare class SkyVerticalTabsetGroupService {
+    messageStream: Subject<SkyVerticalTabsetGroupMessage>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyVerticalTabsetGroupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyVerticalTabsetGroupService>;
+}
+
+declare class SkyVerticalTabComponent implements OnInit, OnDestroy {
+    #private;
+    /**
+     * Whether the tab is active when the tabset loads.
+     * @default false
+     */
+    set active(value: boolean | undefined);
+    get active(): boolean;
+    /**
+     * The HTML element ID of the element that contains
+     * the content that the vertical tab displays, which corresponds to the `tabId`. This property
+     * [supports accessibility rules for disclosures](https://www.w3.org/TR/wai-aria-practices-1.1/#disclosure).
+     * For more information about the `aria-controls` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-controls).
+     * @deprecated Now that the vertical tabs provide aria labels automatically, this input is no longer necessary.
+     */
+    ariaControls: string | undefined;
+    /**
+     * The ARIA role for the vertical tab
+     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility)
+     * by indicating how the tab functions and what it controls. For information about how
+     * an ARIA role indicates what an item represents on a web page, see the
+     * [WAI-ARIA roles model](https://www.w3.org/WAI/PF/aria/#roles).
+     * @default "tab"
+     * @deprecated Any other value than `tab` could lead to a poor user experience for users with assistive technology.
+     * In the next major version, this property will be automatically set to `tab`.
+     */
+    get ariaRole(): string;
+    set ariaRole(value: string | undefined);
+    /**
+     * Whether to disable the tab.
+     */
+    disabled: boolean | undefined;
+    /**
+     * Whether to indicate that the tab has an error.
+     * @internal This is used for sectioned forms and is not currently a supported design for pure vertical tabs.
+     */
+    errorIndicator: boolean | undefined;
+    /**
+     * Whether to indicate that the tab has required content.
+     * @internal This is used for sectioned forms and is not currently a supported design for pure vertical tabs.
+     */
+    requiredIndicator: boolean | undefined;
+    /**
+     * Displays an item count alongside the tab header to indicate how many list items the tab contains.
+     */
+    tabHeaderCount: number | undefined;
+    /**
+     * The tab header.
+     * @required
+     */
+    tabHeading: string | undefined;
+    /**
+     * Whether to display a chevron-right icon on the right hand side of the tab.
+     * @internal
+     */
+    showTabRightArrow: boolean | undefined;
+    /**
+     * The ID for the tab.
+     * @deprecated Now that the vertical tabs provide aria labels automatically, this input is no longer necessary.
+     */
+    set tabId(value: string | undefined);
+    get tabId(): string;
+    set contentRendered(value: boolean);
+    get contentRendered(): boolean;
+    index: number | undefined;
+    isMobile: boolean;
+    tabButton: ElementRef | undefined;
+    tabContent: ElementRef | undefined;
+    groupService: SkyVerticalTabsetGroupService | null;
+    constructor(adapterService: SkyVerticalTabsetAdapterService, changeRef: ChangeDetectorRef, tabsetService: SkyVerticalTabsetService, tabIdSvc?: SkyTabIdService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    activateTab(): void;
+    focusButton(): void;
+    tabButtonActivate(event: Event): void;
+    tabButtonArrowLeft(event: Event): void;
+    tabDeactivated(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyVerticalTabComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkyVerticalTabComponent, "sky-vertical-tab", never, { "active": { "alias": "active"; "required": false; }; "ariaControls": { "alias": "ariaControls"; "required": false; }; "ariaRole": { "alias": "ariaRole"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "errorIndicator": { "alias": "errorIndicator"; "required": false; }; "requiredIndicator": { "alias": "requiredIndicator"; "required": false; }; "tabHeaderCount": { "alias": "tabHeaderCount"; "required": false; }; "tabHeading": { "alias": "tabHeading"; "required": false; }; "showTabRightArrow": { "alias": "showTabRightArrow"; "required": false; }; "tabId": { "alias": "tabId"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class SkyVerticalTabsetGroupComponent implements OnInit, OnDestroy {
+    #private;
+    /**
+     * Whether to disable the ability to expand and collapse the group.
+     * @default false
+     */
+    set disabled(value: boolean | undefined);
+    get disabled(): boolean | undefined;
+    /**
+     * The header for the collapsible group of tabs.
+     */
+    groupHeading: string | undefined;
+    /**
+     * Whether the collapsible group is expanded.
+     * @default false
+     */
+    set open(value: boolean | undefined);
+    get open(): boolean | undefined;
+    tabs: QueryList<SkyVerticalTabComponent> | undefined;
+    groupHeadingButton: ElementRef | undefined;
+    animationDisabled: boolean;
+    slideDirection: 'down' | 'up' | 'void';
+    protected groupId: string;
+    constructor(tabService: SkyVerticalTabsetService, changeRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    updateSlideDirection(event: any): void;
+    toggleMenuOpen(): void;
+    protected groupButtonArrowLeft(event: Event): void;
+    protected groupButtonArrowRight(event: Event): void;
+    isActive(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyVerticalTabsetGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkyVerticalTabsetGroupComponent, "sky-vertical-tabset-group", never, { "disabled": { "alias": "disabled"; "required": false; }; "groupHeading": { "alias": "groupHeading"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, {}, ["tabs"], ["*"], false, never>;
+}
+
+/**
+ * @internal
+ */
+declare class SkyVerticalTabsetService {
+    #private;
+    activeIndex: number | undefined;
+    animationContentVisibleState: string | undefined;
+    animationTabsVisibleState: string | undefined;
+    content: ElementRef | undefined;
+    hidingTabs: BehaviorSubject<boolean>;
+    indexChanged: ReplaySubject<number | undefined>;
+    maintainTabContent: boolean | undefined;
+    showingTabs: BehaviorSubject<boolean>;
+    switchingMobile: Subject<boolean>;
+    tabs: SkyVerticalTabComponent[];
+    tabAdded: Subject<SkyVerticalTabComponent>;
+    tabClicked: ReplaySubject<boolean>;
+    constructor();
+    addTab(tab: SkyVerticalTabComponent): void;
+    destroyTab(tab: SkyVerticalTabComponent): void;
+    addGroup(group: SkyVerticalTabsetGroupComponent): void;
+    destroyGroup(group: SkyVerticalTabsetGroupComponent): void;
+    activateTab(tab: SkyVerticalTabComponent): void;
+    activeTab(): SkyVerticalTabComponent | undefined;
+    isMobile(): boolean;
+    updateContent(): void;
+    tabsVisible(): boolean;
+    contentVisible(): boolean;
+    showTabs(): void;
+    focusActiveTab(tabGroups: ElementRef | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyVerticalTabsetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyVerticalTabsetService>;
+}
+
+declare enum SkySectionedFormMessageType {
+    ShowTabs = 1
+}
+
+interface SkySectionedFormMessage {
+    type: SkySectionedFormMessageType;
+}
+
+/**
+ * Creates a container for the sectioned forms.
+ */
+declare class SkySectionedFormComponent implements OnInit, OnDestroy, AfterViewChecked {
+    #private;
+    tabService: SkyVerticalTabsetService;
+    /**
+     * Whether the sectioned form loads section content during initialization so that it
+     * displays content without moving around elements in the content container.
+     * @default false
+     */
+    maintainSectionContent: boolean | undefined;
+    set messageStream(value: Subject<SkySectionedFormMessage> | undefined);
+    get messageStream(): Subject<SkySectionedFormMessage>;
+    /**
+     * Fires when the active tab changes and emits the index of the active
+     * section. The index is based on the section's position when the form loads.
+     */
+    indexChanged: EventEmitter<number>;
+    /**
+     * Fires when the sectioned form tabs are shown or hidden.
+     */
+    tabsVisibleChanged: EventEmitter<boolean>;
+    ariaOwns: string | undefined;
+    ariaRole: string | undefined;
+    content: ElementRef | undefined;
+    constructor(tabService: SkyVerticalTabsetService, changeRef: ChangeDetectorRef, tabIdSvc: SkyTabIdService, logger: SkyLogService);
+    ngOnInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    /**
+     * @deprecated Use the `tabsVisibleChanged` output to listen for tab visibility changes.
+     */
+    tabsVisible(): boolean;
+    /**
+     * @deprecated Use the `messageStream` input and push a `ShowTabs` message to the message stream instead.
+     */
+    showTabs(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkySectionedFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkySectionedFormComponent, "sky-sectioned-form", never, { "maintainSectionContent": { "alias": "maintainSectionContent"; "required": false; }; "messageStream": { "alias": "messageStream"; "required": false; }; }, { "indexChanged": "indexChanged"; "tabsVisibleChanged": "tabsVisibleChanged"; }, never, ["*"], false, never>;
+}
+
+declare class SkySectionedFormService {
+    /**
+     * @internal
+     */
+    invalidChange: BehaviorSubject<boolean | undefined>;
+    /**
+     * @internal
+     */
+    requiredChange: BehaviorSubject<boolean | undefined>;
+    /**
+     * Sets the current section's invalid state based on the `isInvalid` parameter.
+     * This method is used within a `sky-sectioned-form-section` element.
+     */
+    invalidFieldChanged(isInvalid: boolean | undefined): void;
+    /**
+     * Sets the current section's required state based on the `isRequired` parameter.
+     * This method is used within a `sky-sectioned-form-section` element.
+     */
+    requiredFieldChanged(isRequired: boolean | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkySectionedFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkySectionedFormService>;
+}
+
+/**
+ * Creates an individual form to display as a section within the sectioned form.
+ */
+declare class SkySectionedFormSectionComponent implements OnInit, OnDestroy {
+    #private;
+    sectionTabId: string;
+    sectionContentId: string;
+    /**
+     * The section header.
+     * @required
+     */
+    heading: string | undefined;
+    /**
+     * The number of items within the section. A counter appears beside the section header.
+     */
+    itemCount: number | undefined;
+    /**
+     * Whether the section is active when the form loads.
+     * @default false
+     */
+    active: boolean | undefined;
+    fieldRequired: boolean | undefined;
+    fieldInvalid: boolean | undefined;
+    tab: SkyVerticalTabComponent | undefined;
+    constructor(sectionedFormService: SkySectionedFormService, tabsetService: SkyVerticalTabsetService, changeRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkySectionedFormSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkySectionedFormSectionComponent, "sky-sectioned-form-section", never, { "heading": { "alias": "heading"; "required": false; }; "itemCount": { "alias": "itemCount"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class SkyVerticalTabsetComponent implements OnInit, AfterViewChecked, OnDestroy {
+    #private;
+    adapterService: SkyVerticalTabsetAdapterService;
+    tabService: SkyVerticalTabsetService;
+    tabIdSvc: SkyTabIdService;
+    /**
+     * The text to display on the show tabs button on mobile devices.
+     */
+    showTabsText: string | undefined;
+    /**
+     * The ARIA label for the tabset. This sets the tabset's `aria-label` attribute to provide a text equivalent for screen readers
+     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).
+     * If the tabset includes a visible label, use `ariaLabelledBy` instead.
+     * For more information about the `aria-label` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-label).
+     */
+    ariaLabel: string | undefined;
+    /**
+     * The HTML element ID of the element that labels
+     * the tabset. This sets the tabset's `aria-labelledby` attribute to provide a text equivalent for screen readers
+     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).
+     * If the tabset does not include a visible label, use `ariaLabel` instead.
+     * For more information about the `aria-labelledby` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-labelledby).
+     */
+    ariaLabelledBy: string | undefined;
+    /**
+     * The ARIA role for the vertical tabset
+     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility)
+     * by indicating how the tabset functions and what it controls. For information about how
+     * an ARIA role indicates what an item represents on a web page, see the
+     * [WAI-ARIA roles model](https://www.w3.org/WAI/PF/aria/#roles).
+     * @default "tablist"
+     * @deprecated Any other value than `tablist` could lead to a poor user experience for users with assistive technology.
+     * In the next major version, this property will be automatically set to `tablist`.
+     */
+    get ariaRole(): string;
+    set ariaRole(value: string | undefined);
+    /**
+     * Whether the vertical tabset loads tab content during initialization so that it
+     * displays content without moving around elements in the content container.
+     * @default false
+     */
+    maintainTabContent: boolean | undefined;
+    /**
+     * Fires when the active tab changes. Emits the index of the active tab. The
+     * index is based on the tab's position when it loads.
+     */
+    activeChange: EventEmitter<number>;
+    tabGroups: ElementRef | undefined;
+    content: ElementRef | undefined;
+    contentWrapper: ElementRef | undefined;
+    ariaOwns: string | undefined;
+    isMobile: boolean;
+    protected tablistHasFocus: boolean;
+    constructor(adapterService: SkyVerticalTabsetAdapterService, tabService: SkyVerticalTabsetService, resources: SkyLibResourcesService, changeRef: ChangeDetectorRef, tabIdSvc: SkyTabIdService);
+    ngOnInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    protected tabsetFocus(): void;
+    protected trapFocusInTablist(): void;
+    protected resetTabIndex(): void;
+    protected tabGroupsArrowDown(): void;
+    protected tabGroupsArrowUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyVerticalTabsetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkyVerticalTabsetComponent, "sky-vertical-tabset", never, { "showTabsText": { "alias": "showTabsText"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "ariaRole": { "alias": "ariaRole"; "required": false; }; "maintainTabContent": { "alias": "maintainTabContent"; "required": false; }; }, { "activeChange": "activeChange"; }, never, ["*"], false, never>;
+}
+
+/**
+ * Import into any component library module that needs to use resource strings.
+ */
+declare class SkyTabsResourcesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabsResourcesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyTabsResourcesModule, never, never, [typeof i1.SkyI18nModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyTabsResourcesModule>;
+}
+
+declare class SkyVerticalTabsetModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyVerticalTabsetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyVerticalTabsetModule, [typeof SkyVerticalTabsetComponent, typeof SkyVerticalTabsetGroupComponent, typeof SkyVerticalTabComponent], [typeof i4.CommonModule, typeof i5.SkyIconModule, typeof i6.SkyIdModule, typeof i7.SkyExpansionIndicatorModule, typeof i6.SkyResponsiveHostDirective, typeof i7.SkyStatusIndicatorModule, typeof SkyTabsResourcesModule, typeof i9.SkyThemeModule], [typeof SkyVerticalTabsetComponent, typeof SkyVerticalTabsetGroupComponent, typeof SkyVerticalTabComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyVerticalTabsetModule>;
+}
+
+declare class SkySectionedFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkySectionedFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkySectionedFormModule, [typeof SkySectionedFormComponent, typeof SkySectionedFormSectionComponent], [typeof i4.CommonModule, typeof i4$1.SkyCheckboxModule, typeof i9.SkyThemeModule, typeof SkyVerticalTabsetModule], [typeof SkySectionedFormComponent, typeof SkySectionedFormSectionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkySectionedFormModule>;
+}
+
+type SkyTabIndex = string | number;
+
+type SkyTabLayoutType = 'none' | 'blocks' | 'fit' | 'list';
+
+/**
+ * @internal
+ */
+declare class SkyTabButtonAdapterService {
+    focusButtonLink(buttonEl: ElementRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabButtonAdapterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyTabButtonAdapterService>;
+}
+
+type SkyTabsetStyle = 'tabs' | 'wizard';
+
+/**
+ * @internal
+ */
+interface TabButtonViewModel {
+    active: boolean;
+    ariaControls: string;
+    buttonHref: string | null;
+    buttonId: string;
+    buttonText: string | undefined;
+    buttonTextCount: string | undefined;
+    closeable: boolean;
+    disabled: boolean | undefined;
+    tabIndex: SkyTabIndex | undefined;
+    tabNumber: number;
+    totalTabsCount: number;
+}
+
+interface SkyTabsetActiveTabChangeArgs {
+    tabIndex: SkyTabIndex | undefined;
+    initial?: boolean;
+}
+
+/**
+ * The arguments for the tabset service's `activeTabUnregistered` event.
+ * @internal
+ */
+interface SkyTabsetActiveTabUnregisteredArgs {
+    /**
+     * The array index of the active tab, when it has been unregistered.
+     */
+    arrayIndex: number;
+}
+
+/**
+ * @internal
+ */
+declare class SkyTabsetService implements OnDestroy {
+    #private;
+    readonly activeTabUnregistered: Observable<SkyTabsetActiveTabUnregisteredArgs>;
+    readonly activeTabChange: Observable<SkyTabsetActiveTabChangeArgs>;
+    readonly focusedTabBtnIndex: Observable<SkyTabIndex>;
+    readonly activeTabLayout: Observable<SkyTabLayoutType>;
+    currentActiveTabIndex: SkyTabIndex | undefined;
+    currentFocusedTabBtnIndex: SkyTabIndex;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Sets the active tab by its unique `tabIndex` property.
+     */
+    setActiveTabIndex(value: SkyTabsetActiveTabChangeArgs, config?: {
+        emitChange: boolean;
+    }): void;
+    focusNextTabBtn(tabButtons: TabButtonViewModel[]): void;
+    focusPrevTabBtn(tabButtons: TabButtonViewModel[]): void;
+    focusFirstOrNearestTabBtn(tabButtons: TabButtonViewModel[]): void;
+    focusLastOrNearestTabBtn(tabButtons: TabButtonViewModel[]): void;
+    setFocusedTabBtnIndex(tabIndex: SkyTabIndex): void;
+    /**
+     * Registers a tab component.
+     */
+    registerTab(tabIndex?: SkyTabIndex): SkyTabIndex;
+    updateTabIndex(currentTabIndex: SkyTabIndex, newTabIndex: SkyTabIndex): void;
+    updateActiveTabLayout(layout: SkyTabLayoutType): void;
+    /**
+     * Unregisters a tab component.
+     */
+    unregisterTab(tabIndex: SkyTabIndex): void;
+    /**
+     * Unregisters all tab components at once.
+     */
+    unregisterAll(): void;
+    /**
+     * Compares two tab indexes and returns `true` if they are equal.
+     */
+    tabIndexesEqual(tabIndex1: SkyTabIndex | undefined, tabIndex2: SkyTabIndex | undefined): boolean;
+    /**
+     * Verifies if a provided tab index is registered.
+     */
+    isValidTabIndex(tabIndex: SkyTabIndex): boolean;
+    /**
+     * Activates the first registered tab.
+     */
+    activateFirstTab(): SkyTabIndex | undefined;
+    /**
+     * Activates the next registered tab, or the previous one based on a provided array index.
+     */
+    activateNearestTab(arrayIndex: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabsetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyTabsetService>;
+}
+
+type SkyWizardStepState = 'completed' | 'current' | 'unavailable';
+/**
+ * @internal
+ */
+declare class SkyTabButtonComponent implements AfterViewInit, OnDestroy {
+    #private;
+    get active(): boolean | undefined;
+    set active(value: boolean | undefined);
+    ariaControls: string | undefined;
+    buttonHref: string | undefined;
+    buttonId: string | undefined;
+    buttonText: string | undefined;
+    buttonTextCount: string | undefined;
+    closeable: boolean | undefined;
+    get disabled(): boolean;
+    set disabled(value: boolean | undefined);
+    tabIndex: SkyTabIndex | undefined;
+    tabNumber: number | undefined;
+    totalTabsCount: number | undefined;
+    get tabStyle(): SkyTabsetStyle | undefined;
+    set tabStyle(style: SkyTabsetStyle | undefined);
+    buttonClick: EventEmitter<void>;
+    closeClick: EventEmitter<void>;
+    constructor(elementRef: ElementRef, adapterService: SkyTabButtonAdapterService, changeDetectorRef: ChangeDetectorRef, tabsetService: SkyTabsetService);
+    closeBtnTabIndex: string;
+    wizardStepState: SkyWizardStepState | undefined;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onButtonClick(event: any): void;
+    onTabButtonKeyDown(event: KeyboardEvent): void;
+    onCloseClick(event: any): void;
+    focusBtn(): void;
+    onFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkyTabButtonComponent, "sky-tab-button", never, { "active": { "alias": "active"; "required": false; }; "ariaControls": { "alias": "ariaControls"; "required": false; }; "buttonHref": { "alias": "buttonHref"; "required": false; }; "buttonId": { "alias": "buttonId"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "buttonTextCount": { "alias": "buttonTextCount"; "required": false; }; "closeable": { "alias": "closeable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "tabNumber": { "alias": "tabNumber"; "required": false; }; "totalTabsCount": { "alias": "totalTabsCount"; "required": false; }; "tabStyle": { "alias": "tabStyle"; "required": false; }; }, { "buttonClick": "buttonClick"; "closeClick": "closeClick"; }, never, never, false, never>;
+}
+
+/**
+ * @internal
+ */
+declare class SkyTabsetPermalinkService implements OnDestroy {
+    #private;
+    get popStateChange(): Observable<void>;
+    ngOnDestroy(): void;
+    init(): void;
+    /**
+     * Returns the value of a URL query param.
+     */
+    getParam(name: string): string;
+    /**
+     * Sets the value of a URL query param.
+     */
+    setParam(name: string, value: string | null, initial?: boolean): void;
+    /**
+     * Removes the provided query param from the URL.
+     */
+    clearParam(name: string): void;
+    /**
+     * Returns a relative URL that includes the provided query parameter. The value is intended to be
+     * used by an HTML anchor element.
+     */
+    getParamHref(name: string | undefined, value: string): string | null;
+    /**
+     * Converts the provided string into a value that can be safely used in a URL.
+     */
+    urlify(value: string | undefined): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabsetPermalinkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyTabsetPermalinkService>;
+}
+
+declare class SkyTabComponent implements OnChanges, OnDestroy {
+    #private;
+    /**
+     * Whether the tab is active when the tabset loads. After initialization, the `active`
+     * property on the tabset component should be used to set the active tab.
+     * @default false
+     */
+    set active(value: boolean | undefined);
+    get active(): boolean;
+    get activeChange(): Observable<void>;
+    /**
+     * Whether to disable the tab.
+     * @default false
+     */
+    disabled: boolean | undefined;
+    /**
+     * The custom query parameter value for the tab.
+     * This works in conjunction with the tabset's `permalinkId` to distinguish
+     * the tab's unique state in the URL by generating a query parameter that is
+     * written as `?<queryParam>-active-tab=<sanitized-tab-heading`.
+     * By default, the query parameter's value is parsed automatically from the tab's heading text.
+     * This input only applies when the tabset's `tabStyle` is `"tabs"`.
+     */
+    set permalinkValue(value: string | undefined);
+    get permalinkValue(): string | undefined;
+    /**
+     * Displays a counter beside the tab header.
+     * This input only applies when the tabset's `tabStyle` is `"tabs"`.
+     * @deprecated SKY UX no longer recommends adding counts to tabs.
+     */
+    tabHeaderCount: string | undefined;
+    /**
+     * The tab header.
+     * When using tabs as the main navigation on a page,
+     * use [the Angular `Title` service](https://angular.io/docs/ts/latest/cookbook/set-document-title.html)
+     * and [the SKY UX `title` configuration property](https://developer.blackbaud.com/skyux/learn/reference/configuration#app)
+     * to reflect the tab header in the page title.
+     * @required
+     */
+    set tabHeading(value: string | undefined);
+    get tabHeading(): string | undefined;
+    /**
+     * The unique identifier for the tab.
+     * If not defined, the identifier is set to the position of the tab on load, starting with `0`.
+     */
+    set tabIndexValue(value: SkyTabIndex | undefined);
+    get tabIndexValue(): SkyTabIndex | undefined;
+    /**
+     * The tab layout that applies spacing to the tab container element. Use the layout
+     * that corresponds with the top-level component type used within the tab, or use `fit` to
+     * constrain the tab contents to the available viewport.
+     * Use `none` for custom content that does not adhere to predefined spacing or constraints.
+     * @default "none"
+     */
+    set layout(value: SkyTabLayoutType | undefined);
+    get layout(): SkyTabLayoutType;
+    cssClass: string;
+    /**
+     * Fires when users click the button to close the tab.
+     * The close button is added to the tab when you specify a listener for this event.
+     * This event only applies when the tabset's `tabStyle` is `"tabs"`.
+     */
+    close: EventEmitter<void>;
+    /**
+     * Alerts the tabset component when this component has changes that need to be reflected in the UI.
+     */
+    get stateChange(): Observable<void>;
+    get tabIndexChange(): Observable<SkyTabIndex | undefined>;
+    permalinkValueOrDefault: string;
+    showContent: boolean;
+    tabButtonId: string;
+    tabPanelId: string;
+    constructor(changeDetector: ChangeDetectorRef, permalinkService: SkyTabsetPermalinkService, tabsetService: SkyTabsetService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    init(): void;
+    activate(): void;
+    deactivate(): void;
+    isCloseable(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkyTabComponent, "sky-tab", never, { "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "permalinkValue": { "alias": "permalinkValue"; "required": false; }; "tabHeaderCount": { "alias": "tabHeaderCount"; "required": false; }; "tabHeading": { "alias": "tabHeading"; "required": false; }; "tabIndexValue": { "alias": "tabIndexValue"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; }, { "close": "close"; }, never, ["*"], false, [{ directive: typeof i6.SkyResponsiveHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * @internal
+ */
+declare class SkyTabsetAdapterService implements OnDestroy {
+    #private;
+    get overflowChange(): Observable<boolean>;
+    constructor();
+    ngOnDestroy(): void;
+    registerTabset(tabsetRef: ElementRef): void;
+    /**
+     * Detects if the tab buttons are wider than the tabset container.
+     */
+    detectOverflow(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabsetAdapterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkyTabsetAdapterService>;
+}
+
+type SkyTabsetButtonsDisplayMode = 'dropdown' | 'tabs';
+
+interface SkyTabsetTabIndexesChange {
+    tabs?: {
+        tabHeading?: string;
+        tabIndex?: SkyTabIndex;
+    }[];
+}
+
+declare class SkyTabsetComponent implements AfterViewInit, OnDestroy {
+    #private;
+    /**
+     * Activates a tab by its `tabIndex` property.
+     */
+    set active(value: SkyTabIndex | undefined);
+    get active(): SkyTabIndex | undefined;
+    /**
+     * The ARIA label for the tabset. This sets the tabset's `aria-label` attribute to provide a text equivalent for screen readers
+     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).
+     * If the tabset includes a visible label, use `ariaLabelledBy` instead.
+     * For more information about the `aria-label` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-label).
+     */
+    ariaLabel: string | undefined;
+    /**
+     * The HTML element ID of the element that labels
+     * the tabset. This sets the tabset's `aria-labelledby` attribute to provide a text equivalent for screen readers
+     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).
+     * If the tabset does not include a visible label, use `ariaLabel` instead.
+     * For more information about the `aria-labelledby` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-labelledby).
+     */
+    ariaLabelledBy: string | undefined;
+    /**
+     * Distinguishes a tabset's unique state in the URL by generating a query parameter
+     * that is written as `?<queryParam>-active-tab=<sanitized-tab-heading>`.
+     * The query parameter's value is parsed automatically from the selected tab's heading text,
+     * but you can supply a custom query parameter value for each tab with its `permalinkValue`.
+     * This input only applies when `tabStyle` is `"tabs"`
+     */
+    set permalinkId(value: string | undefined);
+    get permalinkId(): string;
+    /**
+     * The behavior for a series of tabs.
+     * @default "tabs"
+     */
+    set tabStyle(value: SkyTabsetStyle | undefined);
+    get tabStyle(): SkyTabsetStyle;
+    get dataTabStyle(): string;
+    /**
+     * Fires when the active tab changes. This event emits the index of the active tab.
+     */
+    activeChange: EventEmitter<SkyTabIndex>;
+    /**
+     * Fires when users click the button to add a new tab.
+     * The new tab button is added to the tab area when you specify a listener for this event.
+     * This event only applies when `tabStyle` is `"tabs"`.
+     */
+    newTab: EventEmitter<void>;
+    /**
+     * Fires when users click the button to open a tab.
+     * The open tab button is added to the tab area when you specify a listener for this event.
+     * This event only applies when `tabStyle` is `"tabs"`.
+     */
+    openTab: EventEmitter<void>;
+    /**
+     * Fires when any tab's `tabIndex` value changes.
+     * This event only applies when `tabStyle` is `"tabs"`.
+     */
+    tabIndexesChange: EventEmitter<SkyTabsetTabIndexesChange>;
+    set tabDisplayMode(value: SkyTabsetButtonsDisplayMode);
+    get tabDisplayMode(): SkyTabsetButtonsDisplayMode;
+    set tabs(value: QueryList<SkyTabComponent> | undefined);
+    get tabs(): QueryList<SkyTabComponent> | undefined;
+    cssClass: string;
+    dropdownTriggerButtonText: string;
+    /**
+     * This property is used by the deprecated tabset-nav-button component.
+     * @internal
+     */
+    lastActiveTabIndex: SkyTabIndex | undefined;
+    tabButtons: TabButtonViewModel[];
+    constructor(changeDetector: ChangeDetectorRef, elementRef: ElementRef, adapterService: SkyTabsetAdapterService, permalinkService: SkyTabsetPermalinkService, tabsetService: SkyTabsetService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onWindowResize(): void;
+    onTabCloseClick(tabButton: TabButtonViewModel): void;
+    onTabButtonClick(tabButton: TabButtonViewModel): void;
+    onNewTabClick(): void;
+    onOpenTabClick(): void;
+    onRightKeyDown(): void;
+    onLeftKeyDown(): void;
+    onHomeKeyDown(): void;
+    onEndKeyDown(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabsetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkyTabsetComponent, "sky-tabset", never, { "active": { "alias": "active"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "permalinkId": { "alias": "permalinkId"; "required": false; }; "tabStyle": { "alias": "tabStyle"; "required": false; }; }, { "activeChange": "activeChange"; "newTab": "newTab"; "openTab": "openTab"; "tabIndexesChange": "tabIndexesChange"; }, ["tabs"], ["*"], false, never>;
+}
+
+/**
+ * The nav button type.
+ */
+type SkyTabsetNavButtonType = 'previous' | 'next' | 'finish';
+
+/**
+ * Creates a button to navigate between tabs in a tabset when `tabStyle` is `"wizard"`.
+ */
+declare class SkyTabsetNavButtonComponent implements OnDestroy {
+    #private;
+    /**
+     * The tabset wizard component to associate with the nav button.
+     * @required
+     */
+    get tabset(): SkyTabsetComponent | undefined;
+    set tabset(value: SkyTabsetComponent | undefined);
+    /**
+     * The type of nav button to include.
+     * @required
+     */
+    get buttonType(): SkyTabsetNavButtonType | undefined;
+    set buttonType(value: SkyTabsetNavButtonType | undefined);
+    get buttonTypeData(): SkyTabsetNavButtonType | undefined;
+    /**
+     * The label to display on the nav button. The following are the defaults for each `buttonType`:
+     * `next` = "Next", `previous` = "Previous", `finish` = "Finish"
+     */
+    buttonText?: string | undefined;
+    /**
+     * Whether to disable the nav button.
+     * Defaults to the disabled state of the next tab for `next`, the existence of a previous tab for `previous`,
+     * and false for `finish`.
+     */
+    set disabled(value: boolean | undefined);
+    get disabled(): boolean | undefined;
+    buttonClassName: string | undefined;
+    isVisible: boolean;
+    type: 'submit' | 'button';
+    ariaControls: string | undefined;
+    protected tabToSelect: SkyTabComponent | undefined;
+    constructor(logger: SkyLogService);
+    ngOnDestroy(): void;
+    buttonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabsetNavButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkyTabsetNavButtonComponent, "sky-tabset-nav-button", never, { "tabset": { "alias": "tabset"; "required": false; }; "buttonType": { "alias": "buttonType"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SkyTabsetNavButtonDisabledPipe implements PipeTransform {
+    transform(disabled: boolean | undefined, buttonType?: SkyTabsetNavButtonType | string, tabToSelectExists?: boolean, tabToSelectIsDisabled?: boolean): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabsetNavButtonDisabledPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SkyTabsetNavButtonDisabledPipe, "skyTabsetNavButtonDisabled", false>;
+}
+
+declare class SkyTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkyTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyTabsModule, [typeof SkyTabButtonComponent, typeof SkyTabComponent, typeof SkyTabsetComponent, typeof SkyTabsetNavButtonComponent, typeof SkyTabsetNavButtonDisabledPipe], [typeof i4.CommonModule, typeof i6.SkyResponsiveHostDirective, typeof i8.SkyDropdownModule, typeof i5.SkyIconModule, typeof i6.SkyIdModule, typeof SkyTabsResourcesModule, typeof i9.SkyThemeModule], [typeof SkyTabComponent, typeof SkyTabsetComponent, typeof SkyTabsetNavButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SkyTabsModule>;
+}
+
+export { SkySectionedFormComponent, SkySectionedFormMessageType, SkySectionedFormModule, SkySectionedFormService, SkyTabsModule, SkyVerticalTabsetModule, SkyTabComponent as λ1, SkyTabsetComponent as λ2, SkyTabsetNavButtonComponent as λ3, SkyVerticalTabComponent as λ4, SkySectionedFormSectionComponent as λ5, SkyVerticalTabsetComponent as λ6, SkyVerticalTabsetGroupComponent as λ7 };
+export type { SkySectionedFormMessage, SkyTabIndex, SkyTabLayoutType, SkyTabsetButtonsDisplayMode, SkyTabsetNavButtonType, SkyTabsetStyle, SkyTabsetTabIndexesChange };