@ieeesa-npm/dashboard 0.0.0-stage → 0.0.2

package/lib/dashboard.component.d.ts

@@ -0,0 +1,414 @@
+import { ElementRef, 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;
+            paginator: {
+                rangeTemplate: string;
+            };
+        };
+        eventGroupCard: {
+            eventBadge: string;
+            standaloneBadge: string;
+            viewLabel: string;
+            viewEventLabel: string;
+            eventDatesLabel: string;
+            meetingDateLabel: string;
+            timeTimezoneLabel: string;
+            meetingsLabel: string;
+            openForAttendanceTemplate: string;
+            meetingListToggle: {
+                showLabel: string;
+                showLabelPrefix: string;
+                showLabelSuffix: string;
+                hideLabel: string;
+            };
+            ariaLabel: {
+                view: string;
+                viewEvent: string;
+                meetingListToggle: string; /** The resolved target route path from the active {@link DashboardRouteConfig}. */
+            };
+            paginator: {
+                rangeTemplate: string;
+                totalTemplate: string;
+            };
+        };
+        meetingRow: {
+            emptyFieldPlaceholder: string;
+            timeTimezoneLabel: string;
+            viewLabel: 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;
+            unassignedMemberLevel: string;
+            itemsPerPageLabel: 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: {
+                success: string;
+                warning: 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;
+            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;
+    /** Whether the Upcoming Meetings & Events card is expanded. Starts collapsed. */
+    meetingsExpanded: boolean;
+    /** Whether the Your Groups card is expanded. Starts collapsed. */
+    groupsExpanded: boolean;
+    /**
+     * Section host elements used to scroll a "Jump to" target into view. Read as
+     * ElementRef (not the component instance) so the native element is available
+     * for scrollIntoView.
+     */
+    upcomingSection?: ElementRef<HTMLElement>;
+    groupsSection?: ElementRef<HTMLElement>;
+    /**
+     * 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 (5 rows per page per the design). */
+    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: opens the matching section's
+     * card (so its content is visible) and smoothly scrolls it into view. It does
+     * NOT navigate away — the shortcut is an in-page jump to the section.
+     * @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;
+    /**
+     * Lazily loads (or paginates) the child meetings of an expanded EVENT card via
+     * the service, surfacing the attendance error message on failure. Each event
+     * paginates independently.
+     * @param {{ eventId: string; page: number }} request - The event id and one-based page to load.
+     * @return {void}
+     * @memberof DashboardComponent
+     */
+    onLoadEventMeetings(request: {
+        eventId: string;
+        page: number;
+    }): 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/event-meeting-list-item.model.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Raw list item returned by the real "events & meetings" backend
+ * (`POST {apiBaseUrl}/meetings/eventsAndMeetings`). A single list may contain
+ * both EVENT rows (`isMeetingEvent === true` / `hasChildren === true`, which own
+ * child meetings) and STANDALONE MEETING rows (`isMeetingEvent === false`).
+ *
+ * Dates are epoch milliseconds (not ISO strings) and must be formatted with
+ * luxon `DateTime.fromMillis`. This shape mirrors the `events-and-meetings`
+ * library's `EventsAndMeetings` list model so the dashboard reuses the exact
+ * backend contract referenced by the existing
+ * `view-events-meetings-list` screen.
+ */
+export interface EventMeetingListItem {
+    /** Stable identifier of the event or standalone meeting. */
+    id: string;
+    /** Event / meeting display name. */
+    name: string;
+    /** Start date-time as an ISO-8601 string (or epoch ms for legacy fixtures). */
+    startDateTime: string | number;
+    /** End date-time as an ISO-8601 string (or epoch ms for legacy fixtures). */
+    endDateTime: string | number;
+    /** IANA / offset-prefixed timezone string, e.g. "(UTC+05:30) Asia/Kolkata". */
+    timeZone: string;
+    /** Owning group id. */
+    groupId?: string;
+    /** Owning group display name. */
+    groupName?: string;
+    /** Owning group acronym, when provided. */
+    groupAcronym?: string;
+    /** Room / location text, when provided. */
+    meetingLocation?: string | null;
+    /** True when this row is an EVENT that owns child meetings. */
+    hasChildren?: boolean;
+    /**
+     * True when the row represents an EVENT (vs. a standalone meeting). Combined
+     * with {@link hasChildren} this is the EVENT-vs-STANDALONE discriminator.
+     */
+    isMeetingEvent?: boolean;
+    /** Lifecycle status, e.g. "In Progress", "Upcoming", "Starts Soon". */
+    status?: string;
+    /** True when the signed-in user is a member of the owning group. */
+    isMemberOfGroup?: boolean;
+    /** True when the current user is currently attending (drives the pill). */
+    isCurrentlyAttending?: boolean;
+    /** True when the row is open for attendance logging. */
+    isOpenForAttendance?: boolean;
+    /** Event id a standalone/child meeting belongs to, when applicable. */
+    eventId?: string;
+    /** Meeting id, when the row is a meeting. */
+    meetingId?: string;
+    /** Alternate name key some payloads use for meetings. */
+    meetingTitle?: string;
+    /** Alternate status key (the list screen copies status here). */
+    contentUnderLink?: string;
+    /** Alternate location key used by some meeting payloads. */
+    room?: string | null;
+    /** Count of child meetings for an event, when the backend provides it. */
+    meetingCount?: number;
+    /** Count of child meetings open for attendance, when provided. */
+    openForAttendanceCount?: number;
+    /** "Day X of Y" indicator string, when the backend provides it. */
+    dayIndicator?: string;
+}
+/**
+ * Response envelope for the dashboard events-&-meetings list endpoint, matching
+ * the `events-and-meetings` library's `GetEventsAndMeetingsResponse` body shape.
+ */
+export interface EventMeetingListResponse {
+    status: boolean;
+    message?: string;
+    body: {
+        totalRecords: number;
+        eventMeetingList: EventMeetingListItem[];
+    };
+}
+/**
+ * Child-meeting list item returned by the per-event expand endpoint
+ * (`POST {apiBaseUrl}/meetings/meetingsDetails`). Dates are epoch milliseconds.
+ * Mirrors the `events-and-meetings` library's `Meeting` model.
+ */
+export interface EventMeetingDetailItem {
+    meetingId: string;
+    meetingTitle: string;
+    meetingStDate: string | number;
+    meetingEdDate: string | number;
+    meetingLocation?: string;
+    groupId?: string;
+    groupName?: string;
+    groupAcronym?: string;
+    timeZone?: string;
+    status?: string;
+    isMemberOfGroup?: boolean;
+    isCurrentlyAttending?: boolean;
+    isOpenForAttendance?: boolean;
+}
+/**
+ * Response envelope for the per-event child-meetings expand endpoint, matching
+ * the `events-and-meetings` library's `GetMeetingsByEventIdResponse` body shape.
+ */
+export interface EventMeetingDetailResponse {
+    status: boolean;
+    message?: string;
+    body: {
+        totalRecords: number;
+        meetings: EventMeetingDetailItem[];
+    };
+}

package/lib/models/event-meeting-list-payload.model.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Request payloads for the dashboard "events & meetings" backend calls. These
+ * mirror the `events-and-meetings` library's `GetEventsAndMeetingsPayload` /
+ * `GetMeetingsByEventIdPayload` so the dashboard reuses the exact contract the
+ * existing `view-events-meetings-list` screen posts.
+ */
+/** Filter block shared by the list and expand payloads. */
+export interface EventMeetingFilter {
+    /** Lifecycle statuses to include, e.g. ["In Progress", "Upcoming"]. */
+    status: string[];
+    /** Whether every meeting (regardless of membership) should be returned. */
+    isAllMeetingSelected: boolean;
+    /** Optional group-id scope. */
+    groupIds?: string[];
+}
+/** Payload for `POST {apiBaseUrl}/meetings/eventsAndMeetings` (the section list). */
+export interface EventMeetingListPayload {
+    payload: {
+        /** Null for the top-level list; an event id when scoping to one event. */
+        eventId: string | null;
+        sortColumn: string;
+        ascendingOrder: boolean;
+        page: number;
+        size: number;
+        searchTerm?: string | null;
+        filter: EventMeetingFilter;
+    };
+}
+/** Payload for `POST {apiBaseUrl}/meetings/meetingsDetails` (per-event expand). */
+export interface EventMeetingDetailPayload {
+    payload: {
+        eventId: string;
+        sortColumn: string;
+        ascendingOrder: boolean;
+        page: number;
+        size: number;
+        searchTerm?: string | null;
+        filter: EventMeetingFilter;
+    };
+}

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

@@ -0,0 +1,33 @@
+/**
+ * A single node in a group's ancestor hierarchy (root→leaf), as returned by
+ * GET /v1/groups/my-groups. Used to render the expandable hierarchy rows in the
+ * Your Groups table.
+ */
+export interface GroupHierarchyNode {
+    groupId: string;
+    groupName: string;
+    groupShortName?: string;
+    groupAcronym?: string;
+    groupLevel?: number;
+    groupParentId?: string | null;
+    groupType?: string;
+    groupTypeName?: string | null;
+    groupDesc?: string | null;
+    hasChildren?: boolean | null;
+}
+/**
+ * Table-facing view of a group in the Your Groups section. The display fields
+ * are mapped from the backend; `hierarchy` carries the group's ancestor path so
+ * the row can expand to show the hierarchy (matching the My Profile Find Groups
+ * tree).
+ */
+export interface GroupRow {
+    groupId: string;
+    group: string;
+    type?: string;
+    officerRole?: string;
+    affiliation?: string;
+    memberLevel: string;
+    /** Ancestor hierarchy (root→leaf) for the expandable hierarchy rows. */
+    hierarchy?: GroupHierarchyNode[];
+}

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

@@ -0,0 +1,28 @@
+import { AttendanceState } from './attendance-state.model';
+/**
+ * View model for a single meeting row, used both for an event's expanded child
+ * meetings and (via {@link UpcomingEvent}) for standalone meeting cards.
+ *
+ * `startEpochMs` / `endEpochMs` carry the raw epoch-milliseconds values from the
+ * backend and are formatted with luxon `DateTime.fromMillis`. The legacy ISO
+ * `meetingDate` / `meetingTime` fields are retained for existing fixtures/tests.
+ */
+export interface MeetingRow {
+    meetingId: string;
+    meetingName: string;
+    groupOrCommittee?: string;
+    roomOrLocation?: string;
+    /** Start date-time as an ISO-8601 string (or epoch ms for fixtures). */
+    startDateTime?: string | number;
+    /** End date-time as an ISO-8601 string (or epoch ms for fixtures). */
+    endDateTime?: string | number;
+    /** Legacy ISO meeting date, retained for fixtures/tests. */
+    meetingDate?: string;
+    /** Legacy ISO meeting time, retained for fixtures/tests. */
+    meetingTime?: string;
+    timezone: string;
+    status?: string;
+    isMemberOfGroup?: boolean;
+    isOpenForAttendance?: boolean;
+    attendanceState?: AttendanceState;
+}