@ieeesa-npm/dashboard 0.0.0-stage → 0.0.1

package/lib/dashboard.component.d.ts

@@ -0,0 +1,376 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { BreakpointObserverService } from '@ieeesa-npm/presentation';
+import { UserPermission } from '@ieeesa-npm/models';
+import { AlertsService } from '@ieeesa-npm/utility';
+import { AttendanceActionPermissions } from './models/attendance-action-permissions.model';
+import { AttendanceState } from './models/attendance-state.model';
+import { DashboardRouteConfig } from './models/dashboard-route-config.model';
+import { DashboardSectionState } from './models/dashboard-section-state.model';
+import { DashboardUserInfo } from './models/dashboard-user-info.model';
+import { GroupRow } from './models/group-row.model';
+import { PageChange } from './models/page-change.model';
+import { UpcomingEvent } from './models/upcoming-event.model';
+import { DashboardService } from './services/dashboard.service';
+import { UserPermissionsService } from './services/user-permissions.service';
+import { DashboardJumpTarget } from './components/welcome-header/dashboard-welcome-header.component';
+import * as i0 from "@angular/core";
+/**
+ * A navigation intent emitted by {@link DashboardComponent} for the host
+ * application to act on. The library never performs navigation itself; it emits
+ * the resolved target `path` (from the {@link DashboardRouteConfig}) together
+ * with the triggering identifier so the host can route accordingly (Req 11.1).
+ */
+export interface DashboardNavigationIntent {
+    /** The resolved target route path from the active {@link DashboardRouteConfig}. */
+    path: string;
+    /** The identifier that triggered the navigation (event/meeting/group id), when applicable. */
+    id?: string;
+}
+/**
+ * Dashboard (`ieeesa-dashboard`) is the root container and single host entry
+ * point for the "NESC Revision Cycle" dashboard landing page. It owns the
+ * host-supplied configuration (`routePaths`, `apiBaseURL`, `userInfo`,
+ * `userPermissions`), composes the four regions — welcome header, upcoming
+ * meetings & events, your groups, and footer — and orchestrates data loading
+ * and attendance actions through the {@link DashboardService}.
+ *
+ * The component is composition-first and host-agnostic: it subscribes to the
+ * service observables (`upcomingEvents$`, `groups$`, the per-section states, the
+ * attendance-state map, and the in-flight set) with `takeUntil(destroy$)` and
+ * tracks `isMobileView` from the Presentation_Library
+ * {@link BreakpointObserverService} (Req 13.1, 13.2, 13.5, 15.1, 15.2). Child
+ * navigation `@Output()`s are composed into a single {@link dashboardNavigate}
+ * stream of `{ path, id }` intents resolved from `routePaths` (falling back to
+ * the default route configuration in `constants.json` when `routePaths` is
+ * omitted) (Req 5.2, 6.4, 7.4, 8.2, 8.7, 11.1, 11.5). Attendance `@Output()`s
+ * are delegated to the service, and on failure the attendance-action error
+ * message from `constants.json` is surfaced via the shared {@link AlertsService}
+ * (Req 7.7, 7.8, 13.7). Per-row {@link AttendanceActionPermissions} are computed
+ * from `userPermissions` and passed down to the rows (Req 12.3).
+ * @export
+ * @class DashboardComponent
+ */
+export declare class DashboardComponent implements OnInit, OnDestroy {
+    private dashboardService;
+    private userPermissionsService;
+    private breakpointObserverService;
+    private alertService;
+    /** User-facing strings and the default route config sourced from `constants.json`. */
+    constants: {
+        welcomeHeader: {
+            greeting: string;
+            fallbackGreeting: string;
+            helperText: string;
+            jumpToLabel: string;
+            shortcuts: {
+                meetings: {
+                    label: string;
+                    iconUrl: string;
+                    ariaLabel: string;
+                };
+                groups: {
+                    label: string;
+                    iconUrl: string;
+                    ariaLabel: string;
+                };
+            };
+        };
+        upcomingSection: {
+            title: string;
+            viewAllLabel: string;
+            expandLabel: string;
+            collapseLabel: string;
+            ariaLabel: {
+                viewAll: string;
+                toggle: string;
+            };
+            emptyMessage: string;
+            errorMessage: string;
+        };
+        eventGroupCard: {
+            viewEventLabel: string;
+            meetingListToggle: {
+                showLabelPrefix: string;
+                showLabelSuffix: string;
+                hideLabel: string;
+            };
+            ariaLabel: {
+                viewEvent: string;
+                meetingListToggle: string;
+            };
+            paginator: {
+                rangeTemplate: string;
+                totalTemplate: string;
+            };
+        };
+        meetingRow: {
+            emptyFieldPlaceholder: string;
+            currentlyAttendingIndicator: string;
+            logAttendanceLabel: string;
+            leaveMeetingLabel: string;
+            ariaLabel: {
+                meetingNameLink: string;
+                logAttendance: string;
+                leaveMeeting: string;
+            };
+        };
+        groupsSection: {
+            title: string;
+            viewAllLabel: string;
+            expandLabel: string;
+            collapseLabel: string;
+            countSuffix: string;
+            emptyValue: string;
+            ariaLabel: {
+                viewAll: string;
+                toggle: string;
+                groupLink: string;
+            };
+            columns: {
+                group: string;
+                type: string;
+                officerRole: string;
+                affiliation: string;
+                memberLevel: string;
+            };
+            paginator: {
+                rangeTemplate: string;
+                totalTemplate: string;
+            };
+            memberLevelBadge: {
+                votingMember: string;
+                default: string;
+            };
+            emptyMessage: string;
+            errorMessage: string;
+        };
+        memberLevel: {
+            colorMap: {
+                "Voting Member": string;
+                Observer: string;
+                "Associate Member": string;
+                Member: string;
+                default: string;
+            };
+        };
+        attendance: {
+            errorMessage: string;
+        };
+        footer: {
+            links: {
+                label: string;
+                target: string;
+            }[];
+            copyright: string;
+        };
+        defaultRouteConfig: {
+            eventDetail: string;
+            meetingDetail: string;
+            groupDetail: string;
+            viewAllEvents: string;
+            /** The signed-in user's info used by the welcome header greeting (Req 11.3, 4.1). */
+            viewAllGroups: string;
+        };
+    };
+    /** Host navigation paths; falls back to the `constants.json` default when omitted (Req 11.1, 11.5). */
+    routePaths?: DashboardRouteConfig;
+    /** The host application's API base URL, forwarded to the service (Req 11.2). */
+    apiBaseURL: string;
+    /** The signed-in user's info used by the welcome header greeting (Req 11.3, 4.1). */
+    userInfo: DashboardUserInfo;
+    /** The signed-in user's permissions used to gate attendance actions (Req 11.4, 12.3). */
+    userPermissions: UserPermission[];
+    /** Emits a resolved navigation intent for the host to act on (Req 5.2, 6.4, 7.4, 8.2, 8.7, 11.1). */
+    dashboardNavigate: EventEmitter<DashboardNavigationIntent>;
+    /** The user's upcoming events, bound to the upcoming section (Req 13.1, 13.2). */
+    upcomingEvents: UpcomingEvent[];
+    /** The user's groups, bound to the groups section (Req 13.1, 13.2). */
+    groups: GroupRow[];
+    /** The upcoming-events section's load/empty/error state (Req 13.1, 13.2, 13.5). */
+    upcomingState: DashboardSectionState;
+    /** The groups section's load/empty/error state (Req 13.1, 13.2, 13.5). */
+    groupsState: DashboardSectionState;
+    /** The per-meeting attendance-state map passed down to the rows. */
+    attendanceStates: Record<string, AttendanceState>;
+    /** The set of meeting ids with an attendance action awaiting resolution. */
+    inFlightMeetingIds: ReadonlySet<string>;
+    /** The per-row attendance-action permissions derived from `userPermissions` (Req 12.3). */
+    attendancePermissions: AttendanceActionPermissions;
+    /** Whether the viewport is at/below the mobile breakpoint (Req 15.1, 15.2). */
+    isMobileView: boolean;
+    /**
+     * Total number of meetings across the loaded upcoming events, shown in the
+     * welcome header's "Upcoming Meetings & Events" shortcut badge.
+     * @readonly
+     * @memberof DashboardComponent
+     */
+    get meetingsCount(): number;
+    /**
+     * Number of loaded groups, shown in the welcome header's "Your Groups"
+     * shortcut badge.
+     * @readonly
+     * @memberof DashboardComponent
+     */
+    get groupsCount(): number;
+    /** The current zero-based page index of the groups table. */
+    groupsPageIndex: number;
+    /** The current page size of the groups table. */
+    groupsPageSize: number;
+    /** Completes on destroy to tear down all subscriptions (Req 2.4, 2.5). */
+    private readonly destroy$;
+    constructor(dashboardService: DashboardService, userPermissionsService: UserPermissionsService, breakpointObserverService: BreakpointObserverService, alertService: AlertsService);
+    /**
+     * Initializes the dashboard: forwards the host config to the service, derives
+     * the per-row attendance permissions, kicks off the upcoming-events and groups
+     * loads, and wires up subscriptions to the service state observables and the
+     * breakpoint observer — all cleaned up via `takeUntil(destroy$)` (Req 11.2,
+     * 11.4, 12.3, 13.1, 13.2, 13.5, 15.1, 15.2).
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    ngOnInit(): void;
+    /**
+     * Tears down all subscriptions on destroy (Req 2.4, 2.5).
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handles the welcome-header "Jump to" date selection. The dashboard currently
+     * has no date-scoped data load, so the selection is accepted without side
+     * effects; the hook keeps the header's contract satisfied for future filtering.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onJumpToDateSelected(): void;
+    /**
+     * Handles a welcome-header "Jump to" shortcut, emitting the navigation intent
+     * for the matching section so the host app routes to it: MEETINGS →
+     * `viewAllEvents` (/events-and-meetings/view-events-meetings-list), GROUPS →
+     * `viewAllGroups` (/groups).
+     * @param {DashboardJumpTarget} target - The selected shortcut target.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onJumpToShortcut(target: DashboardJumpTarget): void;
+    /**
+     * Emits the "View All" upcoming-events navigation intent, targeting the
+     * `viewAllEvents` route with no id (Req 5.2, 11.1).
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onViewAllEvents(): void;
+    /**
+     * Emits the "View Event" navigation intent, targeting the `eventDetail` route
+     * with the event id (Req 6.4, 11.1).
+     * @param {string} eventId - The id of the event to view.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onViewEvent(eventId: string): void;
+    /**
+     * Emits the open-meeting navigation intent, targeting the `meetingDetail`
+     * route with the meeting id (Req 7.4, 11.1).
+     * @param {string} meetingId - The id of the meeting to open.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onOpenMeeting(meetingId: string): void;
+    /**
+     * Emits the "View All" groups navigation intent, targeting the
+     * `viewAllGroups` route with no id (Req 8.2, 11.1).
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onViewAllGroups(): void;
+    /**
+     * Emits the group-detail navigation intent, targeting the `groupDetail` route
+     * with the group id (Req 8.7, 11.1).
+     * @param {string} groupId - The id of the selected group.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onGroupSelected(groupId: string): void;
+    /**
+     * Updates the groups table paging state in response to a paginator change so
+     * the groups section reflects the requested page (Req 8.10).
+     * @param {PageChange} page - The requested page index and size.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onGroupsPageChange(page: PageChange): void;
+    /**
+     * Delegates a log-attendance request to the service, surfacing the
+     * attendance-action error message via the shared {@link AlertsService} on
+     * failure while the service retains the prior displayed state (Req 7.7, 13.7).
+     * @param {string} meetingId - The meeting to log attendance for.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onLogAttendance(meetingId: string): void;
+    /**
+     * Delegates a leave-meeting request to the service, surfacing the
+     * attendance-action error message via the shared {@link AlertsService} on
+     * failure while the service retains the prior displayed state (Req 7.8, 13.7).
+     * @param {string} meetingId - The meeting to leave.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onLeaveMeeting(meetingId: string): void;
+    /**
+     * The route configuration in effect: the host-supplied `routePaths` when
+     * provided, otherwise the default route config from `constants.json` so
+     * navigation intents always carry valid targets (Req 11.1, 11.5).
+     * @return {DashboardRouteConfig} The active route configuration.
+     * @memberof DashboardComponent
+     */
+    private get activeRouteConfig();
+    /**
+     * Subscribes to the service's state observables, mirroring each into a local
+     * field for the template to bind. All subscriptions are torn down via
+     * `takeUntil(destroy$)` (Req 13.1, 13.2, 13.5).
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    private subscribeToServiceState;
+    /**
+     * Subscribes to the Presentation_Library breakpoint observer to keep
+     * `isMobileView` in sync with the viewport (Req 15.1, 15.2).
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    private subscribeToBreakpoint;
+    /**
+     * Triggers the upcoming-events load, setting the section to `ERROR` on failure
+     * so only the section error region renders (Req 13.1, 13.2, 13.5).
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    private loadUpcomingEvents;
+    /**
+     * Triggers the groups load, setting the section to `ERROR` on failure so only
+     * the section error region renders. Isolated from the upcoming-events load so
+     * one failing does not affect the other (Req 13.1, 13.2, 13.5).
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    private loadGroups;
+    /**
+     * Composes and emits a {@link DashboardNavigationIntent} for the host from the
+     * resolved target path and an optional triggering id (Req 11.1).
+     * @param {string} path - The resolved target route path.
+     * @param {string} [id] - The triggering identifier, when applicable.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    private emitNavigation;
+    /**
+     * Surfaces the attendance-action error message from `constants.json` via the
+     * shared {@link AlertsService} (Req 13.7).
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    private showAttendanceError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardComponent, "ieeesa-dashboard", never, { "routePaths": { "alias": "routePaths"; "required": false; }; "apiBaseURL": { "alias": "apiBaseURL"; "required": false; }; "userInfo": { "alias": "userInfo"; "required": false; }; "userPermissions": { "alias": "userPermissions"; "required": false; }; }, { "dashboardNavigate": "dashboardNavigate"; }, never, never, true, never>;
+}

package/lib/dashboard.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dashboard.component";
+export declare class DashboardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DashboardModule, never, [typeof i1.DashboardComponent], [typeof i1.DashboardComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DashboardModule>;
+}

package/lib/dashboard.routes.d.ts

@@ -0,0 +1,2 @@
+import { Routes } from '@angular/router';
+export declare const DASHBOARD_ROUTES: Routes;

package/lib/models/attendance-action-permissions.model.d.ts

@@ -0,0 +1,4 @@
+export interface AttendanceActionPermissions {
+    canLogAttendance: boolean;
+    canLeaveMeeting: boolean;
+}

package/lib/models/attendance-state.model.d.ts

@@ -0,0 +1,4 @@
+export declare enum AttendanceState {
+    CURRENTLY_ATTENDING = "CURRENTLY_ATTENDING",
+    NOT_ATTENDING = "NOT_ATTENDING"
+}

package/lib/models/dashboard-list-response.model.d.ts

@@ -0,0 +1,5 @@
+export interface DashboardListResponse<T> {
+    status: boolean | string;
+    message?: string;
+    body?: T;
+}

package/lib/models/dashboard-route-config.model.d.ts

@@ -0,0 +1,7 @@
+export interface DashboardRouteConfig {
+    eventDetail: string;
+    meetingDetail: string;
+    groupDetail: string;
+    viewAllEvents: string;
+    viewAllGroups: string;
+}

package/lib/models/dashboard-section-state.model.d.ts

@@ -0,0 +1,6 @@
+export declare enum DashboardSectionState {
+    LOADING = "LOADING",
+    LOADED = "LOADED",
+    EMPTY = "EMPTY",
+    ERROR = "ERROR"
+}

package/lib/models/dashboard-user-info.model.d.ts

@@ -0,0 +1,5 @@
+export interface DashboardUserInfo {
+    name?: string;
+    userId?: string;
+    appId?: string;
+}

package/lib/models/group-row.model.d.ts

@@ -0,0 +1,8 @@
+export interface GroupRow {
+    groupId: string;
+    group: string;
+    type?: string;
+    officerRole?: string;
+    affiliation?: string;
+    memberLevel: string;
+}

package/lib/models/meeting-row.model.d.ts

@@ -0,0 +1,12 @@
+import { AttendanceState } from './attendance-state.model';
+export interface MeetingRow {
+    meetingId: string;
+    meetingName: string;
+    groupOrCommittee?: string;
+    roomOrLocation?: string;
+    meetingDate: string;
+    meetingTime: string;
+    timezone: string;
+    isOpenForAttendance?: boolean;
+    attendanceState?: AttendanceState;
+}

package/lib/models/page-change.model.d.ts

@@ -0,0 +1,4 @@
+export interface PageChange {
+    pageIndex: number;
+    pageSize: number;
+}

package/lib/models/upcoming-event.model.d.ts

@@ -0,0 +1,13 @@
+import { MeetingRow } from './meeting-row.model';
+export interface UpcomingEvent {
+    eventId: string;
+    title: string;
+    status: string;
+    dayIndicator?: string;
+    meetingCount: number;
+    openForAttendanceCount: number;
+    startDate: string;
+    endDate: string;
+    timezone: string;
+    meetings: MeetingRow[];
+}

package/lib/services/attendance-reducers.d.ts

@@ -0,0 +1,43 @@
+import { AttendanceState } from '../models/attendance-state.model';
+/**
+ * Pure reducers for the dashboard attendance state. These functions never
+ * mutate their inputs; each returns a new object/set so they can be exercised
+ * directly by property tests and composed by the DashboardService.
+ */
+/**
+ * Produce a new attendance-state map with the target meeting set to
+ * CURRENTLY_ATTENDING. Every other entry is copied unchanged (frame property).
+ *
+ * @param {Record<string, AttendanceState>} map The current attendance-state map (not mutated).
+ * @param {string} meetingId The meeting whose state transitions to CURRENTLY_ATTENDING.
+ * @return {Record<string, AttendanceState>} A new map reflecting the successful log-attendance action.
+ */
+export declare const applyLogAttendanceSuccess: (map: Record<string, AttendanceState>, meetingId: string) => Record<string, AttendanceState>;
+/**
+ * Produce a new attendance-state map with the target meeting set to
+ * NOT_ATTENDING. Every other entry is copied unchanged (frame property).
+ *
+ * @param {Record<string, AttendanceState>} map The current attendance-state map (not mutated).
+ * @param {string} meetingId The meeting whose state transitions to NOT_ATTENDING.
+ * @return {Record<string, AttendanceState>} A new map reflecting the successful leave-meeting action.
+ */
+export declare const applyLeaveMeetingSuccess: (map: Record<string, AttendanceState>, meetingId: string) => Record<string, AttendanceState>;
+/**
+ * Add a meeting to the in-flight set, returning a new set. Prior membership is
+ * retained so the displayed attendance state is preserved while the request
+ * resolves.
+ *
+ * @param {ReadonlySet<string>} set The current in-flight meeting-id set (not mutated).
+ * @param {string} meetingId The meeting whose attendance action has started.
+ * @return {Set<string>} A new set that additionally contains the meeting id.
+ */
+export declare const beginAttendanceAction: (set: ReadonlySet<string>, meetingId: string) => Set<string>;
+/**
+ * Remove a meeting from the in-flight set, returning a new set. All other
+ * in-flight ids are retained.
+ *
+ * @param {ReadonlySet<string>} set The current in-flight meeting-id set (not mutated).
+ * @param {string} meetingId The meeting whose attendance action has resolved.
+ * @return {Set<string>} A new set that no longer contains the meeting id.
+ */
+export declare const endAttendanceAction: (set: ReadonlySet<string>, meetingId: string) => Set<string>;

package/lib/services/dashboard.service.d.ts

@@ -0,0 +1,119 @@
+import { Observable } from 'rxjs';
+import { HttpService } from '@ieeesa-npm/utility';
+import { UserPermission } from '@ieeesa-npm/models';
+import { AttendanceState } from '../models/attendance-state.model';
+import { DashboardListResponse } from '../models/dashboard-list-response.model';
+import { DashboardSectionState } from '../models/dashboard-section-state.model';
+import { GroupRow } from '../models/group-row.model';
+import { UpcomingEvent } from '../models/upcoming-event.model';
+import * as i0 from "@angular/core";
+/**
+ * DashboardService is the single source of truth for the dashboard landing
+ * page's data and attendance state. It mirrors the `events-and-meetings`
+ * service conventions: it is a `providedIn: 'root'` singleton, holds the host
+ * `apiBaseUrl` / `userPermissions` set via {@link setAppConfig}, owns its state
+ * via `BehaviorSubject`s exposed as observables, and reaches the backend only
+ * through the shared `HttpService` from `@ieeesa-npm/utility` (never
+ * `HttpClient` directly).
+ *
+ * The upcoming-events and groups loads currently return annotated mock data
+ * because their endpoints are not yet available; the attendance actions compose
+ * the pure reducers from `attendance-reducers.ts` so the displayed
+ * `AttendanceState` only advances on a successful resolution and the prior
+ * state is retained on failure.
+ * @export
+ * @class DashboardService
+ */
+export declare class DashboardService {
+    private httpService;
+    apiBaseUrl: string;
+    userPermissions: UserPermission[];
+    private readonly upcomingEvents;
+    private readonly groups;
+    private readonly upcomingState;
+    private readonly groupsState;
+    private readonly attendanceStates;
+    private readonly inFlightMeetingIds;
+    /** Emits the list of the user's upcoming events. */
+    upcomingEvents$: Observable<UpcomingEvent[]>;
+    /** Emits the list of the user's groups. */
+    groups$: Observable<GroupRow[]>;
+    /** Emits the load/empty/error state of the upcoming-events section. */
+    upcomingState$: Observable<DashboardSectionState>;
+    /** Emits the load/empty/error state of the groups section. */
+    groupsState$: Observable<DashboardSectionState>;
+    /** Emits the per-meeting attendance-state map. */
+    attendanceStates$: Observable<Record<string, AttendanceState>>;
+    /** Emits the set of meeting ids with an attendance action in flight. */
+    inFlightMeetingIds$: Observable<ReadonlySet<string>>;
+    constructor(httpService: HttpService);
+    /**
+     * Stores the host-supplied API base URL and user permissions used to build
+     * request URLs and gate permission-controlled actions. Mirrors the
+     * `events-and-meetings` service `setAppConfig`.
+     * @param {string} apiBaseURL - The host application's API base URL.
+     * @param {UserPermission[]} userPermissions - The signed-in user's permissions.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    setAppConfig(apiBaseURL: string, userPermissions: UserPermission[]): void;
+    /**
+     * Loads the user's upcoming events, driving the upcoming section through
+     * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on
+     * failure. Follows the `pipe(map, catchError(throw))` pattern and seeds the
+     * per-meeting attendance-state map from the loaded meetings.
+     *
+     * TODO: Replace mock with real API call when BE is ready
+     * @return {Observable<DashboardListResponse<UpcomingEvent[]>>} The upcoming-events response envelope.
+     * @memberof DashboardService
+     */
+    loadUpcomingEvents(): Observable<DashboardListResponse<UpcomingEvent[]>>;
+    /**
+     * Loads the user's groups, driving the groups section through
+     * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on
+     * failure. Follows the `pipe(map, catchError(throw))` pattern.
+     *
+     * TODO: Replace mock with real API call when BE is ready
+     * @return {Observable<DashboardListResponse<GroupRow[]>>} The groups response envelope.
+     * @memberof DashboardService
+     */
+    loadGroups(): Observable<DashboardListResponse<GroupRow[]>>;
+    /**
+     * Logs attendance for a meeting. Marks the meeting in-flight (retaining the
+     * prior displayed state), posts through `HttpService`, applies the
+     * log-attendance-success reducer on success, clears the in-flight flag on
+     * completion, and rethrows while retaining prior state on failure.
+     * @param {string} meetingId - The meeting to log attendance for.
+     * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.
+     * @memberof DashboardService
+     */
+    logAttendance(meetingId: string): Observable<DashboardListResponse<unknown>>;
+    /**
+     * Leaves a meeting. Marks the meeting in-flight (retaining the prior
+     * displayed state), posts through `HttpService`, applies the
+     * leave-meeting-success reducer on success, clears the in-flight flag on
+     * completion, and rethrows while retaining prior state on failure.
+     * @param {string} meetingId - The meeting to leave.
+     * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.
+     * @memberof DashboardService
+     */
+    leaveMeeting(meetingId: string): Observable<DashboardListResponse<unknown>>;
+    /**
+     * Returns a synchronous snapshot of the per-meeting attendance-state map.
+     * @return {Record<string, AttendanceState>} The current attendance-state map.
+     * @memberof DashboardService
+     */
+    getAttendanceStatesSnapshot(): Record<string, AttendanceState>;
+    /**
+     * Seeds the attendance-state map from a freshly loaded list of events, using
+     * each meeting's `attendanceState` (defaulting to `NOT_ATTENDING`). Keeps the
+     * displayed state in sync with the data load without overwriting ids that are
+     * not present in the new list.
+     * @param {UpcomingEvent[]} events - The loaded upcoming events.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    private seedAttendanceStates;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DashboardService>;
+}

package/lib/services/user-permissions.service.d.ts

@@ -0,0 +1,31 @@
+import { UserPermission } from '@ieeesa-npm/models';
+import { AttendanceActionPermissions } from '../models/attendance-action-permissions.model';
+import * as i0 from "@angular/core";
+/**
+ * Permission identifiers (by name) that gate the dashboard attendance actions.
+ * Mirrors the permission-type pattern used by the `events-and-meetings` and
+ * `groups` user-permissions services.
+ */
+export declare enum DashboardPermissionType {
+    LOG_ATTENDANCE = "Log Attendance",
+    LEAVE_MEETING = "Leave Meeting"
+}
+export declare class UserPermissionsService {
+    /**
+     * Returns access provision for the passed action/feature based on whether the signed in user has appropriate permission.
+     * @param {DashboardPermissionType} permission
+     * @param {UserPermission[]} userPermissions
+     * @return {boolean}
+     * @memberof UserPermissionsService
+     */
+    validateAccessPermission(permission: DashboardPermissionType, userPermissions: UserPermission[]): boolean;
+    /**
+     * Maps the host-supplied user permissions to the attendance-action permissions consumed by the dashboard rows.
+     * @param {UserPermission[]} userPermissions
+     * @return {AttendanceActionPermissions}
+     * @memberof UserPermissionsService
+     */
+    mapToAttendanceActionPermissions(userPermissions: UserPermission[]): AttendanceActionPermissions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserPermissionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserPermissionsService>;
+}