@roarkanalytics/sdk 3.20.0 → 4.0.0

package/src/resources/customer-flow.ts

@@ -211,15 +211,32 @@ export 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
@@ -247,7 +264,7 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
+    stage?: UnionMember0.Stage | null;
 
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
@@ -264,6 +281,14 @@ export namespace FlowStep {
 
       waitSeconds?: number | null;
     }
+
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
   }
 
   export interface UnionMember1 {
@@ -277,11 +302,21 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
+    stage?: UnionMember1.Stage | null;
 
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
 
+  export namespace UnionMember1 {
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
+  }
+
   export interface UnionMember2 {
     type: 'CUSTOMER_FIRST_MESSAGE';
 
@@ -293,11 +328,21 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
+    stage?: UnionMember2.Stage | null;
 
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
 
+  export namespace UnionMember2 {
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
+  }
+
   export interface UnionMember3 {
     type: 'CUSTOMER_VERBATIM_TURN';
 
@@ -309,11 +354,21 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
+    stage?: UnionMember3.Stage | null;
 
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
 
+  export namespace UnionMember3 {
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
+  }
+
   export interface UnionMember4 {
     type: 'CUSTOMER_SILENCE';
 
@@ -323,13 +378,23 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
-
     silenceDurationSeconds?: number | null;
 
+    stage?: UnionMember4.Stage | null;
+
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
 
+  export namespace UnionMember4 {
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
+  }
+
   export interface UnionMember5 {
     type: 'CUSTOMER_DTMF';
 
@@ -341,11 +406,21 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
+    stage?: UnionMember5.Stage | null;
 
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
 
+  export namespace UnionMember5 {
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
+  }
+
   export interface UnionMember6 {
     type: 'AGENT_DTMF';
 
@@ -357,11 +432,21 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
+    stage?: UnionMember6.Stage | null;
 
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
 
+  export namespace UnionMember6 {
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
+  }
+
   export interface UnionMember7 {
     type: 'VOICEMAIL';
 
@@ -371,11 +456,21 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
+    stage?: UnionMember7.Stage | null;
 
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
 
+  export namespace UnionMember7 {
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
+  }
+
   export interface UnionMember8 {
     type: 'CUSTOMER_HANDOFF';
 
@@ -387,11 +482,21 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
+    stage?: UnionMember8.Stage | null;
 
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
 
+  export namespace UnionMember8 {
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
+  }
+
   export interface UnionMember9 {
     type: 'SCENARIO_LINK';
 
@@ -405,10 +510,20 @@ export namespace FlowStep {
 
     ref?: string;
 
-    requiredForValidRun?: boolean;
+    stage?: UnionMember9.Stage | null;
 
     steps?: Array<CustomerFlowAPI.FlowStep>;
   }
+
+  export namespace UnionMember9 {
+    export interface Stage {
+      name: string;
+
+      analyze?: boolean;
+
+      required?: boolean;
+    }
+  }
 }
 
 export interface CustomerFlowCreateResponse {
@@ -778,6 +893,16 @@ export namespace CustomerFlowCreateResponse {
          */
         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
          */
@@ -817,9 +942,13 @@ export namespace CustomerFlowCreateResponse {
         properties: { [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';
 
@@ -1114,6 +1243,16 @@ export namespace CustomerFlowCreateResponse {
          */
         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
          */
@@ -1153,9 +1292,13 @@ export namespace CustomerFlowCreateResponse {
         properties: { [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';
 
@@ -1566,6 +1709,16 @@ export namespace CustomerFlowCreateResponse {
          */
         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
          */
@@ -1605,9 +1758,13 @@ export namespace CustomerFlowCreateResponse {
         properties: { [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';
 
@@ -1796,6 +1953,16 @@ export namespace CustomerFlowCreateResponse {
          */
         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
          */
@@ -1835,9 +2002,13 @@ export namespace CustomerFlowCreateResponse {
         properties: { [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';
 
@@ -2135,6 +2306,16 @@ export namespace CustomerFlowCreateResponse {
          */
         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
          */
@@ -2174,9 +2355,13 @@ export namespace CustomerFlowCreateResponse {
         properties: { [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';
 
@@ -2365,6 +2550,16 @@ export namespace CustomerFlowCreateResponse {
          */
         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
          */
@@ -2404,9 +2599,13 @@ export namespace CustomerFlowCreateResponse {
         properties: { [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';
 
@@ -2782,6 +2981,16 @@ export namespace CustomerFlowCreateResponse {
          */
         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
          */
@@ -2821,9 +3030,13 @@ export namespace CustomerFlowCreateResponse {
         properties: { [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';
 
@@ -3111,6 +3324,16 @@ export namespace CustomerFlowCreateResponse {
          */
         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
          */
@@ -3150,9 +3373,13 @@ export namespace CustomerFlowCreateResponse {
         properties: { [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';
 
@@ -3589,6 +3816,16 @@ export namespace CustomerFlowUpdateResponse {
          */
         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
          */
@@ -3628,9 +3865,13 @@ export namespace CustomerFlowUpdateResponse {
         properties: { [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';
 
@@ -3925,6 +4166,16 @@ export namespace CustomerFlowUpdateResponse {
          */
         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
          */
@@ -3964,9 +4215,13 @@ export namespace CustomerFlowUpdateResponse {
         properties: { [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';
 
@@ -4377,6 +4632,16 @@ export namespace CustomerFlowUpdateResponse {
          */
         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
          */
@@ -4416,9 +4681,13 @@ export namespace CustomerFlowUpdateResponse {
         properties: { [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';
 
@@ -4607,6 +4876,16 @@ export namespace CustomerFlowUpdateResponse {
          */
         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
          */
@@ -4646,9 +4925,13 @@ export namespace CustomerFlowUpdateResponse {
         properties: { [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';
 
@@ -4946,6 +5229,16 @@ export namespace CustomerFlowUpdateResponse {
          */
         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
          */
@@ -4985,9 +5278,13 @@ export namespace CustomerFlowUpdateResponse {
         properties: { [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';
 
@@ -5176,6 +5473,16 @@ export namespace CustomerFlowUpdateResponse {
          */
         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
          */
@@ -5215,9 +5522,13 @@ export namespace CustomerFlowUpdateResponse {
         properties: { [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 +5904,16 @@ export namespace CustomerFlowUpdateResponse {
          */
         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
          */
@@ -5632,9 +5953,13 @@ export namespace CustomerFlowUpdateResponse {
         properties: { [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';
 
@@ -5922,6 +6247,16 @@ export namespace CustomerFlowUpdateResponse {
          */
         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
          */
@@ -5961,9 +6296,13 @@ export namespace CustomerFlowUpdateResponse {
         properties: { [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';
 
@@ -6403,6 +6742,16 @@ export namespace CustomerFlowListResponse {
          */
         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
          */
@@ -6442,9 +6791,13 @@ export namespace CustomerFlowListResponse {
         properties: { [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';
 
@@ -6739,6 +7092,16 @@ export namespace CustomerFlowListResponse {
          */
         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
          */
@@ -6778,9 +7141,13 @@ export namespace CustomerFlowListResponse {
         properties: { [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';
 
@@ -7191,6 +7558,16 @@ export namespace CustomerFlowListResponse {
          */
         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
          */
@@ -7230,9 +7607,13 @@ export namespace CustomerFlowListResponse {
         properties: { [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';
 
@@ -7421,6 +7802,16 @@ export namespace CustomerFlowListResponse {
          */
         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
          */
@@ -7460,9 +7851,13 @@ export namespace CustomerFlowListResponse {
         properties: { [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';
 
@@ -7760,6 +8155,16 @@ export namespace CustomerFlowListResponse {
          */
         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
          */
@@ -7799,9 +8204,13 @@ export namespace CustomerFlowListResponse {
         properties: { [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';
 
@@ -7990,6 +8399,16 @@ export namespace CustomerFlowListResponse {
          */
         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
          */
@@ -8029,9 +8448,13 @@ export namespace CustomerFlowListResponse {
         properties: { [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';
 
@@ -8407,6 +8830,16 @@ export namespace CustomerFlowListResponse {
          */
         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
          */
@@ -8446,9 +8879,13 @@ export namespace CustomerFlowListResponse {
         properties: { [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';
 
@@ -8736,6 +9173,16 @@ export namespace CustomerFlowListResponse {
          */
         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
          */
@@ -8775,9 +9222,13 @@ export namespace CustomerFlowListResponse {
         properties: { [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';
 
@@ -9244,6 +9695,16 @@ export namespace CustomerFlowDuplicateResponse {
          */
         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
          */
@@ -9283,9 +9744,13 @@ export namespace CustomerFlowDuplicateResponse {
         properties: { [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';
 
@@ -9580,6 +10045,16 @@ export namespace CustomerFlowDuplicateResponse {
          */
         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
          */
@@ -9619,9 +10094,13 @@ export namespace CustomerFlowDuplicateResponse {
         properties: { [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';
 
@@ -10032,6 +10511,16 @@ export namespace CustomerFlowDuplicateResponse {
          */
         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
          */
@@ -10071,9 +10560,13 @@ export namespace CustomerFlowDuplicateResponse {
         properties: { [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';
 
@@ -10262,6 +10755,16 @@ export namespace CustomerFlowDuplicateResponse {
          */
         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
          */
@@ -10301,9 +10804,13 @@ export namespace CustomerFlowDuplicateResponse {
         properties: { [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';
 
@@ -10601,6 +11108,16 @@ export namespace CustomerFlowDuplicateResponse {
          */
         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
          */
@@ -10640,9 +11157,13 @@ export namespace CustomerFlowDuplicateResponse {
         properties: { [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';
 
@@ -10831,6 +11352,16 @@ export namespace CustomerFlowDuplicateResponse {
          */
         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
          */
@@ -10870,9 +11401,13 @@ export namespace CustomerFlowDuplicateResponse {
         properties: { [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';
 
@@ -11248,6 +11783,16 @@ export namespace CustomerFlowDuplicateResponse {
          */
         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
          */
@@ -11287,9 +11832,13 @@ export namespace CustomerFlowDuplicateResponse {
         properties: { [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';
 
@@ -11577,6 +12126,16 @@ export namespace CustomerFlowDuplicateResponse {
          */
         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
          */
@@ -11616,9 +12175,13 @@ export namespace CustomerFlowDuplicateResponse {
         properties: { [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';
 
@@ -12055,6 +12618,16 @@ export namespace CustomerFlowGetByIDResponse {
          */
         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
          */
@@ -12094,9 +12667,13 @@ export namespace CustomerFlowGetByIDResponse {
         properties: { [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';
 
@@ -12391,6 +12968,16 @@ export namespace CustomerFlowGetByIDResponse {
          */
         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
          */
@@ -12430,9 +13017,13 @@ export namespace CustomerFlowGetByIDResponse {
         properties: { [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';
 
@@ -12843,6 +13434,16 @@ export namespace CustomerFlowGetByIDResponse {
          */
         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
          */
@@ -12882,9 +13483,13 @@ export namespace CustomerFlowGetByIDResponse {
         properties: { [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';
 
@@ -13073,6 +13678,16 @@ export namespace CustomerFlowGetByIDResponse {
          */
         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
          */
@@ -13112,9 +13727,13 @@ export namespace CustomerFlowGetByIDResponse {
         properties: { [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';
 
@@ -13412,6 +14031,16 @@ export namespace CustomerFlowGetByIDResponse {
          */
         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
          */
@@ -13451,9 +14080,13 @@ export namespace CustomerFlowGetByIDResponse {
         properties: { [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';
 
@@ -13642,6 +14275,16 @@ export namespace CustomerFlowGetByIDResponse {
          */
         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
          */
@@ -13681,9 +14324,13 @@ export namespace CustomerFlowGetByIDResponse {
         properties: { [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';
 
@@ -14059,6 +14706,16 @@ export namespace CustomerFlowGetByIDResponse {
          */
         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
          */
@@ -14098,9 +14755,13 @@ export namespace CustomerFlowGetByIDResponse {
         properties: { [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';
 
@@ -14388,6 +15049,16 @@ export namespace CustomerFlowGetByIDResponse {
          */
         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
          */
@@ -14427,9 +15098,13 @@ export namespace CustomerFlowGetByIDResponse {
         properties: { [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';
 
@@ -14754,6 +15429,16 @@ export namespace CustomerFlowReplaceGraphResponse {
          */
         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
          */
@@ -14793,9 +15478,13 @@ export namespace CustomerFlowReplaceGraphResponse {
         properties: { [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';
 
@@ -15093,6 +15782,16 @@ export namespace CustomerFlowReplaceGraphResponse {
          */
         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
          */
@@ -15132,9 +15831,13 @@ export namespace CustomerFlowReplaceGraphResponse {
         properties: { [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';
 
@@ -15323,6 +16026,16 @@ export namespace CustomerFlowReplaceGraphResponse {
          */
         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
          */
@@ -15362,9 +16075,13 @@ export namespace CustomerFlowReplaceGraphResponse {
         properties: { [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';
 
@@ -15652,6 +16369,16 @@ export namespace CustomerFlowReplaceGraphResponse {
          */
         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
          */
@@ -15691,9 +16418,13 @@ export namespace CustomerFlowReplaceGraphResponse {
         properties: { [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';
 
@@ -16001,6 +16732,16 @@ export namespace CustomerFlowUpdateHappyPathResponse {
        */
       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
        */
@@ -16040,9 +16781,13 @@ export namespace CustomerFlowUpdateHappyPathResponse {
       properties: { [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';
 
@@ -16340,6 +17085,16 @@ export namespace CustomerFlowUpdateHappyPathResponse {
        */
       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
        */
@@ -16379,9 +17134,13 @@ export namespace CustomerFlowUpdateHappyPathResponse {
       properties: { [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';
 
@@ -16570,6 +17329,16 @@ export namespace CustomerFlowUpdateHappyPathResponse {
        */
       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
        */
@@ -16609,9 +17378,13 @@ export namespace CustomerFlowUpdateHappyPathResponse {
       properties: { [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';
 
@@ -16899,6 +17672,16 @@ export namespace CustomerFlowUpdateHappyPathResponse {
        */
       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
        */
@@ -16938,9 +17721,13 @@ export namespace CustomerFlowUpdateHappyPathResponse {
       properties: { [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';