@faable/auth-sdk 2.6.14 → 2.6.15

package/dist/api/types.d.ts

@@ -128,6 +128,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/recovery-channels/capabilities": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Recovery channel capabilities for this tenant
+         * @description Which recovery channels the platform can send, whether the plan allows the paid ones, this month's SMS usage against the included amount, and the tenant configuration as resolved. Drives the "Recovery channels" editor in the dashboard.
+         */
+        get: operations["account/recoveryChannelsCapabilities"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/connection": {
         parameters: {
             query?: never;
@@ -2851,6 +2871,15 @@ export interface components {
                 /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                 remember_device_days?: number;
             };
+            /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+            recovery_channels?: {
+                /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                default?: "email" | "sms" | "whatsapp" | "factor";
+                /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+            };
             /** @description WebAuthn Relying Party ID for this tenant's passkeys. Defaults to the account domain. Set it to a registrable suffix you own (e.g. `acme.com`) when the login screen is served from more than one host — the RP ID is frozen into every credential at registration, so changing it afterwards invalidates every passkey already enrolled. */
             webauthn_rp_id?: string | null;
             /** @description AuthAccount creation date */
@@ -3141,6 +3170,15 @@ export interface components {
                 /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                 remember_device_days?: number;
             };
+            /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+            recovery_channels?: {
+                /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                default?: "email" | "sms" | "whatsapp" | "factor";
+                /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+            };
             /** @description A login flow bound to this client (`loginflow_xxx`), overriding the account's. Absent = inherit. */
             login_flow?: string | null;
             /** @description Object is related with this account */
@@ -3245,6 +3283,14 @@ export interface components {
                 /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                 remember_device_days?: number;
             } | null;
+            recovery_channels?: {
+                /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                default?: "email" | "sms" | "whatsapp" | "factor";
+                /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+            } | null;
             login_flow?: string | null;
             /**
              * @description Free-form client metadata. Replaces the whole object — send the full merged value, not a partial delta.
@@ -4694,6 +4740,14 @@ export interface components {
                 /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                 remember_device_days?: number;
             } | null;
+            recovery_channels?: {
+                /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                default?: "email" | "sms" | "whatsapp" | "factor";
+                /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+            } | null;
             webauthn_rp_id?: string | null;
             login_flow?: string | null;
         };
@@ -4890,6 +4944,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description WebAuthn Relying Party ID for this tenant's passkeys. Defaults to the account domain. Set it to a registrable suffix you own (e.g. `acme.com`) when the login screen is served from more than one host — the RP ID is frozen into every credential at registration, so changing it afterwards invalidates every passkey already enrolled. */
                         webauthn_rp_id?: string | null;
                         /** @description AuthAccount creation date */
@@ -5060,6 +5123,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description WebAuthn Relying Party ID for this tenant's passkeys. Defaults to the account domain. Set it to a registrable suffix you own (e.g. `acme.com`) when the login screen is served from more than one host — the RP ID is frozen into every credential at registration, so changing it afterwards invalidates every passkey already enrolled. */
                         webauthn_rp_id?: string | null;
                         /** @description AuthAccount creation date */
@@ -5184,6 +5256,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description WebAuthn Relying Party ID for this tenant's passkeys. Defaults to the account domain. Set it to a registrable suffix you own (e.g. `acme.com`) when the login screen is served from more than one host — the RP ID is frozen into every credential at registration, so changing it afterwards invalidates every passkey already enrolled. */
                         webauthn_rp_id?: string | null;
                         /** @description AuthAccount creation date */
@@ -5274,6 +5355,14 @@ export interface operations {
                         /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                         remember_device_days?: number;
                     } | null;
+                    recovery_channels?: {
+                        /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                        enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                        default?: "email" | "sms" | "whatsapp" | "factor";
+                        /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                        visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                    } | null;
                     webauthn_rp_id?: string | null;
                     login_flow?: string | null;
                 };
@@ -5379,6 +5468,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description WebAuthn Relying Party ID for this tenant's passkeys. Defaults to the account domain. Set it to a registrable suffix you own (e.g. `acme.com`) when the login screen is served from more than one host — the RP ID is frozen into every credential at registration, so changing it afterwards invalidates every passkey already enrolled. */
                         webauthn_rp_id?: string | null;
                         /** @description AuthAccount creation date */
@@ -5512,6 +5610,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description WebAuthn Relying Party ID for this tenant's passkeys. Defaults to the account domain. Set it to a registrable suffix you own (e.g. `acme.com`) when the login screen is served from more than one host — the RP ID is frozen into every credential at registration, so changing it afterwards invalidates every passkey already enrolled. */
                         webauthn_rp_id?: string | null;
                         /** @description AuthAccount creation date */
@@ -5523,6 +5630,57 @@ export interface operations {
             };
         };
     };
