@chrischall/pickuppatrol-mcp 0.0.0

package/dist/tools/account.d.ts

@@ -0,0 +1,8 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { PickUpPatrolClient } from '../client.js';
+import type { DefaultPlan, Student } from '../types.js';
+/** Project a student down to the fields a parent actually asks about. */
+export declare function summarizeStudent(student: Student): Record<string, unknown>;
+/** Order the weekly defaults Sunday→Saturday and label each day. */
+export declare function summarizeDefaultPlans(plans: DefaultPlan[] | null | undefined): unknown[];
+export declare function registerAccountTools(server: McpServer, client: PickUpPatrolClient): void;

package/dist/tools/account.js

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { textResult, messageOf } from '@chrischall/mcp-utils';
+import { dayIdToName } from '../dates.js';
+import { VERSION } from '../version.js';
+/** Project a student down to the fields a parent actually asks about. */
+export function summarizeStudent(student) {
+    return {
+        studentId: student.StudentId,
+        firstName: student.FirstName,
+        lastName: student.LastName,
+        schoolId: student.SchoolId,
+        schoolName: student.SchoolName,
+        allowPlans: student.AllowPlans ?? null,
+        defaultCarNumber: student.DefaultCarNumber ?? null,
+        defaultsReviewedDate: student.DefaultsReviewedDate ?? null,
+        defaultPlans: summarizeDefaultPlans(student.DefaultPlans),
+    };
+}
+/** Order the weekly defaults Sunday→Saturday and label each day. */
+export function summarizeDefaultPlans(plans) {
+    return [...(plans ?? [])]
+        .sort((a, b) => a.DayId - b.DayId)
+        .map((plan) => ({
+        dayId: plan.DayId,
+        weekday: plan.WeekDayName ?? dayIdToName(plan.DayId),
+        transportationId: plan.TransportationId ?? null,
+        transportation: plan.TransportationName ?? null,
+        note: plan.Note ?? null,
+        earlyDismissalTime: plan.EarlyDismissalTime ?? null,
+        carNumber: plan.UseCarNumbers ? (plan.CarNumber ?? null) : null,
+    }));
+}
+export function registerAccountTools(server, client) {
+    server.registerTool('pup_get_session', {
+        description: 'The signed-in PickUp Patrol parent account: name, email, last sign-in, and the students linked to it. Start here to discover student and school ids.',
+        annotations: { readOnlyHint: true },
+    }, async () => {
+        const session = await client.getSession();
+        return textResult({
+            userId: session.UserId ?? null,
+            name: session.DisplayName ?? [session.FirstName, session.LastName].filter(Boolean).join(' '),
+            email: session.Email ?? session.PrimaryEmail ?? null,
+            lastLoginDate: session.LastLoginDate ?? null,
+            sendPlanConfirmEmails: session.SendPlanConfirmEmails ?? null,
+            hasAcceptedLatestTerms: session.HasAcceptedLatestTerms ?? null,
+            children: session.Children ?? [],
+        });
+    });
+    server.registerTool('pup_list_students', {
+        description: 'Every student on the account, each with their weekly default dismissal plan and whether those defaults still need a parent review.',
+        annotations: { readOnlyHint: true },
+    }, async () => {
+        const [students, review] = await Promise.all([
+            client.getChildren(),
+            client.getDefaultPlansReviewNeeded(),
+        ]);
+        const needsReview = new Map(review.map((r) => [r.StudentId, r.NeedsReview]));
+        return textResult(students.map((student) => ({
+            ...summarizeStudent(student),
+            needsDefaultsReview: needsReview.get(student.StudentId) ?? false,
+        })));
+    });
+    server.registerTool('pup_get_student', {
+        description: 'One student in full, including the default dismissal plan for each weekday. Pass raw: true for the untouched API record.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            student_id: z.number().int().describe('Student id, from pup_list_students'),
+            raw: z
+                .boolean()
+                .optional()
+                .describe('Return the unprojected API record instead of the summary'),
+        },
+    }, async ({ student_id, raw }) => {
+        const student = await client.getStudent(student_id);
+        return textResult(raw === true ? student : summarizeStudent(student));
+    });
+    server.registerTool('pup_healthcheck', {
+        description: 'Verify the configured credentials sign in and the PickUp Patrol API answers. Reports the server version and the students the account can see.',
+        annotations: { readOnlyHint: true },
+    }, async () => {
+        try {
+            const session = await client.getSession();
+            return textResult({
+                ok: true,
+                version: VERSION,
+                signedInAs: session.Email ?? session.PrimaryEmail ?? session.DisplayName ?? null,
+                studentCount: session.Children?.length ?? 0,
+            });
+        }
+        catch (err) {
+            // A healthcheck reports rather than throws: the whole point is to say
+            // what is wrong, and an exception here reads to the host as the tool
+            // itself being broken.
+            return textResult({ ok: false, version: VERSION, error: messageOf(err) });
+        }
+    });
+}

