@insurance-broker/api-client 5.1.0 → 5.2.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;
@@ -7429,6 +7479,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 +7838,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. */
@@ -8126,6 +8188,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 +9177,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 +9251,7 @@ export interface components {
             /** Format: date-time */
             postedAtUtc: string;
             isReversed: boolean;
+            sourceLabel: string;
         };
         StatementResponse: {
             /** Format: uuid */
@@ -11064,6 +11148,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?: {

package/package.json

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