@elevenlabs/elevenlabs-js 2.40.0 → 2.41.0

package/serialization/types/AstLessThanOperatorNodeInputLeft.js

@@ -44,9 +44,11 @@ const AstNumberNodeInput_1 = require("./AstNumberNodeInput");
 const AstStringNodeInput_1 = require("./AstStringNodeInput");
 exports.AstLessThanOperatorNodeInputLeft = core.serialization
     .union("type", {
+    add_operator: core.serialization.lazyObject(() => serializers.AstAdditionOperatorNodeInput),
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeInput),
     boolean_literal: AstBooleanNodeInput_1.AstBooleanNodeInput,
     conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeInput),
+    div_operator: core.serialization.lazyObject(() => serializers.AstDivisionOperatorNodeInput),
     dynamic_variable: AstDynamicVariableNodeInput_1.AstDynamicVariableNodeInput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeInput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeInput),
@@ -56,10 +58,12 @@ exports.AstLessThanOperatorNodeInputLeft = core.serialization
     }),
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeInput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeInput),
+    mul_operator: core.serialization.lazyObject(() => serializers.AstMultiplicationOperatorNodeInput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeInput),
     number_literal: AstNumberNodeInput_1.AstNumberNodeInput,
     or_operator: core.serialization.lazyObject(() => serializers.AstOrOperatorNodeInput),
     string_literal: AstStringNodeInput_1.AstStringNodeInput,
