@elevenlabs/elevenlabs-js 2.38.1 → 2.40.0

package/api/resources/workspace/resources/groups/client/Client.js

@@ -61,6 +61,65 @@ class GroupsClient {
         var _a;
         return ((_a = this._members) !== null && _a !== void 0 ? _a : (this._members = new Client_1.MembersClient(this._options)));
     }
+    /**
+     * Get all groups in the workspace
+     *
+     * @param {GroupsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link ElevenLabs.UnprocessableEntityError}
+     *
+     * @example
+     *     await client.workspace.groups.list()
+     */
+    list(requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__list(requestOptions));
+    }
+    __list(requestOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+            const _headers = (0, headers_1.mergeHeaders)((_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_1.mergeOnlyDefinedHeaders)({ "xi-api-key": (_b = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.apiKey) !== null && _b !== void 0 ? _b : (_c = this._options) === null || _c === void 0 ? void 0 : _c.apiKey }), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
+            const _response = yield ((_d = this._options.fetcher) !== null && _d !== void 0 ? _d : core.fetcher)({
+                url: core.url.join((_f = (_e = (yield core.Supplier.get(this._options.baseUrl))) !== null && _e !== void 0 ? _e : (yield core.Supplier.get(this._options.environment))) !== null && _f !== void 0 ? _f : environments.ElevenLabsEnvironment.Production, "v1/workspace/groups"),
+                method: "GET",
+                headers: _headers,
+                queryParameters: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.queryParams,
+                timeoutMs: ((_j = (_g = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeoutInSeconds) !== null && _g !== void 0 ? _g : (_h = this._options) === null || _h === void 0 ? void 0 : _h.timeoutInSeconds) !== null && _j !== void 0 ? _j : 240) * 1000,
+                maxRetries: (_k = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.maxRetries) !== null && _k !== void 0 ? _k : (_l = this._options) === null || _l === void 0 ? void 0 : _l.maxRetries,
+                abortSignal: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.abortSignal,
+                fetchFn: (_m = this._options) === null || _m === void 0 ? void 0 : _m.fetch,
+                logging: this._options.logging,
+            });
+            if (_response.ok) {
+                return {
+                    data: serializers.workspace.groups.list.Response.parseOrThrow(_response.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        breadcrumbsPrefix: ["response"],
+                    }),
+                    rawResponse: _response.rawResponse,
+                };
+            }
+            if (_response.error.reason === "status-code") {
+                switch (_response.error.statusCode) {
+                    case 422:
+                        throw new ElevenLabs.UnprocessableEntityError(serializers.HttpValidationError.parseOrThrow(_response.error.body, {
+                            unrecognizedObjectKeys: "passthrough",
+                            allowUnrecognizedUnionMembers: true,
+                            allowUnrecognizedEnumValues: true,
+                            breadcrumbsPrefix: ["response"],
+                        }), _response.rawResponse);
+                    default:
+                        throw new errors.ElevenLabsError({
+                            statusCode: _response.error.statusCode,
+                            body: _response.error.body,
+                            rawResponse: _response.rawResponse,
+                        });
+                }
+            }
+            return (0, handleNonStatusCodeError_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/v1/workspace/groups");
+        });
+    }
     /**
      * Searches for user groups in the workspace. Multiple or no groups may be returned.
      *

package/api/resources/workspace/resources/index.d.ts

@@ -1,3 +1,5 @@
+export * as authConnections from "./authConnections";
+export * from "./authConnections/types";
 export * as groups from "./groups";
 export * from "./groups/client/requests";
 export * as invites from "./invites";

package/api/resources/workspace/resources/index.js

@@ -36,7 +36,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resources = exports.members = exports.invites = exports.groups = void 0;
+exports.resources = exports.members = exports.invites = exports.groups = exports.authConnections = void 0;
+exports.authConnections = __importStar(require("./authConnections"));
+__exportStar(require("./authConnections/types"), exports);
 exports.groups = __importStar(require("./groups"));
 __exportStar(require("./groups/client/requests"), exports);
 exports.invites = __importStar(require("./invites"));

package/api/resources/workspace/resources/invites/client/requests/BodyInviteMultipleUsersV1WorkspaceInvitesAddBulkPost.d.ts

@@ -1,3 +1,4 @@
+import type * as ElevenLabs from "../../../../../../index";
 /**
  * @example
  *     {
@@ -7,6 +8,8 @@
 export interface BodyInviteMultipleUsersV1WorkspaceInvitesAddBulkPost {
     /** The email of the customer */
     emails: string[];
