@insurance-broker/api-client 1.24.0 → 1.26.0

package/dist/schema.d.ts

@@ -993,6 +993,8 @@ export interface paths {
          * @description CLM-005. A note your own staff can see. **The customer never sees it.**
          *
          *     Internal notes and the customer's timeline are two different tables, so a note is not hidden from the customer by a filter - there is no route by which a customer can reach one at all (ADR-0041 section 3). To tell the customer what a note says, publish it: that copies its words onto the timeline as a new, attributed entry.
+         *
+         *     **A claim that has closed or been withdrawn takes no further note.** Closing a claim starts the disposal clock on everything filed against it, so a note written afterwards would have no clock at all (ADR-0041 section 8).
          */
         post: operations["WriteClaimNote"];
         delete?: never;
@@ -1041,6 +1043,8 @@ export interface paths {
          * @description CLM-006. Adds an entry to the customer's timeline directly, without an internal note behind it - which is the ordinary case, because most of what a broker tells a customer was never a note.
          *
          *     The timeline is append-only: there is no route that edits or removes an entry. A broker who told a customer something wrong tells them again, and the record keeps both.
+         *
+         *     **A claim that has closed or been withdrawn takes no further entry**, for the reason a note does: its disposal clock has already started (ADR-0041 section 8).
          */
         post: operations["RecordClaimTimelineEntry"];
         delete?: never;
@@ -1049,6 +1053,150 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/claims/{id}/evidence": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What has been filed against a claim
+         * @description CLM-004. Every file filed against the claim, oldest first, with its scan verdict.
+         *
+         *     **A row here is not a file that can be served.** The verdict is what decides that, and only `Clean` is downloadable — so a client renders the others as being checked, refused or unreadable rather than offering a link that will answer 409.
+         *
+         *     There is no paging. A claim's evidence is a handful of files by nature, and the route that would need one is phase 10's reporting rather than this.
+         */
+        get: operations["ListClaimEvidence"];
+        put?: never;
+        /**
+         * File a file against a claim
+         * @description CLM-004. Stores one file against a claim — a photograph, a police abstract, an assessor's report, an estimate for repairs.
+         *
+         *     **The file is quarantined the moment it is stored and only a malware scan moves it**, so a client that has just uploaded should say the file is being checked rather than that it is ready. Nothing but a `Clean` verdict is ever served back.
+         *
+         *     **The type is taken from the file's own bytes, never from the part header.** A part declaring one thing and holding another is refused rather than believed.
+         *
+         *     **Closing the claim starts this file's retention clock**, along with the claim's own and everything else filed against it (ADR-0041 section 8).
+         */
+        post: operations["UploadClaimEvidence"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/claims/{id}/evidence/{evidenceId}/content": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Streams a claim's evidence back, if the malware scan cleared it
+         * @description CLM-004. Returns the stored bytes as an attachment.
+         *
+         *     **Only a `Clean` verdict is served.** A file still being scanned, one the scanner rejected and one it could form no opinion about are three different 409s with three different problem `type`s, because the next thing to do differs: wait, or file a replacement, or file a replacement and never expect this one.
+         *
+         *     **The file's integrity is re-verified as it streams**, so a transfer that does not complete is a file that no longer matches what was uploaded rather than a network fault.
+         *
+         *     There is no shareable link. Sending evidence to an insurer is a separate act with its own record (ADR-0041 section 8).
+         */
+        get: operations["DownloadClaimEvidence"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/claims/{id}/insurer-submissions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read what has been sent to the insurer, and what they said
+         * @description CLM-004, CLM-008. Every time this claim was put to its insurer, oldest first, each with the reference that came back and what the insurer has said about it.
+         *
+         *     **Each outcome says who recorded it.** This platform does not decide claims - acceptance and settlement are the insurer's (CLM-008) - so an outcome here is a record of what somebody was told, carrying the day the insurer said it, how it arrived, and the person who wrote it down. The claim's own `status` says what the broker is doing and never what the insurer decided.
+         */
+        get: operations["ListClaimInsurerSubmissions"];
+        put?: never;
+        /**
+         * Record that a claim was put to its insurer
+         * @description CLM-004. Records that this claim was sent to the insurer, and when.
+         *
+         *     **The insurer is not a field.** It is the insurer the cover was placed with, taken from the policy snapshot written when the claim was opened - so it says what the cover said on the day of the incident, whatever has happened to the policy since.
+         *
+         *     **A claim may be submitted more than once.** A first approach declined and a second made after new evidence are two records, each with its own date, its own reference and its own outcomes. Nothing here is a status on the claim: whether a claim has been submitted is answered by these rows existing (ADR-0041 section 5).
+         *
+         *     The reference comes back afterwards and is recorded by its own route.
+         */
+        post: operations["RecordClaimInsurerSubmission"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/claims/{id}/insurer-submissions/{submissionId}/reference": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Record the reference the insurer gave the claim
+         * @description CLM-004. The insurer's own reference for the claim, exactly as they gave it.
+         *
+         *     **This one may be corrected**, which is the exception on a claim rather than the rule. A scan verdict, a claim form and a timeline entry are conclusions somebody drew at an instant, and rewriting one would erase that somebody. A reference is a label an insurer issued and a person transcribed, so a corrected transcription makes the record truer. Who changed it and when is in the audit trail.
+         *
+         *     A blank reference is refused rather than treated as clearing one.
+         */
+        put: operations["RecordClaimInsurerReference"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/claims/{id}/insurer-submissions/{submissionId}/outcomes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Record what the insurer said
+         * @description CLM-004, CLM-008. Writes down what the insurer decided about this submission.
+         *
+         *     **This platform does not decide claims and this route does not pretend otherwise.** Acceptance and settlement are the insurer's (CLM-008), so what is stored is a record of what somebody was told: the value, the day the insurer said it, how their answer arrived, and the person who wrote it down. **The claim's status is not touched** - it says what the broker is doing, and a claim never becomes 'declined' (ADR-0041 section 2).
+         *
+         *     **Nothing automatic can write one.** There is no consumer, no sweep and no state machine that records an outcome; a person does, and the row names them.
+         *
+         *     `Accepted` leaves the insurer still owing a settlement, so a later outcome may follow it. `Declined` and `Settled` conclude the submission, and a second concluding answer is refused with 409 - an insurer that reverses itself has been approached again, which is a second submission. The same outcome recorded twice is refused for the same reason.
+         *
+         *     The insurer cannot have decided before the claim was put to them, or on a day that has not happened.
+         */
+        post: operations["RecordClaimInsurerOutcome"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/customer/claims": {
         parameters: {
             query?: never;
@@ -1123,6 +1271,30 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/customer/claims/{id}/insurer-outcomes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read what your insurer has said about your claim
+         * @description CLM-006, CLM-008. What the insurer has decided about your claim, oldest decision first.
+         *
+         *     **These are the insurer's decisions and not your broker's.** Acceptance and settlement are decided by the insurer; your broker records what they were told. So each entry says the day the insurer decided it, how their answer reached your broker, and the day your broker wrote it down - and your claim's own status says what your broker is doing about it, never what the insurer concluded.
+         *
+         *     It does not say which member of staff wrote it down, for the same reason your timeline does not.
+         */
+        get: operations["GetOwnClaimInsurerOutcomes"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/claims/emergency-contacts": {
         parameters: {
             query?: never;
@@ -3145,6 +3317,28 @@ export interface components {
             items: components["schemas"]["ProductResponse"][];
             nextCursor: null | string;
         };
+        ClaimEvidenceResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            claimId: string;
+            fileName: string;
+            contentType: string;
+            /** Format: int64 */
+            sizeBytes: number | string;
+            contentSha256: string;
+            /** Format: date-time */
+            uploadedAtUtc: string;
+            uploadedBySubjectId: string;
+            scanVerdict: string;
+            /** Format: date-time */
+            scannedAtUtc: null | string;
+            /** Format: date-time */
+            retentionAnchorAtUtc: null | string;
+        };
+        ClaimEvidenceUpload: {
+            file: components["schemas"]["IFormFile"];
+        };
         ClaimNoteResponse: {
             /** Format: uuid */
             id: string;
@@ -3260,6 +3454,19 @@ export interface components {
             name: null | string;
             registrationNumber: null | string;
         };
+        CustomerInsurerOutcomeResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            claimId: string;
+            /** Format: uuid */
+            insurerId: string;
+            outcome: string;
+            /** Format: date */
+            decidedOn: string;
+            /** Format: date-time */
+            recordedAtUtc: string;
+        };
         CustomerInvitationResponse: {
             /** Format: uuid */
             id: string;
@@ -3607,6 +3814,22 @@ export interface components {
             /** Format: date-time */
             updatedAtUtc: string;
         };
+        InsurerOutcomeResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            submissionId: string;
+            /** Format: uuid */
+            claimId: string;
+            outcome: string;
+            /** Format: date */
+            decidedOn: string;
+            receivedVia: string;
+            recordedBySubjectId: string;
+            /** Format: date-time */
+            recordedAtUtc: string;
+            isConcluding: boolean;
+        };
         InsurerQuoteRequestResponse: {
             /** Format: uuid */
             id: string;
@@ -3668,6 +3891,21 @@ export interface components {
             /** Format: date-time */
             updatedAtUtc: string;
         };
+        InsurerSubmissionResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            claimId: string;
+            /** Format: uuid */
+            insurerId: string;
+            /** Format: date */
+            submittedOn: string;
+            reference: null | string;
+            /** Format: date-time */
+            recordedAtUtc: string;
+            submittedBySubjectId: string;
+            outcomes: components["schemas"]["InsurerOutcomeResponse"][];
+        };
         IntegrationCredentialResponse: {
             /** Format: uuid */
             id: string;
@@ -4200,6 +4438,19 @@ export interface components {
             /** Format: date */
             confirmedOn: null | string;
         };
+        RecordInsurerOutcomeRequest: {
+            outcome: string;
+            /** Format: date */
+            decidedOn: string;
+            receivedVia: string;
+        };
+        RecordInsurerReferenceRequest: {
+            reference: string;
+        };
+        RecordInsurerSubmissionRequest: {
+            /** Format: date */
+            submittedOn: string;
+        };
         RecordRenewalCustomerInformationRequest: {
             /** Format: uuid */
             formSubmissionId: null | string;
@@ -7237,6 +7488,15 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
         };
     };
     PublishClaimNote: {
@@ -7347,42 +7607,18 @@ export interface operations {
                 };
                 content?: never;
             };
-        };
-    };
-    ReportOwnClaim: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["ReportClaimRequest"];
-            };
-        };
-        responses: {
-            /** @description Created */
-            201: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ClaimResponse"];
-                };
-            };
-            /** @description Bad Request */
-            400: {
+            /** @description Conflict */
+            409: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
                 };
             };
         };
     };
-    GetOwnClaimTimeline: {
+    ListClaimEvidence: {
         parameters: {
             query?: never;
             header?: never;
@@ -7399,7 +7635,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ClaimTimelineEntryResponse"][];
+                    "application/json": components["schemas"]["ClaimEvidenceResponse"][];
                 };
             };
             /** @description Not Found */
@@ -7411,24 +7647,398 @@ export interface operations {
             };
         };
     };
