@ngstarter-ui/components 1.0.21

package/types/ngstarter-ui-components-tab-panel.d.ts

@@ -0,0 +1,96 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, OnInit, OnChanges, SimpleChanges } from '@angular/core';
+import * as i1 from '@ngstarter-ui/components/core';
+
+declare class TabPanelApiService {
+    private _selectionModel;
+    readonly itemIdChanged: EventEmitter<any>;
+    activate(id: any, emitEvent?: boolean): void;
+    isActive(id: any): boolean;
+    hasActive(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TabPanelApiService>;
+}
+
+declare class TabPanel implements OnInit, OnChanges {
+    private _destroyRef;
+    readonly api: TabPanelApiService;
+    hideContentIfTabNotSelected: i0.InputSignalWithTransform<boolean, unknown>;
+    activeItemId: i0.InputSignal<any>;
+    compact: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly itemIdChanged: i0.OutputEmitterRef<void>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanel, "ngs-tab-panel", ["ngsTabPanel"], { "hideContentIfTabNotSelected": { "alias": "hideContentIfTabNotSelected"; "required": false; "isSignal": true; }; "activeItemId": { "alias": "activeItemId"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; }, { "itemIdChanged": "itemIdChanged"; }, never, ["ngs-tab-panel-header", "ngs-tab-panel-content", "ngs-tab-panel-footer", "ngs-tab-panel-aside"], true, never>;
+}
+
+declare class TabPanelHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanelHeader, "ngs-tab-panel-header", ["ngsTabPanelHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TabPanelFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelFooter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanelFooter, "ngs-tab-panel-footer", ["ngsTabPanelFooter"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TabPanelItem {
+    readonly api: TabPanelApiService;
+    private _nav;
+    for: i0.InputSignal<any>;
+    protected _handleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanelItem, "ngs-tab-panel-item", ["ngsTabPanelItem"], { "for": { "alias": "for"; "required": false; "isSignal": true; }; }, {}, never, ["[ngsTabPanelItemIcon]", "*"], true, [{ directive: typeof i1.Ripple; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TabPanelNav {
+    nextId: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelNav, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanelNav, "ngs-tab-panel-nav", ["ngsTabPanelNav"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TabPanelItemText {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelItemText, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanelItemText, "ngs-tab-panel-item-text", ["ngsTabPanelItemText"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TabPanelAside {
+    nextId: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelAside, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanelAside, "ngs-tab-panel-aside", ["ngsTabPanelAside"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TabPanelContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanelContent, "ngs-tab-panel-content", ["ngsTabPanelContent"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TabPanelCustomItem {
+    readonly api: TabPanelApiService;
+    for: i0.InputSignal<any>;
+    protected _handleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelCustomItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanelCustomItem, "ngs-tab-panel-custom-item", ["ngsTabPanelCustomItem"], { "for": { "alias": "for"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TabPanelAsideContentDirective implements OnInit {
+    private _aside;
+    private _api;
+    private _templateRef;
+    private _viewContainer;
+    private _destroyRef;
+    id: i0.InputSignal<any>;
+    ngOnInit(): void;
+    private _show;
+    private _hide;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelAsideContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabPanelAsideContentDirective, "[ngsTabPanelAsideContent]", ["ngsTabPanelAsideContent"], { "id": { "alias": "ngsTabPanelAsideContent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TabPanelItemIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanelItemIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabPanelItemIconDirective, "[ngsTabPanelItemIcon]", ["ngsTabPanelItemIcon"], {}, {}, never, never, true, never>;
+}
+
+export { TabPanel, TabPanelAside, TabPanelAsideContentDirective, TabPanelContent, TabPanelCustomItem, TabPanelFooter, TabPanelHeader, TabPanelItem, TabPanelItemIconDirective, TabPanelItemText, TabPanelNav };

package/types/ngstarter-ui-components-table.d.ts

@@ -0,0 +1,277 @@
+import * as i0 from '@angular/core';
+import { QueryList, ElementRef } from '@angular/core';
+import { CdkTable, CdkHeaderRowDef, CdkColumnDef, CdkCell, CdkCellDef, CdkFooterCell, CdkFooterCellDef, CdkFooterRow, CdkFooterRowDef, CdkHeaderCell, CdkHeaderCellDef, CdkHeaderRow, CdkNoDataRow, CdkRow, CdkRowDef, CdkTextColumn } from '@angular/cdk/table';
+import { DataSource } from '@angular/cdk/collections';
+import { Subscription, BehaviorSubject } from 'rxjs';
+import { SortDirective } from '@ngstarter-ui/components/sort';
+import { Paginator } from '@ngstarter-ui/components/paginator';
+
+declare class Table<T> extends CdkTable<T> {
+    hideHeader: i0.InputSignalWithTransform<boolean, unknown>;
+    hideBody: i0.InputSignalWithTransform<boolean, unknown>;
+    hideFooter: i0.InputSignalWithTransform<boolean, unknown>;
+    private readonly destroyRef;
+    /**
+     * Whether the table has any sticky header rows.
+     * This is used to apply the 'ngs-table-sticky-header' class.
+     */
+    private readonly _hasStickyHeader;
+    readonly hasStickyHeader: i0.Signal<boolean>;
+    headerRowDefsQuery: QueryList<CdkHeaderRowDef>;
+    columnDefsQuery: QueryList<CdkColumnDef>;
+    /**
+     * Whether the table has any sticky columns.
+     */
+    private readonly _hasStickyColumns;
+    readonly hasStickyColumns: i0.Signal<boolean>;
+    private _updateStickyStates;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    protected stickyCssClass: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Table<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Table<any>, "ngs-table, table[ngs-table]", ["ngsTable"], { "hideHeader": { "alias": "hideHeader"; "required": false; "isSignal": true; }; "hideBody": { "alias": "hideBody"; "required": false; "isSignal": true; }; "hideFooter": { "alias": "hideFooter"; "required": false; "isSignal": true; }; }, {}, ["headerRowDefsQuery", "columnDefsQuery"], never, true, never>;
+}
+
+/** Cell template container that adds the right classes and role. */
+declare class Cell extends CdkCell {
+    constructor(elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<Cell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Cell, "ngs-cell, [ngs-cell], td[ngs-cell]", never, {}, {}, never, never, true, never>;
+}
+
+/** Cell definition for the ngs-table. */
+declare class CellDef extends CdkCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CellDef, "[ngsCellDef]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Column definition for the ngs-table.
+ * Defines a set of cells available for a table column.
+ */
+declare class ColumnDef extends CdkColumnDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColumnDef, "[ngsColumnDef]", never, { "name": { "alias": "ngsColumnDef"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Footer cell template container that adds the right classes and role. */
+declare class FooterCell extends CdkFooterCell {
+    constructor(elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FooterCell, "ngs-footer-cell, [ngs-footer-cell], td[ngs-footer-cell]", never, {}, {}, never, never, true, never>;
+}
+
+/** Footer cell definition for the ngs-table. */
+declare class FooterCellDef extends CdkFooterCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterCellDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FooterCellDef, "[ngsFooterCellDef]", never, {}, {}, never, never, true, never>;
+}
+
+/** Footer template container that adds the right classes and role. */
+declare class FooterRow extends CdkFooterRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FooterRow, "ngs-footer-row, [ngs-footer-row], tr[ngs-footer-row]", never, {}, {}, never, never, true, never>;
+}
+
+/** Footer row definition for the ngs-table. */
+declare class FooterRowDef extends CdkFooterRowDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterRowDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FooterRowDef, "[ngsFooterRowDef]", never, { "columns": { "alias": "ngsFooterRowDef"; "required": false; }; "sticky": { "alias": "ngsFooterRowDefSticky"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Header cell template container that adds the right classes and role. */
+declare class HeaderCell extends CdkHeaderCell {
+    constructor(elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderCell, "ngs-header-cell, [ngs-header-cell], th[ngs-header-cell]", never, {}, {}, never, never, true, never>;
+}
+
+/** Header cell definition for the ngs-table. */
+declare class HeaderCellDef extends CdkHeaderCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderCellDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderCellDef, "[ngsHeaderCellDef]", never, {}, {}, never, never, true, never>;
+}
+
+/** Header template container that adds the right classes and role. */
+declare class HeaderRow extends CdkHeaderRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderRow, "ngs-header-row, [ngs-header-row], tr[ngs-header-row]", never, {}, {}, never, never, true, never>;
+}
+
+/** Header row definition for the ngs-table. */
+declare class HeaderRowDef extends CdkHeaderRowDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderRowDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderRowDef, "[ngsHeaderRowDef]", never, { "columns": { "alias": "ngsHeaderRowDef"; "required": false; }; "sticky": { "alias": "ngsHeaderRowDefSticky"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Row that can be used to display a message when no data is shown in the table. */
+declare class NoDataRow extends CdkNoDataRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoDataRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NoDataRow, "ng-template[ngsNoDataRow]", never, {}, {}, never, never, true, never>;
+}
+
+/** Data row template container that adds the right classes and role. */
+declare class Row extends CdkRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Row, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Row, "ngs-row, [ngs-row], tr[ngs-row]", never, {}, {}, never, never, true, never>;
+}
+
+/** Data row definition for the ngs-table. */
+declare class RowDef<T> extends CdkRowDef<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowDef<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RowDef<any>, "[ngsRowDef]", never, { "columns": { "alias": "ngsRowDefColumns"; "required": false; }; "when": { "alias": "ngsRowDefWhen"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Column that simply shows text content for the header and row cells. Assumes that the table
+ * is using the native table implementation (`<table>`).
+ *
+ * By default, the name of this column will be the same as the data property that it should show.
+ * The header can be overridden by setting the `headerText` input.
+ *
+ * Example usage:
+ * <table ngs-table [dataSource]="dataSource">
+ *   <ngs-text-column name="userName"></ngs-text-column>
+ *   <tr ngs-header-row *ngsHeaderRowDef="['userName']"></tr>
+ *   <tr ngs-row *ngsRowDef="['userName']"></tr>
+ * </table>
+ */
+declare class TextColumn<T> extends CdkTextColumn<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextColumn<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextColumn<any>, "ngs-text-column", never, {}, {}, never, never, true, never>;
+}
+
+declare class TableDataSource<T> extends DataSource<T> {
+    /** Stream that emits when a new data array is set on the data source. */
+    private readonly _data;
+    /** Stream emitting render data to the table (depends on ordered data changes). */
+    private readonly _renderData;
+    /** Stream that emits when a new filter string is set on the data source. */
+    private readonly _filter;
+    /** Used to react to internal changes of the paginator that the table needs to be notified about. */
+    private readonly _internalPageChanges;
+    /**
+     * Subscription to the changes that should trigger an update to the table's rendered data, such
+     * as filtering, sorting, pagination, or base data changes.
+     */
+    _renderChangesSubscription: Subscription;
+    /**
+     * Cache for quick filter strings. Maps each data object to its concatenated string representation
+     * used for filtering.
+     */
+    private _quickFilterCache;
+    /**
+     * The filtered set of data that has been matched by the filter string, or all the data if there
+     * is no filter. Useful for knowing the set of data the table represents.
+     * For example, a 'scrolled' paginator can use this to know the total number of items when
+     * pagination has been applied.
+     */
+    filteredData: T[];
+    /**
+     * The sorted set of data that has been ordered by the sort state, or all the filtered data if there
+     * is no sort. Useful for knowing the set of data the table represents.
+     */
+    sortedData: T[];
+    /** Array of data that should be rendered by the table, where each object represents one row. */
+    get data(): T[];
+    set data(data: T[]);
+    /**
+     * Filter term that should be used to filter out objects from the data array. To `TableDataSource`'s
+     * default implementation, this string checks for stringification matches anywhere in the object.
+     */
+    get filter(): string;
+    set filter(filter: string);
+    /**
+     * Instance of the MatSort directive used by the table to control its sorting. Sort changes
+     * emitted by the MatSort will trigger an update to the table's rendered data.
+     */
+    get sort(): SortDirective | null;
+    set sort(sort: SortDirective | null);
+    private _sort;
+    /**
+     * Instance of the Paginator component used by the table to control what page of the data is
+     * displayed. Page changes emitted by the Paginator will trigger an update to the
+     * table's rendered data.
+     */
+    get paginator(): Paginator | null;
+    set paginator(paginator: Paginator | null);
+    private _paginator;
+    /**
+     * Data accessor function that is used for accessing data properties for sorting through
+     * the default sortData function.
+     * This default function assumes that the data objects are flat and can be accessed directly by
+     * the column name.
+     */
+    sortingDataAccessor: (data: T, sortHeaderId: string) => string | number;
+    /**
+     * Gets a sorted copy of the data array based on the state of the MatSort. Called
+     * after changes are made to the filtered data or when sort changes are emitted from MatSort.
+     * By default, the function retrieves the active sort and its direction and compares data
+     * objects by retrieving data using the sortingDataAccessor. May be overridden for a
+     * custom implementation of data ordering.
+     * @param data The array of data that should be sorted.
+     * @param sort The connected MatSort that holds the current sort state.
+     */
+    sortData: (data: T[], sort: SortDirective) => T[];
+    /**
+     * Checks if a data object matches the data source's filter string. By default, each data object
+     * is converted to a string of its properties and returns true if the filter has at least one
+     * occurrence in that string. By default, the filter string has its whitespace trimmed and the match
+     * is case-insensitive. May be overridden for a custom implementation of filter matching.
+     * @param data Data object used to check against the filter.
+     * @param filter Filter string that has been set on the data source.
+     * @returns Whether the filter matches the data.
+     */
+    filterPredicate: (data: T, filter: string) => boolean;
+    /**
+     * Gets a string representation of the data object used for quick filtering.
+     * Caches the result to improve performance.
+     * @param data
+     * @private
+     */
+    private _getQuickFilterString;
+    constructor(initialData?: T[]);
+    /**
+     * Subscribe to changes that should trigger an update to the table's rendered data.
+     */
+    _updateChangeSubscription(): void;
+    private _observeOutput;
+    /**
+     * Returns a filtered data array where each filter object contains the filter string within
+     * the result of the filterPredicate function. If no filter is set, returns the entire data
+     * array without changes.
+     */
+    _filterData(data: T[]): T[];
+    /**
+     * Returns a sorted copy of the data if MatSort has a sort applied, otherwise just returns the
+     * data array entirely.
+     */
+    _orderData(data: T[]): T[];
+    /**
+     * Returns a paged splice of the provided data array based on the provided Paginator's page
+     * index and length. If there is no paginator provided, returns the data array as is.
+     */
+    _pageData(data: T[]): T[];
+    /**
+     * Updates the paginator to reflect the length of the filtered data, and makes sure that the page
+     * index does not exceed the amount of pages in the new data set.
+     */
+    _updatePaginator(filteredDataLength: number): void;
+    /**
+     * Used by the CdkTable. Called when it connects to the data source.
+     * @docs-private
+     */
+    connect(): BehaviorSubject<T[]>;
+    /**
+     * Used by the CdkTable. Called when it disconnects from the data source.
+     * @docs-private
+     */
+    disconnect(): void;
+}
+
+declare class NativeTable {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NativeTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NativeTable, "table[ngs-native-table]", ["ngsNativeTable"], {}, {}, never, ["*"], true, never>;
+}
+
+export { Cell, CellDef, ColumnDef, FooterCell, FooterCellDef, FooterRow, FooterRowDef, HeaderCell, HeaderCellDef, HeaderRow, HeaderRowDef, NativeTable, NoDataRow, Row, RowDef, Table, TableDataSource, TextColumn };

package/types/ngstarter-ui-components-tabs.d.ts

@@ -0,0 +1,145 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, InjectionToken, AfterViewInit, OnDestroy, ElementRef, OnInit } from '@angular/core';
+import * as _ngstarter_ui_components_tabs from '@ngstarter-ui/components/tabs';
+import * as _angular_cdk_portal from '@angular/cdk/portal';
+import { TemplatePortal } from '@angular/cdk/portal';
+import * as i1 from '@ngstarter-ui/components/core';
+
+declare class Tab {
+    templateLabel: _angular_core.Signal<_ngstarter_ui_components_tabs.TabLabel | undefined>;
+    explicitContent: _angular_core.Signal<_ngstarter_ui_components_tabs.TabContent | undefined>;
+    implicitContent: _angular_core.Signal<TemplateRef<any> | undefined>;
+    label: _angular_core.InputSignal<string>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    ariaLabelledby: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private _contentPortal;
+    _prepareContent(viewContainerRef: any): TemplatePortal<any> | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tab, "ngs-tab", ["ngsTab"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["templateLabel", "explicitContent"], ["*"], true, never>;
+}
+
+declare const TAB_LABEL: InjectionToken<TabLabel>;
+declare class TabLabel {
+    template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabLabel, "[ngsTabLabel], [ngs-tab-label]", never, {}, {}, never, never, true, never>;
+}
+declare const TAB_CONTENT: InjectionToken<TabContent>;
+declare class TabContent {
+    template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabContent, "[ngsTabContent], [ngs-tab-content]", never, {}, {}, never, never, true, never>;
+}
+
+interface TabChangeEvent {
+    index: number;
+    tab: Tab;
+}
+declare class TabGroup implements AfterViewInit, OnDestroy {
+    private _viewContainerRef;
+    private _cdr;
+    private _platformId;
+    private _tabsSubscription;
+    private _resizeSubscription;
+    private _resizeObserver;
+    _tabs: _angular_core.Signal<readonly Tab[]>;
+    _tabLabels: _angular_core.Signal<readonly ElementRef<any>[]>;
+    _tabListContainer: _angular_core.Signal<ElementRef<any> | undefined>;
+    _tabList: _angular_core.Signal<ElementRef<any> | undefined>;
+    _showPaginationControls: _angular_core.WritableSignal<boolean>;
+    _disableScrollBefore: _angular_core.WritableSignal<boolean>;
+    _disableScrollAfter: _angular_core.WritableSignal<boolean>;
+    selectedIndex: _angular_core.InputSignalWithTransform<number, unknown>;
+    headerPosition: _angular_core.InputSignal<"above" | "below">;
+    preserveContent: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    stretchTabs: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    alignTabs: _angular_core.InputSignal<"start" | "center" | "end">;
+    disableRipple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    animationDuration: _angular_core.InputSignalWithTransform<string, string | number>;
+    enterAnimation: _angular_core.InputSignal<string>;
+    leaveAnimation: _angular_core.InputSignal<string>;
+    selectedIndexChange: _angular_core.OutputEmitterRef<number>;
+    selectedTabChange: _angular_core.OutputEmitterRef<TabChangeEvent>;
+    focusChange: _angular_core.OutputEmitterRef<TabChangeEvent>;
+    _isActive: {
+        [key: number]: boolean;
+    };
+    protected _selectedIndex: number;
+    private _prevIndex;
+    private _isInitialized;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected _clampIndex(): void;
+    _updatePagination(): void;
+    _updateScrollButtonsState(): void;
+    private _scrollToTab;
+    _scrollBefore(): void;
+    _scrollAfter(): void;
+    _handleScroll(): void;
+    _onTabHeaderClick(index: number): void;
+    _getTabContent(tab: Tab): _angular_cdk_portal.TemplatePortal<any> | null;
+    _getEnterAnimation(index: number): string;
+    _getLeaveAnimation(index: number): string;
+    _onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabGroup, "ngs-tab-group", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "headerPosition": { "alias": "headerPosition"; "required": false; "isSignal": true; }; "preserveContent": { "alias": "preserveContent"; "required": false; "isSignal": true; }; "stretchTabs": { "alias": "ngs-stretch-tabs"; "required": false; "isSignal": true; }; "alignTabs": { "alias": "ngs-align-tabs"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "enterAnimation": { "alias": "animate.enter"; "required": false; "isSignal": true; }; "leaveAnimation": { "alias": "animate.leave"; "required": false; "isSignal": true; }; }, { "selectedIndexChange": "selectedIndexChange"; "selectedTabChange": "selectedTabChange"; "focusChange": "focusChange"; }, ["_tabs"], never, true, never>;
+}
+
+declare class TabLink {
+    private _el;
+    private _parent;
+    private _routerLink;
+    readonly active: _angular_core.Signal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    rippleDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    get ngsRippleDisabled(): boolean;
+    _ariaControls(): string | null;
+    _onClick(event: MouseEvent): void;
+    focus(): void;
+    get elementRef(): ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabLink, "a[ngs-tab-link]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "rippleDisabled": { "alias": "ngsRippleDisabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.Ripple; inputs: { "ngsRippleDisabled": "ngsRippleDisabled"; }; outputs: {}; }]>;
+}
+
+declare class TabNavPanel {
+    id: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabNavPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabNavPanel, "ngs-tab-nav-panel", ["ngsTabNavPanel"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class TabNavBar implements AfterViewInit, OnDestroy, OnInit {
+    private _cdr;
+    private platformId;
+    private currentUrl;
+    private _router;
+    private _destroyRef;
+    _links: _angular_core.Signal<readonly TabLink[]>;
+    _tabListContainer: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    _tabList: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    _showPaginationControls: _angular_core.WritableSignal<boolean>;
+    _disableScrollBefore: _angular_core.WritableSignal<boolean>;
+    _disableScrollAfter: _angular_core.WritableSignal<boolean>;
+    tabPanel: _angular_core.InputSignal<TabNavPanel | null>;
+    disableRipple: _angular_core.InputSignal<boolean>;
+    activator: _angular_core.InputSignal<((link: TabLink) => boolean) | undefined>;
+    readonly isActiveFn: _angular_core.Signal<(link: TabLink) => boolean>;
+    private _resizeObserver;
+    private _resizeSubscription;
+    private defaultIsActive;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _handleScroll(): void;
+    _scrollBefore(): void;
+    _scrollAfter(): void;
+    private _updatePagination;
+    private _updateScrollButtonsState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabNavBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabNavBar, "ngs-tab-nav-bar, [ngs-tab-nav-bar]", ["ngsTabNavBar"], { "tabPanel": { "alias": "tabPanel"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; "activator": { "alias": "activator"; "required": false; "isSignal": true; }; }, {}, ["_links"], ["a[ngs-tab-link]"], true, never>;
+}
+
+export { TAB_CONTENT, TAB_LABEL, Tab, TabContent, TabGroup, TabLabel, TabLink, TabNavBar, TabNavPanel };
+export type { TabChangeEvent };