@pam-ai/pam-ordo-contracts 3.27.0 → 3.29.0

package/dist/generated.d.ts

@@ -178,6 +178,30 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/inbox/conversations/{conversationId}/interactions/{interactionId}/attachments/{attachmentId}/url": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Mint a short-lived URL for one attachment's bytes
+         * @description Exchange an attachment identifier for a URL a browser can fetch.
+         *     WHY THIS IS NOT ON THE INTERACTION READ. A Conversation's detail read returns every Interaction it has, and hydrates bodies under a budget it can exhaust. Minting a storage credential for every attachment on every one of those reads would spend that budget on media nobody scrolls to, and would put an expiring secret inside a response a client is entitled to hold. So the attachment travels with the Interaction and the credential is asked for separately, once, by a reader that is about to show it.
+         *     ADDRESSED THROUGH ITS CONVERSATION because that is what authorizes it. The same visibility rule as the Conversation detail read applies: a reader who cannot see the Conversation cannot mint a URL for anything inside it, and the attachment identifier alone is not a grant.
+         *     NOT A REDIRECT TO THE BYTES. It returns the URL as data so a client can see the expiry, decide whether to re-read, and fetch on its own terms — rather than following a redirect it cannot inspect from an `img` tag.
+         *     EXPECT TO CALL IT AGAIN. The URL lapses; the attachment does not. A client that has held one past `expiresAt`, or that is refused by the storage host, re-reads here rather than reporting a failure.
+         */
+        get: operations["getInboxInteractionAttachmentUrl"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/inbox/contacts": {
         parameters: {
             query?: never;
@@ -1131,6 +1155,42 @@ export interface components {
             /** @description Concrete eligible Users, deduplicated across every requested target. */
             users: components["schemas"]["InboxTargetResolutionUserV1"][];
         };
+        /** @description A source-qualified staff identity. The external ID is meaningful only inside the named source system and provider; it is never a PAM User ID and must not be resolved through a display name. */
+        SourceUserIdentityV1: {
+            sourceSystem: string;
+            sourceProvider: string;
+            externalUserId: string;
+        };
+        /**
+         * @description resolved identifies one currently eligible rooftop User. unmapped means no active binding exists. ineligible means the binding exists but its User is inactive, outside the rooftop, or lacks the required Inbox capabilities. ambiguous is a fail-closed integrity result for multiple active bindings. Authority outages fail the request instead of being misreported as an identity result.
+         * @enum {string}
+         */
+        SourceUserResolutionStatusV1: "resolved" | "unmapped" | "ineligible" | "ambiguous";
+        SourceUserResolutionResultV1: {
+            identity: components["schemas"]["SourceUserIdentityV1"];
+            /** @constant */
+            status: "resolved";
+            userId: string;
+        } | {
+            identity: components["schemas"]["SourceUserIdentityV1"];
+            /** @enum {string} */
+            status: "unmapped" | "ineligible" | "ambiguous";
+            userId: null;
+        };
+        SourceUserResolutionRequestV1: {
+            /** @constant */
+            schemaVersion: 1;
+            clientOrgId: string;
+            identities: components["schemas"]["SourceUserIdentityV1"][];
+        };
+        SourceUserResolutionResponseV1: {
+            /** @constant */
+            schemaVersion: 1;
+            clientOrgId: string;
+            results: components["schemas"]["SourceUserResolutionResultV1"][];
+            /** @description Concrete eligible Users, deduplicated across every requested source identity. */
+            users: components["schemas"]["InboxTargetResolutionUserV1"][];
+        };
         /** @description Read-time state specific to the authenticated viewer. */
         ViewerState: {
             unreadCount: number;
@@ -1364,8 +1424,52 @@ export interface components {
             /** Format: date-time */
             occurredAt: string;
             body?: components["schemas"]["HydratedText"] | null;
+            /**
+             * @description Media carried by this Interaction — the photo of the damage, the insurance document, the voice note. Before this field an Interaction could say what was written and never that anything was attached, so a reader saw an empty bubble where a Customer had sent a picture.
+             *     ABSENT AND EMPTY MEAN THE SAME THING and a consumer must not distinguish them. Optional only to keep this addition a minor version; a producer that predates DASH-342 simply omits it.
+             *     AN UNATTACHED INTERACTION IS THE ORDINARY CASE. Most SMS carries no media, and every call, RO event and internal comment carries none by construction, so an empty list is not a hydration gap. A gap is reported the way every other one is, on the attachment's own `availability`.
+             *     CARRIES NO URL, deliberately. Minting a fetch credential for every attachment on every read spends the hydration budget on media nobody scrolls to, and bakes an expiry into a response a client may cache. A reader asks for one attachment's URL when it is about to show that attachment.
+             */
+            attachments?: components["schemas"]["InteractionAttachmentV1"][];
+            availability: components["schemas"]["Availability"];
+        };
+        /**
+         * @description One piece of media on an Interaction, described well enough to render a card for it without fetching a byte.
+         *     THE KIND IS PUBLISHED RATHER THAN DERIVED. A consumer that classifies media by testing whether its content type starts with `image/` shows a download chip for a photograph the moment a provider omits the type or sends `application/octet-stream`, which it does routinely. The system that mastered the record knows the filename and the source as well as the declared type, so it decides once, here, and every consumer agrees.
+         */
+        InteractionAttachmentV1: {
+            /**
+             * Format: uuid
+             * @description Stable identifier for this attachment, addressable at the attachment-url read. Stable across reads of the same Interaction so a client may cache against it, and opaque, so the storage key it resolves to is never published to a browser.
+             */
+            id: string;
+            /**
+             * @description How to present it. FILE is the honest answer for anything with no inline player — a PDF, a contact card — and also for media whose type could not be determined, which renders as a named file rather than as a broken image.
+             * @enum {string}
+             */
+            kind: "IMAGE" | "VIDEO" | "AUDIO" | "FILE";
+            /** @description The declared MIME type, or null when the source recorded none. That null is why `kind` exists, and `kind` is not derived from this. */
+            contentType?: string | null;
+            /** @description Original filename, when the source recorded one. */
+            fileName?: string | null;
+            /** @description Size in bytes, when the source recorded one. */
+            byteSize?: number | null;
+            /** @description Whether this attachment can currently be fetched. One whose stored object has aged out, or whose metadata predates the storage key, is present and unavailable rather than absent: a reader must be able to say that something was sent and cannot be shown, which is a different thing from nothing having been sent. */
             availability: components["schemas"]["Availability"];
         };
+        /**
+         * @description A short-lived authorized URL for one attachment's bytes.
+         *     DELIBERATELY SHORT-LIVED, AND DELIBERATELY NOT PART OF THE INTERACTION READ. The URL is a credential: whoever holds it can fetch the bytes without passing back through this API. A client reads it when it is about to show the attachment rather than storing it, and treats a rejection from the storage host as "ask again" rather than as an error to show somebody.
+         */
+        InteractionAttachmentUrlV1: {
+            /** @description Fetch the bytes from here. Do not persist it. */
+            url: string;
+            /**
+             * Format: date-time
+             * @description When the URL stops working. Published so a client can re-read before it lapses rather than discovering the expiry as a failed image load.
+             */
+            expiresAt: string;
+        };
         MentionRef: {
             /** Format: uuid */
             id: string;
@@ -1685,6 +1789,8 @@ export interface components {
             senderUserExternalId?: string;
             /** @enum {string} */
             lineType?: "pam" | "rooftop" | "advisor";
+            /** @description Verified recipient advisor User for an inbound Customer SMS to an advisor-owned line. This is not the sender and must be resolved within clientOrgId before routing. */
+            recipientUserExternalId?: string;
             dynamoLocator?: components["schemas"]["ProducerDynamoLocatorV1"];
         };
         ProducerRepairOrderTransitionV1: {
@@ -1701,6 +1807,7 @@ export interface components {
             /** Format: uuid */
             customerId: string;
             advisorUserId?: string | null;
+            advisorIdentity?: components["schemas"]["SourceUserIdentityV1"];
             sourceEventId: string;
             /** Format: date-time */
             sourceOccurredAt: string;
@@ -2340,6 +2447,16 @@ export interface components {
                 "application/json": components["schemas"]["CommandResult"];
             };
         };
+        /** @description A short-lived authorized URL for the attachment's bytes. */
+        InteractionAttachmentUrlIssued: {
+            headers: {
+                "x-correlation-id": components["headers"]["CorrelationId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["InteractionAttachmentUrlV1"];
+            };
+        };
         /** @description Applied or idempotently replayed internal-comment result. */
         InternalCommentApplied: {
             headers: {
@@ -2507,6 +2624,8 @@ export interface components {
         /** @description Authorized rooftop context. For commands this value must match body.clientOrgId; neither value is trusted without DASH-233 resolution. */
         ClientOrgId: string;
         ConversationId: string;
+        InteractionId: string;
+        AttachmentId: string;
         StaffUserId: string;
     };
     requestBodies: {
@@ -2998,6 +3117,32 @@ export interface operations {
             503: components["responses"]["ServiceUnavailable"];
         };
     };
+    getInboxInteractionAttachmentUrl: {
+        parameters: {
+            query?: never;
+            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: {
+                conversationId: components["parameters"]["ConversationId"];
+                interactionId: components["parameters"]["InteractionId"];
+                attachmentId: components["parameters"]["AttachmentId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["InteractionAttachmentUrlIssued"];
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
     searchInboxContacts: {
         parameters: {
             query?: {