@automate.ax/integration-contracts 0.151.0 → 0.152.0

package/dist/close/events.d.ts

@@ -124,9 +124,9 @@ export declare const closeTriggerContracts: {
                     failed: "failed";
                     completed: "completed";
                     timeout: "timeout";
+                    "in-progress": "in-progress";
                     busy: "busy";
                     cancel: "cancel";
-                    "in-progress": "in-progress";
                     "no-answer": "no-answer";
                 }>>;
                 type: z.ZodOptional<z.ZodLiteral<"Call">>;
@@ -197,9 +197,9 @@ export declare const closeTriggerContracts: {
                     failed: "failed";
                     completed: "completed";
                     timeout: "timeout";
+                    "in-progress": "in-progress";
                     busy: "busy";
                     cancel: "cancel";
-                    "in-progress": "in-progress";
                     "no-answer": "no-answer";
                 }>>;
                 type: z.ZodOptional<z.ZodLiteral<"Call">>;

package/dist/close/schemas.d.ts

@@ -840,9 +840,9 @@ export declare const CLOSE_CALL_SCHEMA: z.ZodObject<{
         failed: "failed";
         completed: "completed";
         timeout: "timeout";
+        "in-progress": "in-progress";
         busy: "busy";
         cancel: "cancel";
-        "in-progress": "in-progress";
         "no-answer": "no-answer";
     }>;
     type: z.ZodLiteral<"Call">;
@@ -1070,9 +1070,9 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
         failed: "failed";
         completed: "completed";
         timeout: "timeout";
+        "in-progress": "in-progress";
         busy: "busy";
         cancel: "cancel";
-        "in-progress": "in-progress";
         "no-answer": "no-answer";
     }>;
     type: z.ZodLiteral<"Call">;

package/dist/elevenlabs/api.d.ts

@@ -0,0 +1,58 @@
+import type { Encodable } from "@automate.ax/codec";
+import * as z from "zod";
+export interface ElevenLabsRequestOptions<TSchema extends z.ZodType> {
+    body?: Encodable;
+    method?: "DELETE" | "GET" | "PATCH" | "POST";
+    query?: Record<string, boolean | number | readonly string[] | string | undefined>;
+    responseSchema: TSchema;
+}
+/** Structured ElevenLabs REST failure. */
+export declare class ElevenLabsApiError extends Error {
+    readonly body?: Encodable;
+    readonly retryAfter?: number;
+    readonly status: number;
+    /**
+     * Creates a structured ElevenLabs API failure.
+     *
+     * @param options Failure details.
+     * @param options.body Parsed provider response body.
+     * @param options.retryAfter Retry delay in seconds.
+     * @param options.status HTTP status.
+     */
+    constructor(options: {
+        body?: Encodable;
+        retryAfter?: number;
+        status: number;
+    });
+}
+/**
+ * Creates an authenticated ElevenLabs REST client.
+ *
+ * @param secret Account secret containing an ElevenLabs API key.
+ */
+export declare function getElevenLabsApi(secret: Record<string, unknown>): {
+    request<TSchema extends z.ZodType>(path: string, options: ElevenLabsRequestOptions<TSchema>): Promise<z.output<TSchema>>;
+    requestFile(path: string, options: Omit<ElevenLabsRequestOptions<z.ZodType>, "responseSchema"> & {
+        filename: string;
+    }): Promise<File>;
+    requestForm<TSchema extends z.ZodType>(path: string, form: FormData, options: {
+        query?: ElevenLabsRequestOptions<TSchema>["query"];
+        responseSchema: TSchema;
+    }): Promise<z.output<TSchema>>;
+    requestFormFile(path: string, form: FormData, options: {
+        filename: string;
+        query?: ElevenLabsRequestOptions<z.ZodType>["query"];
+    }): Promise<File>;
+};
+/**
+ * Converts camelCase values into ElevenLabs wire names.
+ *
+ * @param value Public value.
+ */
+export declare function toElevenLabs(value: Encodable): Encodable;
+/**
+ * Converts ElevenLabs wire names into camelCase values.
+ *
+ * @param value Provider value.
+ */
+export declare function fromElevenLabs(value: unknown): unknown;

