@insurance-broker/api-client 5.1.0 → 5.3.0

package/dist/schema.d.ts

@@ -846,6 +846,56 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/payment-methods/free-text-sources": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The free-text sources that still have payments with no payment method
+         * @description #568. Every distinct free-text `source` this broker's payments carry with no payment method, and how many payments carry it, most first, then by the text compared character by character. **At most 200**, the most frequent; `moreExist` says whether there are others, which come into the list as these are mapped. Each one is shown to customers as typed until it is mapped to a method with `POST /payment-methods/{id}/source-mappings`. Spellings are listed separately because a mapping matches the text exactly.
+         */
+        get: operations["ListFreeTextPaymentSources"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/payment-methods/{id}/source-mappings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Say which payment method the payments with a free-text source came through
+         * @description #568. Every payment of this broker whose `source` is exactly the given text (after trimming, case as typed) and that names no payment method is given this method. Customers then see the method's label for those payments as `sourceLabel`. **The stored `source` is not changed**, and no amount or reference is.
+         *
+         *     **A payment is never moved between methods.** Payments with this source that already name this method are counted in `alreadyMapped`, and those naming another method in `mappedToAnotherMethod`; neither is changed.
+         *
+         *     **A payment whose reference the method already holds is skipped** and listed in `skipped` with the payment that holds it, because mapping it would put the same reference against the method twice. The method holds a reference through a payment recorded against it, one mapped to it, or a free-text payment typed exactly as its code: the last is cautious, because such a payment is in the method's duplicate space under §5's index. `skippedCount` is the full count and `skipped` lists at most 200, earliest first. The rest are still mapped.
+         *
+         *     **Idempotent.** Repeating the request maps nothing more and answers `mapped: 0`. Only payments that exist when the request runs are mapped: a payment recorded later with the same text is not, until the mapping is requested again.
+         *
+         *     **A mapping cannot be undone yet** (#588): check the source and the method before sending it.
+         *
+         *     A retired method is `409`. A statement already produced keeps the wording it was produced with. A `409` can also be the platform's concurrency conflict, with `retryable: true`, when another write changed one of the payments while it was being mapped.
+         */
+        post: operations["MapFreeTextPaymentSource"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/insurers": {
         parameters: {
             query?: never;
@@ -1827,6 +1877,10 @@ export interface paths {
          *     **One refusal covers four facts.** A policy that does not exist, one belonging to another broker, one belonging to another customer, and one not in force on the incident date are all answered the same way, so the route cannot be used to discover which policies a broker holds.
          *
          *     The customer is named in the request and is not believed: it is checked against the policy, and the claim records the owner the policy gave.
+         *
+         *     **`idempotencyKey` is optional, and it is the only thing that makes a retry safe.** Without one, sending the notification twice opens two claims. With one: a repeat carrying a key already used **returns the original claim and the same `201 Created` with the same `Location`**, so a retry after a lost response opens nothing new. A repeat carrying that key with a **different** policy, customer or incident day is a `409` and opens nothing.
+         *
+         *     **A key is honoured for 30 days from the moment the claim was notified, and then stops being honoured.** After that the same key is one this platform has never seen. Mint a fresh key per form and reuse it only to retry that notification (#565). A key is shared by everybody at this broker — a colleague sending the same string meets the same claim — and is never shared with another broker, or with the key a customer sends when reporting a claim themselves.
          */
         post: operations["NotifyClaim"];
         delete?: never;
@@ -7429,6 +7483,15 @@ export interface components {
         };
         /** @enum {string} */
         FormVersionStatus: "Draft" | "Published" | "Retired";
+        FreeTextPaymentSourceResponse: {
+            source: string;
+            /** Format: int32 */
+            payments: number | string;
+        };
+        FreeTextPaymentSourcesResponse: {
+            sources: components["schemas"]["FreeTextPaymentSourceResponse"][];
+            moreExist: boolean;
+        };
         GenerateDocumentRequest: {
             format: null | string;
         };
@@ -7779,6 +7842,9 @@ export interface components {
             /** Format: date-time */
             publishedAtUtc: string;
         };
+        MapPaymentSourceRequest: {
+            source: string;
+        };
         MissingTemplateValueResponse: {
             key: string;
             /** @description Which refusal this is, as a stable name from a closed set. Key grouping, counting and translation on this, never on message. A new code is additive; renaming one is a break. */
@@ -7828,6 +7894,7 @@ export interface components {
             customerId: string;
             /** Format: date */
             incidentOn: string;
+            idempotencyKey?: null | string;
         };
         ObligationPage: {
             items: components["schemas"]["ObligationSummaryResponse"][];
@@ -8126,6 +8193,20 @@ export interface components {
             reversedAtUtc: string;
             reversedBySubjectId: string;
         };
+        PaymentSourceMappingResponse: {
+            /** Format: uuid */
+            paymentMethodId: string;
+            source: string;
+            /** Format: int32 */
+            mapped: number | string;
+            /** Format: int32 */
+            alreadyMapped: number | string;
+            /** Format: int32 */
+            mappedToAnotherMethod: number | string;
+            /** Format: int32 */
+            skippedCount: number | string;
+            skipped: components["schemas"]["SkippedPaymentResponse"][];
+        };
         PaymentSummaryResponse: {
             /** Format: uuid */
             id: string;
@@ -9101,6 +9182,13 @@ export interface components {
             amount: null | number | string;
             unit: null | string;
         };
+        SkippedPaymentResponse: {
+            /** Format: uuid */
+            paymentId: string;
+            externalReference: string;
+            /** Format: uuid */
+            conflictingPaymentId: string;
+        };
         StaffNameResponse: {
             subjectId: string;
             displayName: string;
@@ -9168,6 +9256,7 @@ export interface components {
             /** Format: date-time */
             postedAtUtc: string;
             isReversed: boolean;
+            sourceLabel: string;
         };
         StatementResponse: {
             /** Format: uuid */
@@ -11064,6 +11153,77 @@ export interface operations {
             };
         };
     };
+    ListFreeTextPaymentSources: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FreeTextPaymentSourcesResponse"];
+                };
+            };
+        };
+    };
+    MapFreeTextPaymentSource: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["MapPaymentSourceRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PaymentSourceMappingResponse"];
+                };
+            };
+            /** @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. A type of urn:brokerplatform:problem:concurrency-conflict means someone else changed the record first and nothing was written: read it again and decide again. Any other type is a conflict this operation decided itself, and retrying it unchanged will not help. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ConcurrencyConflictProblem"] | components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
     ListInsurers: {
         parameters: {
             query?: {
@@ -13801,6 +13961,15 @@ export interface operations {
                     "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
                 };
             };
+            /** @description Conflict. A type of urn:brokerplatform:problem:concurrency-conflict means someone else changed the record first and nothing was written: read it again and decide again. Any other type is a conflict this operation decided itself, and retrying it unchanged will not help. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ConcurrencyConflictProblem"] | components["schemas"]["ProblemDetails"];
+                };
+            };
         };
     };
     GetClaim: {

package/package.json

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