@roarkanalytics/sdk 3.20.0 → 3.21.0

package/resources/customer-flow.d.ts

@@ -524,6 +524,15 @@ export declare namespace CustomerFlowCreateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -543,9 +552,13 @@ export declare namespace CustomerFlowCreateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -719,6 +732,15 @@ export declare namespace CustomerFlowCreateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -738,9 +760,13 @@ export declare namespace CustomerFlowCreateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -1005,6 +1031,15 @@ export declare namespace CustomerFlowCreateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -1024,9 +1059,13 @@ export declare namespace CustomerFlowCreateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -1128,6 +1167,15 @@ export declare namespace CustomerFlowCreateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -1147,9 +1195,13 @@ export declare namespace CustomerFlowCreateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -1325,6 +1377,15 @@ export declare namespace CustomerFlowCreateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -1344,9 +1405,13 @@ export declare namespace CustomerFlowCreateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -1448,6 +1513,15 @@ export declare namespace CustomerFlowCreateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -1467,9 +1541,13 @@ export declare namespace CustomerFlowCreateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -1706,6 +1784,15 @@ export declare namespace CustomerFlowCreateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -1725,9 +1812,13 @@ export declare namespace CustomerFlowCreateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -1895,6 +1986,15 @@ export declare namespace CustomerFlowCreateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -1914,9 +2014,13 @@ export declare namespace CustomerFlowCreateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -2205,6 +2309,15 @@ export declare namespace CustomerFlowUpdateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -2224,9 +2337,13 @@ export declare namespace CustomerFlowUpdateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -2400,6 +2517,15 @@ export declare namespace CustomerFlowUpdateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -2419,9 +2545,13 @@ export declare namespace CustomerFlowUpdateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -2686,6 +2816,15 @@ export declare namespace CustomerFlowUpdateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -2705,9 +2844,13 @@ export declare namespace CustomerFlowUpdateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -2809,6 +2952,15 @@ export declare namespace CustomerFlowUpdateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -2828,9 +2980,13 @@ export declare namespace CustomerFlowUpdateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -3006,6 +3162,15 @@ export declare namespace CustomerFlowUpdateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -3025,9 +3190,13 @@ export declare namespace CustomerFlowUpdateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -3129,6 +3298,15 @@ export declare namespace CustomerFlowUpdateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -3148,9 +3326,13 @@ export declare namespace CustomerFlowUpdateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -3387,6 +3569,15 @@ export declare namespace CustomerFlowUpdateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -3406,9 +3597,13 @@ export declare namespace CustomerFlowUpdateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -3576,6 +3771,15 @@ export declare namespace CustomerFlowUpdateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -3595,9 +3799,13 @@ export declare namespace CustomerFlowUpdateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -3887,6 +4095,15 @@ export declare namespace CustomerFlowListResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -3906,9 +4123,13 @@ export declare namespace CustomerFlowListResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -4082,6 +4303,15 @@ export declare namespace CustomerFlowListResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -4101,9 +4331,13 @@ export declare namespace CustomerFlowListResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -4368,6 +4602,15 @@ export declare namespace CustomerFlowListResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -4387,9 +4630,13 @@ export declare namespace CustomerFlowListResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -4491,6 +4738,15 @@ export declare namespace CustomerFlowListResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -4510,9 +4766,13 @@ export declare namespace CustomerFlowListResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -4688,6 +4948,15 @@ export declare namespace CustomerFlowListResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -4707,9 +4976,13 @@ export declare namespace CustomerFlowListResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -4811,6 +5084,15 @@ export declare namespace CustomerFlowListResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -4830,9 +5112,13 @@ export declare namespace CustomerFlowListResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -5069,6 +5355,15 @@ export declare namespace CustomerFlowListResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -5088,9 +5383,13 @@ export declare namespace CustomerFlowListResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -5258,6 +5557,15 @@ export declare namespace CustomerFlowListResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -5277,9 +5585,13 @@ export declare namespace CustomerFlowListResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -5593,6 +5905,15 @@ export declare namespace CustomerFlowDuplicateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -5612,9 +5933,13 @@ export declare namespace CustomerFlowDuplicateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -5788,6 +6113,15 @@ export declare namespace CustomerFlowDuplicateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -5807,9 +6141,13 @@ export declare namespace CustomerFlowDuplicateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -6074,6 +6412,15 @@ export declare namespace CustomerFlowDuplicateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -6093,9 +6440,13 @@ export declare namespace CustomerFlowDuplicateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -6197,6 +6548,15 @@ export declare namespace CustomerFlowDuplicateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -6216,9 +6576,13 @@ export declare namespace CustomerFlowDuplicateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -6394,6 +6758,15 @@ export declare namespace CustomerFlowDuplicateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -6413,9 +6786,13 @@ export declare namespace CustomerFlowDuplicateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -6517,6 +6894,15 @@ export declare namespace CustomerFlowDuplicateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -6536,9 +6922,13 @@ export declare namespace CustomerFlowDuplicateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -6775,6 +7165,15 @@ export declare namespace CustomerFlowDuplicateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -6794,9 +7193,13 @@ export declare namespace CustomerFlowDuplicateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -6964,6 +7367,15 @@ export declare namespace CustomerFlowDuplicateResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -6983,9 +7395,13 @@ export declare namespace CustomerFlowDuplicateResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -7274,6 +7690,15 @@ export declare namespace CustomerFlowGetByIDResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -7293,9 +7718,13 @@ export declare namespace CustomerFlowGetByIDResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -7469,6 +7898,15 @@ export declare namespace CustomerFlowGetByIDResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -7488,9 +7926,13 @@ export declare namespace CustomerFlowGetByIDResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -7755,6 +8197,15 @@ export declare namespace CustomerFlowGetByIDResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -7774,9 +8225,13 @@ export declare namespace CustomerFlowGetByIDResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -7878,6 +8333,15 @@ export declare namespace CustomerFlowGetByIDResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -7897,9 +8361,13 @@ export declare namespace CustomerFlowGetByIDResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -8075,6 +8543,15 @@ export declare namespace CustomerFlowGetByIDResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -8094,9 +8571,13 @@ export declare namespace CustomerFlowGetByIDResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -8198,6 +8679,15 @@ export declare namespace CustomerFlowGetByIDResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -8217,9 +8707,13 @@ export declare namespace CustomerFlowGetByIDResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -8456,6 +8950,15 @@ export declare namespace CustomerFlowGetByIDResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -8475,9 +8978,13 @@ export declare namespace CustomerFlowGetByIDResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -8645,6 +9152,15 @@ export declare namespace CustomerFlowGetByIDResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -8664,9 +9180,13 @@ export declare namespace CustomerFlowGetByIDResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -8864,6 +9384,15 @@ export declare namespace CustomerFlowReplaceGraphResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -8883,9 +9412,13 @@ export declare namespace CustomerFlowReplaceGraphResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -9061,6 +9594,15 @@ export declare namespace CustomerFlowReplaceGraphResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -9080,9 +9622,13 @@ export declare namespace CustomerFlowReplaceGraphResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -9184,6 +9730,15 @@ export declare namespace CustomerFlowReplaceGraphResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -9203,9 +9758,13 @@ export declare namespace CustomerFlowReplaceGraphResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -9373,6 +9932,15 @@ export declare namespace CustomerFlowReplaceGraphResponse {
                  * How clearly the persona expresses their intentions
                  */
                 intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+                /**
+                 * How much the persona talks over the agent while it is still speaking. OFF waits
+                 * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+                 * taking the floor, which tests whether the agent wrongly stops for them.
+                 * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+                 * Timing is randomised per turn, so two runs of the same persona do not interrupt
+                 * at identical moments.
+                 */
+                interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
                 /**
                  * Primary language ISO 639-1 code for the persona
                  */
@@ -9392,9 +9960,13 @@ export declare namespace CustomerFlowReplaceGraphResponse {
                     [key: string]: unknown;
                 };
                 /**
-                 * Controls how quickly the persona responds to pauses in conversation (QUICK,
-                 * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-                 * for several seconds.
+                 * Deprecated and inert: it no longer affects the call. It set how long the persona
+                 * waited once the agent stopped talking, and measured across production
+                 * simulations it moved the reply gap by less than the noise floor, because model
+                 * and speech latency dominate it. Every persona now uses one voice-activity
+                 * profile. Use `interruption` for a caller who talks over the agent. Still
+                 * accepted and stored so existing clients keep working. BARGE_IN is stored as
+                 * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
                  */
                 responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
                 /**
@@ -9577,6 +10149,15 @@ export declare namespace CustomerFlowUpdateHappyPathResponse {
              * How clearly the persona expresses their intentions
              */
             intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+            /**
+             * How much the persona talks over the agent while it is still speaking. OFF waits
+             * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+             * taking the floor, which tests whether the agent wrongly stops for them.
+             * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+             * Timing is randomised per turn, so two runs of the same persona do not interrupt
+             * at identical moments.
+             */
+            interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
             /**
              * Primary language ISO 639-1 code for the persona
              */
@@ -9596,9 +10177,13 @@ export declare namespace CustomerFlowUpdateHappyPathResponse {
                 [key: string]: unknown;
             };
             /**
-             * Controls how quickly the persona responds to pauses in conversation (QUICK,
-             * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-             * for several seconds.
+             * Deprecated and inert: it no longer affects the call. It set how long the persona
+             * waited once the agent stopped talking, and measured across production
+             * simulations it moved the reply gap by less than the noise floor, because model
+             * and speech latency dominate it. Every persona now uses one voice-activity
+             * profile. Use `interruption` for a caller who talks over the agent. Still
+             * accepted and stored so existing clients keep working. BARGE_IN is stored as
+             * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
              */
             responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
             /**
@@ -9774,6 +10359,15 @@ export declare namespace CustomerFlowUpdateHappyPathResponse {
              * How clearly the persona expresses their intentions
              */
             intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+            /**
+             * How much the persona talks over the agent while it is still speaking. OFF waits
+             * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+             * taking the floor, which tests whether the agent wrongly stops for them.
+             * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+             * Timing is randomised per turn, so two runs of the same persona do not interrupt
+             * at identical moments.
+             */
+            interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
             /**
              * Primary language ISO 639-1 code for the persona
              */
@@ -9793,9 +10387,13 @@ export declare namespace CustomerFlowUpdateHappyPathResponse {
                 [key: string]: unknown;
             };
             /**
-             * Controls how quickly the persona responds to pauses in conversation (QUICK,
-             * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-             * for several seconds.
+             * Deprecated and inert: it no longer affects the call. It set how long the persona
+             * waited once the agent stopped talking, and measured across production
+             * simulations it moved the reply gap by less than the noise floor, because model
+             * and speech latency dominate it. Every persona now uses one voice-activity
+             * profile. Use `interruption` for a caller who talks over the agent. Still
+             * accepted and stored so existing clients keep working. BARGE_IN is stored as
+             * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
              */
             responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
             /**
@@ -9897,6 +10495,15 @@ export declare namespace CustomerFlowUpdateHappyPathResponse {
              * How clearly the persona expresses their intentions
              */
             intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+            /**
+             * How much the persona talks over the agent while it is still speaking. OFF waits
+             * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+             * taking the floor, which tests whether the agent wrongly stops for them.
+             * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+             * Timing is randomised per turn, so two runs of the same persona do not interrupt
+             * at identical moments.
+             */
+            interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
             /**
              * Primary language ISO 639-1 code for the persona
              */
@@ -9916,9 +10523,13 @@ export declare namespace CustomerFlowUpdateHappyPathResponse {
                 [key: string]: unknown;
             };
             /**
-             * Controls how quickly the persona responds to pauses in conversation (QUICK,
-             * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-             * for several seconds.
+             * Deprecated and inert: it no longer affects the call. It set how long the persona
+             * waited once the agent stopped talking, and measured across production
+             * simulations it moved the reply gap by less than the noise floor, because model
+             * and speech latency dominate it. Every persona now uses one voice-activity
+             * profile. Use `interruption` for a caller who talks over the agent. Still
+             * accepted and stored so existing clients keep working. BARGE_IN is stored as
+             * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
              */
             responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
             /**
@@ -10086,6 +10697,15 @@ export declare namespace CustomerFlowUpdateHappyPathResponse {
              * How clearly the persona expresses their intentions
              */
             intentClarity: 'CLEAR' | 'INDIRECT' | 'VAGUE';
+            /**
+             * How much the persona talks over the agent while it is still speaking. OFF waits
+             * its turn. BACKCHANNEL makes listening noises ("mm-hm") over the agent without
+             * taking the floor, which tests whether the agent wrongly stops for them.
+             * OCCASIONAL adds cutting in on some long agent turns, HEAVY on most of them.
+             * Timing is randomised per turn, so two runs of the same persona do not interrupt
+             * at identical moments.
+             */
+            interruption: 'OFF' | 'BACKCHANNEL' | 'OCCASIONAL' | 'HEAVY';
             /**
              * Primary language ISO 639-1 code for the persona
              */
@@ -10105,9 +10725,13 @@ export declare namespace CustomerFlowUpdateHappyPathResponse {
                 [key: string]: unknown;
             };
             /**
-             * Controls how quickly the persona responds to pauses in conversation (QUICK,
-             * NORMAL, RELAXED). BARGE_IN also talks over the agent once it has held the floor
-             * for several seconds.
+             * Deprecated and inert: it no longer affects the call. It set how long the persona
+             * waited once the agent stopped talking, and measured across production
+             * simulations it moved the reply gap by less than the noise floor, because model
+             * and speech latency dominate it. Every persona now uses one voice-activity
+             * profile. Use `interruption` for a caller who talks over the agent. Still
+             * accepted and stored so existing clients keep working. BARGE_IN is stored as
+             * `responseTiming: QUICK` with `interruption: OCCASIONAL`.
              */
             responseTiming: 'RELAXED' | 'NORMAL' | 'QUICK' | 'BARGE_IN';
             /**