@insurance-broker/api-client 5.2.0 → 5.4.0

package/dist/schema.d.ts

@@ -879,13 +879,13 @@ export interface paths {
          * 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 mapping never moves a payment 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 mapping can be undone** with `POST /payment-methods/{id}/source-mappings/removal`, or pointed at another method with `POST /payment-methods/{id}/source-mappings/correction` (#588). A payment with this source that names this method through a mapping not marked as one (made by an API instance from before #588) is marked by this request, so it can then be corrected; it is counted in `alreadyMapped`.
          *
          *     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.
          */
@@ -896,6 +896,56 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/payment-methods/{id}/source-mappings/removal": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Undo a mapping: show the payments with a free-text source as typed again
+         * @description #588. Every payment of this broker whose `source` is exactly the given text (after trimming, case as typed) and that **a mapping** gave this method goes back to naming no method. Customers see the source as typed again, and the source returns to `GET /payment-methods/free-text-sources`. No amount, source or reference changes.
+         *
+         *     **A payment recorded against this method is never changed**: its method is part of what was recorded. Such payments with this text (possible only when the text is the method's own code) are counted in `recordedAgainstMethod`. A payment recorded against the wrong method is corrected by a reversal. A payment that names this method through a mapping not marked as one (made by an API instance from before #588, possible only when the text is not the method's code) is counted in `notYetCorrectable` and left alone: map the source to this method again, which marks it, and then undo.
+         *
+         *     **Idempotent.** Repeating the request answers `unmapped: 0` and records nothing. A retired method can be unmapped from. A statement already produced keeps the wording it was produced with. A `409` is the platform's concurrency conflict, with `retryable: true`, when another write changed one of the payments while this ran.
+         */
+        post: operations["UnmapFreeTextPaymentSource"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/payment-methods/{id}/source-mappings/correction": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Correct a mapping: say the payments with a free-text source came through another method
+         * @description #588. Every payment of this broker whose `source` is exactly the given text and that **a mapping** gave this method is given `paymentMethodId` instead, in one step. Customers then see that method's label. No amount, source or reference changes, and a payment recorded against this method is never moved (counted in `recordedAgainstMethod`). A payment mapped by an API instance from before #588 is counted in `notYetCorrectable` and left alone until the source is mapped to this method again.
+         *
+         *     `paymentMethodId` must be another active method of this broker: the same method, an unknown or another broker's method is `400` on `PaymentMethodId`, and a retired one is `409`. The method in the route may be retired.
+         *
+         *     **All or nothing.** If the target method already holds the reference of any of the payments (a payment recorded against it, one mapped to it, or a free-text payment typed exactly as its code), nothing is moved and the answer is `409` `urn:brokerplatform:problem:payment-source-remap-collision`, which is not retryable, with `collisionCount`. **`collisions` is present only when the caller also holds `billing.payments.read`**: up to 200 entries naming each payment, its reference and the payment holding it. Undo the mapping instead and map the source to the target: the mapping maps the rest and lists those it skips.
+         *
+         *     **Idempotent.** Repeating the request answers `remapped: 0` and records nothing. A statement already produced keeps the wording it was produced with. A `409` can also be the platform's concurrency conflict, `urn:brokerplatform:problem:concurrency-conflict` with `retryable: true`: another write changed one of the payments while this ran, or something other than this API's recording route wrote a payment against the target method between this request's read and its save. Send it again; a retry reports any collision.
+         */
+        post: operations["RemapFreeTextPaymentSource"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/insurers": {
         parameters: {
             query?: never;
@@ -1877,6 +1927,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;
@@ -7890,6 +7944,7 @@ export interface components {
             customerId: string;
             /** Format: date */
             incidentOn: string;
+            idempotencyKey?: null | string;
         };
         ObligationPage: {
             items: components["schemas"]["ObligationSummaryResponse"][];
@@ -8202,6 +8257,30 @@ export interface components {
             skippedCount: number | string;
             skipped: components["schemas"]["SkippedPaymentResponse"][];
         };
+        PaymentSourceRemappingResponse: {
+            /** Format: uuid */
+            fromPaymentMethodId: string;
+            /** Format: uuid */
+            paymentMethodId: string;
+            source: string;
+            /** Format: int32 */
+            remapped: number | string;
+            /** Format: int32 */
+            recordedAgainstMethod: number | string;
+            /** Format: int32 */
+            notYetCorrectable: number | string;
+        };
+        PaymentSourceUnmappingResponse: {
+            /** Format: uuid */
+            paymentMethodId: string;
+            source: string;
+            /** Format: int32 */
+            unmapped: number | string;
+            /** Format: int32 */
+            recordedAgainstMethod: number | string;
+            /** Format: int32 */
+            notYetCorrectable: number | string;
+        };
         PaymentSummaryResponse: {
             /** Format: uuid */
             id: string;
@@ -8868,6 +8947,11 @@ export interface components {
         ReleaseLegalHoldRequest: {
             releaseReason: null | string;
         };
+        RemapPaymentSourceRequest: {
+            source: string;
+            /** Format: uuid */
+            paymentMethodId: string;
+        };
         RenameFormDefinitionRequest: {
             name: null | string;
         };
@@ -9504,6 +9588,9 @@ export interface components {
             /** @description The reason. One, because the caller named one submission; still an array. */
             violations: components["schemas"]["RenewalConfirmationViolationResponse"][];
         };
+        UnmapPaymentSourceRequest: {
+            source: string;
+        };
         /** @description RFC 9457 problem answered when a policy cannot be opened because the quote request it names has no acceptance behind it (ADR-0028). Go back to the quote; nothing about this request will help. */
         UnplaceableQuoteProblem: {
             /**
@@ -11219,6 +11306,108 @@ export interface operations {
             };
         };
     };
+    UnmapFreeTextPaymentSource: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UnmapPaymentSourceRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PaymentSourceUnmappingResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    RemapFreeTextPaymentSource: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RemapPaymentSourceRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PaymentSourceRemappingResponse"];
+                };
+            };
+            /** @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?: {
@@ -13956,6 +14145,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.2.0",
+  "version": "5.4.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,