@insurance-broker/api-client 5.24.0 → 5.26.0

package/dist/schema.d.ts

@@ -4635,6 +4635,115 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/policies/imports": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * This broker's policy import runs, newest first
+         * @description Paged by cursor, newest first (ADR-0031): pass `nextCursor` back as `cursor` until it is null. A cursor this list did not issue is a `400`.
+         */
+        get: operations["ListPolicyImports"];
+        put?: never;
+        /**
+         * Uploads a file of policies to validate and import
+         * @description Reads a CSV file of policies carried across from a previous system and stages every row as a new import run, answering `202` with the run in status `Staged`. Nothing is written to the policy records: each row is validated against the rules `POST /policies/imported` applies, and the whole file is committed later, all of it or none (ADR-0051).
+         *
+         *     **The file.** One `multipart/form-data` file part. UTF-8 (a leading byte-order mark is tolerated), comma-delimited, RFC 4180 quoting, a header row naming `legacy_source`, `legacy_reference`, `customer_legacy_source`, `customer_legacy_reference`, `product_key`, `insurer_code` and `status`, and optionally `cover_start`, `cover_end`, `premium_amount`, `premium_currency`, `insurer_reference`, `insurer_confirmed_on` and `import_notes`, each at most once. Up to 50 further columns named `legacy.` followed by the previous system's own field name become the row's legacy metadata. Nothing else. Dates are `yyyy-MM-dd`; the premium is a plain decimal with a `.` point. The customer is named by the legacy pair it was imported under, the product by its key and the insurer by its code. At most 10,000 data rows and 5 MiB by default.
+         *
+         *     **Refusals.** `413` when the file is larger than this broker accepts. `400` when the body is not multipart, and `400` with problem type `urn:brokerplatform:problem:import-file-refused` when the file cannot be read — invalid UTF-8, a NUL or other control character, a duplicate, unknown or missing header, more than 50 `legacy.` columns, a record whose field count differs from the header's, a misplaced or unclosed quote, more rows than allowed, no rows, or an unusable file name. That problem carries `fault` (`invalid-encoding`, `control-character`, `no-header`, `duplicate-header`, `unknown-column`, `missing-column`, `too-many-legacy-columns`, `field-count`, `misplaced-quote`, `unterminated-quote`, `too-many-rows`, `no-rows`, `no-file-part` or `file-name`) and, when the fault is on a line, `line`; its message names the line and never repeats the file's content. **A refused file creates no run.** `409` with problem type `urn:brokerplatform:problem:import-run-in-progress` when this broker already has a policy import staged, validated or committing — one at a time. `429` when this broker has used its policy upload budget: every admitted upload counts, including refused ones.
+         */
+        post: operations["UploadPolicyImport"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/policies/imports/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One policy import run: its status, counts and who did what when */
+        get: operations["GetPolicyImport"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/policies/imports/{id}/rows": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * A policy import run's rows, in file order
+         * @description Each row's line number in the file, its outcome, the policy it created once committed, and every reason it was refused — a column (`legacy.*` for the legacy columns taken together), a stable code and a fixed sentence, never a value from the file. The codes are those of `POST /policies/imported` (`required`, `too-long`, `invalid-format`, `premium-incomplete`, `premium-negative`, `cover-period-inverted`, `status-not-importable`, `evidence-required`, `evidence-not-allowed`, `legacy-metadata-too-large`, `unknown-customer`, `unknown-product`, `unknown-insurer`, `already-imported`) and two of a file's own: `invalid-character` and `duplicate-in-file`. Filter with `outcome` (`Pending`, `Accepted` or `Refused`). Paged by cursor in file order (ADR-0031). `404` when the run is not this broker's.
+         */
+        get: operations["ListPolicyImportRows"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/policies/imports/{id}/commitment": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Asks for a validated policy import to be committed, every row or none
+         * @description Accepted only from `Validated`. Moves the run to `Committing` and answers `202` with it; the commit then runs in the background and ends `Committed` (one policy per row, each exactly as `POST /policies/imported` would record it, with the run as its import batch), `CommitRefused` (nothing written; `commitRefusalReason` says why, and a row that failed the commit's re-check is `Refused` with its reasons), or `CommitFailed` (nothing written, after the commit stalled). Read the run to follow it.
+         *
+         *     **Requires `If-Match`** with the run's `concurrencyToken`. Without it, or with `*`, `428`; a token that is no longer current is `409` with problem type `urn:brokerplatform:problem:concurrency-conflict` — read the run again. `409` with problem type `urn:brokerplatform:problem:import-run-state-conflict` when the run is not `Validated`; its `runStatus` says what it is. `404` when the run is not this broker's.
+         */
+        post: operations["CommitPolicyImport"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/policies/imports/{id}/abandonment": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Abandons a policy import that has not been committed
+         * @description Accepted only from `Staged` or `Validated`. Ends the run `Abandoned`, removes every value the file held, and frees this broker's policy import slot; the report (line numbers, outcomes and reasons) stays readable. Answers `200` with the run.
+         *
+         *     **Requires `If-Match`** with the run's `concurrencyToken`. Without it, or with `*`, `428`; a token that is no longer current is `409` with problem type `urn:brokerplatform:problem:concurrency-conflict`. `409` with problem type `urn:brokerplatform:problem:import-run-state-conflict` when the run has already ended — including `Refused`, which is already ended and purged — or is committing; its `runStatus` says what it is. `404` when the run is not this broker's.
+         */
+        post: operations["AbandonPolicyImport"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/policies/payment-gates": {
         parameters: {
             query?: never;
@@ -9000,6 +9109,56 @@ export interface components {
         PolicyDocumentUpload: {
             file: components["schemas"]["IFormFile"];
         };
+        PolicyImportRowPage: {
+            items: components["schemas"]["PolicyImportRowResponse"][];
+            nextCursor: null | string;
+        };
+        PolicyImportRowReason: {
+            column: string;
+            code: string;
+            message: string;
+        };
+        PolicyImportRowResponse: {
+            /** Format: int32 */
+            lineNumber: number;
+            outcome: string;
+            /** Format: uuid */
+            policyId: null | string;
+            reasons: components["schemas"]["PolicyImportRowReason"][];
+        };
+        PolicyImportRunPage: {
+            items: components["schemas"]["PolicyImportRunResponse"][];
+            nextCursor: null | string;
+        };
+        PolicyImportRunResponse: {
+            /** Format: uuid */
+            id: string;
+            status: string;
+            fileName: string;
+            /** Format: int32 */
+            rowCount: number;
+            /** Format: int32 */
+            acceptedCount: null | number;
+            /** Format: int32 */
+            refusedCount: null | number;
+            /** Format: int32 */
+            committedCount: null | number;
+            submittedBySubjectId: string;
+            /** Format: date-time */
+            stagedAtUtc: string;
+            /** Format: date-time */
+            validatedAtUtc: null | string;
+            commitRequestedBySubjectId: null | string;
+            /** Format: date-time */
+            commitRequestedAtUtc: null | string;
+            /** Format: date-time */
+            concludedAtUtc: null | string;
+            commitRefusalReason: null | string;
+            concurrencyToken: string;
+        };
+        PolicyImportUpload: {
+            file: components["schemas"]["IFormFile"];
+        };
         PolicyPage: {
             items: components["schemas"]["PolicyResponse"][];
             nextCursor: null | string;
@@ -21250,6 +21409,289 @@ export interface operations {
             };
         };
     };
+    ListPolicyImports: {
+        parameters: {
+            query?: {
+                cursor?: string;
+                limit?: number | string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PolicyImportRunPage"];
+                };
+            };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
+                };
+            };
+        };
+    };
+    UploadPolicyImport: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "multipart/form-data": components["schemas"]["PolicyImportUpload"];
+            };
+        };
+        responses: {
+            /** @description Accepted */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PolicyImportRunResponse"];
+                };
+            };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "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"];
+                };
+            };
+            /** @description Payload Too Large */
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+            /** @description Too Many Requests (ADR-0051). Your organisation has used its budget of import uploads for this kind of record in the last day; every admitted upload counts, including ones refused because the file could not be read. Nothing was read and no import was started. budget is always tenant. Wait the number of seconds in Retry-After (also in retryAfterSeconds) before trying again. */
+            429: {
+                headers: {
+                    /** @description Whole seconds to wait before retrying; at least 1. */
+                    "Retry-After": number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["RateLimitedProblem"];
+                };
+            };
+        };
+    };
+    GetPolicyImport: {
+        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"]["PolicyImportRunResponse"];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    ListPolicyImportRows: {
+        parameters: {
+            query?: {
+                outcome?: string;
+                cursor?: string;
+                limit?: number | string;
+            };
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PolicyImportRowPage"];
+                };
+            };
+            /** @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;
+            };
+        };
+    };
+    CommitPolicyImport: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Required. The concurrencyToken of the record as it was read, sent back unchanged. A write without it, or with *, is refused with 428; a token that is no longer current is refused with 409 (issue #517, client 5.0.0). */
+                "If-Match": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Accepted */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PolicyImportRunResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+            /** @description Precondition Required (RFC 6585). The request carried no If-Match, or carried If-Match: *, which protects nothing. Nothing was read or written. Read the record, then send its concurrencyToken as If-Match. */
+            428: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["PreconditionRequiredProblem"];
+                };
+            };
+        };
+    };
+    AbandonPolicyImport: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Required. The concurrencyToken of the record as it was read, sent back unchanged. A write without it, or with *, is refused with 428; a token that is no longer current is refused with 409 (issue #517, client 5.0.0). */
+                "If-Match": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PolicyImportRunResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+            /** @description Precondition Required (RFC 6585). The request carried no If-Match, or carried If-Match: *, which protects nothing. Nothing was read or written. Read the record, then send its concurrencyToken as If-Match. */
+            428: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["PreconditionRequiredProblem"];
+                };
+            };
+        };
+    };
     ReadPaymentGates: {
         parameters: {
             query?: never;

package/package.json

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