+    /** The seat type of the user */
+    seatType?: ElevenLabs.SeatType;
     /** The group ids of the user */
     groupIds?: string[];
 }

package/api/types/AgentPlatformSettingsRequestModel.d.ts

@@ -14,6 +14,8 @@ export interface AgentPlatformSettingsRequestModel {
     testing?: ElevenLabs.AgentTestingSettings;
     /** Whether the agent is archived */
     archived?: boolean;
+    /** Guardrails configuration for the agent */
+    guardrails?: ElevenLabs.GuardrailsV1Input;
     /** Language for all conversation analysis outputs (summaries, titles, evaluation rationales, data collection rationales). If not set, the language will be inferred from the conversation. Must be one of the supported conversation languages. */
     summaryLanguage?: string;
     /** Settings for authentication */

package/api/types/AgentPlatformSettingsResponseModel.d.ts

@@ -14,6 +14,8 @@ export interface AgentPlatformSettingsResponseModel {
     testing?: ElevenLabs.AgentTestingSettings;
     /** Whether the agent is archived */
     archived?: boolean;
+    /** Guardrails configuration for the agent */
+    guardrails?: ElevenLabs.GuardrailsV1Output;
     /** Language for all conversation analysis outputs (summaries, titles, evaluation rationales, data collection rationales). If not set, the language will be inferred from the conversation. Must be one of the supported conversation languages. */
     summaryLanguage?: string;
     /** Settings for authentication */

package/api/types/ApiIntegrationOAuth2AuthCodeResponse.d.ts

@@ -0,0 +1,18 @@
+import type * as ElevenLabs from "../index";
+/**
+ * Response model for integration-managed OAuth2 Auth Code auth connections
+ */
+export interface ApiIntegrationOAuth2AuthCodeResponse {
+    name: string;
+    provider: string;
+    tokenUrl: string;
+    scopes?: string[];
+    /** Separator for scopes */
+    scopeSeparator?: ElevenLabs.ApiIntegrationOAuth2AuthCodeResponseScopeSeparator;
+    /** ISO 8601 timestamp of when the access token expires */
+    expiresAt: string;
+    integrationId: string;
+    credentialId: string;
+    id: string;
+    usedBy?: ElevenLabs.AuthConnectionDependencies;
+}

package/api/types/ApiIntegrationOAuth2AuthCodeResponseScopeSeparator.d.ts

@@ -0,0 +1,6 @@
+/** Separator for scopes */
+export declare const ApiIntegrationOAuth2AuthCodeResponseScopeSeparator: {
+    readonly Space: " ";
+    readonly Comma: ",";
+};
+export type ApiIntegrationOAuth2AuthCodeResponseScopeSeparator = (typeof ApiIntegrationOAuth2AuthCodeResponseScopeSeparator)[keyof typeof ApiIntegrationOAuth2AuthCodeResponseScopeSeparator];

package/api/types/ApiIntegrationOAuth2AuthCodeResponseScopeSeparator.js

@@ -0,0 +1,9 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiIntegrationOAuth2AuthCodeResponseScopeSeparator = void 0;
+/** Separator for scopes */
+exports.ApiIntegrationOAuth2AuthCodeResponseScopeSeparator = {
+    Space: " ",
+    Comma: ",",
+};

package/api/types/AsrProvider.d.ts

@@ -1,6 +1,5 @@
 export declare const AsrProvider: {
     readonly Elevenlabs: "elevenlabs";
     readonly ScribeRealtime: "scribe_realtime";
-    readonly ScribeV2Turbo: "scribe_v2_turbo";
 };
 export type AsrProvider = (typeof AsrProvider)[keyof typeof AsrProvider];

package/api/types/AsrProvider.js

@@ -5,5 +5,4 @@ exports.AsrProvider = void 0;
 exports.AsrProvider = {
     Elevenlabs: "elevenlabs",
     ScribeRealtime: "scribe_realtime",
-    ScribeV2Turbo: "scribe_v2_turbo",
 };

package/api/types/AstAndOperatorNodeInputChildrenItem.d.ts

@@ -1,5 +1,5 @@
 import type * as ElevenLabs from "../index";
-export type AstAndOperatorNodeInputChildrenItem = ElevenLabs.AstAndOperatorNodeInputChildrenItem.AndOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.BooleanLiteral | ElevenLabs.AstAndOperatorNodeInputChildrenItem.DynamicVariable | ElevenLabs.AstAndOperatorNodeInputChildrenItem.EqOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.GtOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.GteOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.Llm | ElevenLabs.AstAndOperatorNodeInputChildrenItem.LtOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.LteOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.NeqOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.NumberLiteral | ElevenLabs.AstAndOperatorNodeInputChildrenItem.OrOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.StringLiteral;
+export type AstAndOperatorNodeInputChildrenItem = ElevenLabs.AstAndOperatorNodeInputChildrenItem.AndOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.BooleanLiteral | ElevenLabs.AstAndOperatorNodeInputChildrenItem.ConditionalOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.DynamicVariable | ElevenLabs.AstAndOperatorNodeInputChildrenItem.EqOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.GtOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.GteOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.Llm | ElevenLabs.AstAndOperatorNodeInputChildrenItem.LtOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.LteOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.NeqOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.NumberLiteral | ElevenLabs.AstAndOperatorNodeInputChildrenItem.OrOperator | ElevenLabs.AstAndOperatorNodeInputChildrenItem.StringLiteral;
 export declare namespace AstAndOperatorNodeInputChildrenItem {
     interface AndOperator extends ElevenLabs.AstAndOperatorNodeInput {
         type: "and_operator";
@@ -7,6 +7,9 @@ export declare namespace AstAndOperatorNodeInputChildrenItem {
     interface BooleanLiteral extends ElevenLabs.AstBooleanNodeInput {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends ElevenLabs.AstConditionalOperatorNodeInput {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends ElevenLabs.AstDynamicVariableNodeInput {
         type: "dynamic_variable";
     }
@@ -19,8 +22,9 @@ export declare namespace AstAndOperatorNodeInputChildrenItem {
     interface GteOperator extends ElevenLabs.AstGreaterThanOrEqualsOperatorNodeInput {
         type: "gte_operator";
     }
-    interface Llm extends ElevenLabs.AstllmNodeInput {
+    interface Llm {
         type: "llm";
+        value: ElevenLabs.AstllmNodeInput;
     }
     interface LtOperator extends ElevenLabs.AstLessThanOperatorNodeInput {
         type: "lt_operator";

package/api/types/AstAndOperatorNodeOutputChildrenItem.d.ts

@@ -1,5 +1,5 @@
 import type * as ElevenLabs from "../index";
-export type AstAndOperatorNodeOutputChildrenItem = ElevenLabs.AstAndOperatorNodeOutputChildrenItem.AndOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.BooleanLiteral | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.DynamicVariable | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.EqOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.GtOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.GteOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.Llm | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.LtOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.LteOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.NeqOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.NumberLiteral | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.OrOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.StringLiteral;
+export type AstAndOperatorNodeOutputChildrenItem = ElevenLabs.AstAndOperatorNodeOutputChildrenItem.AndOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.BooleanLiteral | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.ConditionalOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.DynamicVariable | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.EqOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.GtOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.GteOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.Llm | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.LtOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.LteOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.NeqOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.NumberLiteral | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.OrOperator | ElevenLabs.AstAndOperatorNodeOutputChildrenItem.StringLiteral;
 export declare namespace AstAndOperatorNodeOutputChildrenItem {
     interface AndOperator extends ElevenLabs.AstAndOperatorNodeOutput {
         type: "and_operator";
@@ -7,6 +7,9 @@ export declare namespace AstAndOperatorNodeOutputChildrenItem {
     interface BooleanLiteral extends ElevenLabs.AstBooleanNodeOutput {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends ElevenLabs.AstConditionalOperatorNodeOutput {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends ElevenLabs.AstDynamicVariableNodeOutput {
         type: "dynamic_variable";
     }

package/api/types/AstConditionalOperatorNodeInput.d.ts

@@ -0,0 +1,9 @@
+import type * as ElevenLabs from "../index";
+export interface AstConditionalOperatorNodeInput {
+    /** Condition deciding which expression should be selected. */
+    condition: ElevenLabs.AstConditionalOperatorNodeInputCondition;
+    /** Expression selected if the condition is true. */
+    trueExpression: ElevenLabs.AstConditionalOperatorNodeInputTrueExpression;
+    /** Expression selected if the condition is false. */
+    falseExpression: ElevenLabs.AstConditionalOperatorNodeInputFalseExpression;
+}

package/api/types/AstConditionalOperatorNodeInputCondition.d.ts

@@ -0,0 +1,50 @@
+import type * as ElevenLabs from "../index";
+/**
+ * Condition deciding which expression should be selected.
+ */
+export type AstConditionalOperatorNodeInputCondition = ElevenLabs.AstConditionalOperatorNodeInputCondition.AndOperator | ElevenLabs.AstConditionalOperatorNodeInputCondition.BooleanLiteral | ElevenLabs.AstConditionalOperatorNodeInputCondition.ConditionalOperator | ElevenLabs.AstConditionalOperatorNodeInputCondition.DynamicVariable | ElevenLabs.AstConditionalOperatorNodeInputCondition.EqOperator | ElevenLabs.AstConditionalOperatorNodeInputCondition.GtOperator | ElevenLabs.AstConditionalOperatorNodeInputCondition.GteOperator | ElevenLabs.AstConditionalOperatorNodeInputCondition.Llm | ElevenLabs.AstConditionalOperatorNodeInputCondition.LtOperator | ElevenLabs.AstConditionalOperatorNodeInputCondition.LteOperator | ElevenLabs.AstConditionalOperatorNodeInputCondition.NeqOperator | ElevenLabs.AstConditionalOperatorNodeInputCondition.NumberLiteral | ElevenLabs.AstConditionalOperatorNodeInputCondition.OrOperator | ElevenLabs.AstConditionalOperatorNodeInputCondition.StringLiteral;
+export declare namespace AstConditionalOperatorNodeInputCondition {
+    interface AndOperator extends ElevenLabs.AstAndOperatorNodeInput {
+        type: "and_operator";
+    }
+    interface BooleanLiteral extends ElevenLabs.AstBooleanNodeInput {
+        type: "boolean_literal";
+    }
+    interface ConditionalOperator extends ElevenLabs.AstConditionalOperatorNodeInput {
+        type: "conditional_operator";
+    }
+    interface DynamicVariable extends ElevenLabs.AstDynamicVariableNodeInput {
+        type: "dynamic_variable";
+    }
+    interface EqOperator extends ElevenLabs.AstEqualsOperatorNodeInput {
+        type: "eq_operator";
+    }
+    interface GtOperator extends ElevenLabs.AstGreaterThanOperatorNodeInput {
+        type: "gt_operator";
+    }
+    interface GteOperator extends ElevenLabs.AstGreaterThanOrEqualsOperatorNodeInput {
+        type: "gte_operator";
+    }
+    interface Llm {
+        type: "llm";
+        value: ElevenLabs.AstllmNodeInput;
+    }
+    interface LtOperator extends ElevenLabs.AstLessThanOperatorNodeInput {
+        type: "lt_operator";
+    }
+    interface LteOperator extends ElevenLabs.AstLessThanOrEqualsOperatorNodeInput {
+        type: "lte_operator";
+    }
+    interface NeqOperator extends ElevenLabs.AstNotEqualsOperatorNodeInput {
+        type: "neq_operator";
+    }
+    interface NumberLiteral extends ElevenLabs.AstNumberNodeInput {
+        type: "number_literal";
+    }
+    interface OrOperator extends ElevenLabs.AstOrOperatorNodeInput {
+        type: "or_operator";
+    }
+    interface StringLiteral extends ElevenLabs.AstStringNodeInput {
+        type: "string_literal";
+    }
+}

package/api/types/AstConditionalOperatorNodeInputFalseExpression.d.ts

@@ -0,0 +1,50 @@
+import type * as ElevenLabs from "../index";
+/**
+ * Expression selected if the condition is false.
+ */
+export type AstConditionalOperatorNodeInputFalseExpression = ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.AndOperator | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.BooleanLiteral | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.ConditionalOperator | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.DynamicVariable | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.EqOperator | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.GtOperator | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.GteOperator | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.Llm | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.LtOperator | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.LteOperator | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.NeqOperator | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.NumberLiteral | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.OrOperator | ElevenLabs.AstConditionalOperatorNodeInputFalseExpression.StringLiteral;
+export declare namespace AstConditionalOperatorNodeInputFalseExpression {
+    interface AndOperator extends ElevenLabs.AstAndOperatorNodeInput {
+        type: "and_operator";
+    }
+    interface BooleanLiteral extends ElevenLabs.AstBooleanNodeInput {
+        type: "boolean_literal";
+    }
+    interface ConditionalOperator extends ElevenLabs.AstConditionalOperatorNodeInput {
+        type: "conditional_operator";
+    }
+    interface DynamicVariable extends ElevenLabs.AstDynamicVariableNodeInput {
+        type: "dynamic_variable";
+    }
+    interface EqOperator extends ElevenLabs.AstEqualsOperatorNodeInput {
+        type: "eq_operator";
+    }
+    interface GtOperator extends ElevenLabs.AstGreaterThanOperatorNodeInput {
+        type: "gt_operator";
+    }
+    interface GteOperator extends ElevenLabs.AstGreaterThanOrEqualsOperatorNodeInput {
+        type: "gte_operator";
+    }
+    interface Llm {
+        type: "llm";
+        value: ElevenLabs.AstllmNodeInput;
+    }
+    interface LtOperator extends ElevenLabs.AstLessThanOperatorNodeInput {
+        type: "lt_operator";
+    }
+    interface LteOperator extends ElevenLabs.AstLessThanOrEqualsOperatorNodeInput {
+        type: "lte_operator";
+    }
+    interface NeqOperator extends ElevenLabs.AstNotEqualsOperatorNodeInput {
+        type: "neq_operator";
+    }
+    interface NumberLiteral extends ElevenLabs.AstNumberNodeInput {
+        type: "number_literal";
+    }
+    interface OrOperator extends ElevenLabs.AstOrOperatorNodeInput {
+        type: "or_operator";
+    }
+    interface StringLiteral extends ElevenLabs.AstStringNodeInput {
+        type: "string_literal";
+    }
+}

package/api/types/AstConditionalOperatorNodeInputFalseExpression.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/api/types/AstConditionalOperatorNodeInputTrueExpression.d.ts

@@ -0,0 +1,50 @@
+import type * as ElevenLabs from "../index";
+/**
+ * Expression selected if the condition is true.
+ */
+export type AstConditionalOperatorNodeInputTrueExpression = ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.AndOperator | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.BooleanLiteral | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.ConditionalOperator | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.DynamicVariable | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.EqOperator | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.GtOperator | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.GteOperator | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.Llm | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.LtOperator | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.LteOperator | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.NeqOperator | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.NumberLiteral | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.OrOperator | ElevenLabs.AstConditionalOperatorNodeInputTrueExpression.StringLiteral;
+export declare namespace AstConditionalOperatorNodeInputTrueExpression {
+    interface AndOperator extends ElevenLabs.AstAndOperatorNodeInput {
+        type: "and_operator";
+    }
+    interface BooleanLiteral extends ElevenLabs.AstBooleanNodeInput {
+        type: "boolean_literal";
+    }
+    interface ConditionalOperator extends ElevenLabs.AstConditionalOperatorNodeInput {
+        type: "conditional_operator";
+    }
+    interface DynamicVariable extends ElevenLabs.AstDynamicVariableNodeInput {
+        type: "dynamic_variable";
+    }
+    interface EqOperator extends ElevenLabs.AstEqualsOperatorNodeInput {
+        type: "eq_operator";
+    }
+    interface GtOperator extends ElevenLabs.AstGreaterThanOperatorNodeInput {
+        type: "gt_operator";
+    }
+    interface GteOperator extends ElevenLabs.AstGreaterThanOrEqualsOperatorNodeInput {
+        type: "gte_operator";
+    }
+    interface Llm {
+        type: "llm";
+        value: ElevenLabs.AstllmNodeInput;
+    }
+    interface LtOperator extends ElevenLabs.AstLessThanOperatorNodeInput {
+        type: "lt_operator";
+    }
+    interface LteOperator extends ElevenLabs.AstLessThanOrEqualsOperatorNodeInput {
+        type: "lte_operator";
+    }
+    interface NeqOperator extends ElevenLabs.AstNotEqualsOperatorNodeInput {
+        type: "neq_operator";
+    }
+    interface NumberLiteral extends ElevenLabs.AstNumberNodeInput {
+        type: "number_literal";
+    }
+    interface OrOperator extends ElevenLabs.AstOrOperatorNodeInput {
+        type: "or_operator";
+    }
+    interface StringLiteral extends ElevenLabs.AstStringNodeInput {
+        type: "string_literal";
+    }
+}

package/api/types/AstConditionalOperatorNodeInputTrueExpression.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/api/types/AstConditionalOperatorNodeOutput.d.ts

@@ -0,0 +1,9 @@
+import type * as ElevenLabs from "../index";
+export interface AstConditionalOperatorNodeOutput {
+    /** Condition deciding which expression should be selected. */
+    condition: ElevenLabs.AstConditionalOperatorNodeOutputCondition;
+    /** Expression selected if the condition is true. */
+    trueExpression: ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression;
+    /** Expression selected if the condition is false. */
+    falseExpression: ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression;
+}

package/api/types/AstConditionalOperatorNodeOutput.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/api/types/AstConditionalOperatorNodeOutputCondition.d.ts

@@ -0,0 +1,49 @@
+import type * as ElevenLabs from "../index";
+/**
+ * Condition deciding which expression should be selected.
+ */
+export type AstConditionalOperatorNodeOutputCondition = ElevenLabs.AstConditionalOperatorNodeOutputCondition.AndOperator | ElevenLabs.AstConditionalOperatorNodeOutputCondition.BooleanLiteral | ElevenLabs.AstConditionalOperatorNodeOutputCondition.ConditionalOperator | ElevenLabs.AstConditionalOperatorNodeOutputCondition.DynamicVariable | ElevenLabs.AstConditionalOperatorNodeOutputCondition.EqOperator | ElevenLabs.AstConditionalOperatorNodeOutputCondition.GtOperator | ElevenLabs.AstConditionalOperatorNodeOutputCondition.GteOperator | ElevenLabs.AstConditionalOperatorNodeOutputCondition.Llm | ElevenLabs.AstConditionalOperatorNodeOutputCondition.LtOperator | ElevenLabs.AstConditionalOperatorNodeOutputCondition.LteOperator | ElevenLabs.AstConditionalOperatorNodeOutputCondition.NeqOperator | ElevenLabs.AstConditionalOperatorNodeOutputCondition.NumberLiteral | ElevenLabs.AstConditionalOperatorNodeOutputCondition.OrOperator | ElevenLabs.AstConditionalOperatorNodeOutputCondition.StringLiteral;
+export declare namespace AstConditionalOperatorNodeOutputCondition {
+    interface AndOperator extends ElevenLabs.AstAndOperatorNodeOutput {
+        type: "and_operator";
+    }
+    interface BooleanLiteral extends ElevenLabs.AstBooleanNodeOutput {
+        type: "boolean_literal";
+    }
+    interface ConditionalOperator extends ElevenLabs.AstConditionalOperatorNodeOutput {
+        type: "conditional_operator";
+    }
+    interface DynamicVariable extends ElevenLabs.AstDynamicVariableNodeOutput {
+        type: "dynamic_variable";
+    }
+    interface EqOperator extends ElevenLabs.AstEqualsOperatorNodeOutput {
+        type: "eq_operator";
+    }
+    interface GtOperator extends ElevenLabs.AstGreaterThanOperatorNodeOutput {
+        type: "gt_operator";
+    }
+    interface GteOperator extends ElevenLabs.AstGreaterThanOrEqualsOperatorNodeOutput {
+        type: "gte_operator";
+    }
+    interface Llm extends ElevenLabs.AstllmNodeOutput {
+        type: "llm";
+    }
+    interface LtOperator extends ElevenLabs.AstLessThanOperatorNodeOutput {
+        type: "lt_operator";
+    }
+    interface LteOperator extends ElevenLabs.AstLessThanOrEqualsOperatorNodeOutput {
+        type: "lte_operator";
+    }
+    interface NeqOperator extends ElevenLabs.AstNotEqualsOperatorNodeOutput {
+        type: "neq_operator";
+    }
+    interface NumberLiteral extends ElevenLabs.AstNumberNodeOutput {
+        type: "number_literal";
+    }
+    interface OrOperator extends ElevenLabs.AstOrOperatorNodeOutput {
+        type: "or_operator";
+    }
+    interface StringLiteral extends ElevenLabs.AstStringNodeOutput {
+        type: "string_literal";
+    }
+}

package/api/types/AstConditionalOperatorNodeOutputCondition.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/api/types/AstConditionalOperatorNodeOutputFalseExpression.d.ts

@@ -0,0 +1,49 @@
+import type * as ElevenLabs from "../index";
+/**
+ * Expression selected if the condition is false.
+ */
+export type AstConditionalOperatorNodeOutputFalseExpression = ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.AndOperator | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.BooleanLiteral | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.ConditionalOperator | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.DynamicVariable | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.EqOperator | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.GtOperator | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.GteOperator | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.Llm | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.LtOperator | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.LteOperator | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.NeqOperator | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.NumberLiteral | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.OrOperator | ElevenLabs.AstConditionalOperatorNodeOutputFalseExpression.StringLiteral;
+export declare namespace AstConditionalOperatorNodeOutputFalseExpression {
+    interface AndOperator extends ElevenLabs.AstAndOperatorNodeOutput {
+        type: "and_operator";
+    }
+    interface BooleanLiteral extends ElevenLabs.AstBooleanNodeOutput {
+        type: "boolean_literal";
+    }
+    interface ConditionalOperator extends ElevenLabs.AstConditionalOperatorNodeOutput {
+        type: "conditional_operator";
+    }
+    interface DynamicVariable extends ElevenLabs.AstDynamicVariableNodeOutput {
+        type: "dynamic_variable";
+    }
+    interface EqOperator extends ElevenLabs.AstEqualsOperatorNodeOutput {
+        type: "eq_operator";
+    }
+    interface GtOperator extends ElevenLabs.AstGreaterThanOperatorNodeOutput {
+        type: "gt_operator";
+    }
+    interface GteOperator extends ElevenLabs.AstGreaterThanOrEqualsOperatorNodeOutput {
+        type: "gte_operator";
+    }
+    interface Llm extends ElevenLabs.AstllmNodeOutput {
+        type: "llm";
+    }
+    interface LtOperator extends ElevenLabs.AstLessThanOperatorNodeOutput {
+        type: "lt_operator";
+    }
+    interface LteOperator extends ElevenLabs.AstLessThanOrEqualsOperatorNodeOutput {
+        type: "lte_operator";
+    }
+    interface NeqOperator extends ElevenLabs.AstNotEqualsOperatorNodeOutput {
+        type: "neq_operator";
+    }
+    interface NumberLiteral extends ElevenLabs.AstNumberNodeOutput {
+        type: "number_literal";
+    }
+    interface OrOperator extends ElevenLabs.AstOrOperatorNodeOutput {
+        type: "or_operator";
+    }
+    interface StringLiteral extends ElevenLabs.AstStringNodeOutput {
+        type: "string_literal";
+    }
+}

package/api/types/AstConditionalOperatorNodeOutputFalseExpression.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/api/types/AstConditionalOperatorNodeOutputTrueExpression.d.ts

@@ -0,0 +1,49 @@
+import type * as ElevenLabs from "../index";
+/**
+ * Expression selected if the condition is true.
+ */
+export type AstConditionalOperatorNodeOutputTrueExpression = ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.AndOperator | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.BooleanLiteral | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.ConditionalOperator | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.DynamicVariable | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.EqOperator | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.GtOperator | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.GteOperator | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.Llm | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.LtOperator | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.LteOperator | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.NeqOperator | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.NumberLiteral | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.OrOperator | ElevenLabs.AstConditionalOperatorNodeOutputTrueExpression.StringLiteral;
+export declare namespace AstConditionalOperatorNodeOutputTrueExpression {
+    interface AndOperator extends ElevenLabs.AstAndOperatorNodeOutput {
+        type: "and_operator";
+    }
+    interface BooleanLiteral extends ElevenLabs.AstBooleanNodeOutput {
+        type: "boolean_literal";
+    }
+    interface ConditionalOperator extends ElevenLabs.AstConditionalOperatorNodeOutput {
+        type: "conditional_operator";
+    }
+    interface DynamicVariable extends ElevenLabs.AstDynamicVariableNodeOutput {
+        type: "dynamic_variable";
+    }
+    interface EqOperator extends ElevenLabs.AstEqualsOperatorNodeOutput {
+        type: "eq_operator";
+    }
+    interface GtOperator extends ElevenLabs.AstGreaterThanOperatorNodeOutput {
+        type: "gt_operator";
+    }
+    interface GteOperator extends ElevenLabs.AstGreaterThanOrEqualsOperatorNodeOutput {
+        type: "gte_operator";
+    }
+    interface Llm extends ElevenLabs.AstllmNodeOutput {
+        type: "llm";
+    }
+    interface LtOperator extends ElevenLabs.AstLessThanOperatorNodeOutput {
+        type: "lt_operator";
+    }
+    interface LteOperator extends ElevenLabs.AstLessThanOrEqualsOperatorNodeOutput {
+        type: "lte_operator";
+    }
+    interface NeqOperator extends ElevenLabs.AstNotEqualsOperatorNodeOutput {
+        type: "neq_operator";
+    }
+    interface NumberLiteral extends ElevenLabs.AstNumberNodeOutput {
+        type: "number_literal";
+    }
+    interface OrOperator extends ElevenLabs.AstOrOperatorNodeOutput {
+        type: "or_operator";
+    }
+    interface StringLiteral extends ElevenLabs.AstStringNodeOutput {
+        type: "string_literal";
+    }
+}

package/api/types/AstConditionalOperatorNodeOutputTrueExpression.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/api/types/AstEqualsOperatorNodeInputLeft.d.ts

@@ -2,7 +2,7 @@ import type * as ElevenLabs from "../index";
 /**
  * Left operand of the binary operator.
  */
-export type AstEqualsOperatorNodeInputLeft = ElevenLabs.AstEqualsOperatorNodeInputLeft.AndOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.BooleanLiteral | ElevenLabs.AstEqualsOperatorNodeInputLeft.DynamicVariable | ElevenLabs.AstEqualsOperatorNodeInputLeft.EqOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.GtOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.GteOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.Llm | ElevenLabs.AstEqualsOperatorNodeInputLeft.LtOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.LteOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.NeqOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.NumberLiteral | ElevenLabs.AstEqualsOperatorNodeInputLeft.OrOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.StringLiteral;
+export type AstEqualsOperatorNodeInputLeft = ElevenLabs.AstEqualsOperatorNodeInputLeft.AndOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.BooleanLiteral | ElevenLabs.AstEqualsOperatorNodeInputLeft.ConditionalOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.DynamicVariable | ElevenLabs.AstEqualsOperatorNodeInputLeft.EqOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.GtOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.GteOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.Llm | ElevenLabs.AstEqualsOperatorNodeInputLeft.LtOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.LteOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.NeqOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.NumberLiteral | ElevenLabs.AstEqualsOperatorNodeInputLeft.OrOperator | ElevenLabs.AstEqualsOperatorNodeInputLeft.StringLiteral;
 export declare namespace AstEqualsOperatorNodeInputLeft {
     interface AndOperator extends ElevenLabs.AstAndOperatorNodeInput {
         type: "and_operator";
@@ -10,6 +10,9 @@ export declare namespace AstEqualsOperatorNodeInputLeft {
     interface BooleanLiteral extends ElevenLabs.AstBooleanNodeInput {
         type: "boolean_literal";
     }
+    interface ConditionalOperator extends ElevenLabs.AstConditionalOperatorNodeInput {
+        type: "conditional_operator";
+    }
     interface DynamicVariable extends ElevenLabs.AstDynamicVariableNodeInput {
         type: "dynamic_variable";
     }
@@ -22,8 +25,9 @@ export declare namespace AstEqualsOperatorNodeInputLeft {
     interface GteOperator extends ElevenLabs.AstGreaterThanOrEqualsOperatorNodeInput {
         type: "gte_operator";
     }
-    interface Llm extends ElevenLabs.AstllmNodeInput {
+    interface Llm {
         type: "llm";
+        value: ElevenLabs.AstllmNodeInput;
     }
     interface LtOperator extends ElevenLabs.AstLessThanOperatorNodeInput {
         type: "lt_operator";