package/dist/tools/defaults.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { PickUpPatrolClient } from '../client.js';
+/**
+ * Accept weekdays as names ("Monday") or ids (1 = Sunday … 7 = Saturday).
+ * A name that is not a weekday is rejected rather than coerced — silently
+ * landing on Sunday would be a plan change nobody asked for.
+ */
+export declare function parseWeekdays(days: Array<string | number>): number[];
+export declare function registerDefaultPlanTools(server: McpServer, client: PickUpPatrolClient): void;

package/dist/tools/defaults.js

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+import { McpToolError, textResult } from '@chrischall/mcp-utils';
+import { applyDefaultPlans, clearDefaultPlans } from '../plans.js';
+import { dayIdToName, nameToDayId } from '../dates.js';
+import { summarizeDefaultPlans } from './account.js';
+import { resolveTransportation } from './plans.js';
+import { previewUnlessConfirmed, schemaConfirm } from './_confirm.js';
+import { withHints } from './_errors.js';
+/**
+ * Accept weekdays as names ("Monday") or ids (1 = Sunday … 7 = Saturday).
+ * A name that is not a weekday is rejected rather than coerced — silently
+ * landing on Sunday would be a plan change nobody asked for.
+ */
+export function parseWeekdays(days) {
+    return days.map((day) => {
+        if (typeof day === 'number') {
+            if (!Number.isInteger(day) || day < 1 || day > 7) {
+                throw new McpToolError(`${day} is not a weekday id (1 = Sunday … 7 = Saturday)`);
+            }
+            return day;
+        }
+        const asNumber = /^[1-7]$/.test(day.trim()) ? Number(day.trim()) : null;
+        if (asNumber !== null)
+            return asNumber;
+        const dayId = nameToDayId(day);
+        if (dayId === null) {
+            throw new McpToolError(`"${day}" is not a weekday`, {
+                hint: 'Use a name like "Monday", or an id 1–7 where 1 is Sunday.',
+            });
+        }
+        return dayId;
+    });
+}
+export function registerDefaultPlanTools(server, client) {
+    server.registerTool('pup_get_default_plans', {
+        description: "A student's weekly default dismissal plan — how they normally leave school on each day of the week — and whether the defaults still need a parent review.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            student_id: z.number().int().describe('Student id, from pup_list_students'),
+        },
+    }, async ({ student_id }) => {
+        const [student, review] = await Promise.all([
+            client.getStudent(student_id),
+            client.getDefaultPlansReviewNeeded(),
+        ]);
+        return textResult({
+            studentId: student.StudentId,
+            name: [student.FirstName, student.LastName].filter(Boolean).join(' '),
+            schoolId: student.SchoolId,
+            schoolName: student.SchoolName,
+            allowPlans: student.AllowPlans ?? null,
+            defaultsReviewedDate: student.DefaultsReviewedDate ?? null,
+            needsDefaultsReview: review.find((r) => r.StudentId === student_id)?.NeedsReview ?? false,
+            defaultPlans: summarizeDefaultPlans(student.DefaultPlans),
+        });
+    });
+    server.registerTool('pup_set_default_plans', {
+        description: "Change a student's weekly default dismissal plan for one or more weekdays, or clear every default. This is how the child leaves school on any date without a specific plan, so it requires confirm: true; without it you get a dry-run. Read pup_list_transportations first.",
+        inputSchema: {
+            student_id: z.number().int().describe('Student id, from pup_list_students'),
+            days: z
+                .array(z.union([z.string(), z.number().int()]))
+                .optional()
+                .describe('Weekdays to change, as names ("Monday") or ids (1 = Sunday … 7 = Saturday)'),
+            transportation_id: z
+                .number()
+                .int()
+                .optional()
+                .describe('Dismissal option id from pup_list_transportations'),
+            note: z.string().optional().describe('Note for the school; required by some options'),
+            early_dismissal_time: z
+                .string()
+                .optional()
+                .describe('HH:MM, required when the option is an early dismissal'),
+            clear_all: z
+                .boolean()
+                .optional()
+                .describe('Remove every weekday default instead of setting one (days is ignored)'),
+            confirm: schemaConfirm,
+        },
+    }, withHints(async ({ student_id, days, transportation_id, note, early_dismissal_time, clear_all, confirm }) => {
+        // Read-modify-write: PickUp Patrol has no default-plans endpoint, so the
+        // whole student record round-trips. Reading it here (before the confirm
+        // gate) is what makes the dry-run show the real payload; it mutates
+        // nothing.
+        const student = await client.getStudent(student_id);
+        if (clear_all === true) {
+            const payload = clearDefaultPlans(student);
+            const gate = previewUnlessConfirmed(confirm, `Clear every weekday default for ${student.FirstName ?? 'the student'}`, 'PUT', 'Student', { StudentId: student.StudentId, DefaultPlans: [] });
+            if (gate)
+                return gate;
+            await client.updateStudent(payload);
+            const after = await client.getStudent(student_id);
+            const remaining = after.DefaultPlans ?? [];
+            return textResult({
+                action: 'Cleared every weekday default',
+                defaultPlans: summarizeDefaultPlans(remaining),
+                verified: remaining.length === 0,
+                ...(remaining.length > 0
+                    ? { warning: 'PickUp Patrol accepted the request but defaults are still set.' }
+                    : {}),
+            });
+        }
+        if (days === undefined || transportation_id === undefined) {
+            throw new McpToolError('days and transportation_id are both required', {
+                hint: 'Pass clear_all: true to remove every default instead.',
+            });
+        }
+        const dayIds = parseWeekdays(days);
+        const transportation = await resolveTransportation(client, student.SchoolId, transportation_id);
+        const payload = applyDefaultPlans({
+            student,
+            dayIds,
+            transportation,
+            note,
+            earlyDismissalTime: early_dismissal_time,
+        });
+        const dayNames = dayIds.map((id) => dayIdToName(id)).join(', ');
+        const action = `Set ${student.FirstName ?? 'the student'}'s default plan on ${dayNames} to "${transportation.Name}"`;
+        const gate = previewUnlessConfirmed(confirm, action, 'PUT', 'Student', {
+            StudentId: student.StudentId,
+            DefaultPlans: payload.DefaultPlans,
+            note: 'The whole student record is sent back with only DefaultPlans changed.',
+        });
+        if (gate)
+            return gate;
+        await client.updateStudent(payload);
+        // Re-read and check the weekdays we changed actually hold the new
+        // option. DefaultsModifiedDate is not compared — it advances by itself.
+        const after = await client.getStudent(student_id);
+        const changed = new Set(dayIds);
+        const unchanged = [...changed].filter((dayId) => {
+            const plan = (after.DefaultPlans ?? []).find((p) => p.DayId === dayId);
+            return plan?.TransportationId !== transportation.TransportationId;
+        });
+        return textResult({
+            action,
+            defaultPlans: summarizeDefaultPlans(after.DefaultPlans),
+            verified: unchanged.length === 0,
+            ...(unchanged.length > 0
+                ? {
+                    warning: 'PickUp Patrol accepted the request but these weekdays did not change — the school may not run default plans on them.',
+                    unchanged: unchanged.map((id) => dayIdToName(id)),
+                }
+                : {}),
+        });
+    }));
+    server.registerTool('pup_mark_defaults_reviewed', {
+        description: "Mark a student's default plans as reviewed, clearing the school's 'needs review' prompt. Requires confirm: true.",
+        inputSchema: {
+            student_id: z.number().int().describe('Student id, from pup_list_students'),
+            reviewed: z.boolean().optional().describe('Defaults to true'),
+            confirm: schemaConfirm,
+        },
+    }, async ({ student_id, reviewed, confirm }) => {
+        const value = reviewed ?? true;
+        const gate = previewUnlessConfirmed(confirm, `Mark student ${student_id}'s defaults as ${value ? 'reviewed' : 'not reviewed'}`, 'PUT', 'SetDefaultsReviewed', { StudentId: student_id, Reviewed: value });
+        if (gate)
+            return gate;
+        await client.setDefaultsReviewed(student_id, value);
+        const review = await client.getDefaultPlansReviewNeeded();
+        const needsReview = review.find((r) => r.StudentId === student_id)?.NeedsReview ?? false;
+        return textResult({
+            studentId: student_id,
+            needsDefaultsReview: needsReview,
+            verified: needsReview === !value,
+        });
+    });
+}

