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;
    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.dev/api/platform-browser/Title)
     * and [the SKY UX page title guidelines](https://developer.blackbaud.com/skyux/design/guidelines/content#page-titles)
     * 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 };