-    GetOwnClaim: {
+    UploadClaimEvidence: {
         parameters: {
             query?: never;
-            header?: never;
+            header?: {
+                "X-Document-Sha256"?: string;
+            };
             path: {
                 id: string;
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "multipart/form-data": components["schemas"]["ClaimEvidenceUpload"];
+            };
+        };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ClaimResponse"];
+                    "application/json": components["schemas"]["ClaimEvidenceResponse"];
+                };
+            };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+            /** @description Payload Too Large */
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
+    DownloadClaimEvidence: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                evidenceId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
+    ListClaimInsurerSubmissions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InsurerSubmissionResponse"][];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    RecordClaimInsurerSubmission: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RecordInsurerSubmissionRequest"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InsurerSubmissionResponse"];
+                };
+            };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
+    RecordClaimInsurerReference: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                submissionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RecordInsurerReferenceRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InsurerSubmissionResponse"];
+                };
+            };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
+    RecordClaimInsurerOutcome: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                submissionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RecordInsurerOutcomeRequest"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InsurerOutcomeResponse"];
+                };
+            };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
+    ReportOwnClaim: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ReportClaimRequest"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimResponse"];
+                };
+            };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
+                };
+            };
+        };
+    };
+    GetOwnClaimTimeline: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimTimelineEntryResponse"][];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    GetOwnClaim: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimResponse"];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    GetOwnClaimInsurerOutcomes: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerInsurerOutcomeResponse"][];
                 };
             };
             /** @description Not Found */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@insurance-broker/api-client",
-  "version": "1.24.0",
+  "version": "1.26.0",
   "description": "Generated TypeScript client for the Insurance Broker Platform API. Do not edit by hand: regenerate with scripts/update-api-contract.",
   "license": "UNLICENSED",
   "private": false,