@insurance-broker/api-client 1.25.0 → 1.27.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;
@@ -1056,7 +1060,15 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: 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
@@ -1101,6 +1113,212 @@ export interface paths {
         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/claims/{id}/outstanding-items": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read what a claim is or was waiting on
+         * @description CLM-005. Everything recorded as outstanding on this claim, newest raised first.
+         *
+         *     `outstanding=true` narrows it to what is still being waited on - the operational question, *what is holding this up* - and `outstanding=false` to what has arrived. Absent, the whole history comes back.
+         *
+         *     Ordered on when an item was **raised** and never on when it was resolved: the list is a history, and ordering on a column that changes moves the boundaries under a reader.
+         *
+         *     **Staff only.** A customer is told what you need from them by being told, on their timeline, in words you chose - not by being handed the working list, which also names everything you owe.
+         */
+        get: operations["ListClaimOutstandingItems"];
+        put?: never;
+        /**
+         * Record that a claim is waiting on something
+         * @description CLM-005. Records what this claim is waiting on, and which side owes it.
+         *
+         *     **This creates a row and never changes the claim's status.** A claim waiting on a customer's photographs is still `Notified`, because the broker is still assisting - which is what that status says (ADR-0041 section 5). A status could not have said *what* is outstanding in any case, which is the other half of why this is a row.
+         *
+         *     **What is outstanding is your own words, not a code from a list.** This platform does not name insurance fields, so there is no vocabulary of permitted items and there will not be one; a broker's own list of the things it asks for is that broker's configuration.
+         *
+         *     **The side is a closed set of two.** `Customer` means the customer owes it and you are waiting on them. `Broker` means you owe it - including when it is your insurer who is waiting. If you in turn need something from the customer to produce it, that is a second item, because it is a different wait with a different person to chase.
+         *
+         *     Refused with 409 once the claim has concluded: nobody is waiting on a claim you have stopped working, and closing starts the disposal clock on everything filed against it.
+         */
+        post: operations["RaiseClaimOutstandingItem"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/claims/{id}/outstanding-items/{itemId}/resolution": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Record that what a claim was waiting on has arrived
+         * @description CLM-005. Marks one outstanding item as received, naming you and the instant.
+         *
+         *     **This is allowed after the claim has concluded**, which is the one place this surface differs from everything else that hangs off a claim. Filing evidence or recording a dealing with an insurer against a closed claim is refused, because both write a row that would carry no disposal clock. This writes no row - it stamps two columns on one that already has a clock - and a police report that arrives in January against a claim closed in December is a fact the record may not be made to deny.
+         *
+         *     A second resolution is refused with 409 naming who dealt with it. Somebody read the item outstanding and decided from it, and overwriting their name would lose the only record of who did the work. Nothing here edits the description or moves the side: correcting a mistake is resolving the wrong item and raising the right one, which is what happened.
+         */
+        post: operations["ResolveClaimOutstandingItem"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/claims/{id}/appointments": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read the visits arranged about a claim
+         * @description CLM-005. Every visit recorded against this claim, soonest first, cancelled ones included and marked as such - a diary is read forwards, and a visit that was called off is part of the account of how the claim went.
+         *
+         *     **Staff only**, for the same reason the outstanding items are.
+         */
+        get: operations["ListClaimAppointments"];
+        put?: never;
+        /**
+         * Record a visit arranged about a claim
+         * @description CLM-005. Records that somebody is expected - an assessor, a repairer, a surveyor - and when.
+         *
+         *     **There is no appointment type and no provider directory, and that is deliberate.** This platform does not name a trade, a service or a provider on behalf of every broker in every country it serves (ADR-0041 section 6). What the visit is for, and who is coming if you want that written down, is `purpose` - your own words.
+         *
+         *     **The time may be in the past**, so last week's visit can be written up on Friday. It is an instant rather than a day, because the time of day is the operative fact about a visit.
+         *
+         *     **Nothing here is a status on the claim.** A claim with an assessor booked is still `Notified`.
+         *
+         *     **There is no reschedule.** Moving a visit is cancelling one and arranging another, which is what actually happened and what a customer told twice experienced; a date that could be edited would leave nothing saying anybody was ever expected on the first day.
+         *
+         *     Refused with 409 once the claim has concluded.
+         */
+        post: operations["ArrangeClaimAppointment"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/claims/{id}/appointments/{appointmentId}/cancellation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Record that a visit was called off
+         * @description CLM-005. Marks one appointment cancelled, naming you and the instant.
+         *
+         *     **Allowed after the claim has concluded**, for the same reason resolving an outstanding item is: it writes no row, and an assessor stood down in January for a claim closed in December is a thing that happened.
+         *
+         *     A second cancellation is refused with 409. There is no reason field - why a visit was called off is a note, and who did it and when is on the row and in the audit trail.
+         */
+        post: operations["CancelClaimAppointment"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/customer/claims": {
         parameters: {
             query?: never;
@@ -1175,6 +1393,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;
@@ -3151,6 +3393,11 @@ export interface components {
             insurerId: null | string;
             channel: null | string;
         };
+        ArrangeClaimAppointmentRequest: {
+            /** Format: date-time */
+            scheduledAtUtc: string;
+            purpose: string;
+        };
         AskAboutQuoteRequest: {
             /** Format: uuid */
             presentationVersionId: null | string;
@@ -3197,6 +3444,22 @@ export interface components {
             items: components["schemas"]["ProductResponse"][];
             nextCursor: null | string;
         };
+        ClaimAppointmentResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            claimId: string;
+            /** Format: date-time */
+            scheduledAtUtc: string;
+            purpose: string;
+            arrangedBySubjectId: string;
+            /** Format: date-time */
+            arrangedAtUtc: string;
+            cancelledBySubjectId: null | string;
+            /** Format: date-time */
+            cancelledAtUtc: null | string;
+            isCancelled: boolean;
+        };
         ClaimEvidenceResponse: {
             /** Format: uuid */
             id: string;
@@ -3231,6 +3494,21 @@ export interface components {
             /** Format: date-time */
             publishedAtUtc: null | string;
         };
+        ClaimOutstandingItemResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            claimId: string;
+            awaitedFrom: string;
+            description: string;
+            raisedBySubjectId: string;
+            /** Format: date-time */
+            raisedAtUtc: string;
+            resolvedBySubjectId: null | string;
+            /** Format: date-time */
+            resolvedAtUtc: null | string;
+            isOutstanding: boolean;
+        };
         ClaimResponse: {
             /** Format: uuid */
             id: string;
@@ -3334,6 +3612,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;
@@ -3681,6 +3972,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;
@@ -3742,6 +4049,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;
@@ -4244,6 +4566,10 @@ export interface components {
             /** Format: date-time */
             declinedAtUtc: null | string;
         };
+        RaiseClaimOutstandingItemRequest: {
+            awaitedFrom: string;
+            description: string;
+        };
         RaiseOutstandingItemRequest: {
             awaitedFrom: null | string;
             description: null | string;
@@ -4274,6 +4600,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;
@@ -7311,6 +7650,15 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
         };
     };
     PublishClaimNote: {
@@ -7421,22 +7769,60 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
         };
     };
-    UploadClaimEvidence: {
+    ListClaimEvidence: {
         parameters: {
             query?: never;
-            header?: {
-                "X-Document-Sha256"?: string;
-            };
+            header?: never;
             path: {
                 id: string;
             };
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "multipart/form-data": components["schemas"]["ClaimEvidenceUpload"];
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimEvidenceResponse"][];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    UploadClaimEvidence: {
+        parameters: {
+            query?: never;
+            header?: {
+                "X-Document-Sha256"?: string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "multipart/form-data": components["schemas"]["ClaimEvidenceUpload"];
             };
         };
         responses: {
@@ -7522,6 +7908,439 @@ export interface operations {
             };
         };
     };
+    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"];
+                };
+            };
+        };
+    };
+    ListClaimOutstandingItems: {
+        parameters: {
+            query?: {
+                outstanding?: boolean;
+            };
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimOutstandingItemResponse"][];
+                };
+            };
+            /** @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;
+            };
+        };
+    };
+    RaiseClaimOutstandingItem: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RaiseClaimOutstandingItemRequest"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimOutstandingItemResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    ResolveClaimOutstandingItem: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                itemId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimOutstandingItemResponse"];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
+    ListClaimAppointments: {
+        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"]["ClaimAppointmentResponse"][];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ArrangeClaimAppointment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ArrangeClaimAppointmentRequest"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimAppointmentResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    CancelClaimAppointment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                appointmentId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimAppointmentResponse"];
+                };
+            };
+            /** @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;
@@ -7613,6 +8432,35 @@ export interface operations {
             };
         };
     };
+    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 */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     ReadEmergencyContacts: {
         parameters: {
             query?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@insurance-broker/api-client",
-  "version": "1.25.0",
+  "version": "1.27.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,