+    sub_operator: core.serialization.lazyObject(() => serializers.AstSubtractionOperatorNodeInput),
 })
     .transform({
     transform: (value) => value,

package/serialization/types/AstLessThanOperatorNodeInputRight.d.ts

@@ -8,7 +8,10 @@ import { AstNumberNodeInput } from "./AstNumberNodeInput";
 import { AstStringNodeInput } from "./AstStringNodeInput";
 export declare const AstLessThanOperatorNodeInputRight: core.serialization.Schema<serializers.AstLessThanOperatorNodeInputRight.Raw, ElevenLabs.AstLessThanOperatorNodeInputRight>;
 export declare namespace AstLessThanOperatorNodeInputRight {
-    type Raw = AstLessThanOperatorNodeInputRight.AndOperator | AstLessThanOperatorNodeInputRight.BooleanLiteral | AstLessThanOperatorNodeInputRight.ConditionalOperator | AstLessThanOperatorNodeInputRight.DynamicVariable | AstLessThanOperatorNodeInputRight.EqOperator | AstLessThanOperatorNodeInputRight.GtOperator | AstLessThanOperatorNodeInputRight.GteOperator | AstLessThanOperatorNodeInputRight.Llm | AstLessThanOperatorNodeInputRight.LtOperator | AstLessThanOperatorNodeInputRight.LteOperator | AstLessThanOperatorNodeInputRight.NeqOperator | AstLessThanOperatorNodeInputRight.NumberLiteral | AstLessThanOperatorNodeInputRight.OrOperator | AstLessThanOperatorNodeInputRight.StringLiteral;
+    type Raw = AstLessThanOperatorNodeInputRight.AddOperator | AstLessThanOperatorNodeInputRight.AndOperator | AstLessThanOperatorNodeInputRight.BooleanLiteral | AstLessThanOperatorNodeInputRight.ConditionalOperator | AstLessThanOperatorNodeInputRight.DivOperator | AstLessThanOperatorNodeInputRight.DynamicVariable | AstLessThanOperatorNodeInputRight.EqOperator | AstLessThanOperatorNodeInputRight.GtOperator | AstLessThanOperatorNodeInputRight.GteOperator | AstLessThanOperatorNodeInputRight.Llm | AstLessThanOperatorNodeInputRight.LtOperator | AstLessThanOperatorNodeInputRight.LteOperator | AstLessThanOperatorNodeInputRight.MulOperator | AstLessThanOperatorNodeInputRight.NeqOperator | AstLessThanOperatorNodeInputRight.NumberLiteral | AstLessThanOperatorNodeInputRight.OrOperator | AstLessThanOperatorNodeInputRight.StringLiteral | AstLessThanOperatorNodeInputRight.SubOperator;
+    interface AddOperator extends serializers.AstAdditionOperatorNodeInput.Raw {
+        type: "add_operator";
+    }
     interface AndOperator extends serializers.AstAndOperatorNodeInput.Raw {
         type: "and_operator";
     }
@@ -18,6 +21,9 @@ export declare namespace AstLessThanOperatorNodeInputRight {
     interface ConditionalOperator extends serializers.AstConditionalOperatorNodeInput.Raw {
         type: "conditional_operator";
     }
+    interface DivOperator extends serializers.AstDivisionOperatorNodeInput.Raw {
+        type: "div_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeInput.Raw {
         type: "dynamic_variable";
     }
@@ -40,6 +46,9 @@ export declare namespace AstLessThanOperatorNodeInputRight {
     interface LteOperator extends serializers.AstLessThanOrEqualsOperatorNodeInput.Raw {
         type: "lte_operator";
     }
+    interface MulOperator extends serializers.AstMultiplicationOperatorNodeInput.Raw {
+        type: "mul_operator";
+    }
     interface NeqOperator extends serializers.AstNotEqualsOperatorNodeInput.Raw {
         type: "neq_operator";
     }
@@ -52,4 +61,7 @@ export declare namespace AstLessThanOperatorNodeInputRight {
     interface StringLiteral extends AstStringNodeInput.Raw {
         type: "string_literal";
     }
+    interface SubOperator extends serializers.AstSubtractionOperatorNodeInput.Raw {
+        type: "sub_operator";
+    }
 }

package/serialization/types/AstLessThanOperatorNodeInputRight.js

@@ -44,9 +44,11 @@ const AstNumberNodeInput_1 = require("./AstNumberNodeInput");
 const AstStringNodeInput_1 = require("./AstStringNodeInput");
 exports.AstLessThanOperatorNodeInputRight = core.serialization
     .union("type", {
+    add_operator: core.serialization.lazyObject(() => serializers.AstAdditionOperatorNodeInput),
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeInput),
     boolean_literal: AstBooleanNodeInput_1.AstBooleanNodeInput,
     conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeInput),
+    div_operator: core.serialization.lazyObject(() => serializers.AstDivisionOperatorNodeInput),
     dynamic_variable: AstDynamicVariableNodeInput_1.AstDynamicVariableNodeInput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeInput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeInput),
@@ -56,10 +58,12 @@ exports.AstLessThanOperatorNodeInputRight = core.serialization
     }),
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeInput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeInput),
+    mul_operator: core.serialization.lazyObject(() => serializers.AstMultiplicationOperatorNodeInput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeInput),
     number_literal: AstNumberNodeInput_1.AstNumberNodeInput,
     or_operator: core.serialization.lazyObject(() => serializers.AstOrOperatorNodeInput),
     string_literal: AstStringNodeInput_1.AstStringNodeInput,
+    sub_operator: core.serialization.lazyObject(() => serializers.AstSubtractionOperatorNodeInput),
 })
     .transform({
     transform: (value) => value,

package/serialization/types/AstLessThanOperatorNodeOutputLeft.d.ts

@@ -8,7 +8,10 @@ import { AstNumberNodeOutput } from "./AstNumberNodeOutput";
 import { AstStringNodeOutput } from "./AstStringNodeOutput";
 export declare const AstLessThanOperatorNodeOutputLeft: core.serialization.Schema<serializers.AstLessThanOperatorNodeOutputLeft.Raw, ElevenLabs.AstLessThanOperatorNodeOutputLeft>;
 export declare namespace AstLessThanOperatorNodeOutputLeft {
-    type Raw = AstLessThanOperatorNodeOutputLeft.AndOperator | AstLessThanOperatorNodeOutputLeft.BooleanLiteral | AstLessThanOperatorNodeOutputLeft.ConditionalOperator | AstLessThanOperatorNodeOutputLeft.DynamicVariable | AstLessThanOperatorNodeOutputLeft.EqOperator | AstLessThanOperatorNodeOutputLeft.GtOperator | AstLessThanOperatorNodeOutputLeft.GteOperator | AstLessThanOperatorNodeOutputLeft.Llm | AstLessThanOperatorNodeOutputLeft.LtOperator | AstLessThanOperatorNodeOutputLeft.LteOperator | AstLessThanOperatorNodeOutputLeft.NeqOperator | AstLessThanOperatorNodeOutputLeft.NumberLiteral | AstLessThanOperatorNodeOutputLeft.OrOperator | AstLessThanOperatorNodeOutputLeft.StringLiteral;
+    type Raw = AstLessThanOperatorNodeOutputLeft.AddOperator | AstLessThanOperatorNodeOutputLeft.AndOperator | AstLessThanOperatorNodeOutputLeft.BooleanLiteral | AstLessThanOperatorNodeOutputLeft.ConditionalOperator | AstLessThanOperatorNodeOutputLeft.DivOperator | AstLessThanOperatorNodeOutputLeft.DynamicVariable | AstLessThanOperatorNodeOutputLeft.EqOperator | AstLessThanOperatorNodeOutputLeft.GtOperator | AstLessThanOperatorNodeOutputLeft.GteOperator | AstLessThanOperatorNodeOutputLeft.Llm | AstLessThanOperatorNodeOutputLeft.LtOperator | AstLessThanOperatorNodeOutputLeft.LteOperator | AstLessThanOperatorNodeOutputLeft.MulOperator | AstLessThanOperatorNodeOutputLeft.NeqOperator | AstLessThanOperatorNodeOutputLeft.NumberLiteral | AstLessThanOperatorNodeOutputLeft.OrOperator | AstLessThanOperatorNodeOutputLeft.StringLiteral | AstLessThanOperatorNodeOutputLeft.SubOperator;
+    interface AddOperator extends serializers.AstAdditionOperatorNodeOutput.Raw {
+        type: "add_operator";
+    }
     interface AndOperator extends serializers.AstAndOperatorNodeOutput.Raw {
         type: "and_operator";
     }
@@ -18,6 +21,9 @@ export declare namespace AstLessThanOperatorNodeOutputLeft {
     interface ConditionalOperator extends serializers.AstConditionalOperatorNodeOutput.Raw {
         type: "conditional_operator";
     }
+    interface DivOperator extends serializers.AstDivisionOperatorNodeOutput.Raw {
+        type: "div_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeOutput.Raw {
         type: "dynamic_variable";
     }
@@ -39,6 +45,9 @@ export declare namespace AstLessThanOperatorNodeOutputLeft {
     interface LteOperator extends serializers.AstLessThanOrEqualsOperatorNodeOutput.Raw {
         type: "lte_operator";
     }
+    interface MulOperator extends serializers.AstMultiplicationOperatorNodeOutput.Raw {
+        type: "mul_operator";
+    }
     interface NeqOperator extends serializers.AstNotEqualsOperatorNodeOutput.Raw {
         type: "neq_operator";
     }
@@ -51,4 +60,7 @@ export declare namespace AstLessThanOperatorNodeOutputLeft {
     interface StringLiteral extends AstStringNodeOutput.Raw {
         type: "string_literal";
     }
+    interface SubOperator extends serializers.AstSubtractionOperatorNodeOutput.Raw {
+        type: "sub_operator";
+    }
 }

package/serialization/types/AstLessThanOperatorNodeOutputLeft.js

@@ -44,9 +44,11 @@ const AstNumberNodeOutput_1 = require("./AstNumberNodeOutput");
 const AstStringNodeOutput_1 = require("./AstStringNodeOutput");
 exports.AstLessThanOperatorNodeOutputLeft = core.serialization
     .union("type", {
+    add_operator: core.serialization.lazyObject(() => serializers.AstAdditionOperatorNodeOutput),
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeOutput),
     boolean_literal: AstBooleanNodeOutput_1.AstBooleanNodeOutput,
     conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeOutput),
+    div_operator: core.serialization.lazyObject(() => serializers.AstDivisionOperatorNodeOutput),
     dynamic_variable: AstDynamicVariableNodeOutput_1.AstDynamicVariableNodeOutput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeOutput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeOutput),
@@ -54,10 +56,12 @@ exports.AstLessThanOperatorNodeOutputLeft = core.serialization
     llm: AstllmNodeOutput_1.AstllmNodeOutput,
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeOutput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeOutput),
+    mul_operator: core.serialization.lazyObject(() => serializers.AstMultiplicationOperatorNodeOutput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeOutput),
     number_literal: AstNumberNodeOutput_1.AstNumberNodeOutput,
     or_operator: core.serialization.lazyObject(() => serializers.AstOrOperatorNodeOutput),
     string_literal: AstStringNodeOutput_1.AstStringNodeOutput,
+    sub_operator: core.serialization.lazyObject(() => serializers.AstSubtractionOperatorNodeOutput),
 })
     .transform({
     transform: (value) => value,

package/serialization/types/AstLessThanOperatorNodeOutputRight.d.ts

@@ -8,7 +8,10 @@ import { AstNumberNodeOutput } from "./AstNumberNodeOutput";
 import { AstStringNodeOutput } from "./AstStringNodeOutput";
 export declare const AstLessThanOperatorNodeOutputRight: core.serialization.Schema<serializers.AstLessThanOperatorNodeOutputRight.Raw, ElevenLabs.AstLessThanOperatorNodeOutputRight>;
 export declare namespace AstLessThanOperatorNodeOutputRight {
-    type Raw = AstLessThanOperatorNodeOutputRight.AndOperator | AstLessThanOperatorNodeOutputRight.BooleanLiteral | AstLessThanOperatorNodeOutputRight.ConditionalOperator | AstLessThanOperatorNodeOutputRight.DynamicVariable | AstLessThanOperatorNodeOutputRight.EqOperator | AstLessThanOperatorNodeOutputRight.GtOperator | AstLessThanOperatorNodeOutputRight.GteOperator | AstLessThanOperatorNodeOutputRight.Llm | AstLessThanOperatorNodeOutputRight.LtOperator | AstLessThanOperatorNodeOutputRight.LteOperator | AstLessThanOperatorNodeOutputRight.NeqOperator | AstLessThanOperatorNodeOutputRight.NumberLiteral | AstLessThanOperatorNodeOutputRight.OrOperator | AstLessThanOperatorNodeOutputRight.StringLiteral;
+    type Raw = AstLessThanOperatorNodeOutputRight.AddOperator | AstLessThanOperatorNodeOutputRight.AndOperator | AstLessThanOperatorNodeOutputRight.BooleanLiteral | AstLessThanOperatorNodeOutputRight.ConditionalOperator | AstLessThanOperatorNodeOutputRight.DivOperator | AstLessThanOperatorNodeOutputRight.DynamicVariable | AstLessThanOperatorNodeOutputRight.EqOperator | AstLessThanOperatorNodeOutputRight.GtOperator | AstLessThanOperatorNodeOutputRight.GteOperator | AstLessThanOperatorNodeOutputRight.Llm | AstLessThanOperatorNodeOutputRight.LtOperator | AstLessThanOperatorNodeOutputRight.LteOperator | AstLessThanOperatorNodeOutputRight.MulOperator | AstLessThanOperatorNodeOutputRight.NeqOperator | AstLessThanOperatorNodeOutputRight.NumberLiteral | AstLessThanOperatorNodeOutputRight.OrOperator | AstLessThanOperatorNodeOutputRight.StringLiteral | AstLessThanOperatorNodeOutputRight.SubOperator;
+    interface AddOperator extends serializers.AstAdditionOperatorNodeOutput.Raw {
+        type: "add_operator";
+    }
     interface AndOperator extends serializers.AstAndOperatorNodeOutput.Raw {
         type: "and_operator";
     }
@@ -18,6 +21,9 @@ export declare namespace AstLessThanOperatorNodeOutputRight {
     interface ConditionalOperator extends serializers.AstConditionalOperatorNodeOutput.Raw {
         type: "conditional_operator";
     }
+    interface DivOperator extends serializers.AstDivisionOperatorNodeOutput.Raw {
+        type: "div_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeOutput.Raw {
         type: "dynamic_variable";
     }
@@ -39,6 +45,9 @@ export declare namespace AstLessThanOperatorNodeOutputRight {
     interface LteOperator extends serializers.AstLessThanOrEqualsOperatorNodeOutput.Raw {
         type: "lte_operator";
     }
+    interface MulOperator extends serializers.AstMultiplicationOperatorNodeOutput.Raw {
+        type: "mul_operator";
+    }
     interface NeqOperator extends serializers.AstNotEqualsOperatorNodeOutput.Raw {
         type: "neq_operator";
     }
@@ -51,4 +60,7 @@ export declare namespace AstLessThanOperatorNodeOutputRight {
     interface StringLiteral extends AstStringNodeOutput.Raw {
         type: "string_literal";
     }
+    interface SubOperator extends serializers.AstSubtractionOperatorNodeOutput.Raw {
+        type: "sub_operator";
+    }
 }

package/serialization/types/AstLessThanOperatorNodeOutputRight.js

@@ -44,9 +44,11 @@ const AstNumberNodeOutput_1 = require("./AstNumberNodeOutput");
 const AstStringNodeOutput_1 = require("./AstStringNodeOutput");
 exports.AstLessThanOperatorNodeOutputRight = core.serialization
     .union("type", {
+    add_operator: core.serialization.lazyObject(() => serializers.AstAdditionOperatorNodeOutput),
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeOutput),
     boolean_literal: AstBooleanNodeOutput_1.AstBooleanNodeOutput,
     conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeOutput),
+    div_operator: core.serialization.lazyObject(() => serializers.AstDivisionOperatorNodeOutput),
     dynamic_variable: AstDynamicVariableNodeOutput_1.AstDynamicVariableNodeOutput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeOutput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeOutput),
@@ -54,10 +56,12 @@ exports.AstLessThanOperatorNodeOutputRight = core.serialization
     llm: AstllmNodeOutput_1.AstllmNodeOutput,
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeOutput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeOutput),
+    mul_operator: core.serialization.lazyObject(() => serializers.AstMultiplicationOperatorNodeOutput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeOutput),
     number_literal: AstNumberNodeOutput_1.AstNumberNodeOutput,
     or_operator: core.serialization.lazyObject(() => serializers.AstOrOperatorNodeOutput),
     string_literal: AstStringNodeOutput_1.AstStringNodeOutput,
+    sub_operator: core.serialization.lazyObject(() => serializers.AstSubtractionOperatorNodeOutput),
 })
     .transform({
     transform: (value) => value,

package/serialization/types/AstLessThanOrEqualsOperatorNodeInputLeft.d.ts

@@ -8,7 +8,10 @@ import { AstNumberNodeInput } from "./AstNumberNodeInput";
 import { AstStringNodeInput } from "./AstStringNodeInput";
 export declare const AstLessThanOrEqualsOperatorNodeInputLeft: core.serialization.Schema<serializers.AstLessThanOrEqualsOperatorNodeInputLeft.Raw, ElevenLabs.AstLessThanOrEqualsOperatorNodeInputLeft>;
 export declare namespace AstLessThanOrEqualsOperatorNodeInputLeft {
-    type Raw = AstLessThanOrEqualsOperatorNodeInputLeft.AndOperator | AstLessThanOrEqualsOperatorNodeInputLeft.BooleanLiteral | AstLessThanOrEqualsOperatorNodeInputLeft.ConditionalOperator | AstLessThanOrEqualsOperatorNodeInputLeft.DynamicVariable | AstLessThanOrEqualsOperatorNodeInputLeft.EqOperator | AstLessThanOrEqualsOperatorNodeInputLeft.GtOperator | AstLessThanOrEqualsOperatorNodeInputLeft.GteOperator | AstLessThanOrEqualsOperatorNodeInputLeft.Llm | AstLessThanOrEqualsOperatorNodeInputLeft.LtOperator | AstLessThanOrEqualsOperatorNodeInputLeft.LteOperator | AstLessThanOrEqualsOperatorNodeInputLeft.NeqOperator | AstLessThanOrEqualsOperatorNodeInputLeft.NumberLiteral | AstLessThanOrEqualsOperatorNodeInputLeft.OrOperator | AstLessThanOrEqualsOperatorNodeInputLeft.StringLiteral;
+    type Raw = AstLessThanOrEqualsOperatorNodeInputLeft.AddOperator | AstLessThanOrEqualsOperatorNodeInputLeft.AndOperator | AstLessThanOrEqualsOperatorNodeInputLeft.BooleanLiteral | AstLessThanOrEqualsOperatorNodeInputLeft.ConditionalOperator | AstLessThanOrEqualsOperatorNodeInputLeft.DivOperator | AstLessThanOrEqualsOperatorNodeInputLeft.DynamicVariable | AstLessThanOrEqualsOperatorNodeInputLeft.EqOperator | AstLessThanOrEqualsOperatorNodeInputLeft.GtOperator | AstLessThanOrEqualsOperatorNodeInputLeft.GteOperator | AstLessThanOrEqualsOperatorNodeInputLeft.Llm | AstLessThanOrEqualsOperatorNodeInputLeft.LtOperator | AstLessThanOrEqualsOperatorNodeInputLeft.LteOperator | AstLessThanOrEqualsOperatorNodeInputLeft.MulOperator | AstLessThanOrEqualsOperatorNodeInputLeft.NeqOperator | AstLessThanOrEqualsOperatorNodeInputLeft.NumberLiteral | AstLessThanOrEqualsOperatorNodeInputLeft.OrOperator | AstLessThanOrEqualsOperatorNodeInputLeft.StringLiteral | AstLessThanOrEqualsOperatorNodeInputLeft.SubOperator;
+    interface AddOperator extends serializers.AstAdditionOperatorNodeInput.Raw {
+        type: "add_operator";
+    }
     interface AndOperator extends serializers.AstAndOperatorNodeInput.Raw {
         type: "and_operator";
     }
@@ -18,6 +21,9 @@ export declare namespace AstLessThanOrEqualsOperatorNodeInputLeft {
     interface ConditionalOperator extends serializers.AstConditionalOperatorNodeInput.Raw {
         type: "conditional_operator";
     }
+    interface DivOperator extends serializers.AstDivisionOperatorNodeInput.Raw {
+        type: "div_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeInput.Raw {
         type: "dynamic_variable";
     }
@@ -40,6 +46,9 @@ export declare namespace AstLessThanOrEqualsOperatorNodeInputLeft {
     interface LteOperator extends serializers.AstLessThanOrEqualsOperatorNodeInput.Raw {
         type: "lte_operator";
     }
+    interface MulOperator extends serializers.AstMultiplicationOperatorNodeInput.Raw {
+        type: "mul_operator";
+    }
     interface NeqOperator extends serializers.AstNotEqualsOperatorNodeInput.Raw {
         type: "neq_operator";
     }
@@ -52,4 +61,7 @@ export declare namespace AstLessThanOrEqualsOperatorNodeInputLeft {
     interface StringLiteral extends AstStringNodeInput.Raw {
         type: "string_literal";
     }
+    interface SubOperator extends serializers.AstSubtractionOperatorNodeInput.Raw {
+        type: "sub_operator";
+    }
 }

package/serialization/types/AstLessThanOrEqualsOperatorNodeInputLeft.js

@@ -44,9 +44,11 @@ const AstNumberNodeInput_1 = require("./AstNumberNodeInput");
 const AstStringNodeInput_1 = require("./AstStringNodeInput");
 exports.AstLessThanOrEqualsOperatorNodeInputLeft = core.serialization
     .union("type", {
+    add_operator: core.serialization.lazyObject(() => serializers.AstAdditionOperatorNodeInput),
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeInput),
     boolean_literal: AstBooleanNodeInput_1.AstBooleanNodeInput,
     conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeInput),
+    div_operator: core.serialization.lazyObject(() => serializers.AstDivisionOperatorNodeInput),
     dynamic_variable: AstDynamicVariableNodeInput_1.AstDynamicVariableNodeInput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeInput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeInput),
@@ -56,10 +58,12 @@ exports.AstLessThanOrEqualsOperatorNodeInputLeft = core.serialization
     }),
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeInput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeInput),
+    mul_operator: core.serialization.lazyObject(() => serializers.AstMultiplicationOperatorNodeInput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeInput),
     number_literal: AstNumberNodeInput_1.AstNumberNodeInput,
     or_operator: core.serialization.lazyObject(() => serializers.AstOrOperatorNodeInput),
     string_literal: AstStringNodeInput_1.AstStringNodeInput,
+    sub_operator: core.serialization.lazyObject(() => serializers.AstSubtractionOperatorNodeInput),
 })
     .transform({
     transform: (value) => value,

package/serialization/types/AstLessThanOrEqualsOperatorNodeInputRight.d.ts

@@ -8,7 +8,10 @@ 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.ConditionalOperator | 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.AddOperator | AstLessThanOrEqualsOperatorNodeInputRight.AndOperator | AstLessThanOrEqualsOperatorNodeInputRight.BooleanLiteral | AstLessThanOrEqualsOperatorNodeInputRight.ConditionalOperator | AstLessThanOrEqualsOperatorNodeInputRight.DivOperator | AstLessThanOrEqualsOperatorNodeInputRight.DynamicVariable | AstLessThanOrEqualsOperatorNodeInputRight.EqOperator | AstLessThanOrEqualsOperatorNodeInputRight.GtOperator | AstLessThanOrEqualsOperatorNodeInputRight.GteOperator | AstLessThanOrEqualsOperatorNodeInputRight.Llm | AstLessThanOrEqualsOperatorNodeInputRight.LtOperator | AstLessThanOrEqualsOperatorNodeInputRight.LteOperator | AstLessThanOrEqualsOperatorNodeInputRight.MulOperator | AstLessThanOrEqualsOperatorNodeInputRight.NeqOperator | AstLessThanOrEqualsOperatorNodeInputRight.NumberLiteral | AstLessThanOrEqualsOperatorNodeInputRight.OrOperator | AstLessThanOrEqualsOperatorNodeInputRight.StringLiteral | AstLessThanOrEqualsOperatorNodeInputRight.SubOperator;
+    interface AddOperator extends serializers.AstAdditionOperatorNodeInput.Raw {
+        type: "add_operator";
+    }
     interface AndOperator extends serializers.AstAndOperatorNodeInput.Raw {
         type: "and_operator";
     }
@@ -18,6 +21,9 @@ export declare namespace AstLessThanOrEqualsOperatorNodeInputRight {
     interface ConditionalOperator extends serializers.AstConditionalOperatorNodeInput.Raw {
         type: "conditional_operator";
     }
+    interface DivOperator extends serializers.AstDivisionOperatorNodeInput.Raw {
+        type: "div_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeInput.Raw {
         type: "dynamic_variable";
     }
@@ -40,6 +46,9 @@ export declare namespace AstLessThanOrEqualsOperatorNodeInputRight {
     interface LteOperator extends serializers.AstLessThanOrEqualsOperatorNodeInput.Raw {
         type: "lte_operator";
     }
+    interface MulOperator extends serializers.AstMultiplicationOperatorNodeInput.Raw {
+        type: "mul_operator";
+    }
     interface NeqOperator extends serializers.AstNotEqualsOperatorNodeInput.Raw {
         type: "neq_operator";
     }
@@ -52,4 +61,7 @@ export declare namespace AstLessThanOrEqualsOperatorNodeInputRight {
     interface StringLiteral extends AstStringNodeInput.Raw {
         type: "string_literal";
     }
+    interface SubOperator extends serializers.AstSubtractionOperatorNodeInput.Raw {
+        type: "sub_operator";
+    }
 }

package/serialization/types/AstLessThanOrEqualsOperatorNodeInputRight.js

@@ -44,9 +44,11 @@ const AstNumberNodeInput_1 = require("./AstNumberNodeInput");
 const AstStringNodeInput_1 = require("./AstStringNodeInput");
 exports.AstLessThanOrEqualsOperatorNodeInputRight = core.serialization
     .union("type", {
+    add_operator: core.serialization.lazyObject(() => serializers.AstAdditionOperatorNodeInput),
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeInput),
     boolean_literal: AstBooleanNodeInput_1.AstBooleanNodeInput,
     conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeInput),
+    div_operator: core.serialization.lazyObject(() => serializers.AstDivisionOperatorNodeInput),
     dynamic_variable: AstDynamicVariableNodeInput_1.AstDynamicVariableNodeInput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeInput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeInput),
@@ -56,10 +58,12 @@ exports.AstLessThanOrEqualsOperatorNodeInputRight = core.serialization
     }),
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeInput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeInput),
+    mul_operator: core.serialization.lazyObject(() => serializers.AstMultiplicationOperatorNodeInput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeInput),
     number_literal: AstNumberNodeInput_1.AstNumberNodeInput,
     or_operator: core.serialization.lazyObject(() => serializers.AstOrOperatorNodeInput),
     string_literal: AstStringNodeInput_1.AstStringNodeInput,
+    sub_operator: core.serialization.lazyObject(() => serializers.AstSubtractionOperatorNodeInput),
 })
     .transform({
     transform: (value) => value,

package/serialization/types/AstLessThanOrEqualsOperatorNodeOutputLeft.d.ts

@@ -8,7 +8,10 @@ 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.ConditionalOperator | 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.AddOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.AndOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.BooleanLiteral | AstLessThanOrEqualsOperatorNodeOutputLeft.ConditionalOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.DivOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.DynamicVariable | AstLessThanOrEqualsOperatorNodeOutputLeft.EqOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.GtOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.GteOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.Llm | AstLessThanOrEqualsOperatorNodeOutputLeft.LtOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.LteOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.MulOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.NeqOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.NumberLiteral | AstLessThanOrEqualsOperatorNodeOutputLeft.OrOperator | AstLessThanOrEqualsOperatorNodeOutputLeft.StringLiteral | AstLessThanOrEqualsOperatorNodeOutputLeft.SubOperator;
+    interface AddOperator extends serializers.AstAdditionOperatorNodeOutput.Raw {
+        type: "add_operator";
+    }
     interface AndOperator extends serializers.AstAndOperatorNodeOutput.Raw {
         type: "and_operator";
     }
@@ -18,6 +21,9 @@ export declare namespace AstLessThanOrEqualsOperatorNodeOutputLeft {
     interface ConditionalOperator extends serializers.AstConditionalOperatorNodeOutput.Raw {
         type: "conditional_operator";
     }
+    interface DivOperator extends serializers.AstDivisionOperatorNodeOutput.Raw {
+        type: "div_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeOutput.Raw {
         type: "dynamic_variable";
     }
@@ -39,6 +45,9 @@ export declare namespace AstLessThanOrEqualsOperatorNodeOutputLeft {
     interface LteOperator extends serializers.AstLessThanOrEqualsOperatorNodeOutput.Raw {
         type: "lte_operator";
     }
+    interface MulOperator extends serializers.AstMultiplicationOperatorNodeOutput.Raw {
+        type: "mul_operator";
+    }
     interface NeqOperator extends serializers.AstNotEqualsOperatorNodeOutput.Raw {
         type: "neq_operator";
     }
@@ -51,4 +60,7 @@ export declare namespace AstLessThanOrEqualsOperatorNodeOutputLeft {
     interface StringLiteral extends AstStringNodeOutput.Raw {
         type: "string_literal";
     }
+    interface SubOperator extends serializers.AstSubtractionOperatorNodeOutput.Raw {
+        type: "sub_operator";
+    }
 }

package/serialization/types/AstLessThanOrEqualsOperatorNodeOutputLeft.js

@@ -44,9 +44,11 @@ const AstNumberNodeOutput_1 = require("./AstNumberNodeOutput");
 const AstStringNodeOutput_1 = require("./AstStringNodeOutput");
 exports.AstLessThanOrEqualsOperatorNodeOutputLeft = core.serialization
     .union("type", {
+    add_operator: core.serialization.lazyObject(() => serializers.AstAdditionOperatorNodeOutput),
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeOutput),
     boolean_literal: AstBooleanNodeOutput_1.AstBooleanNodeOutput,
     conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeOutput),
+    div_operator: core.serialization.lazyObject(() => serializers.AstDivisionOperatorNodeOutput),
     dynamic_variable: AstDynamicVariableNodeOutput_1.AstDynamicVariableNodeOutput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeOutput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeOutput),
@@ -54,10 +56,12 @@ exports.AstLessThanOrEqualsOperatorNodeOutputLeft = core.serialization
     llm: AstllmNodeOutput_1.AstllmNodeOutput,
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeOutput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeOutput),
+    mul_operator: core.serialization.lazyObject(() => serializers.AstMultiplicationOperatorNodeOutput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeOutput),
     number_literal: AstNumberNodeOutput_1.AstNumberNodeOutput,
     or_operator: core.serialization.lazyObject(() => serializers.AstOrOperatorNodeOutput),
     string_literal: AstStringNodeOutput_1.AstStringNodeOutput,
+    sub_operator: core.serialization.lazyObject(() => serializers.AstSubtractionOperatorNodeOutput),
 })
     .transform({
     transform: (value) => value,

package/serialization/types/AstLessThanOrEqualsOperatorNodeOutputRight.d.ts

@@ -8,7 +8,10 @@ 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.ConditionalOperator | 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.AddOperator | AstLessThanOrEqualsOperatorNodeOutputRight.AndOperator | AstLessThanOrEqualsOperatorNodeOutputRight.BooleanLiteral | AstLessThanOrEqualsOperatorNodeOutputRight.ConditionalOperator | AstLessThanOrEqualsOperatorNodeOutputRight.DivOperator | AstLessThanOrEqualsOperatorNodeOutputRight.DynamicVariable | AstLessThanOrEqualsOperatorNodeOutputRight.EqOperator | AstLessThanOrEqualsOperatorNodeOutputRight.GtOperator | AstLessThanOrEqualsOperatorNodeOutputRight.GteOperator | AstLessThanOrEqualsOperatorNodeOutputRight.Llm | AstLessThanOrEqualsOperatorNodeOutputRight.LtOperator | AstLessThanOrEqualsOperatorNodeOutputRight.LteOperator | AstLessThanOrEqualsOperatorNodeOutputRight.MulOperator | AstLessThanOrEqualsOperatorNodeOutputRight.NeqOperator | AstLessThanOrEqualsOperatorNodeOutputRight.NumberLiteral | AstLessThanOrEqualsOperatorNodeOutputRight.OrOperator | AstLessThanOrEqualsOperatorNodeOutputRight.StringLiteral | AstLessThanOrEqualsOperatorNodeOutputRight.SubOperator;
+    interface AddOperator extends serializers.AstAdditionOperatorNodeOutput.Raw {
+        type: "add_operator";
+    }
     interface AndOperator extends serializers.AstAndOperatorNodeOutput.Raw {
         type: "and_operator";
     }
@@ -18,6 +21,9 @@ export declare namespace AstLessThanOrEqualsOperatorNodeOutputRight {
     interface ConditionalOperator extends serializers.AstConditionalOperatorNodeOutput.Raw {
         type: "conditional_operator";
     }
+    interface DivOperator extends serializers.AstDivisionOperatorNodeOutput.Raw {
+        type: "div_operator";
+    }
     interface DynamicVariable extends AstDynamicVariableNodeOutput.Raw {
         type: "dynamic_variable";
     }
@@ -39,6 +45,9 @@ export declare namespace AstLessThanOrEqualsOperatorNodeOutputRight {
     interface LteOperator extends serializers.AstLessThanOrEqualsOperatorNodeOutput.Raw {
         type: "lte_operator";
     }
+    interface MulOperator extends serializers.AstMultiplicationOperatorNodeOutput.Raw {
+        type: "mul_operator";
+    }
     interface NeqOperator extends serializers.AstNotEqualsOperatorNodeOutput.Raw {
         type: "neq_operator";
     }
@@ -51,4 +60,7 @@ export declare namespace AstLessThanOrEqualsOperatorNodeOutputRight {
     interface StringLiteral extends AstStringNodeOutput.Raw {
         type: "string_literal";
     }
+    interface SubOperator extends serializers.AstSubtractionOperatorNodeOutput.Raw {
+        type: "sub_operator";
+    }
 }

package/serialization/types/AstLessThanOrEqualsOperatorNodeOutputRight.js

@@ -44,9 +44,11 @@ const AstNumberNodeOutput_1 = require("./AstNumberNodeOutput");
 const AstStringNodeOutput_1 = require("./AstStringNodeOutput");
 exports.AstLessThanOrEqualsOperatorNodeOutputRight = core.serialization
     .union("type", {
+    add_operator: core.serialization.lazyObject(() => serializers.AstAdditionOperatorNodeOutput),
     and_operator: core.serialization.lazyObject(() => serializers.AstAndOperatorNodeOutput),
     boolean_literal: AstBooleanNodeOutput_1.AstBooleanNodeOutput,
     conditional_operator: core.serialization.lazyObject(() => serializers.AstConditionalOperatorNodeOutput),
+    div_operator: core.serialization.lazyObject(() => serializers.AstDivisionOperatorNodeOutput),
     dynamic_variable: AstDynamicVariableNodeOutput_1.AstDynamicVariableNodeOutput,
     eq_operator: core.serialization.lazyObject(() => serializers.AstEqualsOperatorNodeOutput),
     gt_operator: core.serialization.lazyObject(() => serializers.AstGreaterThanOperatorNodeOutput),
@@ -54,10 +56,12 @@ exports.AstLessThanOrEqualsOperatorNodeOutputRight = core.serialization
     llm: AstllmNodeOutput_1.AstllmNodeOutput,
     lt_operator: core.serialization.lazyObject(() => serializers.AstLessThanOperatorNodeOutput),
     lte_operator: core.serialization.lazyObject(() => serializers.AstLessThanOrEqualsOperatorNodeOutput),
+    mul_operator: core.serialization.lazyObject(() => serializers.AstMultiplicationOperatorNodeOutput),
     neq_operator: core.serialization.lazyObject(() => serializers.AstNotEqualsOperatorNodeOutput),
     number_literal: AstNumberNodeOutput_1.AstNumberNodeOutput,
     or_operator: core.serialization.lazyObject(() => serializers.AstOrOperatorNodeOutput),
     string_literal: AstStringNodeOutput_1.AstStringNodeOutput,
+    sub_operator: core.serialization.lazyObject(() => serializers.AstSubtractionOperatorNodeOutput),
 })
     .transform({
     transform: (value) => value,

package/serialization/types/AstMultiplicationOperatorNodeInput.d.ts

@@ -0,0 +1,10 @@
+import type * as ElevenLabs from "../../api/index";
+import * as core from "../../core";
+import * as serializers from "../index";
+export declare const AstMultiplicationOperatorNodeInput: core.serialization.ObjectSchema<serializers.AstMultiplicationOperatorNodeInput.Raw, ElevenLabs.AstMultiplicationOperatorNodeInput>;
+export declare namespace AstMultiplicationOperatorNodeInput {
+    interface Raw {
+        left: serializers.AstMultiplicationOperatorNodeInputLeft.Raw;
+        right: serializers.AstMultiplicationOperatorNodeInputRight.Raw;
+    }
+}

package/serialization/types/AstMultiplicationOperatorNodeInput.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.AstMultiplicationOperatorNodeInput = void 0;
+const core = __importStar(require("../../core"));
+const serializers = __importStar(require("../index"));
+exports.AstMultiplicationOperatorNodeInput = core.serialization.object({
+    left: core.serialization.lazy(() => serializers.AstMultiplicationOperatorNodeInputLeft),
+    right: core.serialization.lazy(() => serializers.AstMultiplicationOperatorNodeInputRight),
+});

package/serialization/types/AstMultiplicationOperatorNodeInputLeft.d.ts

@@ -0,0 +1,67 @@
+import type * as ElevenLabs from "../../api/index";
+import * as core from "../../core";
+import * as serializers from "../index";
+import { AstBooleanNodeInput } from "./AstBooleanNodeInput";
+import { AstDynamicVariableNodeInput } from "./AstDynamicVariableNodeInput";
+import { AstllmNodeInput } from "./AstllmNodeInput";
+import { AstNumberNodeInput } from "./AstNumberNodeInput";
+import { AstStringNodeInput } from "./AstStringNodeInput";
+export declare const AstMultiplicationOperatorNodeInputLeft: core.serialization.Schema<serializers.AstMultiplicationOperatorNodeInputLeft.Raw, ElevenLabs.AstMultiplicationOperatorNodeInputLeft>;
+export declare namespace AstMultiplicationOperatorNodeInputLeft {
+    type Raw = AstMultiplicationOperatorNodeInputLeft.AddOperator | AstMultiplicationOperatorNodeInputLeft.AndOperator | AstMultiplicationOperatorNodeInputLeft.BooleanLiteral | AstMultiplicationOperatorNodeInputLeft.ConditionalOperator | AstMultiplicationOperatorNodeInputLeft.DivOperator | AstMultiplicationOperatorNodeInputLeft.DynamicVariable | AstMultiplicationOperatorNodeInputLeft.EqOperator | AstMultiplicationOperatorNodeInputLeft.GtOperator | AstMultiplicationOperatorNodeInputLeft.GteOperator | AstMultiplicationOperatorNodeInputLeft.Llm | AstMultiplicationOperatorNodeInputLeft.LtOperator | AstMultiplicationOperatorNodeInputLeft.LteOperator | AstMultiplicationOperatorNodeInputLeft.MulOperator | AstMultiplicationOperatorNodeInputLeft.NeqOperator | AstMultiplicationOperatorNodeInputLeft.NumberLiteral | AstMultiplicationOperatorNodeInputLeft.OrOperator | AstMultiplicationOperatorNodeInputLeft.StringLiteral | AstMultiplicationOperatorNodeInputLeft.SubOperator;
+    interface AddOperator extends serializers.AstAdditionOperatorNodeInput.Raw {
+        type: "add_operator";
+    }
+    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 DivOperator extends serializers.AstDivisionOperatorNodeInput.Raw {
+        type: "div_operator";
+    }
+    interface DynamicVariable extends AstDynamicVariableNodeInput.Raw {
+        type: "dynamic_variable";
+    }
+    interface EqOperator extends serializers.AstEqualsOperatorNodeInput.Raw {
+        type: "eq_operator";
+    }
+    interface GtOperator extends serializers.AstGreaterThanOperatorNodeInput.Raw {
+        type: "gt_operator";
+    }
+    interface GteOperator extends serializers.AstGreaterThanOrEqualsOperatorNodeInput.Raw {
+        type: "gte_operator";
+    }
+    interface Llm {
+        type: "llm";
+        value: AstllmNodeInput.Raw;
+    }
+    interface LtOperator extends serializers.AstLessThanOperatorNodeInput.Raw {
+        type: "lt_operator";
+    }
+    interface LteOperator extends serializers.AstLessThanOrEqualsOperatorNodeInput.Raw {
+        type: "lte_operator";
+    }
+    interface MulOperator extends serializers.AstMultiplicationOperatorNodeInput.Raw {
+        type: "mul_operator";
+    }
+    interface NeqOperator extends serializers.AstNotEqualsOperatorNodeInput.Raw {
+        type: "neq_operator";
+    }
+    interface NumberLiteral extends AstNumberNodeInput.Raw {
+        type: "number_literal";
+    }
+    interface OrOperator extends serializers.AstOrOperatorNodeInput.Raw {
+        type: "or_operator";
+    }
+    interface StringLiteral extends AstStringNodeInput.Raw {
+        type: "string_literal";
+    }
+    interface SubOperator extends serializers.AstSubtractionOperatorNodeInput.Raw {
+        type: "sub_operator";
+    }
+}