@insurance-broker/api-client 5.49.0 → 5.51.0

package/dist/schema.d.ts

@@ -2990,7 +2990,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/customer-account": {
+    "/api/v1/customers/{id}/notes": {
         parameters: {
             query?: never;
             header?: never;
@@ -2998,21 +2998,25 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * The account this broker holds for the signed-in customer.
-         * @description **A `403` here is usually not an error.** `urn:brokerplatform:problem:customer-not-attached` means this sign-in has never been linked to a broker — the ordinary state of a customer who has registered but not yet redeemed an invitation, and the cue to show onboarding rather than a failure. A `403` *without* that type is an ordinary refusal and must not be read as onboarding: it is what a caller whose broker may not transact receives, and what a caller whose account the broker has suspended or closed receives.
-         *
-         *     **The `404` is retained for compatibility and is not the unattached state.** It means the caller holds the permission and the record is gone, which cannot happen through this API today; a client keying its onboarding branch on `404` will never reach it.
+         * Read a customer's internal notes, logged calls and emails
+         * @description CRM-009. Newest first, each saying who wrote it and whether it has been shared with the customer. Paged by cursor (ADR-0031): pass `nextCursor` back as `cursor` until it is null. A cursor this list did not issue is a `400`.
          */
-        get: operations["GetOwnCustomerAccount"];
+        get: operations["ListCustomerNotes"];
         put?: never;
-        post?: never;
+        /**
+         * Write an internal note about a customer, or log a call or an email
+         * @description CRM-009. `kind` is `Consultation`, `Call` or `Email`. The note is internal: **the customer never sees it** unless a member of staff shares it. Writing one counts as contact with the customer, so it moves their last activity forward.
+         *
+         *     A closed customer takes no further notes, because its retention clock has already started (409).
+         */
+        post: operations["WriteCustomerNote"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/v1/customer-account/sessions/revocation": {
+    "/api/v1/customers/{id}/notes/{noteId}/sharing": {
         parameters: {
             query?: never;
             header?: never;
@@ -3022,23 +3026,41 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Signs the customer out of every session they have established, including this one.
-         * @description **Every sign-in this customer established up to now stops working against this API on its next request — including the one making this call.** That is the stolen-device remedy (SEC-012): a phone that is lost keeps a session the customer cannot reach, and this ends what that session can do here without needing the phone.
-         *
-         *     **What a client must do afterwards.** Every request from a session established before the returned `revokedAtUtc` (plus a few seconds' clock allowance) is answered `401` with problem type `urn:brokerplatform:problem:session-revoked` — on any customer route, not only this one. **Do not refresh in answer to it**: the identity provider will issue a new token and that token will be refused the same way, because it belongs to the same sign-in. **Do not answer it with a `prompt=login` sign-in alone either**: on a device that still holds the identity provider's session cookie, that re-authenticates the *same* session and re-admits every refresh token copied from it. End the identity provider's session first (RP-initiated logout with `id_token_hint`), discard the stored tokens, then sign in.
-         *
-         *     **Tell the customer to change their password, and to secure their email account.** Signing out does not stop somebody who knows the password from signing in again, and a password can be reset through the email address.
-         *
-         *     **Where a deployment has enabled the isolated identity-management component (ADR-0049), the identity provider's sessions are also ended**, shortly after this answer and not before it: the request is recorded here and carried out in the background. Nowhere is that a reason to skip the steps above. It does not list sessions, or end one and keep the others. A `409` means the caller is acting for an organisation: sessions belong to the person, so act personally to revoke them.
+         * Share an internal note's words with the customer
+         * @description CRM-009. Copies the note's words into what the customer may be shown, recording who decided to and when. **A copy, not a flag**: the note is unchanged, a share cannot be undone, and sharing the same note twice is a `409`. A closed customer's notes cannot be shared (409).
          */
-        post: operations["RevokeOwnCustomerSessions"];
+        post: operations["ShareCustomerNote"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/v1/customer-account/redemption": {
+    "/api/v1/customers/{id}/next-actions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read a customer's next actions, open and done
+         * @description CRM-008, CRM-009. Newest first, each with its owner, due date and whether it is done. Paged by cursor (ADR-0031): pass `nextCursor` back as `cursor` until it is null.
+         */
+        get: operations["ListCustomerNextActions"];
+        put?: never;
+        /**
+         * Record what a member of staff has to do next for a customer
+         * @description CRM-009. An owner, a due date and a description. The owner must be an active member of this broker holding `crm.customer-actions.manage`. A closed customer takes no further actions (409).
+         */
+        post: operations["RecordCustomerNextAction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/customers/{id}/next-actions/{actionId}/completion": {
         parameters: {
             query?: never;
             header?: never;
@@ -3047,8 +3069,35 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Attaches the signed-in account to the customer an invitation was issued for. The code travels in the X-Broker-Invitation header. */
-        post: operations["RedeemCustomerInvitation"];
+        /**
+         * Mark a customer's next action done
+         * @description CRM-009. Records who did it and when. An action already done is a `409`, and so is the second of two completions racing each other.
+         */
+        post: operations["CompleteCustomerNextAction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/customers/{id}/timeline": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read what has happened on a customer's relationship with the broker
+         * @description CRM-008. Policies, claims, payments, quotes and form submissions as their modules report them, with the notes, logged calls and emails, shares and next actions staff recorded here. Newest first. Each row says what kind of thing happened and when. It never carries a note's words: read those through the notes route, which needs `crm.customer-notes.read`.
+         *
+         *     The timeline begins when this release was deployed; earlier activity is not on it.
+         *
+         *     Paged by cursor (ADR-0031): pass `nextCursor` back as `cursor` until it is null. A cursor this list did not issue is a `400`.
+         */
+        get: operations["ListCustomerTimeline"];
+        put?: never;
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
@@ -3126,6 +3175,71 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/customer-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The account this broker holds for the signed-in customer.
+         * @description **A `403` here is usually not an error.** `urn:brokerplatform:problem:customer-not-attached` means this sign-in has never been linked to a broker — the ordinary state of a customer who has registered but not yet redeemed an invitation, and the cue to show onboarding rather than a failure. A `403` *without* that type is an ordinary refusal and must not be read as onboarding: it is what a caller whose broker may not transact receives, and what a caller whose account the broker has suspended or closed receives.
+         *
+         *     **The `404` is retained for compatibility and is not the unattached state.** It means the caller holds the permission and the record is gone, which cannot happen through this API today; a client keying its onboarding branch on `404` will never reach it.
+         */
+        get: operations["GetOwnCustomerAccount"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/customer-account/sessions/revocation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Signs the customer out of every session they have established, including this one.
+         * @description **Every sign-in this customer established up to now stops working against this API on its next request — including the one making this call.** That is the stolen-device remedy (SEC-012): a phone that is lost keeps a session the customer cannot reach, and this ends what that session can do here without needing the phone.
+         *
+         *     **What a client must do afterwards.** Every request from a session established before the returned `revokedAtUtc` (plus a few seconds' clock allowance) is answered `401` with problem type `urn:brokerplatform:problem:session-revoked` — on any customer route, not only this one. **Do not refresh in answer to it**: the identity provider will issue a new token and that token will be refused the same way, because it belongs to the same sign-in. **Do not answer it with a `prompt=login` sign-in alone either**: on a device that still holds the identity provider's session cookie, that re-authenticates the *same* session and re-admits every refresh token copied from it. End the identity provider's session first (RP-initiated logout with `id_token_hint`), discard the stored tokens, then sign in.
+         *
+         *     **Tell the customer to change their password, and to secure their email account.** Signing out does not stop somebody who knows the password from signing in again, and a password can be reset through the email address.
+         *
+         *     **Where a deployment has enabled the isolated identity-management component (ADR-0049), the identity provider's sessions are also ended**, shortly after this answer and not before it: the request is recorded here and carried out in the background. Nowhere is that a reason to skip the steps above. It does not list sessions, or end one and keep the others. A `409` means the caller is acting for an organisation: sessions belong to the person, so act personally to revoke them.
+         */
+        post: operations["RevokeOwnCustomerSessions"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/customer-account/redemption": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Attaches the signed-in account to the customer an invitation was issued for. The code travels in the X-Broker-Invitation header. */
+        post: operations["RedeemCustomerInvitation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/customer-verification-methods/{key}/label": {
         parameters: {
             query?: never;
@@ -7600,6 +7714,44 @@ export interface components {
             /** Format: date-time */
             revokedAtUtc: null | string;
         };
+        CustomerNextActionPage: {
+            items: components["schemas"]["CustomerNextActionResponse"][];
+            nextCursor: null | string;
+        };
+        CustomerNextActionResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            customerId: string;
+            description: string;
+            ownerSubjectId: string;
+            /** Format: date */
+            dueOn: string;
+            done: boolean;
+            /** Format: date-time */
+            createdAtUtc: string;
+            createdBySubjectId: string;
+            /** Format: date-time */
+            completedAtUtc: null | string;
+            completedBySubjectId: null | string;
+        };
+        CustomerNotePage: {
+            items: components["schemas"]["CustomerNoteResponse"][];
+            nextCursor: null | string;
+        };
+        CustomerNoteResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            customerId: string;
+            kind: string;
+            body: string;
+            /** Format: date-time */
+            writtenAtUtc: string;
+            writtenBySubjectId: string;
+            /** Format: date-time */
+            sharedAtUtc: null | string;
+        };
         CustomerNotificationPage: {
             items: components["schemas"]["CustomerNotificationResponse"][];
             nextCursor: null | string;
@@ -7887,6 +8039,19 @@ export interface components {
             /** Format: date-time */
             revokedAtUtc: string;
         };
+        CustomerSharedNoteResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            noteId: string;
+            /** Format: uuid */
+            customerId: string;
+            kind: string;
+            body: string;
+            /** Format: date-time */
+            sharedAtUtc: string;
+            sharedBySubjectId: string;
+        };
         CustomerSubmissionAttachmentResponse: {
             /** Format: uuid */
             id: string;
@@ -7918,6 +8083,20 @@ export interface components {
             help: null | string;
             section: null | string;
         };
+        CustomerTimelineEntryResponse: {
+            /** Format: uuid */
+            id: string;
+            kind: string;
+            source: string;
+            /** Format: uuid */
+            referenceId: null | string;
+            /** Format: date-time */
+            occurredAtUtc: string;
+        };
+        CustomerTimelinePage: {
+            items: components["schemas"]["CustomerTimelineEntryResponse"][];
+            nextCursor: null | string;
+        };
         CustomerVerificationMethodResponse: {
             key: string;
             name: string;
@@ -9886,6 +10065,12 @@ export interface components {
             /** Format: uuid */
             submissionId: string;
         };
+        RecordCustomerNextActionRequest: {
+            description: null | string;
+            ownerSubjectId: null | string;
+            /** Format: date */
+            dueOn: null | string;
+        };
         RecordFollowUpRequest: {
             /** Format: date */
             dueOn: null | string;
@@ -10946,6 +11131,10 @@ export interface components {
         WriteClaimNoteRequest: {
             body: string;
         };
+        WriteCustomerNoteRequest: {
+            kind: null | string;
+            body: null | string;
+        };
         WriteOffObligationRequest: {
             reason: string;
         };
@@ -17544,14 +17733,16 @@ export interface operations {
             };
         };
     };
-    GetOwnCustomerAccount: {
+    ListCustomerNotes: {
         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"];
+            query?: {
+                cursor?: string;
+                limit?: number | string;
+            };
+            header?: never;
+            path: {
+                id: string;
             };
-            path?: never;
             cookie?: never;
         };
         requestBody?: never;
@@ -17559,64 +17750,73 @@ export interface operations {
             /** @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"]["OwnCustomerAccountResponse"];
+                    "application/json": components["schemas"]["CustomerNotePage"];
                 };
             };
-            /** @description Forbidden */
-            403: {
+            /** @description Bad Request */
+            400: {
                 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/problem+json": components["schemas"]["ProblemDetails"];
+                    "application/problem+json": components["schemas"]["HttpValidationProblemDetails"];
                 };
             };
             /** @description Not Found */
             404: {
                 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?: never;
             };
         };
     };
-    RevokeOwnCustomerSessions: {
+    WriteCustomerNote: {
         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"];
+            header?: never;
+            path: {
+                id: string;
             };
-            path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WriteCustomerNoteRequest"];
+            };
+        };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Created */
+            201: {
                 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"]["CustomerSessionRevocationResponse"];
+                    "application/json": components["schemas"]["CustomerNoteResponse"];
                 };
             };
+            /** @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: {
-                    /** @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: {
@@ -17625,27 +17825,37 @@ export interface operations {
             };
         };
     };
-    RedeemCustomerInvitation: {
+    ShareCustomerNote: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                id: string;
+                noteId: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["RedeemedCustomerAccountResponse"];
+                    "application/json": components["schemas"]["CustomerSharedNoteResponse"];
                 };
             };
-            /** @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: {
+            /** @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: {
@@ -17654,6 +17864,178 @@ export interface operations {
             };
         };
     };
+    ListCustomerNextActions: {
+        parameters: {
+            query?: {
+                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"]["CustomerNextActionPage"];
+                };
+            };
+            /** @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;
+            };
+        };
+    };
+    RecordCustomerNextAction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RecordCustomerNextActionRequest"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerNextActionResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    CompleteCustomerNextAction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                actionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerNextActionResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
+    ListCustomerTimeline: {
+        parameters: {
+            query?: {
+                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"]["CustomerTimelinePage"];
+                };
+            };
+            /** @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;
+            };
+        };
+    };
     ListCustomerVerificationMethods: {
         parameters: {
             query?: {
@@ -17794,6 +18176,116 @@ export interface operations {
             };
         };
     };
+    GetOwnCustomerAccount: {
+        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"]["OwnCustomerAccountResponse"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                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/problem+json": components["schemas"]["ProblemDetails"];
+                };
+            };
+            /** @description Not Found */
+            404: {
+                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?: never;
+            };
+        };
+    };
+    RevokeOwnCustomerSessions: {
+        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"]["CustomerSessionRevocationResponse"];
+                };
+            };
+            /** @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: {
+                    /** @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/problem+json": components["schemas"]["ConcurrencyConflictProblem"] | components["schemas"]["ProblemDetails"];
+                };
+            };
+        };
+    };
+    RedeemCustomerInvitation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RedeemedCustomerAccountResponse"];
+                };
+            };
+            /** @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"];
+                };
+            };
+        };
+    };
     RelabelCustomerVerificationMethod: {
         parameters: {
             query?: never;

package/package.json

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