@pam-ai/pam-ordo-contracts 3.40.0 → 3.42.0

package/dist/generated.d.ts

@@ -59,6 +59,46 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/inbox/reporting/summary": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Team reporting figures for one window
+         * @description The Reporting page's figures, computed by the service rather than counted off listed rows. Scope is TEAM_INBOX exactly - the same visibility, the same teamId and departments semantics - so a tile can drill into the TEAM_INBOX list it counts and the two agree. live is the queue right now and ignores the window; owners and messages are bounded by the window. include names the sections to compute, so a comparison read of the previous window can ask for messages alone.
+         */
+        get: operations["getInboxReportingSummary"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/inbox/reporting/count-snapshots": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The live queue counts as they stood at an earlier moment
+         * @description Open, overdue and needs-attention counts from the hourly snapshot taken at or before at, no earlier than two hours before it, summed over the same scope /v1/inbox/reporting/summary uses today. Snapshots are kept per owner, so the scope is applied to the people in it now: the comparison is the same people then and now. data is null when no snapshot falls inside that tolerance - before the first capture, after the 31-day retention, or across a missed hour - and a client then shows no comparison rather than a wrong one.
+         */
+        get: operations["getInboxReportingCountSnapshot"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/inbox/realtime-session": {
         parameters: {
             query?: never;
@@ -1498,6 +1538,59 @@ export interface components {
              */
             latestUnrespondedInboundPreview?: string | null;
         };
+        /** @description The three queue counts the Reporting page shows, with the same meaning as the matching InboxCounts fields for TEAM_INBOX in the same scope. */
+        ReportingQueueCounts: {
+            open: number;
+            overdue: number;
+            needsAttention: number;
+        };
+        /** @description Time to a first reply. The first unanswered customer inbound in a Conversation starts the clock and the next customer-facing outbound stops it; the gap is credited to whoever sent that outbound, Pam included. A gap counts in the window its outbound falls in. Gaps over 720 minutes are not replies and are left out. Mean and median travel together because the gap between them is the finding. */
+        ReportingReplyStats: {
+            meanMinutes: number | null;
+            medianMinutes: number | null;
+            sampleCount: number;
+        };
+        /** @description One person's line in the Reporting table. Listed when they own open work in scope now, or sent customer-facing outbound in the window. Queue fields are right now; outbound and reply are the window's. */
+        ReportingOwnerRollup: {
+            userId: string;
+            open: number;
+            overdue: number;
+            needsAttention: number;
+            /** @description The longest-waiting unanswered inbound across their open work, or null. */
+            oldestUnrespondedAt: string | null;
+            /** @description Customer-facing outbound this person sent in the window. */
+            outbound: number;
+            reply: components["schemas"]["ReportingReplyStats"];
+        };
+        /** @description Customer-facing outbound in the window - calls and texts, never internal notes or system interactions - and reply time across everyone who answered. */
+        ReportingMessageMetrics: {
+            outbound: number;
+            outboundByPam: number;
+            reply: components["schemas"]["ReportingReplyStats"];
+        };
+        ReportingSummary: {
+            clientOrgId: string;
+            /** Format: date-time */
+            observedAt: string;
+            /** Format: date-time */
+            from: string;
+            /** Format: date-time */
+            to: string;
+            live?: components["schemas"]["ReportingQueueCounts"];
+            owners?: components["schemas"]["ReportingOwnerRollup"][];
+            messages?: components["schemas"]["ReportingMessageMetrics"];
+        };
+        ReportingSummaryResponse: {
+            data: components["schemas"]["ReportingSummary"];
+        };
+        ReportingCountSnapshot: {
+            /** Format: date-time */
+            capturedAt: string;
+            counts: components["schemas"]["ReportingQueueCounts"];
+        };
+        ReportingCountSnapshotResponse: {
+            data: components["schemas"]["ReportingCountSnapshot"] | null;
+        };
         InboxCounts: {
             total: number;
             open: number;
@@ -1565,6 +1658,35 @@ export interface components {
          * @enum {string}
          */
         CallTerminalOutcomeV1: "answered" | "voicemail" | "missed" | "busy" | "no_answer";
+        /** @description One thing the caller wanted, as classified by post-call analysis (pam-postcall `caller_intent`, the source call logs and reporting already use). `key` is the CALLER_INTENT tag, such as SCHEDULE_SERVICE or SPEAK_TO_HUMAN_IN_PARTS; it is an open string because tags are configured outside this contract, so a consumer must render an unknown key gracefully rather than reject it. */
+        CallerIntentV1: {
+            key: string;
+            /**
+             * @description `transfer` when the caller asked for a person or department (the SPEAK_TO_* keys), otherwise `intent`. A call can carry both; consumers show intents before transfers.
+             * @enum {string}
+             */
+            kind: "intent" | "transfer";
+            /** @description The analysis' main reason for the call. At most one entry is primary. */
+            primary: boolean;
+            /** @description Who the caller asked for, on SPEAK_TO_SPECIFIC_HUMAN. Null or absent when the analysis did not name anyone. */
+            requestedPersonName?: string | null;
+            /** @description The department the caller asked for, on a SPEAK_TO_HUMAN_IN_* transfer. */
+            requestedDepartment?: string | null;
+            /** @description Only on SCHEDULE_SERVICE. True when Pam actually called the service-request tool on this call, false when the analysis observed the call's tools and it did not, null when tool calls were not observed. Never derived from `fulfillment`, which is rewritten to service_appointment_request for rooftops without a service integration. */
+            serviceRequestInvoked?: boolean | null;
+        };
+        /** @description The caller intents recorded for one call. `pending` means post-call analysis has not reported yet, which is different from an analyzed call whose only intent is UNCLEAR_INTENT. A pending entry may carry the call summary's primary intent as a provisional item so a reader is not left blank in the seconds before analysis lands. */
+        CallerIntentsV1: {
+            /** @enum {string} */
+            analysis: "pending" | "analyzed";
+            /**
+             * Format: date-time
+             * @description When the analysis that produced `items` ran. Null while pending.
+             */
+            analyzedAt?: string | null;
+            /** @description Producer order with the primary entry first. */
+            items: components["schemas"]["CallerIntentV1"][];
+        };
         InteractionRef: {
             /** Format: uuid */
             id: string;
@@ -1595,6 +1717,8 @@ export interface components {
              *     Null for Interactions Ordo itself authored — an internal comment has no external record to point at — and for any source that has not recorded one. Distinct from `sourceLocator`, which is a native partition/sort key and is published only when the source addresses records that way; a source can have one, both, or neither.
              */
             sourceRecordId?: string | null;
+            /** @description What the caller wanted on this call, one entry per intent or transfer request (DASH-378). Present only on an inbound `call` or `voicemail`; absent or null on every other Interaction. Optional so this addition is a minor version. */
+            callerIntents?: components["schemas"]["CallerIntentsV1"] | null;
             /**
              * @description Present only on an Interaction of kind `ro_event`. Before this field a repair-order Interaction arrived with kind `ro_event`, a null body and nothing else, so a reader could tell that SOMETHING had happened to a repair order but neither which one nor whether it had opened or closed.
              *     NULL IS POSSIBLE ON AN ro_event, and 3.14.0 wrongly said it was not. There are two reasons for it, and only one of them is historical.
@@ -2116,6 +2240,14 @@ export interface components {
             /** @description Optional same-call current-source assessment. It is omitted when the model abstains; consumers must not derive fresh Attention from cumulative snapshot categories. */
             assessment?: components["schemas"]["ConversationAiAssessmentV1"];
         };
+        /** @description The complete set of caller intents one post-call analysis produced for one call. The consumer replaces the call's previous set when `analyzedAt` is later than the stored one and ignores an equal or earlier analysis, so redelivery and out-of-order delivery cannot restore a stale set. */
+        ProducerCallerIntentsObservedPayloadV1: {
+            /** @description The call, as Ordo already knows it: `pam_call_metadata` and the connection id. The call may not have reached Ordo yet; the consumer keeps the intents until it does. */
+            sourceInteraction: components["schemas"]["ProducerSourceInteractionIdentityV1"];
+            /** Format: date-time */
+            analyzedAt: string;
+            intents: components["schemas"]["CallerIntentV1"][];
+        };
         ProducerReminderFirePayloadV1: {
             /** Format: uuid */
             reminderId: string;
@@ -2203,6 +2335,27 @@ export interface components {
             target: components["schemas"]["ProducerSourceActivityTargetV1"];
             payload: components["schemas"]["ProducerAttentionCategoryObservedPayloadV1"];
         };
+        /** @description Reports the caller intents post-call analysis recorded for one call (DASH-378). Unlike other producer commands it has no target: the producer knows the call, not its Conversation or Customer, and the call's own identity is enough for the consumer to find it. occurredAt is the call's business time. It uses its own FIFO message group per call, so it never delays the call's Conversation. */
+        ProducerCallerIntentsObservedCommandV1: {
+            /** @constant */
+            schemaVersion: 1;
+            operationId: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            commandType: "interaction.caller_intents_observed";
+            clientOrgId: string;
+            traceId: string;
+            /** Format: date-time */
+            occurredAt: string;
+            actor: {
+                /** @constant */
+                type: "source";
+            };
+            source: components["schemas"]["ProducerSourceV1"];
+            payload: components["schemas"]["ProducerCallerIntentsObservedPayloadV1"];
+        };
         ProducerReminderFireCommandV1: {
             /** @constant */
             schemaVersion: 1;
@@ -2267,7 +2420,7 @@ export interface components {
             payload: components["schemas"]["ProducerOverdueFirePayloadV1"];
         };
         /** @description Versioned internal FIFO producer command. Serialized SQS bodies are limited to 64 KiB by producers and consumers even though JSON Schema cannot express a byte-size limit. */
-        ProducerCommandV1: components["schemas"]["ProducerSourceActivityCommandV1"] | components["schemas"]["ProducerAttentionCommandV1"] | components["schemas"]["ProducerAttentionCategoryObservedCommandV1"] | components["schemas"]["ProducerReminderFireCommandV1"] | components["schemas"]["ProducerSnoozeReturnCommandV1"] | components["schemas"]["ProducerOverdueFireCommandV1"];
+        ProducerCommandV1: components["schemas"]["ProducerSourceActivityCommandV1"] | components["schemas"]["ProducerAttentionCommandV1"] | components["schemas"]["ProducerAttentionCategoryObservedCommandV1"] | components["schemas"]["ProducerCallerIntentsObservedCommandV1"] | components["schemas"]["ProducerReminderFireCommandV1"] | components["schemas"]["ProducerSnoozeReturnCommandV1"] | components["schemas"]["ProducerOverdueFireCommandV1"];
         CommandEnvelope: {
             operationId: string;
             clientOrgId: string;
@@ -3069,6 +3222,14 @@ export interface components {
         ConversationId: string;
         InteractionId: string;
         AttachmentId: string;
+        /** @description Window start, inclusive. */
+        ReportingFrom: string;
+        /** @description Window end, exclusive. Must be after from. */
+        ReportingTo: string;
+        /** @description Same meaning as teamId on GET /v1/inbox/conversations - the caller's own Team, never another. */
+        ReportingTeamId: string;
+        /** @description Same meaning as departments on GET /v1/inbox/conversations with scope TEAM_INBOX, including the attribution of unassigned work to BDC. A service manager's page sends SERVICE. */
+        ReportingDepartments: ("SERVICE" | "BDC")[];
         StaffUserId: string;
     };
     requestBodies: {
@@ -3358,6 +3519,79 @@ export interface operations {
             503: components["responses"]["ServiceUnavailable"];
         };
     };
+    getInboxReportingSummary: {
+        parameters: {
+            query: {
+                /** @description Window start, inclusive. */
+                from: components["parameters"]["ReportingFrom"];
+                /** @description Window end, exclusive. Must be after from. */
+                to: components["parameters"]["ReportingTo"];
+                /** @description Same meaning as teamId on GET /v1/inbox/conversations - the caller's own Team, never another. */
+                teamId?: components["parameters"]["ReportingTeamId"];
+                /** @description Same meaning as departments on GET /v1/inbox/conversations with scope TEAM_INBOX, including the attribution of unassigned work to BDC. A service manager's page sends SERVICE. */
+                departments?: components["parameters"]["ReportingDepartments"];
+                /** @description Sections to compute. Absent computes all three. */
+                include?: ("LIVE" | "OWNERS" | "MESSAGES")[];
+            };
+            header: {
+                /** @description Authorized rooftop context. For commands this value must match body.clientOrgId; neither value is trusted without DASH-233 resolution. */
+                "x-client-org-id": components["parameters"]["ClientOrgId"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The requested sections for the window. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ReportingSummaryResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            500: components["responses"]["InternalError"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    getInboxReportingCountSnapshot: {
+        parameters: {
+            query: {
+                at: string;
+                /** @description Same meaning as teamId on GET /v1/inbox/conversations - the caller's own Team, never another. */
+                teamId?: components["parameters"]["ReportingTeamId"];
+                /** @description Same meaning as departments on GET /v1/inbox/conversations with scope TEAM_INBOX, including the attribution of unassigned work to BDC. A service manager's page sends SERVICE. */
+                departments?: components["parameters"]["ReportingDepartments"];
+            };
+            header: {
+                /** @description Authorized rooftop context. For commands this value must match body.clientOrgId; neither value is trusted without DASH-233 resolution. */
+                "x-client-org-id": components["parameters"]["ClientOrgId"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The snapshot nearest at, or null. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ReportingCountSnapshotResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            500: components["responses"]["InternalError"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
     createInboxRealtimeSession: {
         parameters: {
             query?: never;