@camp2gether/c2g-ui 0.0.7

package/presets/index.d.ts

@@ -0,0 +1,1437 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import * as _camp2gether_c2g_ui_presets from '@camp2gether/c2g-ui/presets';
+import { C2gAvatarBadge } from '@humbeldore/c2g-ui';
+import { AnimationOptions } from 'ngx-lottie';
+
+type C2gPackingVisibility = 'shared' | 'personal' | 'private';
+type C2gPackingAssignmentStatus = 'assigned' | 'packed' | 'confirmed';
+interface C2gPackingListAssignment {
+    itemId: string;
+    memberId: string;
+    memberName?: string;
+    packedBy?: string;
+    packedByName?: string;
+    status: C2gPackingAssignmentStatus;
+    quantity?: number;
+}
+interface C2gPackingItemAssignedEvent {
+    itemId: string;
+    memberId: string;
+    assigned: boolean;
+    quantity?: number;
+}
+interface C2gPackingListItem {
+    id: string;
+    name: string;
+    category: string;
+    essential?: boolean;
+    visibility: C2gPackingVisibility;
+    quantity?: number;
+    weightKg?: number;
+    packedVolumeL?: number;
+    priority?: string;
+    reason?: string;
+    weather?: boolean;
+    hint?: string;
+    confirmed?: boolean;
+    createdBy?: string;
+    privateOwnerVisible?: boolean;
+    assignments?: C2gPackingListAssignment[];
+}
+interface C2gPackingListMember {
+    id: string;
+    name: string;
+    initials?: string;
+    color?: string;
+    type?: 'adult' | 'child' | 'baby' | 'pet';
+    hasAccount?: boolean;
+}
+interface C2gPackingCategoryInfo {
+    key: string;
+    labelKey: string;
+    label?: string;
+    icon: string;
+}
+interface C2gPackingListFilterState {
+    query: string;
+    visibility: 'all' | C2gPackingVisibility;
+    essentialsOnly: boolean;
+    memberIds: string[];
+}
+interface C2gPackingListMemberStatus {
+    memberId: string;
+    memberName: string;
+    initials?: string;
+    checked: boolean;
+    canToggle: boolean;
+}
+interface C2gPackingListMemberOverlayRequest {
+    itemId: string;
+    itemName: string;
+    members: C2gPackingListMemberStatus[];
+}
+interface C2gPackingListLabels {
+    searchPlaceholderKey: string;
+    essentialsOnlyKey: string;
+    showAllVisibilityKey: string;
+    sharedVisibilityKey: string;
+    personalVisibilityKey: string;
+    privateVisibilityKey: string;
+    privateSectionTitleKey: string;
+    emptyStateKey: string;
+    categoryStatsKey: string;
+    deleteConfirmKey: string;
+    addItemKey?: string;
+    createItemKey?: string;
+    itemNameKey?: string;
+    categoryKey?: string;
+    visibilityKey?: string;
+    essentialKey?: string;
+    quantityKey?: string;
+    weightKey?: string;
+    volumeKey?: string;
+    hintKey?: string;
+    cancelKey?: string;
+    createKey?: string;
+}
+declare const DEFAULT_PACKING_LIST_LABEL_KEYS: C2gPackingListLabels;
+interface C2gPackingListPermissions {
+    isOrganizer: boolean;
+    isGuest: boolean;
+    isSolo: boolean;
+    readOnly: boolean;
+    canManageAssignments?: boolean;
+    canMembersManageSharedItems?: boolean;
+    canMembersAddSharedItems?: boolean;
+}
+/**
+ * Feature flags (like GridOptions booleans).
+ * Applied globally to all rows.
+ */
+interface C2gPackingListFeatures {
+    search?: boolean;
+    filters?: boolean;
+    stats?: boolean;
+    create?: boolean;
+    editItem?: boolean;
+    deleteItem?: boolean;
+    assignments?: boolean;
+    privateSection?: boolean;
+    expandAllOnLoad?: boolean;
+}
+/**
+ * Column definition - generic over host-defined field type.
+ * Host specifies which fields are available via TField generic.
+ */
+interface C2gPackingListColumnDef<TField extends string = string> {
+    field: TField;
+    visible?: boolean;
+    editable?: boolean;
+    sortable?: boolean;
+    labelKey?: string;
+}
+/**
+ * Sort state - generic over host-defined field type.
+ */
+type C2gPackingSortDir = 'asc' | 'desc';
+interface C2gPackingListSortState<TField extends string = string> {
+    field: TField;
+    dir: C2gPackingSortDir;
+}
+/**
+ * Custom row action - host can trigger these via (rowActionTriggered).
+ */
+interface C2gPackingListRowAction {
+    id: string;
+    labelKey: string;
+    icon?: string;
+    showWhen?: (item: C2gPackingListItem, permissions: C2gPackingListPermissions) => boolean;
+}
+/**
+ * Main config object - generic over host-defined field type.
+ * Like AgGrid GridOptions.
+ */
+interface C2gPackingListConfig<TField extends string = string> {
+    features?: C2gPackingListFeatures;
+    columnDefs?: C2gPackingListColumnDef<TField>[];
+    sort?: C2gPackingListSortState<TField>;
+    rowActions?: C2gPackingListRowAction[];
+    initialFilter?: Partial<C2gPackingListFilterState>;
+    defaultExpandedCount?: number;
+}
+declare const DEFAULT_PACKING_LIST_CONFIG: C2gPackingListConfig;
+
+declare const C2G_PACKING_CATEGORY_INFO: Record<string, C2gPackingCategoryInfo>;
+declare function resolvePackingCategory(categoryKey: string): C2gPackingCategoryInfo;
+
+declare class PackingListComponent<TField extends string = string> {
+    readonly items: _angular_core.InputSignal<C2gPackingListItem[]>;
+    readonly members: _angular_core.InputSignal<C2gPackingListMember[]>;
+    readonly currentUserId: _angular_core.InputSignal<string>;
+    readonly permissions: _angular_core.InputSignal<C2gPackingListPermissions>;
+    readonly labels: _angular_core.InputSignal<C2gPackingListLabels>;
+    readonly categories: _angular_core.InputSignal<C2gPackingCategoryInfo[]>;
+    readonly config: _angular_core.InputSignal<C2gPackingListConfig<TField>>;
+    readonly showPrivateAsSeparateList: _angular_core.InputSignal<boolean>;
+    readonly showStats: _angular_core.InputSignal<boolean>;
+    readonly itemChecked: _angular_core.OutputEmitterRef<{
+        itemId: string;
+        checked: boolean;
+    }>;
+    readonly itemAssigned: _angular_core.OutputEmitterRef<C2gPackingItemAssignedEvent>;
+    readonly itemDeleted: _angular_core.OutputEmitterRef<string>;
+    readonly itemEditRequested: _angular_core.OutputEmitterRef<string>;
+    readonly itemCreated: _angular_core.OutputEmitterRef<Partial<C2gPackingListItem>>;
+    readonly personalItemToggled: _angular_core.OutputEmitterRef<{
+        itemId: string;
+        memberId: string;
+        checked: boolean;
+    }>;
+    readonly memberOverlayRequested: _angular_core.OutputEmitterRef<C2gPackingListMemberOverlayRequest>;
+    readonly externalMemberViewRequested: _angular_core.OutputEmitterRef<void>;
+    readonly filterChanged: _angular_core.OutputEmitterRef<C2gPackingListFilterState>;
+    readonly sortChanged: _angular_core.OutputEmitterRef<C2gPackingListSortState<TField>>;
+    readonly rowActionTriggered: _angular_core.OutputEmitterRef<{
+        actionId: string;
+        item: C2gPackingListItem;
+    }>;
+    readonly mergedConfig: _angular_core.Signal<C2gPackingListConfig<TField>>;
+    readonly filter: _angular_core.WritableSignal<C2gPackingListFilterState>;
+    readonly expandedCategories: _angular_core.WritableSignal<Set<string>>;
+    readonly hasUserToggled: _angular_core.WritableSignal<boolean>;
+    readonly filteredItems: _angular_core.Signal<C2gPackingListItem[]>;
+    readonly categoryGroups: _angular_core.Signal<{
+        key: string;
+        items: C2gPackingListItem[];
+    }[]>;
+    constructor();
+    onFilterChange(next: C2gPackingListFilterState): void;
+    onExternalMemberViewRequested(): void;
+    onItemCreated(item: Partial<C2gPackingListItem>): void;
+    isCategoryExpanded(category: string): boolean;
+    toggleCategory(category: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackingListComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackingListComponent<any>, "c2g-packing-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "members": { "alias": "members"; "required": true; "isSignal": true; }; "currentUserId": { "alias": "currentUserId"; "required": true; "isSignal": true; }; "permissions": { "alias": "permissions"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "categories": { "alias": "categories"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "showPrivateAsSeparateList": { "alias": "showPrivateAsSeparateList"; "required": false; "isSignal": true; }; "showStats": { "alias": "showStats"; "required": false; "isSignal": true; }; }, { "itemChecked": "itemChecked"; "itemAssigned": "itemAssigned"; "itemDeleted": "itemDeleted"; "itemEditRequested": "itemEditRequested"; "itemCreated": "itemCreated"; "personalItemToggled": "personalItemToggled"; "memberOverlayRequested": "memberOverlayRequested"; "externalMemberViewRequested": "externalMemberViewRequested"; "filterChanged": "filterChanged"; "sortChanged": "sortChanged"; "rowActionTriggered": "rowActionTriggered"; }, never, never, true, never>;
+}
+
+declare class PackingListFiltersComponent {
+    readonly filter: _angular_core.InputSignal<C2gPackingListFilterState>;
+    readonly members: _angular_core.InputSignal<C2gPackingListMember[]>;
+    readonly labels: _angular_core.InputSignal<C2gPackingListLabels>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly filterChange: _angular_core.OutputEmitterRef<C2gPackingListFilterState>;
+    readonly overlayRequested: _angular_core.OutputEmitterRef<void>;
+    readonly membersPanelOpen: _angular_core.WritableSignal<boolean>;
+    readonly memberQuery: _angular_core.WritableSignal<string>;
+    readonly memberSelectionLabel: _angular_core.Signal<string>;
+    readonly filteredMembers: _angular_core.Signal<C2gPackingListMember[]>;
+    onQueryChange(event: Event): void;
+    onVisibilityChange(event: Event): void;
+    onEssentialsOnlyToggle(event: Event): void;
+    toggleMembersPanel(): void;
+    onMemberSearch(event: Event): void;
+    isMemberSelected(memberId: string): boolean;
+    toggleMember(memberId: string): void;
+    clearMemberSelection(): void;
+    selectAllMembers(): void;
+    requestExternalOverlay(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackingListFiltersComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackingListFiltersComponent, "c2g-packing-list-filters", never, { "filter": { "alias": "filter"; "required": true; "isSignal": true; }; "members": { "alias": "members"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "filterChange": "filterChange"; "overlayRequested": "overlayRequested"; }, never, never, true, never>;
+}
+
+declare class PackingListStatsComponent {
+    readonly items: _angular_core.InputSignal<C2gPackingListItem[]>;
+    readonly stats: _angular_core.Signal<{
+        total: number;
+        packed: number;
+        essential: number;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackingListStatsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackingListStatsComponent, "c2g-packing-list-stats", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PackingListCategoryComponent {
+    readonly categoryKey: _angular_core.InputSignal<string>;
+    readonly items: _angular_core.InputSignal<C2gPackingListItem[]>;
+    readonly members: _angular_core.InputSignal<C2gPackingListMember[]>;
+    readonly selectedMemberIds: _angular_core.InputSignal<string[]>;
+    readonly currentUserId: _angular_core.InputSignal<string>;
+    readonly permissions: _angular_core.InputSignal<C2gPackingListPermissions>;
+    readonly expanded: _angular_core.InputSignal<boolean>;
+    readonly toggle: _angular_core.OutputEmitterRef<string>;
+    readonly itemChecked: _angular_core.OutputEmitterRef<{
+        itemId: string;
+        checked: boolean;
+    }>;
+    readonly itemAssigned: _angular_core.OutputEmitterRef<C2gPackingItemAssignedEvent>;
+    readonly itemDeleted: _angular_core.OutputEmitterRef<string>;
+    readonly itemEditRequested: _angular_core.OutputEmitterRef<string>;
+    readonly personalItemToggled: _angular_core.OutputEmitterRef<{
+        itemId: string;
+        memberId: string;
+        checked: boolean;
+    }>;
+    readonly memberOverlayRequested: _angular_core.OutputEmitterRef<C2gPackingListMemberOverlayRequest>;
+    readonly category: _angular_core.Signal<_camp2gether_c2g_ui_presets.C2gPackingCategoryInfo>;
+    readonly stats: _angular_core.Signal<{
+        total: number;
+        essential: number;
+        packed: number;
+    }>;
+    onToggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackingListCategoryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackingListCategoryComponent, "c2g-packing-list-category", never, { "categoryKey": { "alias": "categoryKey"; "required": true; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; "members": { "alias": "members"; "required": true; "isSignal": true; }; "selectedMemberIds": { "alias": "selectedMemberIds"; "required": false; "isSignal": true; }; "currentUserId": { "alias": "currentUserId"; "required": true; "isSignal": true; }; "permissions": { "alias": "permissions"; "required": true; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "toggle": "toggle"; "itemChecked": "itemChecked"; "itemAssigned": "itemAssigned"; "itemDeleted": "itemDeleted"; "itemEditRequested": "itemEditRequested"; "personalItemToggled": "personalItemToggled"; "memberOverlayRequested": "memberOverlayRequested"; }, never, never, true, never>;
+}
+
+declare class PackingListItemComponent {
+    readonly item: _angular_core.InputSignal<C2gPackingListItem>;
+    readonly members: _angular_core.InputSignal<C2gPackingListMember[]>;
+    readonly currentUserId: _angular_core.InputSignal<string>;
+    readonly permissions: _angular_core.InputSignal<C2gPackingListPermissions>;
+    readonly selectedMemberIds: _angular_core.InputSignal<string[]>;
+    readonly itemChecked: _angular_core.OutputEmitterRef<{
+        itemId: string;
+        checked: boolean;
+    }>;
+    readonly itemAssigned: _angular_core.OutputEmitterRef<C2gPackingItemAssignedEvent>;
+    readonly itemDeleted: _angular_core.OutputEmitterRef<string>;
+    readonly itemEditRequested: _angular_core.OutputEmitterRef<string>;
+    readonly personalItemToggled: _angular_core.OutputEmitterRef<{
+        itemId: string;
+        memberId: string;
+        checked: boolean;
+    }>;
+    readonly memberOverlayRequested: _angular_core.OutputEmitterRef<C2gPackingListMemberOverlayRequest>;
+    readonly overlayOpen: _angular_core.WritableSignal<boolean>;
+    readonly overlaySearch: _angular_core.WritableSignal<string>;
+    readonly ctaMenuOpen: _angular_core.WritableSignal<boolean>;
+    readonly quantityPickerOpen: _angular_core.WritableSignal<boolean>;
+    readonly quantityPickerValue: _angular_core.WritableSignal<number>;
+    readonly delegateDialogOpen: _angular_core.WritableSignal<boolean>;
+    readonly delegateMemberId: _angular_core.WritableSignal<string | null>;
+    readonly delegateQuantity: _angular_core.WritableSignal<number>;
+    readonly avatarDialogOpen: _angular_core.WritableSignal<boolean>;
+    readonly avatarDialogMemberId: _angular_core.WritableSignal<string | null>;
+    readonly avatarDialogQuantity: _angular_core.WritableSignal<number>;
+    readonly personalAssignDialogOpen: _angular_core.WritableSignal<boolean>;
+    readonly personalAssignSearch: _angular_core.WritableSignal<string>;
+    readonly personalAssignMemberId: _angular_core.WritableSignal<string | null>;
+    readonly applicableMembers: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly visibleMembers: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly packedCount: _angular_core.Signal<number>;
+    readonly isPacked: _angular_core.Signal<boolean>;
+    readonly requiredQuantity: _angular_core.Signal<number>;
+    readonly checkedMembers: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly personalAssignedMembers: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly missingMembers: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly checkedPreview: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly hiddenCheckedCount: _angular_core.Signal<number>;
+    readonly personalAssignedPreview: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly personalHiddenAssignedCount: _angular_core.Signal<number>;
+    readonly missingPreview: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly hiddenMissingCount: _angular_core.Signal<number>;
+    readonly currentUserMember: _angular_core.Signal<C2gPackingListMember | null>;
+    readonly isItemOwner: _angular_core.Signal<boolean>;
+    readonly canEditOrDeleteItem: _angular_core.Signal<boolean>;
+    readonly canShowAssignCta: _angular_core.Signal<boolean>;
+    readonly sharedAssignmentsCount: _angular_core.Signal<number>;
+    readonly sharedTotalAssignedCount: _angular_core.Signal<number>;
+    readonly sharedMissingSlots: _angular_core.Signal<number>;
+    readonly selfAssignableMaxQuantity: _angular_core.Signal<number>;
+    readonly delegateCandidates: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly selfAssignedToShared: _angular_core.Signal<boolean>;
+    readonly isPlanner: _angular_core.Signal<boolean>;
+    readonly joinBtnLabel: _angular_core.Signal<"+ Eintragen" | "Menge anpassen" | "Meine Menge anpassen">;
+    readonly pickerLabel: _angular_core.Signal<"Wie viel wird mitgenommen?" | "Wie viel nimmst du mit?">;
+    readonly delegatePickerLabel: _angular_core.Signal<string>;
+    readonly canSelfAssignShared: _angular_core.Signal<boolean>;
+    readonly selectedDelegateMember: _angular_core.Signal<C2gPackingListMember | null>;
+    readonly canManagePersonalAssignments: _angular_core.Signal<boolean>;
+    readonly personalAssignableMembers: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly filteredPersonalAssignableMembers: _angular_core.Signal<C2gPackingListMember[]>;
+    readonly selectedPersonalAssignMember: _angular_core.Signal<C2gPackingListMember | null>;
+    readonly completionText: _angular_core.Signal<string>;
+    readonly progressNumerator: _angular_core.Signal<number>;
+    readonly progressDenominator: _angular_core.Signal<number>;
+    readonly progressRatioText: _angular_core.Signal<string>;
+    readonly quantityBadge: _angular_core.Signal<{
+        readonly value: `${number}/${number}`;
+        readonly tone: "danger" | "warning" | "success";
+    } | null>;
+    readonly progressPercentage: _angular_core.Signal<number>;
+    readonly progressTone: _angular_core.Signal<"danger" | "warning" | "success">;
+    readonly needsPackLabel: _angular_core.Signal<string>;
+    readonly overlayMembers: _angular_core.Signal<C2gPackingListMemberStatus[]>;
+    readonly filteredOverlayMembers: _angular_core.Signal<C2gPackingListMemberStatus[]>;
+    readonly personalStatusBadges: _angular_core.Signal<{
+        key: string;
+        text: string;
+        tone: "success" | "warning";
+        dotColor: string;
+    }[]>;
+    readonly sharedCountChips: _angular_core.Signal<{
+        key: string;
+        text: string;
+        tone: "success" | "warning";
+    }[]>;
+    memberAssignmentStatus(memberId: string): 'confirmed' | 'packed' | 'assigned' | 'none';
+    memberAssignedQuantity(memberId: string): number;
+    memberRingTone(memberId: string): 'custom';
+    memberRingColor(memberId: string): string;
+    memberBadge(memberId: string): C2gAvatarBadge | null;
+    memberBackground(member: C2gPackingListMember): string;
+    isMemberChecked(memberId: string): boolean;
+    hasAnyAssignment(memberId: string): boolean;
+    canPackForMember(memberId: string): boolean;
+    isAssignmentChecked(memberId: string): boolean;
+    isSharedAssigned(memberId: string): boolean;
+    canAssignShared(memberId: string): boolean;
+    onSoloToggle(checked: boolean): void;
+    onPrivateToggle(checked: boolean): void;
+    onSharedToggle(memberId: string, quantity?: number): void;
+    private setSharedAssignment;
+    private setPersonalAssignment;
+    onPersonalToggle(memberId: string): void;
+    deleteItem(): void;
+    requestEdit(): void;
+    requestAssign(): void;
+    openPersonalAssignDialog(): void;
+    closePersonalAssignDialog(): void;
+    onPersonalAssignSearch(event: Event): void;
+    selectPersonalAssignMember(memberId: string): void;
+    confirmPersonalAssignment(): void;
+    onPersonalAvatarClick(memberId: string): void;
+    onAssignMeToggle(): void;
+    openDelegateDialog(): void;
+    closeDelegateDialog(): void;
+    onDelegateMemberChange(event: Event): void;
+    increaseDelegateQuantity(): void;
+    decreaseDelegateQuantity(): void;
+    confirmDelegateAssignment(): void;
+    onSharedAvatarClick(memberId: string): void;
+    closeAvatarDialog(): void;
+    increaseAvatarDialogQuantity(): void;
+    decreaseAvatarDialogQuantity(): void;
+    confirmAvatarDialogUpdate(): void;
+    increaseSelfAssignQuantity(): void;
+    decreaseSelfAssignQuantity(): void;
+    cancelSelfAssignQuantity(): void;
+    confirmSelfAssignQuantity(): void;
+    toggleCtaMenu(): void;
+    closeCtaMenu(): void;
+    onMenuAssign(): void;
+    onMenuEdit(): void;
+    onMenuDelete(): void;
+    openOverlay(): void;
+    closeOverlay(): void;
+    onOverlaySearch(event: Event): void;
+    toggleFromOverlay(memberId: string): void;
+    privateItemOwnerLabel(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackingListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackingListItemComponent, "c2g-packing-list-item", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "members": { "alias": "members"; "required": true; "isSignal": true; }; "currentUserId": { "alias": "currentUserId"; "required": true; "isSignal": true; }; "permissions": { "alias": "permissions"; "required": true; "isSignal": true; }; "selectedMemberIds": { "alias": "selectedMemberIds"; "required": false; "isSignal": true; }; }, { "itemChecked": "itemChecked"; "itemAssigned": "itemAssigned"; "itemDeleted": "itemDeleted"; "itemEditRequested": "itemEditRequested"; "personalItemToggled": "personalItemToggled"; "memberOverlayRequested": "memberOverlayRequested"; }, never, never, true, never>;
+}
+
+declare class PackingListItemCreateComponent {
+    readonly permissions: _angular_core.InputSignal<C2gPackingListPermissions>;
+    readonly labels: _angular_core.InputSignal<C2gPackingListLabels>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    readonly categories: _angular_core.InputSignal<C2gPackingCategoryInfo[]>;
+    readonly itemCreated: _angular_core.OutputEmitterRef<Partial<C2gPackingListItem>>;
+    readonly dialogOpen: _angular_core.WritableSignal<boolean>;
+    readonly formData: _angular_core.WritableSignal<{
+        name: string;
+        category: string;
+        visibility: C2gPackingVisibility;
+        essential: boolean;
+        quantity: number;
+        weightKg: number | undefined;
+        packedVolumeL: number | undefined;
+        hint: string;
+    }>;
+    readonly availableVisibilities: _angular_core.Signal<{
+        value: C2gPackingVisibility;
+        label: string;
+    }[]>;
+    readonly categoryOptions: _angular_core.Signal<{
+        value: string;
+        label: string;
+    }[]>;
+    openDialog(): void;
+    closeDialog(): void;
+    resetForm(): void;
+    submit(): void;
+    updateVisibility(visibility: C2gPackingVisibility): void;
+    getCategoryLabel(categoryKey: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackingListItemCreateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackingListItemCreateComponent, "c2g-packing-list-item-create", never, { "permissions": { "alias": "permissions"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "categories": { "alias": "categories"; "required": false; "isSignal": true; }; }, { "itemCreated": "itemCreated"; }, never, never, true, never>;
+}
+
+declare class PackingListPrivateListComponent {
+    readonly items: _angular_core.InputSignal<C2gPackingListItem[]>;
+    readonly members: _angular_core.InputSignal<C2gPackingListMember[]>;
+    readonly selectedMemberIds: _angular_core.InputSignal<string[]>;
+    readonly currentUserId: _angular_core.InputSignal<string>;
+    readonly permissions: _angular_core.InputSignal<C2gPackingListPermissions>;
+    readonly labels: _angular_core.InputSignal<C2gPackingListLabels>;
+    readonly privateItems: _angular_core.Signal<C2gPackingListItem[]>;
+    readonly itemChecked: _angular_core.OutputEmitterRef<{
+        itemId: string;
+        checked: boolean;
+    }>;
+    readonly itemAssigned: _angular_core.OutputEmitterRef<C2gPackingItemAssignedEvent>;
+    readonly itemDeleted: _angular_core.OutputEmitterRef<string>;
+    readonly itemEditRequested: _angular_core.OutputEmitterRef<string>;
+    readonly personalItemToggled: _angular_core.OutputEmitterRef<{
+        itemId: string;
+        memberId: string;
+        checked: boolean;
+    }>;
+    readonly memberOverlayRequested: _angular_core.OutputEmitterRef<C2gPackingListMemberOverlayRequest>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackingListPrivateListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackingListPrivateListComponent, "c2g-packing-list-private-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "members": { "alias": "members"; "required": true; "isSignal": true; }; "selectedMemberIds": { "alias": "selectedMemberIds"; "required": false; "isSignal": true; }; "currentUserId": { "alias": "currentUserId"; "required": true; "isSignal": true; }; "permissions": { "alias": "permissions"; "required": true; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, { "itemChecked": "itemChecked"; "itemAssigned": "itemAssigned"; "itemDeleted": "itemDeleted"; "itemEditRequested": "itemEditRequested"; "personalItemToggled": "personalItemToggled"; "memberOverlayRequested": "memberOverlayRequested"; }, never, never, true, never>;
+}
+
+interface WeatherDay {
+    date: string;
+    icon: string;
+    description: string;
+    temperature: {
+        min: number;
+        max: number;
+    };
+}
+
+declare class WeatherWidgetComponent {
+    readonly currentDay: _angular_core.InputSignal<WeatherDay | null>;
+    readonly forecastSlots: _angular_core.InputSignal<WeatherDay[]>;
+    readonly destination: _angular_core.InputSignal<string>;
+    readonly dates: _angular_core.InputSignal<{
+        from: string;
+        to: string;
+    } | null>;
+    getWeatherIcon(icon: string): string;
+    formatDate(date: string): string;
+    formatShortDate(date: string): string;
+    getSlotLabel(index: number, total: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WeatherWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WeatherWidgetComponent, "c2g-weather-widget", never, { "currentDay": { "alias": "currentDay"; "required": false; "isSignal": true; }; "forecastSlots": { "alias": "forecastSlots"; "required": false; "isSignal": true; }; "destination": { "alias": "destination"; "required": false; "isSignal": true; }; "dates": { "alias": "dates"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const WEATHER_ICON_MAP: Record<string, string>;
+/**
+ * Resolves a backend weather icon string to an emoji.
+ * @param icon    Raw icon string from the API (e.g. "partly-cloudy")
+ * @param fallback Emoji to return for unrecognised keys. Defaults to '🌤️'.
+ *                 Pass `icon` as fallback to preserve the raw string (useful
+ *                 for debugging in the full weather widget).
+ */
+declare function resolveWeatherIcon(icon: string, fallback?: string): string;
+
+type MemberRoleKey = 'organizer' | 'treasurer' | 'transport' | 'cook' | 'firstaid' | 'equipment' | null | undefined;
+interface C2gMember {
+    id: string;
+    name: string;
+    avatarInitials: string;
+    type: string;
+    isCurrentUser?: boolean;
+    isRegistered?: boolean;
+    roleKey?: MemberRoleKey;
+}
+
+declare class MemberTagsComponent {
+    readonly isCurrentUser: _angular_core.InputSignal<boolean>;
+    readonly isRegistered: _angular_core.InputSignal<boolean>;
+    readonly roleKey: _angular_core.InputSignal<MemberRoleKey>;
+    getRoleLabel(roleKey: MemberRoleKey): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MemberTagsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MemberTagsComponent, "c2g-member-tags", never, { "isCurrentUser": { "alias": "isCurrentUser"; "required": false; "isSignal": true; }; "isRegistered": { "alias": "isRegistered"; "required": false; "isSignal": true; }; "roleKey": { "alias": "roleKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ActionMenuItem {
+    key: string;
+    label: string;
+    icon?: string;
+    variant?: 'default' | 'danger';
+    disabled?: boolean;
+}
+
+declare class MemberItemComponent {
+    readonly member: _angular_core.InputSignal<C2gMember>;
+    readonly remove: _angular_core.OutputEmitterRef<C2gMember>;
+    readonly invite: _angular_core.OutputEmitterRef<C2gMember>;
+    readonly edit: _angular_core.OutputEmitterRef<C2gMember>;
+    readonly avatarBackgroundColor: _angular_core.Signal<"#e8f0ea" | "#1a6044">;
+    readonly avatarTextColor: _angular_core.Signal<"#1a6044" | "#ffffff">;
+    readonly menuItems: _angular_core.Signal<ActionMenuItem[]>;
+    onMenuItemSelected(item: ActionMenuItem): void;
+    getMemberTypeLabel(type: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MemberItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MemberItemComponent, "c2g-member-item", never, { "member": { "alias": "member"; "required": true; "isSignal": true; }; }, { "remove": "remove"; "invite": "invite"; "edit": "edit"; }, never, never, true, never>;
+}
+
+declare class MemberListComponent {
+    readonly members: _angular_core.InputSignal<C2gMember[]>;
+    readonly memberRemove: _angular_core.OutputEmitterRef<C2gMember>;
+    readonly memberInvite: _angular_core.OutputEmitterRef<C2gMember>;
+    readonly memberEdit: _angular_core.OutputEmitterRef<C2gMember>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MemberListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MemberListComponent, "c2g-member-list", never, { "members": { "alias": "members"; "required": true; "isSignal": true; }; }, { "memberRemove": "memberRemove"; "memberInvite": "memberInvite"; "memberEdit": "memberEdit"; }, never, never, true, never>;
+}
+
+declare class MemberPanelComponent {
+    readonly members: _angular_core.InputSignal<C2gMember[]>;
+    readonly memberRemove: _angular_core.OutputEmitterRef<C2gMember>;
+    readonly memberInvite: _angular_core.OutputEmitterRef<C2gMember>;
+    readonly memberEdit: _angular_core.OutputEmitterRef<C2gMember>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MemberPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MemberPanelComponent, "c2g-member-panel", never, { "members": { "alias": "members"; "required": true; "isSignal": true; }; }, { "memberRemove": "memberRemove"; "memberInvite": "memberInvite"; "memberEdit": "memberEdit"; }, never, ["[slot=header-actions]"], true, never>;
+}
+
+declare class ActionMenuComponent {
+    readonly items: _angular_core.InputSignal<ActionMenuItem[]>;
+    readonly triggerLabel: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<ActionMenuItem>;
+    select(item: ActionMenuItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionMenuComponent, "c2g-action-menu", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "triggerLabel": { "alias": "triggerLabel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+interface C2gMenuItem {
+    key: string;
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+    variant?: 'default' | 'danger';
+    children?: C2gMenuItem[];
+}
+interface C2gMenuSelection {
+    item: C2gMenuItem;
+    parent?: C2gMenuItem;
+}
+interface C2gSubmenuItem {
+    key: string;
+    label: string;
+    href?: string;
+    disabled?: boolean;
+    active?: boolean;
+}
+interface C2gMainNavigationItem {
+    key: string;
+    label: string;
+    href?: string;
+    disabled?: boolean;
+    active?: boolean;
+    subItems?: C2gSubmenuItem[];
+}
+interface C2gSubmenuSelection {
+    main: C2gMainNavigationItem;
+    sub: C2gSubmenuItem;
+}
+
+declare class MenuComponent {
+    readonly items: _angular_core.InputSignal<C2gMenuItem[]>;
+    readonly triggerLabel: _angular_core.InputSignal<string>;
+    readonly triggerAriaLabel: _angular_core.InputSignal<string>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<C2gMenuSelection>;
+    readonly flatItems: _angular_core.Signal<C2gMenuItem[]>;
+    select(item: C2gMenuItem): void;
+    selectChild(parent: C2gMenuItem, child: C2gMenuItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuComponent, "c2g-menu", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "triggerLabel": { "alias": "triggerLabel"; "required": false; "isSignal": true; }; "triggerAriaLabel": { "alias": "triggerAriaLabel"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+declare class MainNavigationComponent {
+    readonly items: _angular_core.InputSignal<C2gMainNavigationItem[]>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly mainItemSelected: _angular_core.OutputEmitterRef<C2gMainNavigationItem>;
+    readonly subItemSelected: _angular_core.OutputEmitterRef<C2gSubmenuSelection>;
+    onMainItemSelected(item: C2gMainNavigationItem): void;
+    onSubItemSelected(selection: C2gSubmenuSelection): void;
+    trackByKey: (_index: number, item: C2gMainNavigationItem) => string;
+    trackSubByKey: (_index: number, item: C2gSubmenuItem) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MainNavigationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MainNavigationComponent, "c2g-main-navigation", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "mainItemSelected": "mainItemSelected"; "subItemSelected": "subItemSelected"; }, never, never, true, never>;
+}
+
+declare class MainNavigationItemComponent {
+    readonly item: _angular_core.InputSignal<C2gMainNavigationItem>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<C2gMainNavigationItem>;
+    readonly subItemSelected: _angular_core.OutputEmitterRef<C2gSubmenuSelection>;
+    readonly submenuOpen: _angular_core.WritableSignal<boolean>;
+    readonly hasSubmenu: _angular_core.Signal<boolean>;
+    onItemClick(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onSubItemSelected(sub: C2gSubmenuItem): void;
+    onItemKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MainNavigationItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MainNavigationItemComponent, "c2g-main-navigation-item", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, { "itemSelected": "itemSelected"; "subItemSelected": "subItemSelected"; }, never, never, true, never>;
+}
+
+declare class SubmenuComponent {
+    readonly items: _angular_core.InputSignal<C2gSubmenuItem[]>;
+    readonly open: _angular_core.InputSignal<boolean>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<C2gSubmenuItem>;
+    readonly activeIndex: _angular_core.WritableSignal<number>;
+    onItemSelected(item: C2gSubmenuItem): void;
+    setActiveIndex(index: number): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SubmenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SubmenuComponent, "c2g-submenu", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+declare class SubmenuItemComponent {
+    readonly item: _angular_core.InputSignal<C2gSubmenuItem>;
+    readonly active: _angular_core.InputSignal<boolean>;
+    readonly selected: _angular_core.OutputEmitterRef<C2gSubmenuItem>;
+    readonly mouseenter: _angular_core.OutputEmitterRef<void>;
+    onClick(): void;
+    onMouseEnter(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SubmenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SubmenuItemComponent, "c2g-submenu-item", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "mouseenter": "mouseenter"; }, never, never, true, never>;
+}
+
+interface DashboardWeatherDay {
+    date: string;
+    icon: string;
+    description: string;
+    tempMin: number;
+    tempMax: number;
+}
+interface NextAdventureData {
+    tourName: string;
+    destination: string;
+    fromDate: string;
+    toDate: string;
+    tourType?: string;
+    coverImage?: string;
+    weather?: DashboardWeatherDay[];
+    showPulse?: boolean;
+}
+interface PackStatusData {
+    totalItems: number;
+    completedItems: number;
+    criticalTotal: number;
+    criticalCompleted: number;
+    tourName?: string;
+}
+interface PackWeightData {
+    currentWeightG: number;
+    previousWeightG?: number;
+    tourName?: string;
+}
+interface MemberReadinessEntry {
+    name: string;
+    avatarUrl?: string;
+    initials: string;
+    totalItems: number;
+    completedItems: number;
+    isSelf?: boolean;
+}
+interface MemberReadinessData {
+    members: MemberReadinessEntry[];
+    groupName?: string;
+}
+interface StreakData {
+    streakDays: number;
+    level: number;
+    experiencePoints: number;
+    nextLevelXp: number;
+    favoriteSeason?: string;
+    totalDistanceKm?: number;
+    totalNightsCamped?: number;
+}
+interface CampingScoreFactor {
+    /** Display label e.g. 'Sonne', 'Regen', 'Wind' */
+    label: string;
+    /** Emoji or short icon string */
+    icon: string;
+    /** 0–10 */
+    score: number;
+    /** When true, high score = bad (e.g. Regen, Wind). Tier color is flipped. */
+    inverted?: boolean;
+}
+interface CampingScoreData {
+    /** 0–10 scale */
+    score: number;
+    label?: string;
+    highlights?: string[];
+    warnings?: string[];
+    tourName?: string;
+    fromDate?: string;
+    toDate?: string;
+    /** Optional structured sub-scores shown as factor tiles */
+    factors?: CampingScoreFactor[];
+}
+interface RainForecastDay {
+    /** ISO date string */
+    date: string;
+    /** 0–1 */
+    precipitationProbability: number;
+    /** mm */
+    precipitation: number;
+    icon?: string;
+}
+interface RainVisualizationData {
+    days: RainForecastDay[];
+    tourName?: string;
+}
+type MemberType = 'adult' | 'teen' | 'child' | 'toddler' | 'senior' | 'dog' | 'cat' | 'pet';
+interface GroupMemberCompositionEntry {
+    type: MemberType;
+    count: number;
+    names?: string[];
+}
+interface GroupCompositionData {
+    members: GroupMemberCompositionEntry[];
+    groupName?: string;
+    groupType?: string;
+}
+interface CriticalItemAlertEntry {
+    name: string;
+    category?: string;
+    /**
+     * personal = every group member needs their own copy.
+     * shared   = a minimum quantity must be covered, regardless of who brings it.
+     */
+    scope: 'personal' | 'shared';
+    /** For shared items: how many are needed in total */
+    neededCount?: number;
+    /** For shared items: how many are already covered */
+    coveredCount?: number;
+    /** For personal items: which members still haven't packed it */
+    missingFor?: string[];
+    /** For shared items: who is bringing it (if anyone) */
+    coveredBy?: string[];
+}
+type SuccessVisualType = 'lottie' | 'image' | 'icon';
+interface SuccessVisual {
+    type: SuccessVisualType;
+    /** lottie: animationData object | image: URL string | icon: emoji or short text */
+    value: unknown;
+    /** Optional alt text for images */
+    alt?: string;
+}
+interface CriticalItemsAlertData {
+    openItems: CriticalItemAlertEntry[];
+    totalCritical: number;
+    /** ISO date string */
+    tourFromDate: string;
+    tourName?: string;
+    /** Optional visual shown in the all-clear success state */
+    successVisual?: SuccessVisual;
+}
+interface WindForecastDay {
+    date: string;
+    /** km/h */
+    windSpeed: number;
+    /** 0–360 degrees */
+    windDirection: number;
+    description?: string;
+}
+interface WindIndicatorData {
+    days: WindForecastDay[];
+    tourName?: string;
+}
+interface TotalKmSparkPoint {
+    /** ISO date (tour end date) */
+    date: string;
+    /** cumulative km at this point */
+    km: number;
+}
+interface TotalKmData {
+    totalKm: number;
+    yearKm?: number;
+    sparkline?: TotalKmSparkPoint[];
+    /** count of tours included */
+    tourCount?: number;
+}
+type TourType = 'hiking' | 'cycling' | 'paddling' | 'climbing' | 'skiing' | 'other';
+interface TourTypeSplitEntry {
+    type: TourType;
+    count: number;
+    km?: number;
+}
+interface TourTypeSplitData {
+    entries: TourTypeSplitEntry[];
+    totalTours: number;
+}
+interface TourRhythmWeek {
+    /** ISO week start date (Monday) */
+    weekStart: string;
+    /** 0 = no activity, 1–4 = intensity level */
+    level: 0 | 1 | 2 | 3 | 4;
+    tourName?: string;
+    km?: number;
+}
+interface TourRhythmData {
+    /** 52 weeks, oldest first */
+    weeks: TourRhythmWeek[];
+    totalActiveDays?: number;
+    currentStreakWeeks?: number;
+}
+type Season = 'spring' | 'summer' | 'autumn' | 'winter';
+interface SeasonDnaEntry {
+    season: Season;
+    tourCount: number;
+    km?: number;
+    nights?: number;
+}
+interface SeasonDnaData {
+    entries: SeasonDnaEntry[];
+    dominantSeason?: Season;
+    totalTours: number;
+}
+interface WeightHistoryPoint {
+    /** ISO date (tour end date) */
+    date: string;
+    /** total packed weight in grams */
+    weightG: number;
+    tourName?: string;
+}
+interface WeightHistoryData {
+    points: WeightHistoryPoint[];
+    /** personal best (lowest) in grams */
+    bestG?: number;
+    /** latest weight in grams */
+    latestG?: number;
+}
+interface GearValueData {
+    /** total value in base currency */
+    totalValue: number;
+    currency: string;
+    itemCount: number;
+    /** optional: breakdown by category */
+    categories?: {
+        label: string;
+        value: number;
+        count: number;
+    }[];
+}
+interface WeightBreakdownEntry {
+    category: string;
+    weightG: number;
+    itemCount: number;
+    color?: string;
+}
+interface WeightBreakdownData {
+    entries: WeightBreakdownEntry[];
+    totalG: number;
+}
+interface AdventureScoreData {
+    score: number;
+    /** 0–100 scale */
+    level: number;
+    levelLabel: string;
+    totalTours: number;
+    totalKm: number;
+    totalNights: number;
+    uniqueTypes: number;
+    sparkline?: {
+        date: string;
+        score: number;
+    }[];
+}
+interface TopGearEntry {
+    name: string;
+    category?: string;
+    usageCount: number;
+    totalTours: number;
+    imageUrl?: string;
+    weightG?: number;
+}
+interface TopGearData {
+    entries: TopGearEntry[];
+}
+interface GroupActivityEntry {
+    name: string;
+    initials: string;
+    avatarUrl?: string;
+    completedItems: number;
+    totalItems: number;
+    isSelf?: boolean;
+}
+interface GroupActivityData {
+    members: GroupActivityEntry[];
+    groupName?: string;
+}
+interface GearSharingData {
+    sharedItems: number;
+    totalItems: number;
+    memberCount: number;
+    /** kg saved per person through sharing */
+    savedWeightPerPersonG?: number;
+}
+interface AdventureRadiusData {
+    avgRadiusKm: number;
+    maxRadiusKm: number;
+    maxTourName?: string;
+    /** home coordinates label, e.g. "München" */
+    homeLabel?: string;
+    /** distribution buckets in km */
+    buckets?: {
+        labelKm: string;
+        count: number;
+    }[];
+}
+interface PackProgressRow {
+    label: string;
+    icon: string;
+    packed: number;
+    total: number;
+    /** Draws extra visual attention — use for baby/toddler and pet rows */
+    highlight?: boolean;
+}
+interface PackProgressData {
+    rows: PackProgressRow[];
+    tourName?: string;
+}
+
+declare class NextAdventureWidgetComponent {
+    readonly data: _angular_core.InputSignal<NextAdventureData>;
+    readonly countdown: _angular_core.Signal<number>;
+    readonly duration: _angular_core.Signal<number>;
+    readonly countdownLabel: _angular_core.Signal<string>;
+    readonly dateRange: _angular_core.Signal<string>;
+    readonly tourTypeIcon: _angular_core.Signal<string>;
+    readonly weatherSlots: _angular_core.Signal<_camp2gether_c2g_ui_presets.DashboardWeatherDay[]>;
+    readonly urgencyClass: _angular_core.Signal<"" | "c2g-next-adventure--now" | "c2g-next-adventure--soon">;
+    weatherIcon(icon: string): string;
+    formatWeatherDate(date: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NextAdventureWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NextAdventureWidgetComponent, "c2g-next-adventure-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PackStatusWidgetComponent {
+    readonly data: _angular_core.InputSignal<PackStatusData>;
+    readonly percent: _angular_core.Signal<number>;
+    readonly criticalOpen: _angular_core.Signal<number>;
+    readonly statusColor: _angular_core.Signal<"warning" | "success" | "primary">;
+    readonly statusLabel: _angular_core.Signal<"Alles gepackt!" | "Fast fertig" | "Gut dabei" | "Packen gestartet" | "Noch nicht gepackt">;
+    readonly radius = 44;
+    readonly strokeWidth = 8;
+    readonly circumference: number;
+    readonly strokeDashoffset: _angular_core.Signal<number>;
+    readonly ticks: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    }[];
+    readonly itemDots: _angular_core.Signal<boolean[]>;
+    readonly displayPercent: _angular_core.WritableSignal<number>;
+    private raf;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackStatusWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackStatusWidgetComponent, "c2g-pack-status-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PackWeightWidgetComponent implements OnDestroy {
+    readonly data: _angular_core.InputSignal<PackWeightData>;
+    readonly zone: _angular_core.Signal<{
+        readonly label: "Ultraleicht";
+        readonly maxG: 7000;
+        readonly color: "#22c55e";
+        readonly bgColor: "rgba(34,197,94,0.18)";
+    } | {
+        readonly label: "Leicht";
+        readonly maxG: 12000;
+        readonly color: "#84cc16";
+        readonly bgColor: "rgba(132,204,22,0.15)";
+    } | {
+        readonly label: "Mittel";
+        readonly maxG: 18000;
+        readonly color: "#f59e0b";
+        readonly bgColor: "rgba(245,158,11,0.14)";
+    } | {
+        readonly label: "Schwer";
+        readonly maxG: 25000;
+        readonly color: "#f97316";
+        readonly bgColor: "rgba(249,115,22,0.14)";
+    } | {
+        readonly label: "Sehr schwer";
+        readonly maxG: 30000;
+        readonly color: "#ef4444";
+        readonly bgColor: "rgba(239,68,68,0.15)";
+    }>;
+    readonly scalePercent: _angular_core.Signal<number>;
+    readonly prevScalePercent: _angular_core.Signal<number | null>;
+    readonly diffG: _angular_core.Signal<number | null>;
+    readonly diffKg: _angular_core.Signal<string | null>;
+    readonly diffTrend: _angular_core.Signal<"better" | "worse" | "same" | null>;
+    readonly animatedPercent: _angular_core.WritableSignal<number>;
+    readonly displayKg: _angular_core.WritableSignal<string>;
+    private rafMarker;
+    private rafKg;
+    constructor();
+    readonly zoneSegments: _angular_core.Signal<{
+        left: number;
+        width: number;
+        color: "#22c55e" | "#84cc16" | "#f59e0b" | "#f97316" | "#ef4444";
+        bgColor: "rgba(34,197,94,0.18)" | "rgba(132,204,22,0.15)" | "rgba(245,158,11,0.14)" | "rgba(249,115,22,0.14)" | "rgba(239,68,68,0.15)";
+        label: "Ultraleicht" | "Leicht" | "Mittel" | "Schwer" | "Sehr schwer";
+    }[]>;
+    readonly ticks: {
+        pct: number;
+        label: string;
+    }[];
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackWeightWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackWeightWidgetComponent, "c2g-pack-weight-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ReadinessGroup {
+    label: string;
+    emoji: string;
+    color: 'success' | 'warning' | 'danger' | 'neutral';
+    min: number;
+    max: number;
+    members: MemberReadinessEntry[];
+}
+declare class MemberReadinessWidgetComponent {
+    readonly members: _angular_core.InputSignal<MemberReadinessEntry[]>;
+    readonly tourName: _angular_core.InputSignal<string | undefined>;
+    readonly overallPercent: _angular_core.Signal<number>;
+    readonly fullyReady: _angular_core.Signal<number>;
+    readonly useGrouped: _angular_core.Signal<boolean>;
+    readonly groups: _angular_core.Signal<ReadinessGroup[]>;
+    readonly flatSorted: _angular_core.Signal<MemberReadinessEntry[]>;
+    readyPercent(entry: MemberReadinessEntry): number;
+    readyColor(entry: MemberReadinessEntry): 'success' | 'warning' | 'danger' | 'neutral';
+    readonly collapsed: Map<number, boolean>;
+    toggleGroup(index: number): void;
+    isCollapsed(index: number): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MemberReadinessWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MemberReadinessWidgetComponent, "c2g-member-readiness-widget", never, { "members": { "alias": "members"; "required": true; "isSignal": true; }; "tourName": { "alias": "tourName"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class StreakWidgetComponent {
+    readonly data: _angular_core.InputSignal<StreakData>;
+    readonly xpPercent: _angular_core.Signal<number>;
+    readonly streakTier: _angular_core.Signal<"cold" | "warm" | "hot" | "legendary">;
+    readonly streakEmoji: _angular_core.Signal<"🏆" | "🔥" | "⚡" | "🌱">;
+    readonly levelLabel: _angular_core.Signal<"Legende" | "Experte" | "Erfahren" | "Fortgeschritten" | "Einsteiger">;
+    readonly streakLabel: _angular_core.Signal<string>;
+    readonly xpToNext: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreakWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StreakWidgetComponent, "c2g-streak-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CampingScoreWidgetComponent implements OnDestroy {
+    readonly data: _angular_core.InputSignal<CampingScoreData>;
+    readonly tier: _angular_core.Signal<"great" | "good" | "ok" | "bad">;
+    readonly tierLabel: _angular_core.Signal<string>;
+    readonly tierEmoji: _angular_core.Signal<"☀️" | "⛅" | "🌧️" | "🌤">;
+    readonly factors: _angular_core.Signal<CampingScoreFactor[]>;
+    factorBarPct(score: number): number;
+    factorTier(score: number, inverted?: boolean): string;
+    readonly displayScore: _angular_core.WritableSignal<string>;
+    private raf;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CampingScoreWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CampingScoreWidgetComponent, "c2g-camping-score-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface RainDay extends RainForecastDay {
+    dayLabel: string;
+    probPct: number;
+    barPct: number;
+    level: 'none' | 'light' | 'moderate' | 'heavy';
+    icon: string;
+}
+declare class RainVisualizationWidgetComponent {
+    readonly data: _angular_core.InputSignal<RainVisualizationData>;
+    readonly enriched: _angular_core.Signal<RainDay[]>;
+    readonly overallRisk: _angular_core.Signal<"low" | "medium" | "high">;
+    readonly riskLabel: _angular_core.Signal<string>;
+    readonly summaryIcon: _angular_core.Signal<"☀️" | "⛈" | "🌦">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RainVisualizationWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RainVisualizationWidgetComponent, "c2g-rain-visualization-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GroupCompositionWidgetComponent {
+    readonly data: _angular_core.InputSignal<GroupCompositionData>;
+    readonly sorted: _angular_core.Signal<_camp2gether_c2g_ui_presets.GroupMemberCompositionEntry[]>;
+    readonly totalPeople: _angular_core.Signal<number>;
+    readonly totalPets: _angular_core.Signal<number>;
+    readonly maxCount: _angular_core.Signal<number>;
+    readonly avatars: _angular_core.Signal<{
+        emoji: string;
+        color: string;
+        key: string;
+    }[]>;
+    configFor(type: MemberType): {
+        emoji: string;
+        label: string;
+        color: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupCompositionWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupCompositionWidgetComponent, "c2g-group-composition-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CriticalItemsAlertWidgetComponent {
+    readonly data: _angular_core.InputSignal<CriticalItemsAlertData>;
+    readonly daysUntil: _angular_core.Signal<number>;
+    readonly urgency: _angular_core.Signal<"warning" | "ok" | "critical">;
+    readonly urgencyLabel: _angular_core.Signal<string>;
+    readonly allClear: _angular_core.Signal<boolean>;
+    readonly personalItems: _angular_core.Signal<CriticalItemAlertEntry[]>;
+    readonly sharedItems: _angular_core.Signal<CriticalItemAlertEntry[]>;
+    readonly personalHidden: _angular_core.Signal<number>;
+    readonly sharedHidden: _angular_core.Signal<number>;
+    readonly successVisualType: _angular_core.Signal<_camp2gether_c2g_ui_presets.SuccessVisualType>;
+    readonly lottieOptions: _angular_core.Signal<AnimationOptions>;
+    readonly imageValue: _angular_core.Signal<string | null>;
+    readonly imageAlt: _angular_core.Signal<string>;
+    readonly iconValue: _angular_core.Signal<string>;
+    sharedProgress(item: CriticalItemAlertEntry): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CriticalItemsAlertWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CriticalItemsAlertWidgetComponent, "c2g-critical-items-alert-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class WindIndicatorWidgetComponent {
+    readonly data: _angular_core.InputSignal<WindIndicatorData>;
+    readonly days: _angular_core.Signal<WindForecastDay[]>;
+    readonly peak: _angular_core.Signal<WindForecastDay>;
+    readonly peakBeaufort: _angular_core.Signal<{
+        max: number;
+        label: string;
+        emoji: string;
+        color: string;
+    }>;
+    readonly overallRisk: _angular_core.Signal<"calm" | "breezy" | "windy" | "stormy">;
+    enriched: _angular_core.Signal<{
+        bf: {
+            max: number;
+            label: string;
+            emoji: string;
+            color: string;
+        };
+        dirLabel: string;
+        arrowDeg: number;
+        barPct: number;
+        date: string;
+        windSpeed: number;
+        windDirection: number;
+        description?: string;
+    }[]>;
+    formatDate(iso: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindIndicatorWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindIndicatorWidgetComponent, "c2g-wind-indicator-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TotalKmWidgetComponent implements OnDestroy {
+    readonly data: _angular_core.InputSignal<TotalKmData>;
+    readonly displayKm: _angular_core.WritableSignal<number>;
+    readonly displayYearKm: _angular_core.WritableSignal<number>;
+    private rafId;
+    private rafYearId;
+    constructor();
+    private animateCount;
+    readonly sparklinePath: _angular_core.Signal<{
+        line: string;
+        area: string;
+        lastX: number;
+        lastY: number;
+    } | null>;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TotalKmWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TotalKmWidgetComponent, "c2g-total-km-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface Segment {
+    type: TourType;
+    label: string;
+    emoji: string;
+    color: string;
+    count: number;
+    km: number;
+    pct: number;
+    offset: number;
+    dash: number;
+}
+declare class TourTypeSplitWidgetComponent {
+    readonly data: _angular_core.InputSignal<TourTypeSplitData>;
+    readonly segments: _angular_core.Signal<Segment[]>;
+    readonly dominantSegment: _angular_core.Signal<Segment | null>;
+    readonly circumference: number;
+    trackByType(_: number, seg: Segment): TourType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TourTypeSplitWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TourTypeSplitWidgetComponent, "c2g-tour-type-split-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface WeekCell extends TourRhythmWeek {
+    col: number;
+    monthLabel: string | null;
+}
+declare class TourRhythmWidgetComponent {
+    readonly data: _angular_core.InputSignal<TourRhythmData>;
+    readonly cells: _angular_core.Signal<WeekCell[]>;
+    readonly totalCols: _angular_core.Signal<number>;
+    readonly levelColors: string[];
+    levelColor(level: 0 | 1 | 2 | 3 | 4): string;
+    trackByCol(_: number, cell: WeekCell): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TourRhythmWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TourRhythmWidgetComponent, "c2g-tour-rhythm-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface SeasonSegment {
+    season: Season;
+    label: string;
+    emoji: string;
+    color: string;
+    tourCount: number;
+    km: number;
+    nights: number;
+    pct: number;
+    startAngle: number;
+    endAngle: number;
+    pathD: string;
+    labelX: number;
+    labelY: number;
+}
+declare class SeasonDnaWidgetComponent {
+    readonly data: _angular_core.InputSignal<SeasonDnaData>;
+    readonly segments: _angular_core.Signal<SeasonSegment[]>;
+    readonly dominantSeason: _angular_core.Signal<{
+        label: string;
+        emoji: string;
+        color: string;
+    } | null>;
+    trackBySeason(_: number, seg: SeasonSegment): Season;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SeasonDnaWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SeasonDnaWidgetComponent, "c2g-season-dna-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class WeightHistoryWidgetComponent {
+    readonly data: _angular_core.InputSignal<WeightHistoryData>;
+    readonly points: _angular_core.Signal<WeightHistoryPoint[]>;
+    readonly sparklinePath: _angular_core.Signal<{
+        line: string;
+        area: string;
+        lastX: number;
+        lastY: number;
+        improving: boolean;
+    } | null>;
+    readonly trend: _angular_core.Signal<{
+        diffG: number;
+        pct: number;
+        improving: boolean;
+    } | null>;
+    formatKg(g: number): string;
+    formatDate(iso: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WeightHistoryWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WeightHistoryWidgetComponent, "c2g-weight-history-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GearValueWidgetComponent {
+    readonly data: _angular_core.InputSignal<GearValueData>;
+    readonly topCategories: _angular_core.Signal<{
+        label: string;
+        value: number;
+        count: number;
+    }[]>;
+    readonly maxCatValue: _angular_core.Signal<number>;
+    readonly formattedTotal: _angular_core.Signal<string>;
+    formatValue(v: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GearValueWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GearValueWidgetComponent, "c2g-gear-value-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface EnrichedEntry extends WeightBreakdownEntry {
+    pct: number;
+    color: string;
+    barOffset: number;
+}
+declare class WeightBreakdownWidgetComponent {
+    readonly data: _angular_core.InputSignal<WeightBreakdownData>;
+    readonly entries: _angular_core.Signal<EnrichedEntry[]>;
+    readonly totalKg: _angular_core.Signal<string>;
+    readonly circumference = 100;
+    formatKg(g: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WeightBreakdownWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WeightBreakdownWidgetComponent, "c2g-weight-breakdown-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AdventureScoreWidgetComponent implements OnDestroy {
+    readonly data: _angular_core.InputSignal<AdventureScoreData>;
+    readonly displayScore: _angular_core.WritableSignal<number>;
+    private raf;
+    constructor();
+    readonly arcPath: _angular_core.Signal<string>;
+    readonly trackPath = "M 60 8 A 52 52 0 1 1 59.99 8";
+    readonly levelColor: _angular_core.Signal<"#22c55e" | "#f59e0b" | "#ff6b35" | "#3b82f6" | "#94a3b8">;
+    readonly sparklinePath: _angular_core.Signal<string | null>;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AdventureScoreWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AdventureScoreWidgetComponent, "c2g-adventure-score-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TopGearWidgetComponent {
+    readonly data: _angular_core.InputSignal<TopGearData>;
+    readonly top: _angular_core.Signal<_camp2gether_c2g_ui_presets.TopGearEntry[]>;
+    readonly maxUsage: _angular_core.Signal<number>;
+    usagePct(count: number): number;
+    medal(index: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TopGearWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TopGearWidgetComponent, "c2g-top-gear-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface RankedEntry extends GroupActivityEntry {
+    rank: number;
+    pct: number;
+}
+declare class GroupActivityWidgetComponent {
+    readonly data: _angular_core.InputSignal<GroupActivityData>;
+    readonly ranked: _angular_core.Signal<RankedEntry[]>;
+    medal(rank: number): string;
+    completionPct(m: GroupActivityEntry): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupActivityWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupActivityWidgetComponent, "c2g-group-activity-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GearSharingWidgetComponent implements OnDestroy {
+    readonly data: _angular_core.InputSignal<GearSharingData>;
+    readonly displayPct: _angular_core.WritableSignal<number>;
+    private raf;
+    constructor();
+    readonly sharingPct: _angular_core.Signal<number>;
+    readonly tier: _angular_core.Signal<"low" | "medium" | "high">;
+    readonly arcPath: _angular_core.Signal<string>;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GearSharingWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GearSharingWidgetComponent, "c2g-gear-sharing-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AdventureRadiusWidgetComponent {
+    readonly data: _angular_core.InputSignal<AdventureRadiusData>;
+    readonly buckets: _angular_core.Signal<{
+        labelKm: string;
+        count: number;
+    }[]>;
+    readonly maxBucketCount: _angular_core.Signal<number>;
+    bucketPct(count: number): number;
+    readonly radiusTier: _angular_core.Signal<"local" | "regional" | "national" | "international">;
+    readonly tierEmoji: _angular_core.Signal<"🌍" | "🗺️" | "🏔️" | "🏡">;
+    readonly tierLabel: _angular_core.Signal<"Weltenbummler" | "Deutschlandreisender" | "Regionalentdecker" | "Heimatverbunden">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AdventureRadiusWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AdventureRadiusWidgetComponent, "c2g-adventure-radius-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PackProgressWidgetComponent {
+    readonly data: _angular_core.InputSignal<PackProgressData>;
+    readonly rows: _angular_core.Signal<PackProgressRow[]>;
+    readonly overallPacked: _angular_core.Signal<number>;
+    readonly overallTotal: _angular_core.Signal<number>;
+    readonly overallPercent: _angular_core.Signal<number>;
+    pct(row: PackProgressRow): number;
+    tone(row: PackProgressRow): 'success' | 'warning' | 'danger';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackProgressWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackProgressWidgetComponent, "c2g-pack-progress-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ActionMenuComponent, AdventureRadiusWidgetComponent, AdventureScoreWidgetComponent, C2G_PACKING_CATEGORY_INFO, CampingScoreWidgetComponent, CriticalItemsAlertWidgetComponent, DEFAULT_PACKING_LIST_CONFIG, DEFAULT_PACKING_LIST_LABEL_KEYS, GearSharingWidgetComponent, GearValueWidgetComponent, GroupActivityWidgetComponent, GroupCompositionWidgetComponent, MainNavigationComponent, MainNavigationItemComponent, MemberItemComponent, MemberListComponent, MemberPanelComponent, MemberReadinessWidgetComponent, MemberTagsComponent, MenuComponent, NextAdventureWidgetComponent, PackProgressWidgetComponent, PackStatusWidgetComponent, PackWeightWidgetComponent, PackingListCategoryComponent, PackingListComponent, PackingListFiltersComponent, PackingListItemComponent, PackingListItemCreateComponent, PackingListPrivateListComponent, PackingListStatsComponent, RainVisualizationWidgetComponent, SeasonDnaWidgetComponent, StreakWidgetComponent, SubmenuComponent, SubmenuItemComponent, TopGearWidgetComponent, TotalKmWidgetComponent, TourRhythmWidgetComponent, TourTypeSplitWidgetComponent, WEATHER_ICON_MAP, WeatherWidgetComponent, WeightBreakdownWidgetComponent, WeightHistoryWidgetComponent, WindIndicatorWidgetComponent, resolvePackingCategory, resolveWeatherIcon };
+export type { ActionMenuItem, AdventureRadiusData, AdventureScoreData, C2gMainNavigationItem, C2gMember, C2gMenuItem, C2gMenuSelection, C2gPackingAssignmentStatus, C2gPackingCategoryInfo, C2gPackingItemAssignedEvent, C2gPackingListAssignment, C2gPackingListColumnDef, C2gPackingListConfig, C2gPackingListFeatures, C2gPackingListFilterState, C2gPackingListItem, C2gPackingListLabels, C2gPackingListMember, C2gPackingListMemberOverlayRequest, C2gPackingListMemberStatus, C2gPackingListPermissions, C2gPackingListRowAction, C2gPackingListSortState, C2gPackingSortDir, C2gPackingVisibility, C2gSubmenuItem, C2gSubmenuSelection, CampingScoreData, CampingScoreFactor, CriticalItemAlertEntry, CriticalItemsAlertData, DashboardWeatherDay, GearSharingData, GearValueData, GroupActivityData, GroupActivityEntry, GroupCompositionData, GroupMemberCompositionEntry, MemberReadinessData, MemberReadinessEntry, MemberRoleKey, MemberType, NextAdventureData, PackProgressData, PackProgressRow, PackStatusData, PackWeightData, RainForecastDay, RainVisualizationData, Season, SeasonDnaData, SeasonDnaEntry, StreakData, SuccessVisual, SuccessVisualType, TopGearData, TopGearEntry, TotalKmData, TotalKmSparkPoint, TourRhythmData, TourRhythmWeek, TourType, TourTypeSplitData, TourTypeSplitEntry, WeatherDay, WeightBreakdownData, WeightBreakdownEntry, WeightHistoryData, WeightHistoryPoint, WindForecastDay, WindIndicatorData };