package/dist/tools/plans.d.ts

@@ -0,0 +1,15 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { PickUpPatrolClient } from '../client.js';
+import type { Student, Transportation } from '../types.js';
+/**
+ * The transportation id a date should show once a write has landed.
+ *
+ * For a normal change that is the id we asked for. For a revert
+ * (`TransportationId: null`) the date falls back to the student's default for
+ * that weekday, so the id to expect is that default's — and when the student
+ * has no default for the day there is nothing to assert, hence `undefined`.
+ */
+export declare function expectedTransportationId(student: Student, planDate: string, requested: number | null): number | null | undefined;
+/** Resolve a transportation id against the school's list, or fail with the options. */
+export declare function resolveTransportation(client: PickUpPatrolClient, schoolId: number, transportationId: number): Promise<Transportation>;
+export declare function registerPlanTools(server: McpServer, client: PickUpPatrolClient): void;

package/dist/tools/plans.js

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+import { McpToolError, textResult } from '@chrischall/mcp-utils';
+import { buildPlanUpdates } from '../plans.js';
+import { dateToDayId, weekdayOf } from '../dates.js';
+import { previewUnlessConfirmed, schemaConfirm } from './_confirm.js';
+import { withHints } from './_errors.js';
+/**
+ * The transportation id a date should show once a write has landed.
+ *
+ * For a normal change that is the id we asked for. For a revert
+ * (`TransportationId: null`) the date falls back to the student's default for
+ * that weekday, so the id to expect is that default's — and when the student
+ * has no default for the day there is nothing to assert, hence `undefined`.
+ */
+export function expectedTransportationId(student, planDate, requested) {
+    if (requested !== null)
+        return requested;
+    const dayId = dateToDayId(planDate);
+    if (dayId === null)
+        return undefined;
+    const fallback = (student.DefaultPlans ?? []).find((plan) => plan.DayId === dayId);
+    return fallback === undefined ? undefined : (fallback.TransportationId ?? null);
+}
+/** Resolve a transportation id against the school's list, or fail with the options. */
+export async function resolveTransportation(client, schoolId, transportationId) {
+    const options = await client.getTransportations(schoolId);
+    const match = options.find((o) => o.TransportationId === transportationId);
+    if (!match) {
+        throw new McpToolError(`No dismissal option ${transportationId} at school ${schoolId}`, {
+            hint: `Available: ${options.map((o) => `${o.TransportationId} (${o.Name})`).join(', ')}`,
+        });
+    }
+    return match;
+}
+export function registerPlanTools(server, client) {
+    server.registerTool('pup_list_plans', {
+        description: 'Day-by-day dismissal plans across a date range for every student on the account, as PickUp Patrol returns them.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            start_date: z.string().describe('YYYY-MM-DD'),
+            end_date: z.string().describe('YYYY-MM-DD'),
+        },
+    }, async ({ start_date, end_date }) => textResult(await client.getParentPlans(start_date, end_date)));
+    server.registerTool('pup_get_plan', {
+        description: 'The dismissal plan for one student on one date — the option in force, any note, the early-dismissal time, and whether the date is locked because the cutoff has passed.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            student_id: z.number().int().describe('Student id, from pup_list_students'),
+            date: z.string().describe('YYYY-MM-DD'),
+        },
+    }, async ({ student_id, date }) => textResult(await client.getPlanEdit(date, student_id)));
+    server.registerTool('pup_set_plan', {
+        description: "Change how a student is dismissed on one or more specific dates, or clear those dates back to the student's weekly default. This changes how a child actually leaves school, so it requires confirm: true; without it you get a dry-run of the exact payload. Read pup_list_transportations first — options differ in whether they require a note, a car number or an early-dismissal time.",
+        inputSchema: {
+            student_id: z.number().int().describe('Student id, from pup_list_students'),
+            dates: z
+                .array(z.string())
+                .min(1)
+                .describe('One or more YYYY-MM-DD dates to apply this plan to'),
+            transportation_id: z
+                .number()
+                .int()
+                .nullable()
+                .describe("Dismissal option id from pup_list_transportations, or null to clear these dates back to the student's default plan"),
+            note: z.string().optional().describe('Note for the school; required by some options'),
+            early_dismissal_time: z
+                .string()
+                .optional()
+                .describe('HH:MM, required when the option is an early dismissal'),
+            car_number: z
+                .string()
+                .optional()
+                .describe('Car number, for options where usesCarNumbers is true'),
+            confirm: schemaConfirm,
+        },
+    }, withHints(async ({ student_id, dates, transportation_id, note, early_dismissal_time, car_number, confirm }) => {
+        // The reads below resolve and validate the payload; they mutate nothing.
+        // Running them before the confirm gate is deliberate: it makes the
+        // dry-run show the exact bytes that would be sent, already checked
+        // against this school's rules, instead of an unvalidated echo of the
+        // arguments.
+        const student = await client.getStudent(student_id);
+        const transportation = transportation_id === null
+            ? null
+            : await resolveTransportation(client, student.SchoolId, transportation_id);
+        const plans = buildPlanUpdates({
+            student,
+            dates,
+            transportation,
+            note,
+            earlyDismissalTime: early_dismissal_time,
+            carNumber: car_number,
+        });
+        const action = transportation === null
+            ? `Clear ${dates.length} date(s) back to ${student.FirstName ?? 'the student'}'s default plan`
+            : `Set ${dates.length} date(s) for ${student.FirstName ?? 'the student'} to "${transportation.Name}"`;
+        const gate = previewUnlessConfirmed(confirm, action, 'PUT', 'UpdatePlans', { Plans: plans });
+        if (gate)
+            return gate;
+        await client.updatePlans(plans);
+        // A 2xx is not proof the change persisted — re-read each date and
+        // compare the one field that proves it. ModifiedDate is deliberately not
+        // compared: it advances on its own, which would make every write look
+        // successful.
+        const verification = await Promise.all(dates.map(async (date) => {
+            const after = await client.getPlanEdit(date, student_id);
+            const expected = expectedTransportationId(student, date, transportation_id);
+            const actual = after.TransportationId ?? null;
+            return {
+                date,
+                weekday: weekdayOf(date),
+                transportationId: actual,
+                transportation: after.TransportationName ?? null,
+                note: after.Note ?? null,
+                earlyDismissalTime: after.EarlyDismissalTime ?? null,
+                locked: after.IsLocked ?? false,
+                verified: expected === undefined ? null : actual === expected,
+            };
+        }));
+        const failed = verification.filter((v) => v.verified === false);
+        return textResult({
+            action,
+            applied: verification,
+            verified: failed.length === 0,
+            ...(failed.length > 0
+                ? {
+                    warning: 'PickUp Patrol accepted the request but these dates did not change — they are usually past the school cutoff, or the date is not a school day.',
+                    unchanged: failed.map((v) => v.date),
+                }
+                : {}),
+        });
+    }));
+}

