@insurance-broker/api-client 5.3.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;
@@ -8207,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;
@@ -8873,6 +8947,11 @@ export interface components {
         ReleaseLegalHoldRequest: {
             releaseReason: null | string;
         };
+        RemapPaymentSourceRequest: {
+            source: string;
+            /** Format: uuid */
+            paymentMethodId: string;
+        };
         RenameFormDefinitionRequest: {
             name: null | string;
         };
@@ -9509,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: {
             /**
@@ -11224,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?: {

package/package.json

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