@roarkanalytics/sdk 3.20.0 → 4.0.0

package/resources/customer-flow.d.ts

@@ -164,15 +164,32 @@ export declare class CustomerFlow extends APIResource {
  * flow's policy. Use it where one missed step makes the rest of the call
  * meaningless: an authentication menu, say, with `then: HANG_UP_INVALIDATE`.
  *
- * Any step may set `requiredForValidRun`, which marks a step the flow requires a
- * run to reach for its result to count. A run that ends without ever reaching it
- * is invalidated: it stays in the report, labelled with the step it never reached
- * and where it stopped, and is left out of the run score and the success-criteria
- * verdict. Put it on the step where the test itself begins, typically the first
- * one after an IVR or a login, so an agent that never gets past the menu does not
- * fail every check in a scenario it never started. A path may have one; a
- * branching flow may mark one step per branch, and reaching any of them makes the
- * call valid. A path that marks none behaves exactly as before.
+ * Any step may set `stage`, the named phase of the flow it belongs to: the IVR,
+ * the login, the scenario itself. Steps in one stage are drawn as a group in the
+ * editor, and the name is yours: the reports say it back to you. The stage does
+ * not have to exist first, it is created the first time a step names it, and a
+ * name already in the project is matched ignoring case.
+ *
+ * A stage with `required: true` is a gate. A run that ends without getting PAST it
+ * never reached what was being measured, so it stays in the report, labelled with
+ * the stage it never completed and the one it stopped in, and is left out of the
+ * run score and the success-criteria verdict: an agent that never clears the IVR
+ * does not fail every check in a scenario it never started. `required` belongs to
+ * the stage rather than to the step, so a read returns it on every step in that
+ * stage, and a write that sets it on any one of them marks the whole stage. A flow
+ * that requires no stage is scored exactly as before.
+ *
+ * A stage with `analyze: false` is not measured. Its turns are kept out of the
+ * core call metrics (talk time, speech pace, turn and response timings), which is
+ * what an IVR usually wants alongside `required: true`: the run has to get through
+ * the menu, but how the agent sounded reading it is not what is being tested.
+ * Coverage is being extended package by package, so the judged metrics (quality,
+ * compliance, repetition, escalation, tone) still read the whole call for now.
+ * Nothing is cut and nothing is re-timed, so a turn at 4:10 is still at 4:10 with
+ * an earlier stage excluded, and rate metrics divide by the part of the call that
+ * was measured rather than by the whole of it. Defaults to true, belongs to the
+ * stage the same way `required` does, and turning it off on any one step turns it
+ * off for the stage.
  */
 export type FlowStep = FlowStep.UnionMember0 | FlowStep.UnionMember1 | FlowStep.UnionMember2 | FlowStep.UnionMember3 | FlowStep.UnionMember4 | FlowStep.UnionMember5 | FlowStep.UnionMember6 | FlowStep.UnionMember7 | FlowStep.UnionMember8 | FlowStep.UnionMember9;
 export declare namespace FlowStep {
@@ -183,7 +200,7 @@ export declare namespace FlowStep {
         nodeId?: string;
         offScriptPolicy?: UnionMember0.OffScriptPolicy | null;
         ref?: string;
-        requiredForValidRun?: boolean;
+        stage?: UnionMember0.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
     namespace UnionMember0 {
@@ -194,6 +211,11 @@ export declare namespace FlowStep {
             sayLine?: string | null;
             waitSeconds?: number | null;
         }
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
     }
     interface UnionMember1 {
         type: 'CUSTOMER_TURN';
@@ -201,71 +223,127 @@ export declare namespace FlowStep {
         mergeIntoNodeIds?: Array<string>;
         nodeId?: string;
         ref?: string;
-        requiredForValidRun?: boolean;
+        stage?: UnionMember1.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
+    namespace UnionMember1 {
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
+    }
     interface UnionMember2 {
         type: 'CUSTOMER_FIRST_MESSAGE';
         content?: string | null;
         mergeIntoNodeIds?: Array<string>;
         nodeId?: string;
         ref?: string;
-        requiredForValidRun?: boolean;
+        stage?: UnionMember2.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
+    namespace UnionMember2 {
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
+    }
     interface UnionMember3 {
         type: 'CUSTOMER_VERBATIM_TURN';
         content?: string | null;
         mergeIntoNodeIds?: Array<string>;
         nodeId?: string;
         ref?: string;
-        requiredForValidRun?: boolean;
+        stage?: UnionMember3.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
+    namespace UnionMember3 {
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
+    }
     interface UnionMember4 {
         type: 'CUSTOMER_SILENCE';
         mergeIntoNodeIds?: Array<string>;
         nodeId?: string;
         ref?: string;
-        requiredForValidRun?: boolean;
         silenceDurationSeconds?: number | null;
+        stage?: UnionMember4.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
+    namespace UnionMember4 {
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
+    }
     interface UnionMember5 {
         type: 'CUSTOMER_DTMF';
         dtmfDigits?: string | null;
         mergeIntoNodeIds?: Array<string>;
         nodeId?: string;
         ref?: string;
-        requiredForValidRun?: boolean;
+        stage?: UnionMember5.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
+    namespace UnionMember5 {
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
+    }
     interface UnionMember6 {
         type: 'AGENT_DTMF';
         dtmfDigits?: string | null;
         mergeIntoNodeIds?: Array<string>;
         nodeId?: string;
         ref?: string;
-        requiredForValidRun?: boolean;
+        stage?: UnionMember6.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
+    namespace UnionMember6 {
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
+    }
     interface UnionMember7 {
         type: 'VOICEMAIL';
         mergeIntoNodeIds?: Array<string>;
         nodeId?: string;
         ref?: string;
-        requiredForValidRun?: boolean;
+        stage?: UnionMember7.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
+    namespace UnionMember7 {
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
+    }
     interface UnionMember8 {
         type: 'CUSTOMER_HANDOFF';
         handoffPersonaId?: string | null;
         mergeIntoNodeIds?: Array<string>;
         nodeId?: string;
         ref?: string;
-        requiredForValidRun?: boolean;
+        stage?: UnionMember8.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
+    namespace UnionMember8 {
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
+    }
     interface UnionMember9 {
         type: 'SCENARIO_LINK';
         linkedCustomerFlowId?: string | null;
@@ -273,9 +351,16 @@ export declare namespace FlowStep {
         mergeIntoNodeIds?: Array<string>;
         nodeId?: string;
         ref?: string;
-        requiredForValidRun?: boolean;
+        stage?: UnionMember9.Stage | null;
         steps?: Array<CustomerFlowAPI.FlowStep>;
     }
+    namespace UnionMember9 {
+        interface Stage {
+            name: string;
+            analyze?: boolean;
+            required?: boolean;
+        }
+    }
 }
 export interface CustomerFlowCreateResponse {
     /**
@@ -524,6 +609,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 +637,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 +817,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 +845,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 +1116,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 +1144,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 +1252,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 +1280,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 +1462,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 +1490,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 +1598,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 +1626,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 +1869,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 +1897,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 +2071,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 +2099,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 +2394,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 +2422,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 +2602,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 +2630,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 +2901,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 +2929,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 +3037,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 +3065,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 +3247,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 +3275,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 +3383,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 +3411,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 +3654,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 +3682,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 +3856,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 +3884,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 +4180,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 +4208,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 +4388,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 +4416,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 +4687,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 +4715,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 +4823,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 +4851,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 +5033,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 +5061,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 +5169,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 +5197,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 +5440,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 +5468,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 +5642,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 +5670,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 +5990,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 +6018,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 +6198,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 +6226,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 +6497,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 +6525,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 +6633,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 +6661,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 +6843,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 +6871,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 +6979,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 +7007,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 +7250,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 +7278,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 +7452,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 +7480,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 +7775,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 +7803,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 +7983,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 +8011,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 +8282,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 +8310,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 +8418,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 +8446,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 +8628,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 +8656,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 +8764,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 +8792,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 +9035,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 +9063,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 +9237,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 +9265,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 +9469,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 +9497,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 +9679,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 +9707,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 +9815,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 +9843,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 +10017,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 +10045,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 +10234,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 +10262,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 +10444,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 +10472,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 +10580,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 +10608,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 +10782,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 +10810,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';
             /**