@elevenlabs/elevenlabs-js 2.38.1 → 2.40.0

package/serialization/types/AstLessThanOrEqualsOperatorNodeInputRight.d.ts

@@ -8,13 +8,16 @@ import { AstNumberNodeInput } from "./AstNumberNodeInput";
 import { AstStringNodeInput } from "./AstStringNodeInput";
 export declare const AstLessThanOrEqualsOperatorNodeInputRight: core.serialization.Schema<serializers.AstLessThanOrEqualsOperatorNodeInputRight.Raw, ElevenLabs.AstLessThanOrEqualsOperatorNodeInputRight>;
 export declare namespace AstLessThanOrEqualsOperatorNodeInputRight {
-    type Raw = AstLessThanOrEqualsOperatorNodeInputRight.AndOperator | AstLessThanOrEqualsOperatorNodeInputRight.BooleanLiteral | AstLessThanOrEqualsOperatorNodeInputRight.DynamicVariable | AstLessThanOrEqualsOperatorNodeInputRight.EqOperator | AstLessThanOrEqualsOperatorNodeInputRight.GtOperator | AstLessThanOrEqualsOperatorNodeInputRight.GteOperator | AstLessThanOrEqualsOperatorNodeInputRight.Llm | AstLessThanOrEqualsOperatorNodeInputRight.LtOperator | AstLessThanOrEqualsOperatorNodeInputRight.LteOperator | AstLessThanOrEqualsOperatorNodeInputRight.NeqOperator | AstLessThanOrEqualsOperatorNodeInputRight.NumberLiteral | AstLessThanOrEqualsOperatorNodeInputRight.OrOperator | AstLessThanOrEqualsOperatorNodeInputRight.StringLiteral;
+    type Raw = AstLessThanOrEqualsOperatorNodeInputRight.AndOperator | AstLessThanOrEqualsOperatorNodeInputRight.BooleanLiteral | AstLessThanOrEqualsOperatorNodeInputRight.ConditionalOperator | AstLessThanOrEqualsOperatorNodeInputRight.DynamicVariable | AstLessThanOrEqualsOperatorNodeInputRight.EqOperator | AstLessThanOrEqualsOperatorNodeInputRight.GtOperator | AstLessThanOrEqualsOperatorNodeInputRight.GteOperator | AstLessThanOrEqualsOperatorNodeInputRight.Llm | AstLessThanOrEqualsOperatorNodeInputRight.LtOperator | AstLessThanOrEqualsOperatorNodeInputRight.LteOperator | AstLessThanOrEqualsOperatorNodeInputRight.NeqOperator | AstLessThanOrEqualsOperatorNodeInputRight.NumberLiteral | AstLessThanOrEqualsOperatorNodeInputRight.OrOperator | AstLessThanOrEqualsOperatorNodeInputRight.StringLiteral;
     interface AndOperator extends serializers.AstAndOperatorNodeInput.Raw {
         type: "and_operator";
     }
     interface BooleanLiteral extends AstBooleanNodeInput.Raw {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends serializers.AstConditionalOperatorNodeInput.Raw {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeInput.Raw {
         type: "dynamic_variable";
     }
@@ -27,8 +30,9 @@ export declare namespace AstLessThanOrEqualsOperatorNodeInputRight {
     interface GteOperator extends serializers.AstGreaterThanOrEqualsOperatorNodeInput.Raw {
         type: "gte_operator";
     }
-    interface Llm extends AstllmNodeInput.Raw {
+    interface Llm {
         type: "llm";
+        value: AstllmNodeInput.Raw;
     }
     interface LtOperator extends serializers.AstLessThanOperatorNodeInput.Raw {
         type: "lt_operator";

package/serialization/types/AstLessThanOrEqualsOperatorNodeInputRight.js

@@ -46,11 +46,14 @@ exports.AstLessThanOrEqualsOperatorNodeInputRight = core.serialization
     .union("type", {
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeInput),
     boolean_literal: AstBooleanNodeInput_1.AstBooleanNodeInput,
+    conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeInput),
     dynamic_variable: AstDynamicVariableNodeInput_1.AstDynamicVariableNodeInput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeInput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeInput),
     gte_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOrEqualsOperatorNodeInput),
-    llm: AstllmNodeInput_1.AstllmNodeInput,
+    llm: core.serialization.object({
+        value: AstllmNodeInput_1.AstllmNodeInput,
+    }),
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeInput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeInput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeInput),

package/serialization/types/AstLessThanOrEqualsOperatorNodeOutputLeft.d.ts

@@ -8,13 +8,16 @@ import { AstNumberNodeOutput } from "./AstNumberNodeOutput";
 import { AstStringNodeOutput } from "./AstStringNodeOutput";
 export declare const AstLessThanOrEqualsOperatorNodeOutputLeft: core.serialization.Schema<serializers.AstLessThanOrEqualsOperatorNodeOutputLeft.Raw, ElevenLabs.AstLessThanOrEqualsOperatorNodeOutputLeft>;
 export declare namespace AstLessThanOrEqualsOperatorNodeOutputLeft {
-    type Raw = AstLessThanOrEqualsOperatorNodeOutputLeft.AndOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.BooleanLiteral | AstLessThanOrEqualsOperatorNodeOutputLeft.DynamicVariable | AstLessThanOrEqualsOperatorNodeOutputLeft.EqOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.GtOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.GteOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.Llm | AstLessThanOrEqualsOperatorNodeOutputLeft.LtOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.LteOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.NeqOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.NumberLiteral | AstLessThanOrEqualsOperatorNodeOutputLeft.OrOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.StringLiteral;
+    type Raw = AstLessThanOrEqualsOperatorNodeOutputLeft.AndOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.BooleanLiteral | AstLessThanOrEqualsOperatorNodeOutputLeft.ConditionalOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.DynamicVariable | AstLessThanOrEqualsOperatorNodeOutputLeft.EqOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.GtOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.GteOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.Llm | AstLessThanOrEqualsOperatorNodeOutputLeft.LtOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.LteOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.NeqOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.NumberLiteral | AstLessThanOrEqualsOperatorNodeOutputLeft.OrOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.StringLiteral;
     interface AndOperator extends serializers.AstAndOperatorNodeOutput.Raw {
         type: "and_operator";
     }
     interface BooleanLiteral extends AstBooleanNodeOutput.Raw {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends serializers.AstConditionalOperatorNodeOutput.Raw {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeOutput.Raw {
         type: "dynamic_variable";
     }

package/serialization/types/AstLessThanOrEqualsOperatorNodeOutputLeft.js

@@ -46,6 +46,7 @@ exports.AstLessThanOrEqualsOperatorNodeOutputLeft = core.serialization
     .union("type", {
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeOutput),
     boolean_literal: AstBooleanNodeOutput_1.AstBooleanNodeOutput,
+    conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeOutput),
     dynamic_variable: AstDynamicVariableNodeOutput_1.AstDynamicVariableNodeOutput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeOutput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeOutput),

package/serialization/types/AstLessThanOrEqualsOperatorNodeOutputRight.d.ts

@@ -8,13 +8,16 @@ import { AstNumberNodeOutput } from "./AstNumberNodeOutput";
 import { AstStringNodeOutput } from "./AstStringNodeOutput";
 export declare const AstLessThanOrEqualsOperatorNodeOutputRight: core.serialization.Schema<serializers.AstLessThanOrEqualsOperatorNodeOutputRight.Raw, ElevenLabs.AstLessThanOrEqualsOperatorNodeOutputRight>;
 export declare namespace AstLessThanOrEqualsOperatorNodeOutputRight {
-    type Raw = AstLessThanOrEqualsOperatorNodeOutputRight.AndOperator | AstLessThanOrEqualsOperatorNodeOutputRight.BooleanLiteral | AstLessThanOrEqualsOperatorNodeOutputRight.DynamicVariable | AstLessThanOrEqualsOperatorNodeOutputRight.EqOperator | AstLessThanOrEqualsOperatorNodeOutputRight.GtOperator | AstLessThanOrEqualsOperatorNodeOutputRight.GteOperator | AstLessThanOrEqualsOperatorNodeOutputRight.Llm | AstLessThanOrEqualsOperatorNodeOutputRight.LtOperator | AstLessThanOrEqualsOperatorNodeOutputRight.LteOperator | AstLessThanOrEqualsOperatorNodeOutputRight.NeqOperator | AstLessThanOrEqualsOperatorNodeOutputRight.NumberLiteral | AstLessThanOrEqualsOperatorNodeOutputRight.OrOperator | AstLessThanOrEqualsOperatorNodeOutputRight.StringLiteral;
+    type Raw = AstLessThanOrEqualsOperatorNodeOutputRight.AndOperator | AstLessThanOrEqualsOperatorNodeOutputRight.BooleanLiteral | AstLessThanOrEqualsOperatorNodeOutputRight.ConditionalOperator | AstLessThanOrEqualsOperatorNodeOutputRight.DynamicVariable | AstLessThanOrEqualsOperatorNodeOutputRight.EqOperator | AstLessThanOrEqualsOperatorNodeOutputRight.GtOperator | AstLessThanOrEqualsOperatorNodeOutputRight.GteOperator | AstLessThanOrEqualsOperatorNodeOutputRight.Llm | AstLessThanOrEqualsOperatorNodeOutputRight.LtOperator | AstLessThanOrEqualsOperatorNodeOutputRight.LteOperator | AstLessThanOrEqualsOperatorNodeOutputRight.NeqOperator | AstLessThanOrEqualsOperatorNodeOutputRight.NumberLiteral | AstLessThanOrEqualsOperatorNodeOutputRight.OrOperator | AstLessThanOrEqualsOperatorNodeOutputRight.StringLiteral;
     interface AndOperator extends serializers.AstAndOperatorNodeOutput.Raw {
         type: "and_operator";
     }
     interface BooleanLiteral extends AstBooleanNodeOutput.Raw {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends serializers.AstConditionalOperatorNodeOutput.Raw {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeOutput.Raw {
         type: "dynamic_variable";
     }

package/serialization/types/AstLessThanOrEqualsOperatorNodeOutputRight.js

@@ -46,6 +46,7 @@ exports.AstLessThanOrEqualsOperatorNodeOutputRight = core.serialization
     .union("type", {
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeOutput),
     boolean_literal: AstBooleanNodeOutput_1.AstBooleanNodeOutput,
+    conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeOutput),
     dynamic_variable: AstDynamicVariableNodeOutput_1.AstDynamicVariableNodeOutput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeOutput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeOutput),

package/serialization/types/AstNotEqualsOperatorNodeInputLeft.d.ts

@@ -8,13 +8,16 @@ import { AstNumberNodeInput } from "./AstNumberNodeInput";
 import { AstStringNodeInput } from "./AstStringNodeInput";
 export declare const AstNotEqualsOperatorNodeInputLeft: core.serialization.Schema<serializers.AstNotEqualsOperatorNodeInputLeft.Raw, ElevenLabs.AstNotEqualsOperatorNodeInputLeft>;
 export declare namespace AstNotEqualsOperatorNodeInputLeft {
-    type Raw = AstNotEqualsOperatorNodeInputLeft.AndOperator | AstNotEqualsOperatorNodeInputLeft.BooleanLiteral | AstNotEqualsOperatorNodeInputLeft.DynamicVariable | AstNotEqualsOperatorNodeInputLeft.EqOperator | AstNotEqualsOperatorNodeInputLeft.GtOperator | AstNotEqualsOperatorNodeInputLeft.GteOperator | AstNotEqualsOperatorNodeInputLeft.Llm | AstNotEqualsOperatorNodeInputLeft.LtOperator | AstNotEqualsOperatorNodeInputLeft.LteOperator | AstNotEqualsOperatorNodeInputLeft.NeqOperator | AstNotEqualsOperatorNodeInputLeft.NumberLiteral | AstNotEqualsOperatorNodeInputLeft.OrOperator | AstNotEqualsOperatorNodeInputLeft.StringLiteral;
+    type Raw = AstNotEqualsOperatorNodeInputLeft.AndOperator | AstNotEqualsOperatorNodeInputLeft.BooleanLiteral | AstNotEqualsOperatorNodeInputLeft.ConditionalOperator | AstNotEqualsOperatorNodeInputLeft.DynamicVariable | AstNotEqualsOperatorNodeInputLeft.EqOperator | AstNotEqualsOperatorNodeInputLeft.GtOperator | AstNotEqualsOperatorNodeInputLeft.GteOperator | AstNotEqualsOperatorNodeInputLeft.Llm | AstNotEqualsOperatorNodeInputLeft.LtOperator | AstNotEqualsOperatorNodeInputLeft.LteOperator | AstNotEqualsOperatorNodeInputLeft.NeqOperator | AstNotEqualsOperatorNodeInputLeft.NumberLiteral | AstNotEqualsOperatorNodeInputLeft.OrOperator | AstNotEqualsOperatorNodeInputLeft.StringLiteral;
     interface AndOperator extends serializers.AstAndOperatorNodeInput.Raw {
         type: "and_operator";
     }
     interface BooleanLiteral extends AstBooleanNodeInput.Raw {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends serializers.AstConditionalOperatorNodeInput.Raw {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeInput.Raw {
         type: "dynamic_variable";
     }
@@ -27,8 +30,9 @@ export declare namespace AstNotEqualsOperatorNodeInputLeft {
     interface GteOperator extends serializers.AstGreaterThanOrEqualsOperatorNodeInput.Raw {
         type: "gte_operator";
     }
-    interface Llm extends AstllmNodeInput.Raw {
+    interface Llm {
         type: "llm";
+        value: AstllmNodeInput.Raw;
     }
     interface LtOperator extends serializers.AstLessThanOperatorNodeInput.Raw {
         type: "lt_operator";

package/serialization/types/AstNotEqualsOperatorNodeInputLeft.js

@@ -46,11 +46,14 @@ exports.AstNotEqualsOperatorNodeInputLeft = core.serialization
     .union("type", {
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeInput),
     boolean_literal: AstBooleanNodeInput_1.AstBooleanNodeInput,
+    conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeInput),
     dynamic_variable: AstDynamicVariableNodeInput_1.AstDynamicVariableNodeInput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeInput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeInput),
     gte_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOrEqualsOperatorNodeInput),
-    llm: AstllmNodeInput_1.AstllmNodeInput,
+    llm: core.serialization.object({
+        value: AstllmNodeInput_1.AstllmNodeInput,
+    }),
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeInput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeInput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeInput),

package/serialization/types/AstNotEqualsOperatorNodeInputRight.d.ts

@@ -8,13 +8,16 @@ import { AstNumberNodeInput } from "./AstNumberNodeInput";
 import { AstStringNodeInput } from "./AstStringNodeInput";
 export declare const AstNotEqualsOperatorNodeInputRight: core.serialization.Schema<serializers.AstNotEqualsOperatorNodeInputRight.Raw, ElevenLabs.AstNotEqualsOperatorNodeInputRight>;
 export declare namespace AstNotEqualsOperatorNodeInputRight {
-    type Raw = AstNotEqualsOperatorNodeInputRight.AndOperator | AstNotEqualsOperatorNodeInputRight.BooleanLiteral | AstNotEqualsOperatorNodeInputRight.DynamicVariable | AstNotEqualsOperatorNodeInputRight.EqOperator | AstNotEqualsOperatorNodeInputRight.GtOperator | AstNotEqualsOperatorNodeInputRight.GteOperator | AstNotEqualsOperatorNodeInputRight.Llm | AstNotEqualsOperatorNodeInputRight.LtOperator | AstNotEqualsOperatorNodeInputRight.LteOperator | AstNotEqualsOperatorNodeInputRight.NeqOperator | AstNotEqualsOperatorNodeInputRight.NumberLiteral | AstNotEqualsOperatorNodeInputRight.OrOperator | AstNotEqualsOperatorNodeInputRight.StringLiteral;
+    type Raw = AstNotEqualsOperatorNodeInputRight.AndOperator | AstNotEqualsOperatorNodeInputRight.BooleanLiteral | AstNotEqualsOperatorNodeInputRight.ConditionalOperator | AstNotEqualsOperatorNodeInputRight.DynamicVariable | AstNotEqualsOperatorNodeInputRight.EqOperator | AstNotEqualsOperatorNodeInputRight.GtOperator | AstNotEqualsOperatorNodeInputRight.GteOperator | AstNotEqualsOperatorNodeInputRight.Llm | AstNotEqualsOperatorNodeInputRight.LtOperator | AstNotEqualsOperatorNodeInputRight.LteOperator | AstNotEqualsOperatorNodeInputRight.NeqOperator | AstNotEqualsOperatorNodeInputRight.NumberLiteral | AstNotEqualsOperatorNodeInputRight.OrOperator | AstNotEqualsOperatorNodeInputRight.StringLiteral;
     interface AndOperator extends serializers.AstAndOperatorNodeInput.Raw {
         type: "and_operator";
     }
     interface BooleanLiteral extends AstBooleanNodeInput.Raw {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends serializers.AstConditionalOperatorNodeInput.Raw {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeInput.Raw {
         type: "dynamic_variable";
     }
@@ -27,8 +30,9 @@ export declare namespace AstNotEqualsOperatorNodeInputRight {
     interface GteOperator extends serializers.AstGreaterThanOrEqualsOperatorNodeInput.Raw {
         type: "gte_operator";
     }
-    interface Llm extends AstllmNodeInput.Raw {
+    interface Llm {
         type: "llm";
+        value: AstllmNodeInput.Raw;
     }
     interface LtOperator extends serializers.AstLessThanOperatorNodeInput.Raw {
         type: "lt_operator";

package/serialization/types/AstNotEqualsOperatorNodeInputRight.js

@@ -46,11 +46,14 @@ exports.AstNotEqualsOperatorNodeInputRight = core.serialization
     .union("type", {
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeInput),
     boolean_literal: AstBooleanNodeInput_1.AstBooleanNodeInput,
+    conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeInput),
     dynamic_variable: AstDynamicVariableNodeInput_1.AstDynamicVariableNodeInput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeInput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeInput),
     gte_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOrEqualsOperatorNodeInput),
-    llm: AstllmNodeInput_1.AstllmNodeInput,
+    llm: core.serialization.object({
+        value: AstllmNodeInput_1.AstllmNodeInput,
+    }),
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeInput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeInput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeInput),

package/serialization/types/AstNotEqualsOperatorNodeOutputLeft.d.ts

@@ -8,13 +8,16 @@ import { AstNumberNodeOutput } from "./AstNumberNodeOutput";
 import { AstStringNodeOutput } from "./AstStringNodeOutput";
 export declare const AstNotEqualsOperatorNodeOutputLeft: core.serialization.Schema<serializers.AstNotEqualsOperatorNodeOutputLeft.Raw, ElevenLabs.AstNotEqualsOperatorNodeOutputLeft>;
 export declare namespace AstNotEqualsOperatorNodeOutputLeft {
-    type Raw = AstNotEqualsOperatorNodeOutputLeft.AndOperator | AstNotEqualsOperatorNodeOutputLeft.BooleanLiteral | AstNotEqualsOperatorNodeOutputLeft.DynamicVariable | AstNotEqualsOperatorNodeOutputLeft.EqOperator | AstNotEqualsOperatorNodeOutputLeft.GtOperator | AstNotEqualsOperatorNodeOutputLeft.GteOperator | AstNotEqualsOperatorNodeOutputLeft.Llm | AstNotEqualsOperatorNodeOutputLeft.LtOperator | AstNotEqualsOperatorNodeOutputLeft.LteOperator | AstNotEqualsOperatorNodeOutputLeft.NeqOperator | AstNotEqualsOperatorNodeOutputLeft.NumberLiteral | AstNotEqualsOperatorNodeOutputLeft.OrOperator | AstNotEqualsOperatorNodeOutputLeft.StringLiteral;
+    type Raw = AstNotEqualsOperatorNodeOutputLeft.AndOperator | AstNotEqualsOperatorNodeOutputLeft.BooleanLiteral | AstNotEqualsOperatorNodeOutputLeft.ConditionalOperator | AstNotEqualsOperatorNodeOutputLeft.DynamicVariable | AstNotEqualsOperatorNodeOutputLeft.EqOperator | AstNotEqualsOperatorNodeOutputLeft.GtOperator | AstNotEqualsOperatorNodeOutputLeft.GteOperator | AstNotEqualsOperatorNodeOutputLeft.Llm | AstNotEqualsOperatorNodeOutputLeft.LtOperator | AstNotEqualsOperatorNodeOutputLeft.LteOperator | AstNotEqualsOperatorNodeOutputLeft.NeqOperator | AstNotEqualsOperatorNodeOutputLeft.NumberLiteral | AstNotEqualsOperatorNodeOutputLeft.OrOperator | AstNotEqualsOperatorNodeOutputLeft.StringLiteral;
     interface AndOperator extends serializers.AstAndOperatorNodeOutput.Raw {
         type: "and_operator";
     }
     interface BooleanLiteral extends AstBooleanNodeOutput.Raw {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends serializers.AstConditionalOperatorNodeOutput.Raw {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeOutput.Raw {
         type: "dynamic_variable";
     }

package/serialization/types/AstNotEqualsOperatorNodeOutputLeft.js

@@ -46,6 +46,7 @@ exports.AstNotEqualsOperatorNodeOutputLeft = core.serialization
     .union("type", {
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeOutput),
     boolean_literal: AstBooleanNodeOutput_1.AstBooleanNodeOutput,
+    conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeOutput),
     dynamic_variable: AstDynamicVariableNodeOutput_1.AstDynamicVariableNodeOutput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeOutput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeOutput),

package/serialization/types/AstNotEqualsOperatorNodeOutputRight.d.ts

@@ -8,13 +8,16 @@ import { AstNumberNodeOutput } from "./AstNumberNodeOutput";
 import { AstStringNodeOutput } from "./AstStringNodeOutput";
 export declare const AstNotEqualsOperatorNodeOutputRight: core.serialization.Schema<serializers.AstNotEqualsOperatorNodeOutputRight.Raw, ElevenLabs.AstNotEqualsOperatorNodeOutputRight>;
 export declare namespace AstNotEqualsOperatorNodeOutputRight {
-    type Raw = AstNotEqualsOperatorNodeOutputRight.AndOperator | AstNotEqualsOperatorNodeOutputRight.BooleanLiteral | AstNotEqualsOperatorNodeOutputRight.DynamicVariable | AstNotEqualsOperatorNodeOutputRight.EqOperator | AstNotEqualsOperatorNodeOutputRight.GtOperator | AstNotEqualsOperatorNodeOutputRight.GteOperator | AstNotEqualsOperatorNodeOutputRight.Llm | AstNotEqualsOperatorNodeOutputRight.LtOperator | AstNotEqualsOperatorNodeOutputRight.LteOperator | AstNotEqualsOperatorNodeOutputRight.NeqOperator | AstNotEqualsOperatorNodeOutputRight.NumberLiteral | AstNotEqualsOperatorNodeOutputRight.OrOperator | AstNotEqualsOperatorNodeOutputRight.StringLiteral;
+    type Raw = AstNotEqualsOperatorNodeOutputRight.AndOperator | AstNotEqualsOperatorNodeOutputRight.BooleanLiteral | AstNotEqualsOperatorNodeOutputRight.ConditionalOperator | AstNotEqualsOperatorNodeOutputRight.DynamicVariable | AstNotEqualsOperatorNodeOutputRight.EqOperator | AstNotEqualsOperatorNodeOutputRight.GtOperator | AstNotEqualsOperatorNodeOutputRight.GteOperator | AstNotEqualsOperatorNodeOutputRight.Llm | AstNotEqualsOperatorNodeOutputRight.LtOperator | AstNotEqualsOperatorNodeOutputRight.LteOperator | AstNotEqualsOperatorNodeOutputRight.NeqOperator | AstNotEqualsOperatorNodeOutputRight.NumberLiteral | AstNotEqualsOperatorNodeOutputRight.OrOperator | AstNotEqualsOperatorNodeOutputRight.StringLiteral;
     interface AndOperator extends serializers.AstAndOperatorNodeOutput.Raw {
         type: "and_operator";
     }
     interface BooleanLiteral extends AstBooleanNodeOutput.Raw {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends serializers.AstConditionalOperatorNodeOutput.Raw {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeOutput.Raw {
         type: "dynamic_variable";
     }

package/serialization/types/AstNotEqualsOperatorNodeOutputRight.js

@@ -46,6 +46,7 @@ exports.AstNotEqualsOperatorNodeOutputRight = core.serialization
     .union("type", {
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeOutput),
     boolean_literal: AstBooleanNodeOutput_1.AstBooleanNodeOutput,
+    conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeOutput),
     dynamic_variable: AstDynamicVariableNodeOutput_1.AstDynamicVariableNodeOutput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeOutput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeOutput),

package/serialization/types/AstOrOperatorNodeInputChildrenItem.d.ts

@@ -8,13 +8,16 @@ import { AstNumberNodeInput } from "./AstNumberNodeInput";
 import { AstStringNodeInput } from "./AstStringNodeInput";
 export declare const AstOrOperatorNodeInputChildrenItem: core.serialization.Schema<serializers.AstOrOperatorNodeInputChildrenItem.Raw, ElevenLabs.AstOrOperatorNodeInputChildrenItem>;
 export declare namespace AstOrOperatorNodeInputChildrenItem {
-    type Raw = AstOrOperatorNodeInputChildrenItem.AndOperator | AstOrOperatorNodeInputChildrenItem.BooleanLiteral | AstOrOperatorNodeInputChildrenItem.DynamicVariable | AstOrOperatorNodeInputChildrenItem.EqOperator | AstOrOperatorNodeInputChildrenItem.GtOperator | AstOrOperatorNodeInputChildrenItem.GteOperator | AstOrOperatorNodeInputChildrenItem.Llm | AstOrOperatorNodeInputChildrenItem.LtOperator | AstOrOperatorNodeInputChildrenItem.LteOperator | AstOrOperatorNodeInputChildrenItem.NeqOperator | AstOrOperatorNodeInputChildrenItem.NumberLiteral | AstOrOperatorNodeInputChildrenItem.OrOperator | AstOrOperatorNodeInputChildrenItem.StringLiteral;
+    type Raw = AstOrOperatorNodeInputChildrenItem.AndOperator | AstOrOperatorNodeInputChildrenItem.BooleanLiteral | AstOrOperatorNodeInputChildrenItem.ConditionalOperator | AstOrOperatorNodeInputChildrenItem.DynamicVariable | AstOrOperatorNodeInputChildrenItem.EqOperator | AstOrOperatorNodeInputChildrenItem.GtOperator | AstOrOperatorNodeInputChildrenItem.GteOperator | AstOrOperatorNodeInputChildrenItem.Llm | AstOrOperatorNodeInputChildrenItem.LtOperator | AstOrOperatorNodeInputChildrenItem.LteOperator | AstOrOperatorNodeInputChildrenItem.NeqOperator | AstOrOperatorNodeInputChildrenItem.NumberLiteral | AstOrOperatorNodeInputChildrenItem.OrOperator | AstOrOperatorNodeInputChildrenItem.StringLiteral;
     interface AndOperator extends serializers.AstAndOperatorNodeInput.Raw {
         type: "and_operator";
     }
     interface BooleanLiteral extends AstBooleanNodeInput.Raw {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends serializers.AstConditionalOperatorNodeInput.Raw {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeInput.Raw {
         type: "dynamic_variable";
     }
@@ -27,8 +30,9 @@ export declare namespace AstOrOperatorNodeInputChildrenItem {
     interface GteOperator extends serializers.AstGreaterThanOrEqualsOperatorNodeInput.Raw {
         type: "gte_operator";
     }
-    interface Llm extends AstllmNodeInput.Raw {
+    interface Llm {
         type: "llm";
+        value: AstllmNodeInput.Raw;
     }
     interface LtOperator extends serializers.AstLessThanOperatorNodeInput.Raw {
         type: "lt_operator";

package/serialization/types/AstOrOperatorNodeInputChildrenItem.js

@@ -46,11 +46,14 @@ exports.AstOrOperatorNodeInputChildrenItem = core.serialization
     .union("type", {
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeInput),
     boolean_literal: AstBooleanNodeInput_1.AstBooleanNodeInput,
+    conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeInput),
     dynamic_variable: AstDynamicVariableNodeInput_1.AstDynamicVariableNodeInput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeInput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeInput),
     gte_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOrEqualsOperatorNodeInput),
-    llm: AstllmNodeInput_1.AstllmNodeInput,
+    llm: core.serialization.object({
+        value: AstllmNodeInput_1.AstllmNodeInput,
+    }),
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeInput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeInput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeInput),

package/serialization/types/AstOrOperatorNodeOutputChildrenItem.d.ts

@@ -8,13 +8,16 @@ import { AstNumberNodeOutput } from "./AstNumberNodeOutput";
 import { AstStringNodeOutput } from "./AstStringNodeOutput";
 export declare const AstOrOperatorNodeOutputChildrenItem: core.serialization.Schema<serializers.AstOrOperatorNodeOutputChildrenItem.Raw, ElevenLabs.AstOrOperatorNodeOutputChildrenItem>;
 export declare namespace AstOrOperatorNodeOutputChildrenItem {
-    type Raw = AstOrOperatorNodeOutputChildrenItem.AndOperator | AstOrOperatorNodeOutputChildrenItem.BooleanLiteral | AstOrOperatorNodeOutputChildrenItem.DynamicVariable | AstOrOperatorNodeOutputChildrenItem.EqOperator | AstOrOperatorNodeOutputChildrenItem.GtOperator | AstOrOperatorNodeOutputChildrenItem.GteOperator | AstOrOperatorNodeOutputChildrenItem.Llm | AstOrOperatorNodeOutputChildrenItem.LtOperator | AstOrOperatorNodeOutputChildrenItem.LteOperator | AstOrOperatorNodeOutputChildrenItem.NeqOperator | AstOrOperatorNodeOutputChildrenItem.NumberLiteral | AstOrOperatorNodeOutputChildrenItem.OrOperator | AstOrOperatorNodeOutputChildrenItem.StringLiteral;
+    type Raw = AstOrOperatorNodeOutputChildrenItem.AndOperator | AstOrOperatorNodeOutputChildrenItem.BooleanLiteral | AstOrOperatorNodeOutputChildrenItem.ConditionalOperator | AstOrOperatorNodeOutputChildrenItem.DynamicVariable | AstOrOperatorNodeOutputChildrenItem.EqOperator | AstOrOperatorNodeOutputChildrenItem.GtOperator | AstOrOperatorNodeOutputChildrenItem.GteOperator | AstOrOperatorNodeOutputChildrenItem.Llm | AstOrOperatorNodeOutputChildrenItem.LtOperator | AstOrOperatorNodeOutputChildrenItem.LteOperator | AstOrOperatorNodeOutputChildrenItem.NeqOperator | AstOrOperatorNodeOutputChildrenItem.NumberLiteral | AstOrOperatorNodeOutputChildrenItem.OrOperator | AstOrOperatorNodeOutputChildrenItem.StringLiteral;
     interface AndOperator extends serializers.AstAndOperatorNodeOutput.Raw {
         type: "and_operator";
     }
     interface BooleanLiteral extends AstBooleanNodeOutput.Raw {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends serializers.AstConditionalOperatorNodeOutput.Raw {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeOutput.Raw {
         type: "dynamic_variable";
     }

package/serialization/types/AstOrOperatorNodeOutputChildrenItem.js

@@ -46,6 +46,7 @@ exports.AstOrOperatorNodeOutputChildrenItem = core.serialization
     .union("type", {
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeOutput),
     boolean_literal: AstBooleanNodeOutput_1.AstBooleanNodeOutput,
+    conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeOutput),
     dynamic_variable: AstDynamicVariableNodeOutput_1.AstDynamicVariableNodeOutput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeOutput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeOutput),

package/serialization/types/AstllmNodeInput.d.ts

@@ -1,9 +1,9 @@
 import type * as ElevenLabs from "../../api/index";
 import * as core from "../../core";
 import type * as serializers from "../index";
-export declare const AstllmNodeInput: core.serialization.ObjectSchema<serializers.AstllmNodeInput.Raw, ElevenLabs.AstllmNodeInput>;
+import { AstllmNodeInputPrompt } from "./AstllmNodeInputPrompt";
+import { AstllmNodeInputValueSchema } from "./AstllmNodeInputValueSchema";
+export declare const AstllmNodeInput: core.serialization.Schema<serializers.AstllmNodeInput.Raw, ElevenLabs.AstllmNodeInput>;
 export declare namespace AstllmNodeInput {
-    interface Raw {
-        prompt: string;
-    }
+    type Raw = AstllmNodeInputValueSchema.Raw | AstllmNodeInputPrompt.Raw;
 }

package/serialization/types/AstllmNodeInput.js

@@ -36,6 +36,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstllmNodeInput = void 0;
 const core = __importStar(require("../../core"));
-exports.AstllmNodeInput = core.serialization.object({
-    prompt: core.serialization.string(),
-});
+const AstllmNodeInputPrompt_1 = require("./AstllmNodeInputPrompt");
+const AstllmNodeInputValueSchema_1 = require("./AstllmNodeInputValueSchema");
+exports.AstllmNodeInput = core.serialization.undiscriminatedUnion([AstllmNodeInputValueSchema_1.AstllmNodeInputValueSchema, AstllmNodeInputPrompt_1.AstllmNodeInputPrompt]);

package/serialization/types/AstllmNodeInputPrompt.d.ts

@@ -0,0 +1,10 @@
+import type * as ElevenLabs from "../../api/index";
+import * as core from "../../core";
+import type * as serializers from "../index";
+export declare const AstllmNodeInputPrompt: core.serialization.ObjectSchema<serializers.AstllmNodeInputPrompt.Raw, ElevenLabs.AstllmNodeInputPrompt>;
+export declare namespace AstllmNodeInputPrompt {
+    interface Raw {
+        type?: "llm" | null;
+        prompt: string;
+    }
+}

package/serialization/types/AstllmNodeInputPrompt.js

@@ -0,0 +1,42 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstllmNodeInputPrompt = void 0;
+const core = __importStar(require("../../core"));
+exports.AstllmNodeInputPrompt = core.serialization.object({
+    type: core.serialization.stringLiteral("llm").optional(),
+    prompt: core.serialization.string(),
+});

package/serialization/types/AstllmNodeInputValueSchema.d.ts

@@ -0,0 +1,11 @@
+import type * as ElevenLabs from "../../api/index";
+import * as core from "../../core";
+import type * as serializers from "../index";
+import { LlmLiteralJsonSchemaProperty } from "./LlmLiteralJsonSchemaProperty";
+export declare const AstllmNodeInputValueSchema: core.serialization.ObjectSchema<serializers.AstllmNodeInputValueSchema.Raw, ElevenLabs.AstllmNodeInputValueSchema>;
+export declare namespace AstllmNodeInputValueSchema {
+    interface Raw {
+        type?: "llm" | null;
+        value_schema: LlmLiteralJsonSchemaProperty.Raw;
+    }
+}

package/serialization/types/AstllmNodeInputValueSchema.js

@@ -0,0 +1,43 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstllmNodeInputValueSchema = void 0;
+const core = __importStar(require("../../core"));
+const LlmLiteralJsonSchemaProperty_1 = require("./LlmLiteralJsonSchemaProperty");
+exports.AstllmNodeInputValueSchema = core.serialization.object({
+    type: core.serialization.stringLiteral("llm").optional(),
+    valueSchema: core.serialization.property("value_schema", LlmLiteralJsonSchemaProperty_1.LlmLiteralJsonSchemaProperty),
+});

package/serialization/types/AstllmNodeOutput.d.ts

@@ -1,9 +1,11 @@
 import type * as ElevenLabs from "../../api/index";
 import * as core from "../../core";
 import type * as serializers from "../index";
+import { LlmLiteralJsonSchemaProperty } from "./LlmLiteralJsonSchemaProperty";
 export declare const AstllmNodeOutput: core.serialization.ObjectSchema<serializers.AstllmNodeOutput.Raw, ElevenLabs.AstllmNodeOutput>;
 export declare namespace AstllmNodeOutput {
     interface Raw {
+        value_schema: LlmLiteralJsonSchemaProperty.Raw;
         prompt: string;
     }
 }

package/serialization/types/AstllmNodeOutput.js

@@ -36,6 +36,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstllmNodeOutput = void 0;
 const core = __importStar(require("../../core"));
+const LlmLiteralJsonSchemaProperty_1 = require("./LlmLiteralJsonSchemaProperty");
 exports.AstllmNodeOutput = core.serialization.object({
+    valueSchema: core.serialization.property("value_schema", LlmLiteralJsonSchemaProperty_1.LlmLiteralJsonSchemaProperty),
     prompt: core.serialization.string(),
 });

package/serialization/types/AuthConnectionDependencies.d.ts

@@ -0,0 +1,14 @@
+import type * as ElevenLabs from "../../api/index";
+import * as core from "../../core";
+import type * as serializers from "../index";
+import { AuthConnectionDependenciesMcpServersItem } from "./AuthConnectionDependenciesMcpServersItem";
+import { AuthConnectionDependenciesToolsItem } from "./AuthConnectionDependenciesToolsItem";
+import { DependentIntegrationConnectionIdentifier } from "./DependentIntegrationConnectionIdentifier";
+export declare const AuthConnectionDependencies: core.serialization.ObjectSchema<serializers.AuthConnectionDependencies.Raw, ElevenLabs.AuthConnectionDependencies>;
+export declare namespace AuthConnectionDependencies {
+    interface Raw {
+        tools?: AuthConnectionDependenciesToolsItem.Raw[] | null;
+        mcp_servers?: AuthConnectionDependenciesMcpServersItem.Raw[] | null;
+        integration_connections?: DependentIntegrationConnectionIdentifier.Raw[] | null;
+    }
+}

package/serialization/types/AuthConnectionDependencies.js

@@ -0,0 +1,46 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthConnectionDependencies = void 0;
+const core = __importStar(require("../../core"));
+const AuthConnectionDependenciesMcpServersItem_1 = require("./AuthConnectionDependenciesMcpServersItem");
+const AuthConnectionDependenciesToolsItem_1 = require("./AuthConnectionDependenciesToolsItem");
+const DependentIntegrationConnectionIdentifier_1 = require("./DependentIntegrationConnectionIdentifier");
+exports.AuthConnectionDependencies = core.serialization.object({
+    tools: core.serialization.list(AuthConnectionDependenciesToolsItem_1.AuthConnectionDependenciesToolsItem).optional(),
+    mcpServers: core.serialization.property("mcp_servers", core.serialization.list(AuthConnectionDependenciesMcpServersItem_1.AuthConnectionDependenciesMcpServersItem).optional()),
+    integrationConnections: core.serialization.property("integration_connections", core.serialization.list(DependentIntegrationConnectionIdentifier_1.DependentIntegrationConnectionIdentifier).optional()),
+});

package/serialization/types/AuthConnectionDependenciesMcpServersItem.d.ts

@@ -0,0 +1,15 @@
+import type * as ElevenLabs from "../../api/index";
+import * as core from "../../core";
+import type * as serializers from "../index";
+import { DependentAvailableMcpServerIdentifier } from "./DependentAvailableMcpServerIdentifier";
+import { DependentUnknownMcpServerIdentifier } from "./DependentUnknownMcpServerIdentifier";
+export declare const AuthConnectionDependenciesMcpServersItem: core.serialization.Schema<serializers.AuthConnectionDependenciesMcpServersItem.Raw, ElevenLabs.AuthConnectionDependenciesMcpServersItem>;
+export declare namespace AuthConnectionDependenciesMcpServersItem {
+    type Raw = AuthConnectionDependenciesMcpServersItem.Available | AuthConnectionDependenciesMcpServersItem.Unknown;
+    interface Available extends DependentAvailableMcpServerIdentifier.Raw {
+        type: "available";
+    }
+    interface Unknown extends DependentUnknownMcpServerIdentifier.Raw {
+        type: "unknown";
+    }
+}