+    "account/recoveryChannelsCapabilities": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Whether the platform can send on each channel right now. */
+                        provider: {
+                            sms: boolean;
+                            whatsapp: boolean;
+                        };
+                        plan: {
+                            /** @description False when billing did not answer. Messaging channels are then treated as not allowed — the failure mode for a paid-per-message channel is "do not send", not "allow". */
+                            known: boolean;
+                            tier?: string;
+                            allows_messaging: boolean;
+                        };
+                        usage: {
+                            /** @description YYYY-MM, UTC. */
+                            month: string;
+                            sent: number;
+                            included: number;
+                            metered: boolean;
+                            hard_ceiling: number;
+                        };
+                        resolved: {
+                            enabled: ("email" | "sms" | "whatsapp" | "factor")[];
+                            default: "email" | "sms" | "whatsapp" | "factor";
+                            visible: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
+                        /** @description Tenant-level availability (configuration × platform × plan). The per-user step — verified phone, enrolled factor — is not applied here. */
+                        channels: {
+                            channel: "email" | "sms" | "whatsapp" | "factor";
+                            available: boolean;
+                            reason?: string;
+                        }[];
+                    };
+                };
+            };
+        };
+    };
     "connection/list": {
         parameters: {
             query?: {
@@ -6222,6 +6380,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description A login flow bound to this client (`loginflow_xxx`), overriding the account's. Absent = inherit. */
                         login_flow?: string | null;
                         /** @description Object is related with this account */
@@ -6325,6 +6492,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description A login flow bound to this client (`loginflow_xxx`), overriding the account's. Absent = inherit. */
                         login_flow?: string | null;
                         /** @description Object is related with this account */
@@ -6421,6 +6597,14 @@ export interface operations {
                         /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                         remember_device_days?: number;
                     } | null;
+                    recovery_channels?: {
+                        /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                        enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                        default?: "email" | "sms" | "whatsapp" | "factor";
+                        /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                        visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                    } | null;
                     login_flow?: string | null;
                     /**
                      * @description Free-form client metadata. Replaces the whole object — send the full merged value, not a partial delta.
@@ -6505,6 +6689,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description A login flow bound to this client (`loginflow_xxx`), overriding the account's. Absent = inherit. */
                         login_flow?: string | null;
                         /** @description Object is related with this account */
@@ -6608,6 +6801,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description A login flow bound to this client (`loginflow_xxx`), overriding the account's. Absent = inherit. */
                         login_flow?: string | null;
                         /** @description Object is related with this account */
@@ -6711,6 +6913,15 @@ export interface operations {
                             /** @description How long a browser that already passed a challenge may skip the next one. 0 (default) challenges every time. */
                             remember_device_days?: number;
                         };
+                        /** @description Password-recovery delivery channels. Set on the Account as the tenant default; the same object on a Client overrides it field by field, like `login_methods` and `mfa_policy`. */
+                        recovery_channels?: {
+                            /** @description Channels the tenant has turned on. `email` is always on regardless of this list: it is what every other channel falls back to. A channel listed here is still offered only if the platform can send it, the plan allows it and the user has a verified destination for it. */
+                            enabled?: ("email" | "sms" | "whatsapp" | "factor")[];
+                            /** @description The channel used when the user is not asked to choose. Falls back to `email` when it is not available for that user. */
+                            default?: "email" | "sms" | "whatsapp" | "factor";
+                            /** @description Channels the recovery screen offers the user to pick from, after they enter their identifier. Empty (the default) keeps today's behaviour: the default channel is used silently and the response never reveals whether the account exists. A non-empty list shows a picker with masked destinations — which does reveal that the account exists and which channels it has, the same trade-off Google and Microsoft make. A tenant decision. */
+                            visible?: ("email" | "sms" | "whatsapp" | "factor")[];
+                        };
                         /** @description A login flow bound to this client (`loginflow_xxx`), overriding the account's. Absent = inherit. */
                         login_flow?: string | null;
                         /** @description Object is related with this account */

package/dist/version.js

@@ -9,13 +9,13 @@
 // login pages could not import the SDK at all. Same pattern as auth-js.
 //
 // The sentinels MUST stay byte-identical to the `from` values in `.releaserc`.
-export const version = "2.6.14";
+export const version = "2.6.15";
 // Short git SHA of the released commit. The version dates a build; this names
 // the exact tree, so a canonical log line or an audit entry leads straight to
 // `git show <sha>`. Deliberately NOT hex: an unreleased build (dev, a local
 // link) cannot be mistaken for a real commit — auth only records values that
 // look like a SHA, and this one never will.
-export const commit = "0acc568";
+export const commit = "1f0c0e0";
 // What this SDK writes in `x-faable-client`. Exported for a consumer that
 // builds a strategy on its own (outside `FaableAuthApi`) and still wants the
 // token request attributed — a bare `authClientCredentials` stamps only what

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/auth-sdk",
-  "version": "2.6.14",
+  "version": "2.6.15",
   "author": "Marc Pomar <marc@faable.com>",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",