package/dist/tools/school.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { PickUpPatrolClient } from '../client.js';
+import type { Transportation } from '../types.js';
+/**
+ * Project a transportation to its identity plus the rules that decide what a
+ * plan using it must carry — an agent choosing an option needs those rules up
+ * front, not after a rejected write.
+ */
+export declare function summarizeTransportation(option: Transportation): Record<string, unknown>;
+export declare function registerSchoolTools(server: McpServer, client: PickUpPatrolClient): void;

package/dist/tools/school.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { textResult } from '@chrischall/mcp-utils';
+/**
+ * Project a transportation to its identity plus the rules that decide what a
+ * plan using it must carry — an agent choosing an option needs those rules up
+ * front, not after a rejected write.
+ */
+export function summarizeTransportation(option) {
+    return {
+        transportationId: option.TransportationId,
+        name: option.Name,
+        noteRequired: option.IsNoteRequired ?? false,
+        noteHint: option.NoteHint ?? null,
+        usesCarNumbers: option.UseCarNumbers ?? false,
+        isEarlyDismissal: option.IsEarlyDismissal ?? false,
+        isLimited: option.IsLimited ?? false,
+        cutoffTime: option.CutoffTime ?? null,
+        active: option.IsActive ?? true,
+    };
+}
+export function registerSchoolTools(server, client) {
+    server.registerTool('pup_list_transportations', {
+        description: 'The dismissal options a school offers (bus, car pickup, walker, absent …) with the rules each one imposes: whether a note is required, whether it takes a car number, whether it is an early dismissal, and the daily cutoff time. Read this before setting a plan.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            school_id: z.number().int().describe('School id, from pup_list_students'),
+            include_inactive: z
+                .boolean()
+                .optional()
+                .describe('Include options the school has deactivated (default false)'),
+        },
+    }, async ({ school_id, include_inactive }) => {
+        const options = await client.getTransportations(school_id);
+        const visible = include_inactive === true ? options : options.filter((o) => o.IsActive !== false);
+        return textResult(visible.map(summarizeTransportation));
+    });
+    server.registerTool('pup_get_school', {
+        description: 'A school profile together with its per-weekday notify times and plan cutoff times, and the settings that decide whether parents may set plans at all.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            school_id: z.number().int().describe('School id, from pup_list_students'),
+        },
+    }, async ({ school_id }) => {
+        const [school, notifyTimes, settings] = await Promise.all([
+            client.getSchool(school_id),
+            client.getSchoolNotifyTimes(school_id),
+            client.getSchoolSettings(school_id),
+        ]);
+        return textResult({ school, notifyTimes, settings });
+    });
+    server.registerTool('pup_list_non_school_days', {
+        description: 'Dates a plan cannot be set for at a school (holidays, closures, weekends), and optionally the dates in a range that already differ from the student defaults.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            school_id: z.number().int().describe('School id, from pup_list_students'),
+            start_date: z
+                .string()
+                .optional()
+                .describe('YYYY-MM-DD; with end_date, also return dates that differ from the default'),
+            end_date: z.string().optional().describe('YYYY-MM-DD'),
+        },
+    }, async ({ school_id, start_date, end_date }) => {
+        const invalidDates = await client.getInvalidPlanDates(school_id);
+        if (start_date === undefined || end_date === undefined) {
+            return textResult({ invalidDates });
+        }
+        const changedDates = await client.getBoldedDates(start_date, end_date);
+        return textResult({ invalidDates, changedDates });
+    });
+    server.registerTool('pup_list_car_numbers', {
+        description: 'The car numbers a school has issued to this account, for dismissal options where usesCarNumbers is true.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            school_id: z.number().int().describe('School id, from pup_list_students'),
+        },
+    }, async ({ school_id }) => textResult(await client.getCarNumbers(school_id)));
+}

