@camp2gether/c2g-ui 0.0.7

package/layout/index.d.ts

@@ -0,0 +1,443 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ElementRef } from '@angular/core';
+import { C2gLottieLoaderPreset } from '@humbeldore/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 };

package/maps/index.d.ts

@@ -0,0 +1,62 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
+import * as L from 'leaflet';
+
+type ActivityType = 'water' | 'forest' | 'mountain' | 'desert' | 'urban' | 'adventure' | 'point-of-interest';
+type TourStatus = 'declined' | 'completed' | 'current' | 'upcoming';
+type MarkerSize = 'small' | 'medium' | 'large';
+interface C2gMapMarkerData {
+    id: string;
+    latitude: number;
+    longitude: number;
+    activityType?: ActivityType;
+    tourStatus?: TourStatus;
+    title?: string;
+    selected?: boolean;
+    size?: MarkerSize;
+    variant?: 'default' | 'new-tour';
+}
+
+declare class MapComponent implements AfterViewInit, OnDestroy {
+    mapContainer: ElementRef<HTMLDivElement>;
+    readonly center: _angular_core.InputSignal<[number, number]>;
+    readonly zoom: _angular_core.InputSignal<number>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly markers: _angular_core.InputSignal<C2gMapMarkerData[]>;
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    readonly mapReady: _angular_core.OutputEmitterRef<L.Map>;
+    readonly mapClick: _angular_core.OutputEmitterRef<L.LeafletMouseEvent>;
+    readonly markerClick: _angular_core.OutputEmitterRef<{
+        marker: C2gMapMarkerData;
+        event: L.LeafletMouseEvent;
+    }>;
+    private map?;
+    private markerGroup?;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private initializeMap;
+    private updateMarkers;
+    private buildMarkerHtml;
+    private markerIcon;
+    private markerSize;
+    private markerAnchor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MapComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MapComponent, "c2g-map", never, { "center": { "alias": "center"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "markers": { "alias": "markers"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; }, { "mapReady": "mapReady"; "mapClick": "mapClick"; "markerClick": "markerClick"; }, never, never, true, never>;
+}
+
+declare class MapMarkerComponent {
+    readonly activityType: _angular_core.InputSignal<ActivityType>;
+    readonly tourStatus: _angular_core.InputSignal<TourStatus | null>;
+    readonly selected: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<MarkerSize>;
+    readonly variant: _angular_core.InputSignal<"default" | "new-tour">;
+    readonly markerType: _angular_core.Signal<string>;
+    readonly markerIcon: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MapMarkerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MapMarkerComponent, "c2g-map-marker", never, { "activityType": { "alias": "activityType"; "required": false; "isSignal": true; }; "tourStatus": { "alias": "tourStatus"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { MapComponent, MapMarkerComponent };
+export type { ActivityType, C2gMapMarkerData, MarkerSize, TourStatus };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@camp2gether/c2g-ui",
+  "version": "0.0.7",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": "^20.3.0",
+    "@angular/core": "^20.3.0",
+    "@angular/cdk": "^20.2.14",
+    "leaflet": "^1.9.4"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "exports": {
+    "./src/lib/styles/design-tokens.css": "./src/lib/styles/design-tokens.css",
+    "./src/lib/styles/themes.scss": "./src/lib/styles/themes.scss",
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/camp2gether-c2g-ui.mjs"
+    },
+    "./charts": {
+      "types": "./charts/index.d.ts",
+      "default": "./fesm2022/camp2gether-c2g-ui-charts.mjs"
+    },
+    "./layout": {
+      "types": "./layout/index.d.ts",
+      "default": "./fesm2022/camp2gether-c2g-ui-layout.mjs"
+    },
+    "./maps": {
+      "types": "./maps/index.d.ts",
+      "default": "./fesm2022/camp2gether-c2g-ui-maps.mjs"
+    },
+    "./presets": {
+      "types": "./presets/index.d.ts",
+      "default": "./fesm2022/camp2gether-c2g-ui-presets.mjs"
+    },
+    "./theme": {
+      "types": "./theme/index.d.ts",
+      "default": "./fesm2022/camp2gether-c2g-ui-theme.mjs"
+    }
+  },
+  "module": "fesm2022/camp2gether-c2g-ui.mjs",
+  "typings": "index.d.ts"
+}