@insurance-broker/api-client 5.20.0 → 5.22.0

package/dist/schema.d.ts

@@ -3052,6 +3052,141 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/customer-verification-methods": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The ways this broker's staff may verify a customer before signing them out, in the broker's order.
+         * @description The broker's closed set of verification methods (ADR-0049). A member of staff signing a customer out of every session picks one of these keys and the choice is recorded in the audit entry. The set is configuration, never without an active method once configured; an empty list means this broker has not configured one yet, and staff-assisted sign-out is refused until it does.
+         *
+         *     **Only active methods by default**, because only those can be chosen. `includeRetired=true` adds the retired ones, marked `isActive: false` with `retiredAtUtc`, for somebody managing the set (#648); they cannot be chosen and keep their keys.
+         */
+        get: operations["ListCustomerVerificationMethods"];
+        put?: never;
+        /**
+         * Add a way this broker's staff may verify a customer before signing them out
+         * @description #648. `key` is a stable identifier — lower-case letters, digits and hyphens, at most 64 characters — unique within this broker and never changed or reused, because audit entries for staff sign-outs record it. `name` is what staff read, at most 120 characters; `description`, optional and at most 500, says what staff must actually have checked. Neither may hold control or invisible formatting characters. The method is appended to the end of the set and is active at once. A broker with no set may add its first method here.
+         *
+         *     **Refusals.** `400` for a malformed field. `409` `urn:brokerplatform:problem:verification-method-key-taken` when this broker already has a method with that key, active or retired: choose another key, or reactivate the retired one.
+         */
+        post: operations["AddCustomerVerificationMethod"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/customers/{id}/sessions/revocation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Signs a customer out of every session they have established, after a member of staff has verified them.
+         * @description **Every sign-in this customer established up to now stops working against this API on its next request** — the same effect as the customer's own `POST /api/v1/customer-account/sessions/revocation`, for a customer who rings in because a device was lost or stolen (SEC-012). The customer signs in again afterwards on the device they hold.
+         *
+         *     **Verify the customer first, then say how.** `verificationMethod` is a key from `GET /api/v1/customer-verification-methods`, this broker's closed set; `reason` is required, at most 500 characters, and is recorded with the method and the member of staff in the audit entry on the customer record (action `crm.customer.sessions-revoked-by-staff`). Tell the customer to change their password and secure their email account: signing out does not stop somebody who knows the password.
+         *
+         *     **Refusals.** `400` when either field is missing or the reason is too long. `404` when the customer is not this broker's. `409` with problem type `urn:brokerplatform:problem:verification-method-not-offered` when the method is not in this broker's set, has been retired, or the broker has configured none — read the set and choose from it. `409` with no type when the customer has never attached a sign-in account, so has no session to end.
+         *
+         *     **What it does not do yet.** It does not end the sessions at the identity provider or list them; those need the isolated identity-management component ADR-0049 describes.
+         */
+        post: operations["RevokeCustomerSessions"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/customer/contexts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The parties the signed-in customer may act as: themselves, and every organisation they hold an active membership of. The identifier of each is what X-Broker-Acting-For takes. */
+        get: operations["ListActingContexts"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/customer-verification-methods/{key}/label": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Correct what staff read for one of this broker's verification methods
+         * @description #648. Replaces the method's `name` and `description` (an absent or blank description removes it). **The key does not change**, so every audit entry naming it keeps its meaning: correct the wording here, and retire the method and add another to change what it is. A retired method can be corrected too.
+         *
+         *     **Refusals.** `400` for a malformed field. `404` when this broker has no method with that key. `409` `urn:brokerplatform:problem:concurrency-conflict` with `retryable: true` when another write changed the method after it was read: read it again and retry.
+         */
+        put: operations["RelabelCustomerVerificationMethod"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/customer-verification-methods/{key}/retirement": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Stop offering one of this broker's verification methods
+         * @description #648. A retired method cannot be chosen for a staff sign-out, drops out of `GET /api/v1/customer-verification-methods` unless `includeRetired=true`, and keeps its key, which is never given to another method. Retiring one already retired changes nothing and answers `200` with it as it stands.
+         *
+         *     **A broker always keeps one active method.** Retiring the last is `409` `urn:brokerplatform:problem:last-active-verification-method`, which is not retryable: add or reactivate another method first. `404` when this broker has no method with that key. A `409` can also be `urn:brokerplatform:problem:concurrency-conflict` with `retryable: true` when another write changed the method after it was read.
+         */
+        post: operations["RetireCustomerVerificationMethod"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/customer-verification-methods/{key}/reactivation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Offer a retired verification method again
+         * @description #648. The method comes back under the key it always had, in its old place in the set. Reactivating one already active changes nothing and answers `200` with it as it stands. `404` when this broker has no method with that key. `409` `urn:brokerplatform:problem:concurrency-conflict` with `retryable: true` when another write changed the method after it was read.
+         */
+        post: operations["ReactivateCustomerVerificationMethod"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/organisations": {
         parameters: {
             query?: never;
@@ -3190,23 +3325,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/customer/contexts": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /** The parties the signed-in customer may act as: themselves, and every organisation they hold an active membership of. The identifier of each is what X-Broker-Acting-For takes. */
-        get: operations["ListActingContexts"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/api/v1/customer/organisations/{id}/membership/acceptance": {
         parameters: {
             query?: never;
@@ -6394,6 +6512,11 @@ export interface components {
             kind: string;
             role: null | string;
         };
+        AddCustomerVerificationMethodRequest: {
+            key: null | string;
+            name: null | string;
+            description: null | string;
+        };
         AddInsurerRequest: {
             code: null | string;
             name: null | string;
@@ -7301,6 +7424,14 @@ export interface components {
             help: null | string;
             section: null | string;
         };
+        CustomerVerificationMethodResponse: {
+            key: string;
+            name: string;
+            description: null | string;
+            isActive: boolean;
+            /** Format: date-time */
+            retiredAtUtc: null | string;
+        };
         DataClassificationResponse: {
             key: string;
             name: string;
@@ -9239,6 +9370,10 @@ export interface components {
             name: null | string;
             registrationNumber: null | string;
         };
+        RelabelCustomerVerificationMethodRequest: {
+            name: null | string;
+            description: null | string;
+        };
         RelabelPaymentMethodRequest: {
             label: string;
         };
@@ -9589,6 +9724,17 @@ export interface components {
             /** Format: uuid */
             conflictingPaymentId: string;
         };
+        StaffCustomerSessionRevocationRequest: {
+            verificationMethod: null | string;
+            reason: null | string;
+        };
+        StaffCustomerSessionRevocationResponse: {
+            /** Format: uuid */
+            customerId: string;
+            /** Format: date-time */
+            revokedAtUtc: string;
+            verificationMethod: string;
+        };
         StaffNameResponse: {
             subjectId: string;
             displayName: string;
@@ -16763,6 +16909,273 @@ export interface operations {
             };
         };
     };
+    ListCustomerVerificationMethods: {
+        parameters: {
+            query?: {
+                includeRetired?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerVerificationMethodResponse"][];
+                };
+            };
+        };
+    };
+    AddCustomerVerificationMethod: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AddCustomerVerificationMethodRequest"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerVerificationMethodResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    RevokeCustomerSessions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["StaffCustomerSessionRevocationRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StaffCustomerSessionRevocationResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    ListActingContexts: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The organisation to act for: one of the identifiers GET /api/v1/customer/contexts lists. Omit it, or send it empty, to act for your own account; there is no mode in which it becomes mandatory. A value you hold no active membership of, or one that is not an organisation identifier, is refused with 403 naming nothing, and never quietly treated as your own account. */
+                "X-Broker-Acting-For"?: components["parameters"]["ActingFor"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description The party this request actually acted for. Present, carrying the organisation identifier, when it acted for an organisation; absent when it acted for your own account. It mirrors the request header, so it can be sent back unchanged. Compare it with what you meant to send: it is the only way to see that a request you meant for an organisation was made personally. */
+                    "X-Broker-Acting-For"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ActingContextResponse"][];
+                };
+            };
+        };
+    };
+    RelabelCustomerVerificationMethod: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RelabelCustomerVerificationMethodRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerVerificationMethodResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    RetireCustomerVerificationMethod: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerVerificationMethodResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    ReactivateCustomerVerificationMethod: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerVerificationMethodResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
     ListOrganisations: {
         parameters: {
             query?: {
@@ -17142,31 +17555,6 @@ export interface operations {
             };
         };
     };
-    ListActingContexts: {
-        parameters: {
-            query?: never;
-            header?: {
-                /** @description The organisation to act for: one of the identifiers GET /api/v1/customer/contexts lists. Omit it, or send it empty, to act for your own account; there is no mode in which it becomes mandatory. A value you hold no active membership of, or one that is not an organisation identifier, is refused with 403 naming nothing, and never quietly treated as your own account. */
-                "X-Broker-Acting-For"?: components["parameters"]["ActingFor"];
-            };
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description OK */
-            200: {
-                headers: {
-                    /** @description The party this request actually acted for. Present, carrying the organisation identifier, when it acted for an organisation; absent when it acted for your own account. It mirrors the request header, so it can be sent back unchanged. Compare it with what you meant to send: it is the only way to see that a request you meant for an organisation was made personally. */
-                    "X-Broker-Acting-For"?: string;
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ActingContextResponse"][];
-                };
-            };
-        };
-    };
     AcceptOrganisationMembership: {
         parameters: {
             query?: never;

package/package.json

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