package/dist/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Wire types for the PickUp Patrol ServiceStack API.
+ *
+ * Every field here was read off the shipped SPA's own request/response DTO
+ * classes or observed on a live response — see `docs/PICKUPPATROL-API.md` for
+ * the capture. Responses are typed loosely on purpose: the API is
+ * undocumented, so an unexpected extra field must not break a read.
+ */
+/** ServiceStack's error envelope, present on any non-2xx JSON body. */
+export interface ResponseStatus {
+    ErrorCode?: string | null;
+    Message?: string | null;
+    Errors?: Array<{
+        ErrorCode?: string | null;
+        FieldName?: string | null;
+        Message?: string | null;
+    }> | null;
+}
+export interface AuthenticateResponse {
+    UserId?: string | number | null;
+    SessionId?: string | null;
+    UserName?: string | null;
+    DisplayName?: string | null;
+    BearerToken?: string | null;
+    RefreshToken?: string | null;
+    ResponseStatus?: ResponseStatus | null;
+}
+/** One weekday of a student's recurring dismissal plan. */
+export interface DefaultPlan {
+    /** 1-based, **Sunday = 1** — the SPA renders `dayNamesMin[DayId - 1]`. */
+    DayId: number;
+    StudentId?: number;
+    TransportationId?: number | null;
+    TransportationName?: string | null;
+    Note?: string | null;
+    WeekDayName?: string | null;
+    EarlyDismissalTime?: string | null;
+    CarNumber?: string | null;
+    UseCarNumbers?: boolean;
+}
+export interface Student {
+    StudentId: number;
+    SchoolId: number;
+    SchoolName?: string | null;
+    FirstName?: string | null;
+    LastName?: string | null;
+    IsActive?: boolean;
+    SASId?: string | null;
+    TeacherId?: number | null;
+    AllowPlans?: boolean;
+    CreateDate?: string | null;
+    CreatedBy?: number | null;
+    ModifiedDate?: string | null;
+    ModifiedBy?: number | null;
+    DefaultsModifiedDate?: string | null;
+    DefaultPlanModifiedBy?: number | null;
+    DefaultsReviewedDate?: string | null;
+    DefaultsReviewedBy?: number | null;
+    DefaultPlans?: DefaultPlan[] | null;
+    SafetyFlag?: boolean | null;
+    DefaultCarNumber?: string | null;
+    LimitedIds?: number[] | null;
+}
+export interface Transportation {
+    TransportationId: number;
+    SchoolId: number;
+    Name: string;
+    NoteHint?: string | null;
+    IsNoteRequired?: boolean;
+    UseCarNumbers?: boolean;
+    IsNotePrivate?: boolean;
+    IsActive?: boolean;
+    Sequence?: number | null;
+    IsEarlyDismissal?: boolean;
+    IsLimited?: boolean;
+    CutoffTime?: string | null;
+    AllowParentCheck?: boolean;
+}
+export interface PlanEdit {
+    PlanDate?: string | null;
+    StudentId?: number;
+    FirstName?: string | null;
+    LastName?: string | null;
+    SchoolId?: number;
+    TransportationId?: number | null;
+    TransportationName?: string | null;
+    Note?: string | null;
+    IsLocked?: boolean;
+    SchoolName?: string | null;
+    BusRouteUrl?: string | null;
+    ValidationErrors?: unknown;
+    EarlyDismissalTime?: string | null;
+    CarNumber?: string | null;
+    LimitedIds?: number[] | null;
+    IsNotePrivate?: boolean;
+}
+/** One element of the `UpdatePlans` request array. */
+export interface PlanUpdate {
+    StudentId: number;
+    SchoolId: number;
+    PlanDate: string;
+    TransportationId: number | null;
+    TransportationName: string;
+    Note: string | null;
+    EarlyDismissalTime?: string;
+    CarNumber?: string;
+}
+export interface SessionResponse {
+    UserId?: number | null;
+    FirstName?: string | null;
+    LastName?: string | null;
+    DisplayName?: string | null;
+    Email?: string | null;
+    PrimaryEmail?: string | null;
+    LastLoginDate?: string | null;
+    HasAcceptedLatestTerms?: boolean;
+    SendPlanConfirmEmails?: boolean;
+    Children?: Array<{
+        StudentId: number;
+        SchoolId: number;
+    }> | null;
+}
+export interface School {
+    SchoolId: number;
+    Name?: string | null;
+    IsActive?: boolean;
+    TimeZoneId?: string | null;
+    HelpPhone?: string | null;
+    HelpEmail?: string | null;
+    BusRouteUrl?: string | null;
+    AllowPlans?: boolean;
+    AllowDefaultPlans?: boolean;
+    [key: string]: unknown;
+}
+export interface SchoolNotifyTimes {
+    SchoolId: number;
+    [key: string]: unknown;
+}
+export interface DefaultsReviewNeeded {
+    StudentId: number;
+    NeedsReview: boolean;
+}