package/dist/elevenlabs/api.js

@@ -0,0 +1,237 @@
+import { encodableSchema } from "@automate.ax/codec";
+import * as z from "zod";
+const ELEVENLABS_API_BASE_URL = "https://api.elevenlabs.io/";
+const ELEVENLABS_API_ORIGIN = new URL(ELEVENLABS_API_BASE_URL).origin;
+const ELEVENLABS_SECRET_SCHEMA = z.object({ apiKey: z.string().min(1) });
+/** Structured ElevenLabs REST failure. */
+export class ElevenLabsApiError extends Error {
+    body;
+    retryAfter;
+    status;
+    /**
+     * Creates a structured ElevenLabs API failure.
+     *
+     * @param options Failure details.
+     * @param options.body Parsed provider response body.
+     * @param options.retryAfter Retry delay in seconds.
+     * @param options.status HTTP status.
+     */
+    constructor(options) {
+        super(getErrorMessage(options.body) ??
+            `ElevenLabs API request failed with status ${options.status}.`);
+        this.name = "ElevenLabsApiError";
+        this.body = options.body;
+        this.retryAfter = options.retryAfter;
+        this.status = options.status;
+    }
+}
+/**
+ * Creates an authenticated ElevenLabs REST client.
+ *
+ * @param secret Account secret containing an ElevenLabs API key.
+ */
+export function getElevenLabsApi(secret) {
+    const { apiKey } = ELEVENLABS_SECRET_SCHEMA.parse(secret);
+    /**
+     * Sends one authenticated provider request and validates HTTP status.
+     *
+     * @param path Versioned or v1-relative API path.
+     * @param options Request options.
+     * @param options.body Encoded request body.
+     * @param options.headers Additional request headers.
+     * @param options.method HTTP method.
+     * @param options.query Query parameters.
+     */
+    async function fetchResponse(path, options) {
+        const headers = new Headers(options.headers);
+        headers.set("xi-api-key", apiKey);
+        const response = await fetch(createElevenLabsUrl(path, options.query), {
+            body: options.body,
+            headers,
+            method: options.method ?? "GET",
+        });
+        if (!response.ok) {
+            const body = encodableSchema.safeParse(fromElevenLabs(parseJson(await response.text())));
+            throw new ElevenLabsApiError({
+                ...(body.success && { body: body.data }),
+                retryAfter: parseRetryAfter(response.headers.get("retry-after")),
+                status: response.status,
+            });
+        }
+        return response;
+    }
+    return {
+        async request(path, options) {
+            return options.responseSchema.parse(fromElevenLabs(parseJson(await (await fetchResponse(path, {
+                body: options.body === undefined
+                    ? undefined
+                    : JSON.stringify(toElevenLabs(options.body)),
+                headers: options.body === undefined
+                    ? { Accept: "application/json" }
+                    : {
+                        Accept: "application/json",
+                        "Content-Type": "application/json",
+                    },
+                method: options.method,
+                query: options.query,
+            })).text())));
+        },
+        async requestFile(path, options) {
+            const response = await fetchResponse(path, {
+                body: options.body === undefined
+                    ? undefined
+                    : JSON.stringify(toElevenLabs(options.body)),
+                headers: options.body === undefined
+                    ? undefined
+                    : { "Content-Type": "application/json" },
+                method: options.method,
+                query: options.query,
+            });
+            const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+            return new File([await response.blob()], contentType.startsWith("video/mp4")
+                ? options.filename.replace(/\.[^.]+$/, ".mp4")
+                : options.filename, {
+                type: contentType,
+            });
+        },
+        async requestForm(path, form, options) {
+            return options.responseSchema.parse(fromElevenLabs(parseJson(await (await fetchResponse(path, {
+                body: form,
+                method: "POST",
+                query: options.query,
+            })).text())));
+        },
+        async requestFormFile(path, form, options) {
+            const response = await fetchResponse(path, {
+                body: form,
+                method: "POST",
+                query: options.query,
+            });
+            const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+            return new File([await response.blob()], contentType.startsWith("video/mp4")
+                ? options.filename.replace(/\.[^.]+$/, ".mp4")
+                : options.filename, { type: contentType });
+        },
+    };
+}
+/**
+ * Converts camelCase values into ElevenLabs wire names.
+ *
+ * @param value Public value.
+ */
+export function toElevenLabs(value) {
+    return encodeElevenLabsValue(value, false);
+}
+/**
+ * Converts one value while optionally preserving opaque object keys.
+ *
+ * @param value Public value.
+ * @param preserveKeys Whether object keys are user-defined identifiers.
+ */
+function encodeElevenLabsValue(value, preserveKeys) {
+    if (value instanceof Date)
+        return value.toISOString();
+    if (Array.isArray(value)) {
+        return value.map((item) => encodeElevenLabsValue(item, preserveKeys));
+    }
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => {
+        const encodedKey = preserveKeys
+            ? key
+            : key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+        return [
+            encodedKey,
+            encodeElevenLabsValue(item, preserveKeys || encodedKey === "dynamic_variables"),
+        ];
+    }));
+}
+/**
+ * Converts ElevenLabs wire names into camelCase values.
+ *
+ * @param value Provider value.
+ */
+export function fromElevenLabs(value) {
+    if (Array.isArray(value))
+        return value.map(fromElevenLabs);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key.replace(/_([a-z0-9])/g, (_, letter) => letter.toUpperCase()),
+        fromElevenLabs(item),
+    ]));
+}
+/**
+ * Creates a same-origin ElevenLabs URL with encoded query parameters.
+ *
+ * @param path Versioned or v1-relative API path.
+ * @param query Query parameters.
+ * @throws When a path resolves outside the ElevenLabs API origin.
+ */
+function createElevenLabsUrl(path, query) {
+    const requestedPath = path.replace(/^\//, "");
+    const url = new URL(/^v\d+\//.test(requestedPath) ? requestedPath : `v1/${requestedPath}`, ELEVENLABS_API_BASE_URL);
+    if (url.origin !== ELEVENLABS_API_ORIGIN) {
+        throw new Error("ElevenLabs API paths must use the ElevenLabs API origin.");
+    }
+    for (const [name, value] of Object.entries(query ?? {})) {
+        if (value === undefined)
+            continue;
+        const key = name.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+        if (Array.isArray(value)) {
+            for (const item of value)
+                url.searchParams.append(key, item);
+        }
+        else {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return url;
+}
+/**
+ * Parses a JSON response without masking the original HTTP status.
+ *
+ * @param value Response text.
+ */
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Parses a numeric Retry-After header in seconds.
+ *
+ * @param value Header value.
+ */
+function parseRetryAfter(value) {
+    if (value === null)
+        return undefined;
+    const seconds = Number(value);
+    return Number.isFinite(seconds) ? seconds : undefined;
+}
+/**
+ * Extracts the provider's most useful structured error message.
+ *
+ * @param body Parsed response body.
+ */
+function getErrorMessage(body) {
+    if (!isPlainObject(body))
+        return undefined;
+    if (typeof body.message === "string")
+        return body.message;
+    if (isPlainObject(body.detail) && typeof body.detail.message === "string") {
+        return body.detail.message;
+    }
+    return undefined;
+}
+/**
+ * Checks whether a value is a non-array object.
+ *
+ * @param value Candidate value.
+ */
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/elevenlabs/events.d.ts

@@ -0,0 +1,264 @@
+import * as z from "zod";
+export declare const ELEVENLABS_TRIGGER_CONFIG_SCHEMA: z.ZodObject<{}, z.core.$strip>;
+export declare const elevenLabsTriggerContracts: {
+    readonly "elevenlabs.event": {
+        readonly configSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly eventSchema: z.ZodUnion<readonly [z.ZodObject<{
+            data: z.ZodObject<{
+                noticePeriodDays: z.ZodOptional<z.ZodNumber>;
+                voiceId: z.ZodString;
+                voiceName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            eventTimestamp: z.ZodNumber;
+            type: z.ZodEnum<{
+                voice_removal_notice: "voice_removal_notice";
+                voice_removal_notice_withdrawn: "voice_removal_notice_withdrawn";
+                voice_removed: "voice_removed";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+                requestId: z.ZodString;
+                transcription: z.ZodUnion<readonly [z.ZodObject<{
+                    languageCode: z.ZodString;
+                    languageProbability: z.ZodNumber;
+                    text: z.ZodString;
+                    words: z.ZodArray<z.ZodObject<{
+                        channelIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        end: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        logprob: z.ZodOptional<z.ZodNumber>;
+                        speakerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        start: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        text: z.ZodString;
+                        type: z.ZodEnum<{
+                            audio_event: "audio_event";
+                            spacing: "spacing";
+                            word: "word";
+                        }>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    transcripts: z.ZodArray<z.ZodObject<{
+                        languageCode: z.ZodString;
+                        languageProbability: z.ZodNumber;
+                        text: z.ZodString;
+                        words: z.ZodArray<z.ZodObject<{
+                            channelIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                            end: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                            logprob: z.ZodOptional<z.ZodNumber>;
+                            speakerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                            start: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                            text: z.ZodString;
+                            type: z.ZodEnum<{
+                                audio_event: "audio_event";
+                                spacing: "spacing";
+                                word: "word";
+                            }>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>;
+                webhookMetadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+            }, z.core.$strip>;
+            eventTimestamp: z.ZodOptional<z.ZodNumber>;
+            type: z.ZodLiteral<"speech_to_text_transcription">;
+        }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                contentMimeType: z.ZodString;
+                contentUrl: z.ZodURL;
+                id: z.ZodString;
+                status: z.ZodLiteral<"completed">;
+            }, z.core.$strip>, z.ZodObject<{
+                errorMessage: z.ZodString;
+                failureReason: z.ZodEnum<{
+                    timeout: "timeout";
+                    charging_failed: "charging_failed";
+                    dependency_failed: "dependency_failed";
+                    internal_error: "internal_error";
+                    invalid_parameters: "invalid_parameters";
+                    model_error: "model_error";
+                    moderated: "moderated";
+                }>;
+                id: z.ZodString;
+                status: z.ZodLiteral<"failed">;
+            }, z.core.$strip>], "status">;
+            eventTimestamp: z.ZodNumber;
+            type: z.ZodLiteral<"flows_generation">;
+        }, z.core.$strip>]>;
+    };
+    readonly "elevenlabs.flowGenerationCompleted": {
+        readonly configSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly eventSchema: z.ZodObject<{
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                contentMimeType: z.ZodString;
+                contentUrl: z.ZodURL;
+                id: z.ZodString;
+                status: z.ZodLiteral<"completed">;
+            }, z.core.$strip>, z.ZodObject<{
+                errorMessage: z.ZodString;
+                failureReason: z.ZodEnum<{
+                    timeout: "timeout";
+                    charging_failed: "charging_failed";
+                    dependency_failed: "dependency_failed";
+                    internal_error: "internal_error";
+                    invalid_parameters: "invalid_parameters";
+                    model_error: "model_error";
+                    moderated: "moderated";
+                }>;
+                id: z.ZodString;
+                status: z.ZodLiteral<"failed">;
+            }, z.core.$strip>], "status">;
+            eventTimestamp: z.ZodNumber;
+            type: z.ZodLiteral<"flows_generation">;
+        }, z.core.$strip>;
+    };
+    readonly "elevenlabs.flowGenerationEvent": {
+        readonly configSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly eventSchema: z.ZodObject<{
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                contentMimeType: z.ZodString;
+                contentUrl: z.ZodURL;
+                id: z.ZodString;
+                status: z.ZodLiteral<"completed">;
+            }, z.core.$strip>, z.ZodObject<{
+                errorMessage: z.ZodString;
+                failureReason: z.ZodEnum<{
+                    timeout: "timeout";
+                    charging_failed: "charging_failed";
+                    dependency_failed: "dependency_failed";
+                    internal_error: "internal_error";
+                    invalid_parameters: "invalid_parameters";
+                    model_error: "model_error";
+                    moderated: "moderated";
+                }>;
+                id: z.ZodString;
+                status: z.ZodLiteral<"failed">;
+            }, z.core.$strip>], "status">;
+            eventTimestamp: z.ZodNumber;
+            type: z.ZodLiteral<"flows_generation">;
+        }, z.core.$strip>;
+    };
+    readonly "elevenlabs.flowGenerationFailed": {
+        readonly configSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly eventSchema: z.ZodObject<{
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                contentMimeType: z.ZodString;
+                contentUrl: z.ZodURL;
+                id: z.ZodString;
+                status: z.ZodLiteral<"completed">;
+            }, z.core.$strip>, z.ZodObject<{
+                errorMessage: z.ZodString;
+                failureReason: z.ZodEnum<{
+                    timeout: "timeout";
+                    charging_failed: "charging_failed";
+                    dependency_failed: "dependency_failed";
+                    internal_error: "internal_error";
+                    invalid_parameters: "invalid_parameters";
+                    model_error: "model_error";
+                    moderated: "moderated";
+                }>;
+                id: z.ZodString;
+                status: z.ZodLiteral<"failed">;
+            }, z.core.$strip>], "status">;
+            eventTimestamp: z.ZodNumber;
+            type: z.ZodLiteral<"flows_generation">;
+        }, z.core.$strip>;
+    };
+    readonly "elevenlabs.transcriptionCompleted": {
+        readonly configSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly eventSchema: z.ZodObject<{
+            data: z.ZodObject<{
+                requestId: z.ZodString;
+                transcription: z.ZodUnion<readonly [z.ZodObject<{
+                    languageCode: z.ZodString;
+                    languageProbability: z.ZodNumber;
+                    text: z.ZodString;
+                    words: z.ZodArray<z.ZodObject<{
+                        channelIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        end: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        logprob: z.ZodOptional<z.ZodNumber>;
+                        speakerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        start: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        text: z.ZodString;
+                        type: z.ZodEnum<{
+                            audio_event: "audio_event";
+                            spacing: "spacing";
+                            word: "word";
+                        }>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    transcripts: z.ZodArray<z.ZodObject<{
+                        languageCode: z.ZodString;
+                        languageProbability: z.ZodNumber;
+                        text: z.ZodString;
+                        words: z.ZodArray<z.ZodObject<{
+                            channelIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                            end: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                            logprob: z.ZodOptional<z.ZodNumber>;
+                            speakerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                            start: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                            text: z.ZodString;
+                            type: z.ZodEnum<{
+                                audio_event: "audio_event";
+                                spacing: "spacing";
+                                word: "word";
+                            }>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>;
+                webhookMetadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+            }, z.core.$strip>;
+            eventTimestamp: z.ZodOptional<z.ZodNumber>;
+            type: z.ZodLiteral<"speech_to_text_transcription">;
+        }, z.core.$strip>;
+    };
+    readonly "elevenlabs.voiceRemovalEvent": {
+        readonly configSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly eventSchema: z.ZodObject<{
+            data: z.ZodObject<{
+                noticePeriodDays: z.ZodOptional<z.ZodNumber>;
+                voiceId: z.ZodString;
+                voiceName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            eventTimestamp: z.ZodNumber;
+            type: z.ZodEnum<{
+                voice_removal_notice: "voice_removal_notice";
+                voice_removal_notice_withdrawn: "voice_removal_notice_withdrawn";
+                voice_removed: "voice_removed";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly "elevenlabs.voiceRemovalScheduled": {
+        readonly configSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly eventSchema: z.ZodObject<{
+            data: z.ZodObject<{
+                noticePeriodDays: z.ZodOptional<z.ZodNumber>;
+                voiceId: z.ZodString;
+                voiceName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            eventTimestamp: z.ZodNumber;
+            type: z.ZodLiteral<"voice_removal_notice">;
+        }, z.core.$strip>;
+    };
+    readonly "elevenlabs.voiceRemovalWithdrawn": {
+        readonly configSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly eventSchema: z.ZodObject<{
+            data: z.ZodObject<{
+                noticePeriodDays: z.ZodOptional<z.ZodNumber>;
+                voiceId: z.ZodString;
+                voiceName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            eventTimestamp: z.ZodNumber;
+            type: z.ZodLiteral<"voice_removal_notice_withdrawn">;
+        }, z.core.$strip>;
+    };
+    readonly "elevenlabs.voiceRemoved": {
+        readonly configSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly eventSchema: z.ZodObject<{
+            data: z.ZodObject<{
+                noticePeriodDays: z.ZodOptional<z.ZodNumber>;
+                voiceId: z.ZodString;
+                voiceName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            eventTimestamp: z.ZodNumber;
+            type: z.ZodLiteral<"voice_removed">;
+        }, z.core.$strip>;
+    };
+};

package/dist/elevenlabs/events.js

@@ -0,0 +1,47 @@
+import * as z from "zod";
+import { ELEVENLABS_FLOW_GENERATION_EVENT_SCHEMA, ELEVENLABS_TRANSCRIPTION_EVENT_SCHEMA, ELEVENLABS_VOICE_REMOVAL_EVENT_SCHEMA, ELEVENLABS_WEBHOOK_EVENT_SCHEMA, } from "./schemas.js";
+export const ELEVENLABS_TRIGGER_CONFIG_SCHEMA = z.object({});
+export const elevenLabsTriggerContracts = {
+    "elevenlabs.event": {
+        configSchema: ELEVENLABS_TRIGGER_CONFIG_SCHEMA,
+        eventSchema: ELEVENLABS_WEBHOOK_EVENT_SCHEMA,
+    },
+    "elevenlabs.flowGenerationCompleted": {
+        configSchema: ELEVENLABS_TRIGGER_CONFIG_SCHEMA,
+        eventSchema: ELEVENLABS_FLOW_GENERATION_EVENT_SCHEMA.refine(({ data }) => data.status === "completed"),
+    },
+    "elevenlabs.flowGenerationEvent": {
+        configSchema: ELEVENLABS_TRIGGER_CONFIG_SCHEMA,
+        eventSchema: ELEVENLABS_FLOW_GENERATION_EVENT_SCHEMA,
+    },
+    "elevenlabs.flowGenerationFailed": {
+        configSchema: ELEVENLABS_TRIGGER_CONFIG_SCHEMA,
+        eventSchema: ELEVENLABS_FLOW_GENERATION_EVENT_SCHEMA.refine(({ data }) => data.status === "failed"),
+    },
+    "elevenlabs.transcriptionCompleted": {
+        configSchema: ELEVENLABS_TRIGGER_CONFIG_SCHEMA,
+        eventSchema: ELEVENLABS_TRANSCRIPTION_EVENT_SCHEMA,
+    },
+    "elevenlabs.voiceRemovalEvent": {
+        configSchema: ELEVENLABS_TRIGGER_CONFIG_SCHEMA,
+        eventSchema: ELEVENLABS_VOICE_REMOVAL_EVENT_SCHEMA,
+    },
+    "elevenlabs.voiceRemovalScheduled": {
+        configSchema: ELEVENLABS_TRIGGER_CONFIG_SCHEMA,
+        eventSchema: ELEVENLABS_VOICE_REMOVAL_EVENT_SCHEMA.extend({
+            type: z.literal("voice_removal_notice"),
+        }),
+    },
+    "elevenlabs.voiceRemovalWithdrawn": {
+        configSchema: ELEVENLABS_TRIGGER_CONFIG_SCHEMA,
+        eventSchema: ELEVENLABS_VOICE_REMOVAL_EVENT_SCHEMA.extend({
+            type: z.literal("voice_removal_notice_withdrawn"),
+        }),
+    },
+    "elevenlabs.voiceRemoved": {
+        configSchema: ELEVENLABS_TRIGGER_CONFIG_SCHEMA,
+        eventSchema: ELEVENLABS_VOICE_REMOVAL_EVENT_SCHEMA.extend({
+            type: z.literal("voice_removed"),
+        }),
+    },
+};

package/dist/elevenlabs/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./api.js";
+export * from "./events.js";
+export * from "./schemas.js";

package/dist/elevenlabs/index.js

@@ -0,0 +1,3 @@
+export * from "./api.js";
+export * from "./events.js";
+export * from "./schemas.js";