import * as _angular_core from '@angular/core';
import { OnDestroy, ElementRef } from '@angular/core';
import { C2gLottieLoaderPreset } from '@camp2gether/c2g-ui';
import { ControlValueAccessor } from '@angular/forms';
import * as _camp2gether_c2g_ui_layout from '@camp2gether/c2g-ui/layout';

declare class ContentPanelComponent {
    eyebrow: _angular_core.InputSignal<string>;
    title: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContentPanelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContentPanelComponent, "app-content-panel", never, { "eyebrow": { "alias": "eyebrow"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["[panel-actions]", "*"], true, never>;
}

declare class CoverageKpiComponent {
    label: _angular_core.InputSignal<string>;
    coveragePercent: _angular_core.InputSignal<number>;
    readonly ringCircumference = 125.66;
    readonly ringOffset: _angular_core.Signal<number>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoverageKpiComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoverageKpiComponent, "app-coverage-kpi", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "coveragePercent": { "alias": "coveragePercent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HeroComponent {
    eyebrow: _angular_core.InputSignal<string | undefined>;
    title: _angular_core.InputSignal<string | undefined>;
    lead: _angular_core.InputSignal<string | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeroComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeroComponent, "app-hero", never, { "eyebrow": { "alias": "eyebrow"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "lead": { "alias": "lead"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

type KpiCardTone = 'owned' | 'missing' | 'total';
declare class KpiCardComponent {
    value: _angular_core.InputSignal<number>;
    label: _angular_core.InputSignal<string>;
    icon: _angular_core.InputSignal<string>;
    tone: _angular_core.InputSignal<KpiCardTone>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KpiCardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KpiCardComponent, "app-kpi-card", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "tone": { "alias": "tone"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface DangerZoneAction {
    labelKey?: string;
    variant?: 'primary' | 'secondary' | 'ghost' | 'destructive';
    icon?: string;
    ariaLabelKey?: string;
    disabled?: boolean;
    label?: string;
    ariaLabel?: string;
}
interface DangerZoneItem {
    id: string;
    titleKey?: string;
    descriptionKey?: string;
    action: DangerZoneAction;
    onTrigger?: (item: DangerZoneItem) => void;
    title?: string;
    description?: string;
}
declare class DangerZoneComponent {
    readonly headingKey: _angular_core.InputSignal<string>;
    readonly items: _angular_core.InputSignal<DangerZoneItem[]>;
    /**
      * Emits the clicked item id so consumers can map actions in their container.
      *
      * Prefer the per-item callback (`item.onTrigger`) when you want action logic to
      * live directly on each item config.
     *
      * Output binding:
      * ```html
      * <c2g-danger-zone [items]="dangerItems" (itemTriggered)="onDangerAction($event)" />
      * ```
      *
      * Example mapping:
      * ```ts
      * onDangerAction(id: string) {
      *   if (id === 'delete-project') {
      *     this.openDeleteDialog();
      *   }
      * }
      * ```
     */
    readonly itemTriggered: _angular_core.OutputEmitterRef<string>;
    readonly resolvedHeadingKey: _angular_core.Signal<string>;
    onItemTriggered(item: DangerZoneItem): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DangerZoneComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DangerZoneComponent, "c2g-danger-zone", never, { "headingKey": { "alias": "headingKey"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; }, { "itemTriggered": "itemTriggered"; }, never, never, true, never>;
}

declare class DangerZoneItemComponent {
    readonly item: _angular_core.InputSignal<DangerZoneItem>;
    readonly triggered: _angular_core.OutputEmitterRef<DangerZoneItem>;
    titleKey(): string;
    descriptionKey(): string | null;
    actionLabelKey(): string;
    actionAriaLabelKey(): string;
    onTriggered(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DangerZoneItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DangerZoneItemComponent, "c2g-danger-zone-item", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, { "triggered": "triggered"; }, never, never, true, never>;
}

interface C2gListItemData {
    name: string;
    description?: string | null;
    memberCount?: number | null;
    members?: unknown[];
}
declare class ListItemComponent {
    readonly group: _angular_core.InputSignal<C2gListItemData | null>;
    readonly active: _angular_core.InputSignal<boolean>;
    readonly selected: _angular_core.OutputEmitterRef<C2gListItemData | null>;
    readonly opened: _angular_core.OutputEmitterRef<C2gListItemData | null>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListItemComponent, "c2g-list-item", never, { "group": { "alias": "group"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "opened": "opened"; }, never, never, true, never>;
}

interface StatCardBackground {
    type: 'gradient' | 'image';
    value: string;
    overlay?: string;
}
interface StatCardData {
    value: string | number;
    label: string;
    icon?: string;
    lottiePreset?: C2gLottieLoaderPreset;
    iconBackgroundTone?: 'primary' | 'secondary' | 'neutral';
    background?: StatCardBackground;
    disabled?: boolean;
    trend?: {
        direction: 'up' | 'down' | 'neutral';
        value: string | number;
    };
}
declare class StatCardComponent {
    readonly data: _angular_core.InputSignal<StatCardData>;
    readonly cardBackgroundStyle: _angular_core.Signal<Record<string, string> | null>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatCardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatCardComponent, "c2g-stat-card", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

type ActionCardLayout = 'icon-left' | 'hero-top' | 'icon-detail';
interface ActionCardData {
    icon?: string;
    title: string;
    text?: string;
    description?: string;
    image?: string;
    lottiePreset?: C2gLottieLoaderPreset;
    disabled?: boolean;
    iconBackgroundTone?: 'primary' | 'secondary' | 'neutral';
    ctaLabel?: string;
}
declare class ActionCardComponent {
    readonly data: _angular_core.InputSignal<ActionCardData>;
    readonly clickable: _angular_core.InputSignal<boolean>;
    readonly variant: _angular_core.InputSignal<ActionCardLayout>;
    readonly cardClicked: _angular_core.OutputEmitterRef<void>;
    readonly effectiveText: _angular_core.Signal<string>;
    readonly supportingDescription: _angular_core.Signal<string>;
    readonly isInteractive: _angular_core.Signal<boolean>;
    readonly iconToneClass: _angular_core.Signal<"primary" | "secondary" | "neutral">;
    onCardClick(): void;
    onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionCardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionCardComponent, "c2g-action-card", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "cardClicked": "cardClicked"; }, never, ["[ctas]", "*", "[ctas]"], true, never>;
}

interface ViewToggleOption<T extends string = string> {
    value: T;
    icon: string;
    label: string;
}

declare class ViewToggleComponent<T extends string = string> {
    options: _angular_core.InputSignal<ViewToggleOption<T>[]>;
    activeValue: _angular_core.InputSignal<T | null>;
    valueChange: _angular_core.OutputEmitterRef<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ViewToggleComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ViewToggleComponent<any>, "app-view-toggle", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "activeValue": { "alias": "activeValue"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

interface SegmentedToggleOption<T extends string = string> {
    value: T;
    label: string;
    icon?: string;
    iconFontSet?: string;
    iconFontIcon?: string;
    iconAriaLabel?: string;
    disabled?: boolean;
}

declare class SegmentedToggleComponent<T extends string = string> implements ControlValueAccessor {
    readonly options: _angular_core.InputSignal<SegmentedToggleOption<T>[]>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    readonly iconOnly: _angular_core.InputSignal<boolean>;
    readonly valueChange: _angular_core.OutputEmitterRef<T>;
    readonly value: _angular_core.WritableSignal<T | null>;
    readonly cvaDisabled: _angular_core.WritableSignal<boolean>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private onChange;
    private onTouched;
    writeValue(value: T | null): void;
    registerOnChange(fn: (value: T) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    tabIndexFor(option: T): number;
    select(next: T): void;
    onKeydown(event: KeyboardEvent, index: number): void;
    private focusValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedToggleComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedToggleComponent<any>, "c2g-segmented-toggle", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class SearchInputComponent {
    searchChange: _angular_core.OutputEmitterRef<string>;
    onInput(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchInputComponent, "app-search-input", never, {}, { "searchChange": "searchChange"; }, never, never, true, never>;
}

interface EmptyStateData {
    icon?: string;
    lottiePreset?: C2gLottieLoaderPreset;
    title: string;
    description?: string;
    actionLabel?: string;
}

declare class EmptyStateComponent {
    readonly data: _angular_core.InputSignal<EmptyStateData>;
    readonly actionClicked: _angular_core.OutputEmitterRef<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyStateComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyStateComponent, "c2g-empty-state", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, { "actionClicked": "actionClicked"; }, never, ["*"], true, never>;
}

interface PaginationState {
    currentPage: number;
    totalPages: number;
    pageSize?: number;
    totalItems?: number;
}

declare class PaginationComponent {
    readonly state: _angular_core.InputSignal<PaginationState>;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    readonly pageChanged: _angular_core.OutputEmitterRef<number>;
    readonly currentPage: _angular_core.Signal<number>;
    readonly totalPages: _angular_core.Signal<number>;
    readonly hasPrev: _angular_core.Signal<boolean>;
    readonly hasNext: _angular_core.Signal<boolean>;
    readonly visiblePages: _angular_core.Signal<number[]>;
    readonly showStartEllipsis: _angular_core.Signal<boolean>;
    readonly showEndEllipsis: _angular_core.Signal<boolean>;
    go(page: number): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginationComponent, "c2g-pagination", never, { "state": { "alias": "state"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "pageChanged": "pageChanged"; }, never, never, true, never>;
}

interface C2gTableColumn<T = any> {
    key: string;
    label: string;
    sortable?: boolean;
    width?: string;
    align?: 'left' | 'center' | 'right';
    valueGetter?: (row: T) => string | number;
}
type C2gSortDirection = 'asc' | 'desc' | null;
interface C2gSortState {
    key: string;
    direction: C2gSortDirection;
}

declare class TableComponent<T extends Record<string, any> = Record<string, any>> {
    readonly rows: _angular_core.InputSignal<T[]>;
    readonly columns: _angular_core.InputSignal<C2gTableColumn<T>[]>;
    readonly rowHeight: _angular_core.InputSignal<number>;
    readonly maxHeight: _angular_core.InputSignal<string>;
    readonly selectable: _angular_core.InputSignal<boolean>;
    readonly virtualScroll: _angular_core.InputSignal<boolean>;
    readonly sortChanged: _angular_core.OutputEmitterRef<C2gSortState>;
    readonly rowSelected: _angular_core.OutputEmitterRef<T>;
    readonly sortState: _angular_core.WritableSignal<C2gSortState>;
    readonly selectedRow: _angular_core.WritableSignal<T | null>;
    readonly sortedRows: _angular_core.Signal<T[]>;
    getCellValue(row: T, col: C2gTableColumn<T>): string | number;
    sort(key: string): void;
    select(row: T): void;
    isSelected(row: T): boolean;
    sortIcon(key: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent<any>, "c2g-table", never, { "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; }, { "sortChanged": "sortChanged"; "rowSelected": "rowSelected"; }, never, never, true, never>;
}

interface C2gTab {
    key: string;
    label: string;
    icon?: string;
    disabled?: boolean;
    badge?: number;
}

declare class TabsComponent {
    readonly tabs: _angular_core.InputSignal<C2gTab[]>;
    readonly activeKey: _angular_core.ModelSignal<string>;
    readonly tabChanged: _angular_core.OutputEmitterRef<C2gTab>;
    readonly activeTab: _angular_core.Signal<C2gTab>;
    select(tab: C2gTab): void;
    isActive(tab: C2gTab): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsComponent, "c2g-tabs", never, { "tabs": { "alias": "tabs"; "required": true; "isSignal": true; }; "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; }, { "activeKey": "activeKeyChange"; "tabChanged": "tabChanged"; }, never, ["*"], true, never>;
}

interface C2gBreadcrumbItem {
    label: string;
    href?: string;
    icon?: string;
}

declare class BreadcrumbComponent {
    readonly items: _angular_core.InputSignal<C2gBreadcrumbItem[]>;
    readonly separator: _angular_core.InputSignal<string>;
    readonly itemClicked: _angular_core.OutputEmitterRef<C2gBreadcrumbItem>;
    navigate(event: Event, item: C2gBreadcrumbItem): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbComponent, "c2g-breadcrumb", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, { "itemClicked": "itemClicked"; }, never, never, true, never>;
}

interface C2gStep {
    key: string;
    label: string;
    description?: string;
    optional?: boolean;
}
type C2gStepState = 'completed' | 'active' | 'pending' | 'error';

declare class StepperComponent {
    readonly steps: _angular_core.InputSignal<C2gStep[]>;
    readonly activeIndex: _angular_core.ModelSignal<number>;
    readonly completedIndices: _angular_core.InputSignal<number[]>;
    readonly errorIndices: _angular_core.InputSignal<number[]>;
    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
    readonly stepChanged: _angular_core.OutputEmitterRef<{
        step: C2gStep;
        index: number;
    }>;
    readonly canGoNext: _angular_core.Signal<boolean>;
    readonly canGoPrev: _angular_core.Signal<boolean>;
    getState(index: number): C2gStepState;
    goTo(index: number): void;
    next(): void;
    prev(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepperComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepperComponent, "c2g-stepper", never, { "steps": { "alias": "steps"; "required": true; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "completedIndices": { "alias": "completedIndices"; "required": false; "isSignal": true; }; "errorIndices": { "alias": "errorIndices"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; "stepChanged": "stepChanged"; }, never, never, true, never>;
}

type C2gKpiTrend = 'up' | 'down' | 'neutral';
type C2gKpiColor = 'primary' | 'success' | 'warning' | 'danger' | 'neutral';
interface C2gKpiCardData {
    label: string;
    value: string | number;
    unit?: string;
    icon?: string;
    trend?: C2gKpiTrend;
    change?: string | number;
    changeLabel?: string;
    color?: C2gKpiColor;
    /** 5–8 numbers for the mini sparkline, oldest → newest */
    sparkline?: number[];
}

declare class C2gKpiCardComponent implements OnDestroy {
    private el;
    readonly data: _angular_core.InputSignal<C2gKpiCardData>;
    readonly color: _angular_core.Signal<_camp2gether_c2g_ui_layout.C2gKpiColor>;
    readonly hostClass: _angular_core.Signal<string>;
    readonly displayValue: _angular_core.WritableSignal<string>;
    private countUpRaf;
    constructor(el: ElementRef<HTMLElement>);
    private startCountUp;
    readonly sparklinePath: _angular_core.Signal<{
        line: string;
        area: string;
        lastX: number;
        lastY: number;
    } | null>;
    readonly tilt: _angular_core.WritableSignal<{
        x: number;
        y: number;
    }>;
    onMouseMove(e: MouseEvent): void;
    onMouseLeave(): void;
    readonly tiltStyle: _angular_core.Signal<string>;
    readonly trendArrow: _angular_core.Signal<"↑" | "↓" | "→">;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<C2gKpiCardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<C2gKpiCardComponent, "c2g-kpi-card", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface C2gFilterOption {
    key: string;
    label: string;
    icon?: string;
    count?: number;
}
interface C2gFilterGroup {
    key: string;
    label?: string;
    options: C2gFilterOption[];
    multiple?: boolean;
}
type C2gFilterState = Record<string, string[]>;

declare class FilterBarComponent {
    readonly groups: _angular_core.InputSignal<C2gFilterGroup[]>;
    readonly searchPlaceholder: _angular_core.InputSignal<string>;
    readonly showSearch: _angular_core.InputSignal<boolean>;
    readonly search: _angular_core.ModelSignal<string>;
    readonly activeFilters: _angular_core.ModelSignal<C2gFilterState>;
    readonly filterChanged: _angular_core.OutputEmitterRef<C2gFilterState>;
    readonly searchChanged: _angular_core.OutputEmitterRef<string>;
    readonly activeCount: _angular_core.Signal<number>;
    readonly hasActiveFilters: _angular_core.Signal<boolean>;
    isSelected(groupKey: string, optionKey: string): boolean;
    toggle(groupKey: string, optionKey: string, multiple: boolean): void;
    clearAll(): void;
    onSearch(value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterBarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilterBarComponent, "c2g-filter-bar", never, { "groups": { "alias": "groups"; "required": true; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "showSearch": { "alias": "showSearch"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "activeFilters": { "alias": "activeFilters"; "required": false; "isSignal": true; }; }, { "search": "searchChange"; "activeFilters": "activeFiltersChange"; "filterChanged": "filterChanged"; "searchChanged": "searchChanged"; }, never, never, true, never>;
}

declare class SkeletonTableComponent {
    readonly rows: _angular_core.InputSignal<number>;
    readonly columns: _angular_core.InputSignal<number>;
    readonly showHeader: _angular_core.InputSignal<boolean>;
    readonly rowIndices: number[];
    readonly colIndices: number[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonTableComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonTableComponent, "c2g-skeleton-table", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { ActionCardComponent, BreadcrumbComponent, C2gKpiCardComponent, ContentPanelComponent, CoverageKpiComponent, DangerZoneComponent, DangerZoneItemComponent, EmptyStateComponent, FilterBarComponent, HeroComponent, KpiCardComponent, ListItemComponent, PaginationComponent, SearchInputComponent, SegmentedToggleComponent, SkeletonTableComponent, StatCardComponent, StepperComponent, TableComponent, TabsComponent, ViewToggleComponent };
export type { ActionCardData, ActionCardLayout, C2gBreadcrumbItem, C2gFilterGroup, C2gFilterOption, C2gFilterState, C2gKpiCardData, C2gKpiColor, C2gKpiTrend, C2gListItemData, C2gSortDirection, C2gSortState, C2gStep, C2gStepState, C2gTab, C2gTableColumn, DangerZoneAction, DangerZoneItem, EmptyStateData, KpiCardTone, PaginationState, SegmentedToggleOption, StatCardData, ViewToggleOption };