@insurance-broker/api-client 1.31.0 → 1.33.0

package/dist/schema.d.ts

@@ -255,7 +255,7 @@ export interface paths {
          * Read one payment
          * @description Another broker's payment and another customer's are invisible here rather than refused: the tenant and owner query filters remove them before the read runs, so all three cases answer the same `404` (ADR-0008, ADR-0030).
          *
-         *     There is **no approval field**: approval is a separate recorded act and arrives in step 9.6, so a field here would be an unreachable `false` a reader would take for a fact.
+         *     **`approvedBySubjectId` and `approvedAtUtc` are null until somebody approves**, which is the ordinary state of a payment just recorded. Approval is a separate act on its own route and never a status: the status set is untouched by it.
          */
         get: operations["GetPayment"];
         put?: never;
@@ -266,6 +266,118 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/payments/{id}/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What happened to this payment, and who said so
+         * @description ADR-0042 section 8's *"every payment's history is explainable"*. One row per thing that happened to this payment, in the order it happened, each naming the subject that caused it.
+         *
+         *     **Append-only in the strong sense.** `UPDATE` and `DELETE` are revoked from the application role on this table, so a row here cannot be rewritten by a data fix or a restored backup - which is the half a convention cannot give.
+         *
+         *     **It is not an event source.** The payment carries its own state and this explains how it got there; deriving the state by replaying these rows would be a second representation able to disagree with the first.
+         *
+         *     A refusal row **names the attempt** it is about rather than repeating its figures. The amounts, the source and the reference are on that attempt, which the reconciliation history read returns.
+         */
+        get: operations["ReadPaymentHistory"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/payments/{id}/approval": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Approve a payment somebody else recorded
+         * @description PAY-003's second half. Records that somebody accepted responsibility for a payment another person wrote down.
+         *
+         *     **The subject who recorded the payment cannot approve it.** That is refused here and again by a check constraint, so it holds over a data fix, an import and a restored backup as well as over this route (ADR-0042 section 15, step 9.6's amendment).
+         *
+         *     **A payment with no evidence a scan has passed cannot be approved.** File the bank slip first and wait for the scan; only a `Clean` verdict counts, which is the rule step 6.7 already applies to a form's evidence checklist.
+         *
+         *     **Approval is an act and not a status.** The payment's status set is untouched: collapsing the two would make *"recorded but not yet approved"* and *"the money is definitely there"* the same value.
+         *
+         *     There is no un-approval. A payment approved in error is corrected by a reversal, which is step 9.7's, for the reason BR-010 gives about every financially significant record.
+         */
+        post: operations["ApprovePayment"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/payments/{id}/evidence/{evidenceId}/content": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Take a copy of a document filed against a payment
+         * @description PAY-003. Streams one file back, and only when the malware scan has passed it.
+         *
+         *     **A `409` here is about the scan and not about the request.** `urn:brokerplatform:problem:document-scan-pending` means wait and ask again; `document-infected` and `document-unscannable` mean this file will never be served and another must be filed. The `type` is what tells them apart — all three are 409 so that a client branching on status alone still behaves safely.
+         *
+         *     **The response is verified as it is written.** If the store no longer holds what was filed, the transfer is aborted rather than completed over bytes nobody can vouch for.
+         */
+        get: operations["DownloadPaymentEvidence"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/payments/{id}/evidence": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What has been filed against a payment
+         * @description PAY-003. Every file filed against the payment, 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 payment's evidence is a handful of files by nature.
+         */
+        get: operations["ListPaymentEvidence"];
+        put?: never;
+        /**
+         * File a document supporting a recorded payment
+         * @description PAY-003. Stores one file against a payment — a bank slip, a statement line, a remittance advice, a counter receipt.
+         *
+         *     **The file is quarantined the moment it is stored and only a malware scan moves it**, so a client that has just uploaded should say the file is being checked rather than that it is ready. Nothing but a `Clean` verdict is ever served back.
+         *
+         *     **The type is taken from the file's own bytes, never from the part header.** A part declaring one thing and holding another is refused rather than believed.
+         *
+         *     **A payment cannot be approved until at least one of its files is `Clean`**, which is the other half of PAY-003 and the reason this route exists.
+         */
+        post: operations["UploadPaymentEvidence"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/insurers": {
         parameters: {
             query?: never;
@@ -4636,6 +4748,36 @@ export interface components {
             /** Format: double */
             existingAmount: null | number | string;
         };
+        PaymentEventResponse: {
+            /** Format: uuid */
+            id: string;
+            kind: string;
+            /** Format: date-time */
+            occurredAtUtc: string;
+            actorSubjectId: string;
+            /** Format: uuid */
+            paymentAttemptId: null | string;
+        };
+        PaymentEvidenceResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            paymentId: string;
+            fileName: string;
+            contentType: string;
+            /** Format: int64 */
+            sizeBytes: number | string;
+            contentSha256: string;
+            /** Format: date-time */
+            uploadedAtUtc: string;
+            uploadedBySubjectId: string;
+            scanVerdict: string;
+            /** Format: date-time */
+            scannedAtUtc: null | string;
+        };
+        PaymentEvidenceUpload: {
+            file: components["schemas"]["IFormFile"];
+        };
         PaymentResponse: {
             /** Format: uuid */
             id: string;
@@ -4652,6 +4794,9 @@ export interface components {
             recordedBySubjectId: string;
             /** Format: date-time */
             postedAtUtc: string;
+            approvedBySubjectId: null | string;
+            /** Format: date-time */
+            approvedAtUtc: null | string;
         };
         PlaceLegalHoldRequest: {
             moduleName: null | string;
@@ -5813,6 +5958,192 @@ export interface operations {
             };
         };
     };
+    ReadPaymentHistory: {
+        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"]["PaymentEventResponse"][];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ApprovePayment: {
+        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"]["PaymentResponse"];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
+    DownloadPaymentEvidence: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                evidenceId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
+    ListPaymentEvidence: {
+        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"]["PaymentEvidenceResponse"][];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    UploadPaymentEvidence: {
+        parameters: {
+            query?: never;
+            header?: {
+                "X-Document-Sha256"?: string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "multipart/form-data": components["schemas"]["PaymentEvidenceUpload"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PaymentEvidenceResponse"];
+                };
+            };
+            /** @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 Payload Too Large */
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
     ListInsurers: {
         parameters: {
             query?: {

package/package.json

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