@serviceai/api-spec 1.2.409 → 1.2.411

package/types.d.ts

@@ -1826,6 +1826,1575 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/time-tracking/day": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** My work day: what is open, today's days, and what this client may record. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                    /** @description Send `1` to declare this client understands work days. The first request carrying it moves the caller onto the day model permanently (users.time_clock_day_model_since); from then on their fence arrivals only open entries inside an open day. */
+                    "X-Day-Clock"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Always returned for a permitted caller. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MyDayResponse"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/day/clock-in": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start my day (the master clock). The snapshot is taken at the tap.
+         * @description Where the tap landed decides whether an admin has to look: inside the office fence needs no review; inside an assigned job's site circle needs none only when the org auto-approves those; anywhere else, or no usable fix, goes to review. The button must not wait on GPS — send the cached fix and follow up with POST /api/time-tracking/entries/{id}/location.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                    /** @description Send `1` to declare this client understands work days. The first request carrying it moves the caller onto the day model permanently (users.time_clock_day_model_since); from then on their fence arrivals only open entries inside an open day. */
+                    "X-Day-Clock"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        lat?: number | null;
+                        lng?: number | null;
+                        accuracyM?: number | null;
+                        /** @enum {string|null} */
+                        device?: "ios" | "web" | "android" | null;
+                        /**
+                         * Format: date-time
+                         * @description When the tap happened. The server clamps it.
+                         */
+                        occurredAt?: string | null;
+                        notes?: string | null;
+                    };
+                };
+            };
+            responses: {
+                /** @description Day started. */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["DayClockResponse"];
+                    };
+                };
+                /** @description Validation failure. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description A day is already running (code DAY_ALREADY_OPEN). The body carries that day — adopt it rather than retrying. */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            message: string;
+                            /** @enum {string} */
+                            code: "DAY_ALREADY_OPEN";
+                            day: components["schemas"]["WorkDay"] & (Record<string, never> | null);
+                        };
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/day/clock-out": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** End my day. Closes every open entry with it. */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                    /** @description Send `1` to declare this client understands work days. The first request carrying it moves the caller onto the day model permanently (users.time_clock_day_model_since); from then on their fence arrivals only open entries inside an open day. */
+                    "X-Day-Clock"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        lat?: number | null;
+                        lng?: number | null;
+                        accuracyM?: number | null;
+                        /** @enum {string|null} */
+                        device?: "ios" | "web" | "android" | null;
+                        /**
+                         * Format: date-time
+                         * @description When the tap happened. The server clamps it.
+                         */
+                        occurredAt?: string | null;
+                        note?: string | null;
+                    };
+                };
+            };
+            responses: {
+                /** @description Day ended. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            day: components["schemas"]["WorkDay"] & (Record<string, never> | null);
+                            closedEntries: number;
+                        };
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description No day is running (code NO_OPEN_DAY). */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description The day was already closed. */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/crossings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Report fence crossings. Batched, idempotent, and the ONLY way a client moves the automatic clock.
+         * @description The server resolver owns automatic clock-in/out. Report what the device saw and read the outcome back from `openEntries`; never decide the clock locally. Re-delivery of a clientEventId is a no-op, so an at-least-once queue is correct. Max 200 events per call.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                    /** @description Send `1` to declare this client can decode an entry or fence with a null jobId (the office as a site). Older builds decode jobId as a required number, so office rows are withheld from them. */
+                    "X-Sites"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        events: components["schemas"]["ClockCrossing"][];
+                    };
+                };
+            };
+            responses: {
+                /** @description Stored. Also returned when nothing was stored because consent is missing — check `reason`. */
+                202: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CrossingsAck"];
+                    };
+                };
+                /** @description Validation failure, or a job crossing with no jobId. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description A job in the batch is not in this organization, or the office fence is not set. */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/clock-config": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** What this org's clock does — dwell, radii, sampling mode, limits. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Effective settings, clamped. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ClockConfig"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Organization not found. */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/user-geofences": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The fences this user should watch. */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description 'assigned' fences only the jobs the caller is on. Useful when an owner's job count exceeds the 20 regions iOS can watch. */
+                    scope?: "all" | "assigned";
+                    /** @description Keep jobs outside their tracking window. For the manual Clock In picker only — never for fences. */
+                    includeClosed?: "1" | "true";
+                    /** @description Prepend the office fence (jobId null). Only send it if this client can decode a null jobId. */
+                    sites?: "1" | "true";
+                };
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Fences, office first when requested. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Geofence"][];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/active": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** My open entries right now (or the team's). */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Everyone on the clock. Requires time_tracking.view_all. */
+                    scope?: "team";
+                };
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                    /** @description Send `1` to declare this client can decode an entry or fence with a null jobId (the office as a site). Older builds decode jobId as a required number, so office rows are withheld from them. */
+                    "X-Sites"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Open entries. Normally zero or one for a single user. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TimeEntry"][];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/entries": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Time entries, scoped by permission. */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description `me` always means the caller — use it for 'My Time' rather than a cached id. Absent means the whole org for a view_all role. Another user's id requires view_all. */
+                    userId?: string;
+                    jobId?: number;
+                    from?: string;
+                    to?: string;
+                    limit?: number;
+                    offset?: number;
+                };
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                    /** @description Send `1` to declare this client can decode an entry or fence with a null jobId (the office as a site). Older builds decode jobId as a required number, so office rows are withheld from them. */
+                    "X-Sites"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Entries, newest-first by the storage layer's ordering. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TimeEntry"][];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/clock-in": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Clock in to a job or the office by hand.
+         * @description A deliberate button press. On the day model a press with no day running starts the day at that moment; a fence-driven clock-in from an old-model client cannot, and is refused.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                    /** @description Send `1` to declare this client can decode an entry or fence with a null jobId (the office as a site). Older builds decode jobId as a required number, so office rows are withheld from them. */
+                    "X-Sites"?: string;
+                    /** @description Send `1` to declare this client understands work days. The first request carrying it moves the caller onto the day model permanently (users.time_clock_day_model_since); from then on their fence arrivals only open entries inside an open day. */
+                    "X-Day-Clock"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description Omit or null together with siteType 'office'. */
+                        jobId?: number | null;
+                        /** @enum {string} */
+                        siteType?: "job" | "office";
+                        /** @description Clock someone else in. Requires time_tracking.edit_all. */
+                        userId?: string;
+                        lat?: number;
+                        lng?: number;
+                        /** @enum {string} */
+                        source?: "manual" | "auto";
+                        notes?: string;
+                        budgetItemId?: number | null;
+                        /**
+                         * Format: date-time
+                         * @description When the tech actually arrived. The server clamps it.
+                         */
+                        occurredAt?: string;
+                        accuracyM?: number | null;
+                        /** @enum {string|null} */
+                        device?: "ios" | "web" | "android" | null;
+                    };
+                };
+            };
+            responses: {
+                /** @description Entry opened. */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TimeEntry"];
+                    };
+                };
+                /** @description Validation failure, or jobId missing on a job clock-in. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Job not in this organization, or the office fence is not set. */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Already clocked in at this site (code ALREADY_CLOCKED_IN_SAME_JOB). The body carries the existing entry — adopt it. */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            message: string;
+                            code: string;
+                            entry: components["schemas"]["TimeEntry"];
+                        };
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/clock-out": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Clock out of a job or the office by hand. */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                    /** @description Send `1` to declare this client can decode an entry or fence with a null jobId (the office as a site). Older builds decode jobId as a required number, so office rows are withheld from them. */
+                    "X-Sites"?: string;
+                    /** @description Send `1` to declare this client understands work days. The first request carrying it moves the caller onto the day model permanently (users.time_clock_day_model_since); from then on their fence arrivals only open entries inside an open day. */
+                    "X-Day-Clock"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        jobId?: number | null;
+                        /** @enum {string} */
+                        siteType?: "job" | "office";
+                        /** @description Requires time_tracking.edit_all. */
+                        userId?: string;
+                        lat?: number;
+                        lng?: number;
+                        /** @enum {string} */
+                        source?: "manual" | "auto";
+                        notes?: string;
+                        /**
+                         * Format: date-time
+                         * @description When the tech actually left. Clamped to [entry.clockIn, now].
+                         */
+                        occurredAt?: string;
+                        accuracyM?: number | null;
+                        /** @enum {string|null} */
+                        device?: "ios" | "web" | "android" | null;
+                    };
+                };
+            };
+            responses: {
+                /** @description Entry closed. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TimeEntry"];
+                    };
+                };
+                /** @description Validation failure. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description No open entry at that site. */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/switch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Move my clock to another job in one atomic call.
+         * @description Closes the caller's open entry and opens one on the target. One request instead of clock-out + clock-in, so an offline drop between the two cannot strand the tech clocked out. Own entry only.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        targetJobId: number;
+                        /**
+                         * Format: date-time
+                         * @description Pull the start back to when they actually moved. Must be after the current clock-in and no more than a minute in the future.
+                         */
+                        switchAt?: string;
+                        lat?: number;
+                        lng?: number;
+                    };
+                };
+            };
+            responses: {
+                /** @description Switched. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            closed: components["schemas"]["TimeEntry"];
+                            opened: components["schemas"]["TimeEntry"];
+                            targetEligible: boolean;
+                        };
+                    };
+                };
+                /** @description No active clock-in, already on that job, or an out-of-range switch time. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Target job not in this organization. */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/entries/{id}/retarget": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Move an open automatic entry to a co-located job ('which unit?').
+         * @description The target's fence must overlap the entry's — same address. Anything further is a job reassignment and belongs on the web. Open, automatic, own entries only.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                };
+                path: {
+                    id: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        jobId: number;
+                    };
+                };
+            };
+            responses: {
+                /** @description Entry moved. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TimeEntry"];
+                    };
+                };
+                /** @description Not open, not automatic, office time, or the target is not at this address. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Entry or target job not found. */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/entries/{id}/location": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * The fresh fix taken AFTER a manual clock press, so the button never waits on GPS.
+         * @description Manual entries only, own entry (or edit_all), within ten minutes of the press.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                };
+                path: {
+                    id: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        kind: "in" | "out";
+                        lat: number;
+                        lng: number;
+                        accuracyM?: number | null;
+                        /** @enum {string|null} */
+                        device?: "ios" | "web" | "android" | null;
+                    };
+                };
+            };
+            responses: {
+                /** @description Recorded. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @enum {boolean} */
+                            ok: true;
+                        };
+                    };
+                };
+                /** @description Not kept — no signed location consent. */
+                202: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @enum {boolean} */
+                            ok: false;
+                            reason: string;
+                        };
+                    };
+                };
+                /** @description Not a manual entry, not clocked out yet, or too late. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Entry not found. */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/pings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * The location trail while my day is open.
+         * @description Nothing is stored outside an open day, without signed consent, or when the org turned the trail off — each returns 202 with a `reason`. Max 200 readings per call.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        pings: {
+                            lat: number;
+                            lng: number;
+                            accuracyM?: number | null;
+                            speedMps?: number | null;
+                            /**
+                             * Format: date-time
+                             * @description When the device took the reading.
+                             */
+                            recordedAt: string;
+                            /** @enum {string} */
+                            source?: "trail" | "day_start" | "day_end";
+                        }[];
+                        /** @enum {string|null} */
+                        device?: "ios" | "web" | "android" | null;
+                    };
+                };
+            };
+            responses: {
+                /** @description Always returned. A non-null `reason` means stop sending until state changes. */
+                202: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TrailPingResponse"];
+                    };
+                };
+                /** @description Validation failure. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/time-tracking/activity-hints": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Job-scoped work I did recently — the input to the 'switch the clock?' prompt.
+         * @description Activity NEVER creates time by itself; it only proposes rerouting time the geofence already justified. Window defaults to 4 hours and is capped at 24.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Clamped to at most 24 hours ago. */
+                    since?: string;
+                };
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description One row per job touched. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            jobId: number;
+                            jobName: string;
+                            /** Format: date-time */
+                            firstAt: string;
+                            /** Format: date-time */
+                            lastAt: string;
+                            count: number;
+                        }[];
+                    };
+                };
+                /** @description Invalid `since`. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Time tracking access denied, or no organization on the session. */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/me/week": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * My published schedule, my hours, and my time-off requests.
+         * @description The clock-in expectation. Published shifts only. Job assignments are deliberately absent — the job calendar is where those live.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Any day inside the wanted week. Defaults to today; the response covers Sunday to Saturday. */
+                    date?: string;
+                };
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The week. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MyWeek"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/me/time-off": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Ask for time off.
+         * @description Goes to a manager. On approval the days are written onto the schedule as published all-day entries and the person is notified.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description Semver of the calling app build. Drives the 426 / soft-upgrade handshake. */
+                    "X-Client-Version"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        kind: "pto" | "off";
+                        /** Format: date */
+                        startDate: string;
+                        /** Format: date */
+                        endDate: string;
+                        note?: string | null;
+                    };
+                };
+            };
+            responses: {
+                /** @description Request queued for review. */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TimeOffRequestSummary"];
+                    };
+                };
+                /** @description Validation failure. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not signed in. */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description A request for those dates is already waiting. */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Client major below minClientVersion. */
+                426: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpgradeRequiredEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -1850,7 +3419,7 @@ export interface components {
         };
         /** @description Cross-platform version handshake manifest. See docs/api-versioning.md. */
         VersionManifest: {
-            /** @example 1.2.409 */
+            /** @example 1.2.411 */
             apiVersion: string;
             /** @example 1.0.0 */
             minClientVersion: string;
@@ -2450,6 +4019,397 @@ export interface components {
         RealtimeWebrtcRequest: {
             sdp: string;
         };
+        /** @description One stretch of time at one site, inside a work day. durationMinutes stays gross; paid time is gross minus breakMinutes. */
+        TimeEntry: {
+            id: number;
+            organizationId: string;
+            userId: string;
+            /** @description Null at the office — see siteType. */
+            jobId: number | null;
+            /** @enum {string} */
+            siteType: "job" | "office";
+            /** @description The work day this entry sits inside, when the caller is on the day model. */
+            workDayId: number | null;
+            budgetItemId: number | null;
+            /** Format: date-time */
+            clockIn: string;
+            /**
+             * Format: date-time
+             * @description Null while the entry is open.
+             */
+            clockOut: string | null;
+            clockInLat: number | null;
+            clockInLng: number | null;
+            clockOutLat: number | null;
+            clockOutLng: number | null;
+            /**
+             * @description 'manual' (a button press) or 'auto' (the resolver).
+             * @example auto
+             */
+            source: string;
+            /** @description Time outside the job's Accepted→Completed window, and all office time: on the timesheet and in payroll, never in the job's labor actuals. */
+            excludedFromBudget: boolean;
+            /** @description GROSS minutes (clock-out minus clock-in). Subtract breakMinutes for paid time. */
+            durationMinutes: number | null;
+            notes: string | null;
+            editedBy: string | null;
+            /** Format: date-time */
+            editedAt: string | null;
+            /** Format: date-time */
+            originalClockIn: string | null;
+            /** Format: date-time */
+            originalClockOut: string | null;
+            /** Format: date-time */
+            staleWarnedAt: string | null;
+            /** @description Unpaid break minutes recorded against this entry. */
+            breakMinutes: number;
+            /** Format: date-time */
+            createdAt: string | null;
+            /** @description Enrichment on /active and /entries. 'Office' for an office entry. */
+            jobName?: string;
+            /** @description Enrichment on /entries and /active?scope=team. */
+            userName?: string;
+        };
+        /** @description Where a day's minutes went (shared/workDays.ts splitDayMinutes). */
+        WorkDayMinutes: {
+            /** @description Gross minutes on the day; an open day is measured to now. */
+            total: number;
+            /** @description total minus unpaid breaks. */
+            paid: number;
+            office: number;
+            jobs: number;
+            /** @description paid minus office minus jobs — time between sites, shown rather than hidden. */
+            drive: number;
+            breaks: number;
+        };
+        /** @description The master clock. One per person per day; the day itself is the payroll number. */
+        WorkDay: {
+            id: number;
+            userId: string;
+            /** Format: date-time */
+            clockIn: string;
+            /**
+             * Format: date-time
+             * @description Null while the day is running.
+             */
+            clockOut: string | null;
+            /**
+             * @description 'tech' (the button), 'admin', or 'job_clock_in'.
+             * @example tech
+             */
+            openedBy: string;
+            /** @description 'tech', 'admin', or 'auto' (the stale safety net). */
+            closedBy: string | null;
+            /** @enum {string} */
+            clockInSite: "office" | "job" | "away" | "unknown";
+            /**
+             * @description An away-from-office start waits for an admin unless the org auto-approves a start inside an assigned job.
+             * @enum {string}
+             */
+            clockInReview: "not_needed" | "pending" | "approved" | "rejected";
+            reviewedBy: string | null;
+            /** Format: date-time */
+            reviewedAt: string | null;
+            reviewNote: string | null;
+            /** @description The fix taken at the Clock In tap. Null when the tap had no usable position. */
+            snapshot: {
+                lat: number;
+                lng: number;
+                accuracyM: number | null;
+                device: string | null;
+                distanceToOfficeM: number | null;
+                nearestJobId: number | null;
+                nearestJobDistanceM: number | null;
+                /** @description Reverse-geocoded after the tap, best effort. */
+                address: string | null;
+                nearestJob?: unknown;
+            } | null;
+            notes: string | null;
+            editedBy: string | null;
+            /** Format: date-time */
+            editedAt: string | null;
+            /** Format: date-time */
+            originalClockIn: string | null;
+            /** Format: date-time */
+            originalClockOut: string | null;
+            minutes: components["schemas"]["WorkDayMinutes"];
+            entryIds: number[];
+            /** @description Every admin edit to this day (time_edit_log). */
+            edits: {
+                id: number;
+                editedBy: string | null;
+                /** Format: date-time */
+                editedAt: string;
+                /** @description { field: { from, to } } */
+                changes?: unknown;
+                /** @description Required — a changed timesheet always says why. */
+                note: string;
+            }[];
+        };
+        /** @description The location gate (shared/locationConsent.ts). Without a signed consent the clock still runs by hand — only location stops. */
+        LocationConsentSummary: {
+            required: boolean;
+            /** @description May this client use location for the clock right now? False → report no crossings, pings or fixes. */
+            locationAllowed: boolean;
+            needsSignature: boolean;
+            version: string;
+        };
+        /** @description Everything the phone needs to draw the day card and decide what it may record. */
+        MyDayResponse: {
+            /** @description True once this person is on the day model. */
+            dayModel: boolean;
+            open: components["schemas"]["WorkDay"] & (Record<string, never> | null);
+            today: components["schemas"]["WorkDay"][];
+            /** @example America/New_York */
+            timeZone: string;
+            /** @description Set when the published work shift already ended and the day is still running — the 'Still working?' prompt. */
+            shiftEnd: {
+                /** @example 17:00 */
+                endTime: string;
+                minutesAgo: number;
+            } | null;
+            locationConsent: components["schemas"]["LocationConsentSummary"];
+            locationTrail: boolean;
+            /** @description The office fence, when the org profile address is on the map. */
+            office: {
+                lat: number;
+                lng: number;
+                radiusM: number;
+                address: string | null;
+            } | null;
+        };
+        /** @description The day after the tap. */
+        DayClockResponse: {
+            day: components["schemas"]["WorkDay"] & (Record<string, never> | null);
+        };
+        /** @description One fence to watch. iOS can register at most 20 regions, so watch the nearest 20 and re-pick as the device travels. */
+        Geofence: {
+            /** @description Null for the office fence (siteType 'office'). */
+            jobId: number | null;
+            /** @enum {string} */
+            siteType: "job" | "office";
+            jobName: string;
+            jobNumber: string | null;
+            lat: number;
+            lng: number;
+            /** @description The TRIGGER circle to hand CoreLocation. Deliberately large. */
+            radius: number;
+            /** @description The SITE circle the server verifies against. Small. Use it only to tell co-located fences apart, never to decide the clock. */
+            siteRadius: number;
+            location: string | null;
+            eligible: boolean;
+            eligibilityReason: string;
+            stagePriority: number | null;
+            /** Format: date-time */
+            stageChangedAt: string | null;
+        };
+        /** @description One fence crossing as the device saw it. */
+        ClockCrossing: {
+            /** @description Client-generated UUID. Re-delivery is a no-op (unique index), so retry freely. */
+            clientEventId: string;
+            jobId?: number | null;
+            /**
+             * @description Defaults to 'office' when jobId is null, else 'job'.
+             * @enum {string}
+             */
+            siteType?: "job" | "office";
+            /**
+             * @description enter / exit / present are fence events. 'sample' is a location fix taken during a dwell window — presence evidence the resolver weighs against the fence, never an event on its own.
+             * @enum {string}
+             */
+            kind: "enter" | "exit" | "present" | "sample";
+            /** Format: date-time */
+            occurredAt: string;
+            lat?: number | null;
+            lng?: number | null;
+            accuracyM?: number | null;
+            /** @enum {string|null} */
+            device?: "ios" | "web" | "android" | null;
+            /** @description The user's auto-clock toggle at crossing time. False → the crossing is logged but never acted on. */
+            autoClockEnabled?: boolean;
+        };
+        /** @description Always 202. The clock state to trust is `openEntries`, not the client's own guess. */
+        CrossingsAck: {
+            accepted: number;
+            duplicates: number;
+            /** @description Present when nothing was stored — see `reason`. */
+            dropped?: number;
+            /**
+             * @description Why the batch was dropped. On 'no_consent' the client should clear its queue rather than retry.
+             * @example no_consent
+             */
+            reason?: string | null;
+            /** @description Result of the inline resolver kick. Null means it did not finish inside the deadline — the crossings ARE stored and the background tick will resolve them. Not an error; do not retry. */
+            resolver: {
+                applied: number;
+                clockedIn: number;
+                clockedOut: number;
+                pending: number;
+            } | null;
+            resolverError: string | null;
+            resolverSkip: string | null;
+            /** @description The caller's open entries after resolution — the authoritative clock state. */
+            openEntries: components["schemas"]["TimeEntry"][];
+        };
+        /** @description What this org's clock does (shared/timeClockSettings.ts). Several keys are platform-owned and read at fixed values regardless of any stored override. */
+        ClockConfig: {
+            serverResolver: boolean;
+            /**
+             * @description How long a device must stay on one side of a fence before it counts. A choice from a fixed set of steps, not a free number: a tech driving past a job must not be clocked in, and one walking in must not wait. An older org may still have a free value stored; the server snaps it to the nearest step, so read this value rather than assuming what was configured.
+             * @enum {integer}
+             */
+            dwellSeconds: 30 | 60 | 100 | 120;
+            staleShiftHours: number;
+            autoCloseHours: number;
+            presenceCheck: boolean;
+            /**
+             * @description What the phone does during a dwell. 'balanced' = cheap positioning, GPS only for the last ~30s. The battery lever an admin can pull without an app update — re-read this every few minutes.
+             * @enum {string}
+             */
+            presenceSampling: "precise" | "balanced" | "off";
+            switchOnArrival: boolean;
+            impliedDeparture: boolean;
+            heartbeat: boolean;
+            siteRadiusM: number;
+            /** @enum {string} */
+            masterClock: "auto" | "on" | "off";
+            awayClockInAutoApproveOnJob: boolean;
+            lateGraceMinutes: number;
+            shiftEndReminderMinutes: number;
+            /** @description The master switch. Off → no fences, no automatic clock, no readings, no trail; people clock in by hand. */
+            locationTracking: boolean;
+            locationConsentRequired: boolean;
+            locationTrail: boolean;
+            locationTrailRetentionDays: number;
+            afterHours: {
+                /** @example 17:00 */
+                start: string;
+                /** @example 08:00 */
+                end: string;
+                weekends: boolean;
+            };
+            limits: {
+                [key: string]: {
+                    min: number;
+                    max: number;
+                };
+            };
+            /** @description True only for the primary account. */
+            canEdit: boolean;
+        };
+        /** @description Always 202. */
+        TrailPingResponse: {
+            accepted: number;
+            dropped: number;
+            /** @description 'no_open_day' | 'no_consent' | 'trail_off' | null. Any non-null reason means stop sending until state changes. */
+            reason: string | null;
+        };
+        /** @description One person, one day: working, on call, off, or PTO. Job assignments are NOT part of this schedule. */
+        EmployeeShift: {
+            id: number;
+            organizationId: string;
+            userId: string;
+            /**
+             * Format: date
+             * @example 2026-09-16
+             */
+            shiftDate: string;
+            /**
+             * @description 'HH:MM' local. Null = all day, and always null for 'off' and 'pto'.
+             * @example 08:00
+             */
+            startTime: string | null;
+            /**
+             * @description An end at or before the start means the shift runs overnight into the next day.
+             * @example 17:00
+             */
+            endTime: string | null;
+            /**
+             * @description 'on_call' never sets a clock-in deadline — on call means reachable, not at work.
+             * @enum {string}
+             */
+            kind: "work" | "on_call" | "off" | "pto";
+            note: string | null;
+            /**
+             * Format: date-time
+             * @description Null = DRAFT. /api/me/week only ever returns published rows.
+             */
+            publishedAt: string | null;
+            createdBy: string | null;
+            /** Format: date-time */
+            createdAt: string | null;
+            /** Format: date-time */
+            updatedAt: string | null;
+        };
+        /** @description A time-off ask. Approval writes published all-day shifts onto the schedule for every date in the range. */
+        TimeOffRequestSummary: {
+            id: number;
+            userId: string;
+            /** @enum {string} */
+            status: "pending" | "approved" | "rejected";
+            /** @enum {string} */
+            kind: "pto" | "off";
+            /** Format: date */
+            startDate: string;
+            /** Format: date */
+            endDate: string;
+            note: string | null;
+            /** Format: date-time */
+            createdAt: string | null;
+            reviewNote: string | null;
+            /** Format: date-time */
+            reviewedAt: string | null;
+        };
+        /** @description When I should be in, plus what I actually worked. The clock-in expectation lives here. */
+        MyWeek: {
+            /**
+             * Format: date
+             * @description Sunday of the week containing the anchor date.
+             */
+            from: string;
+            /** Format: date */
+            to: string;
+            /**
+             * Format: date
+             * @description The org-local date, which is not necessarily the device's.
+             */
+            today: string;
+            /** @description Keyed by org-local ISO date. */
+            hours: {
+                [key: string]: {
+                    paid: number;
+                    office: number;
+                    jobs: number;
+                    drive: number;
+                    breaks: number;
+                    /** @description True when the numbers come from work days; false when they were added up from entries. */
+                    fromDays: boolean;
+                    /** @description 'pending' | 'rejected' when that day's clock-in is under review. */
+                    review?: string;
+                };
+            };
+            attendance: {
+                /**
+                 * @description An exempt person is never called late or missing.
+                 * @enum {string}
+                 */
+                mode: "tracked" | "exempt";
+                lateGraceMinutes: number;
+                dayModel: boolean;
+                /** @description Whether a published work / on-call shift covers this minute, yesterday's overnight shifts included. Drives the missed clock-in prompt. */
+                coveredNow: {
+                    work: boolean;
+                    onCall: boolean;
+                };
+                locationConsent: components["schemas"]["LocationConsentSummary"];
+            };
+            /** @description Published rows only — a draft the person has never seen can't make them late. */
+            shifts: components["schemas"]["EmployeeShift"][];
+            /** @description Every pending request, not only this week's. */
+            timeOff: components["schemas"]["TimeOffRequestSummary"][];
+            /** @description The last few decided ones, newest first. */
+            recentTimeOff: components["schemas"]["TimeOffRequestSummary"][];
+        };
     };
     responses: never;
     parameters: never;