@meistrari/tela-sdk-js 2.4.3 → 2.6.0

package/dist/index.d.cts

@@ -1,6 +1,6 @@
-import * as _zod from 'zod';
-import _zod__default, { ZodError, z } from 'zod';
+import z, { z as z$1 } from 'zod';
 import Emittery from 'emittery';
+import { JSONSchema } from 'zod/v4/core';
 
 /**
  * Base HTTP client with retry logic, request/response transformation, and streaming support.
@@ -22,6 +22,7 @@ type RequestOptions<Req = unknown | Record<string, unknown>> = {
     stream?: boolean | undefined;
     timeout?: number;
     signal?: AbortSignal | undefined | null;
+    transformCase?: boolean;
 };
 interface BaseClientOptions {
     baseURL: string;
@@ -145,6 +146,24 @@ declare class ExecutionFailedError extends TelaError {
     readonly rawOutput: Record<string, any>;
     constructor(rawOutput: Record<string, any>);
 }
+/**
+ * Thrown when a workstation task fails on the server.
+ *
+ * @category Errors
+ */
+declare class TaskFailedError extends TelaError {
+    readonly rawTask: Record<string, any>;
+    constructor(rawTask: Record<string, any>, message?: string, cause?: Error);
+}
+/**
+ * Thrown when batch execution fails on the server.
+ *
+ * @category Errors
+ */
+declare class BatchExecutionFailedError extends TelaError {
+    readonly rawResponse: Record<string, any>;
+    constructor(rawResponse: Record<string, any>);
+}
 /**
  * Base class for all API-related errors.
  *
@@ -247,7 +266,7 @@ type TelaFileOptions = BaseTelaFileOptions | TelaFileOptionsWithMimeType;
  * which can be a URL string, Uint8Array, ReadableStream, ReadStream, Blob, or File.
  */
 type TelaFileInput = string | Uint8Array | ReadableStream | Blob | File;
-declare function TelaFileSchema(): _zod__default.ZodCustom<TelaFile, TelaFile>;
+declare function TelaFileSchema(): z.ZodCustom<TelaFile, TelaFile>;
 /**
  * Represents a file with support for various types including URLs, binary data, streams, and Blobs.
  *
@@ -384,17 +403,488 @@ declare class TelaFile {
      */
     private isValidVaultReference;
 }
+declare function isTelaFile(obj: unknown): obj is TelaFile;
+declare function isTelaFileArray(obj: unknown): obj is TelaFile[];
 
 /**
- * Canvas execution module for managing canvas execution lifecycle and modes.
+ * Represents a variable that can be used in a canvas template.
+ */
+type CanvasVariable = {
+    /**
+     * The name of the variable.
+     */
+    name: string;
+    /**
+     * The type of the variable (e.g., 'string', 'number', 'file').
+     */
+    type: string;
+    /**
+     * Whether this variable is required for canvas execution.
+     */
+    required: boolean;
+    /**
+     * Description of the variable's purpose.
+     */
+    description: string;
+    /**
+     * Processing options for the variable.
+     */
+    processingOptions: {
+        /**
+         * Whether multimodal content (images, files) is allowed.
+         */
+        allowMultimodal: boolean;
+    };
+};
+
+/**
+ * Represents a specific version of a canvas/prompt from the Tela API.
+ */
+type PromptVersion = {
+    /**
+     * Unique identifier for this prompt version.
+     */
+    id: string;
+    /**
+     * The raw content of the prompt.
+     */
+    content: string;
+    /**
+     * The markdown-formatted content of the prompt.
+     */
+    markdownContent: any;
+    /**
+     * The ID of the parent prompt.
+     */
+    promptId: string;
+    /**
+     * Variables available in this prompt version.
+     */
+    variables: Array<CanvasVariable>;
+    /**
+     * The title/name of the prompt.
+     */
+    title: string;
+    /**
+     * Configuration settings for this prompt version.
+     */
+    configuration: {
+        /**
+         * The AI model to use (e.g., 'gpt-4', 'claude-3').
+         */
+        model: string;
+        /**
+         * The type of prompt ('chat' or 'completion').
+         */
+        type: string;
+        /**
+         * Temperature setting for response randomness (0-1).
+         */
+        temperature: number;
+        /**
+         * Structured output configuration.
+         */
+        structuredOutput: {
+            /**
+             * JSON schema for validating structured output.
+             */
+            schema: JSONSchema.JSONSchema;
+            /**
+             * Whether structured output is enabled.
+             */
+            enabled: boolean;
+        };
+    };
+    /**
+     * Whether this version is promoted to production.
+     */
+    promoted: boolean;
+    /**
+     * Whether this is a draft version.
+     */
+    draft: boolean;
+    /**
+     * ID of the workspace this prompt belongs to.
+     */
+    workspaceId: string;
+    /**
+     * Workflow specification if this is a workflow-based prompt.
+     */
+    workflowSpec: any;
+    /**
+     * Graph representation of the workflow.
+     */
+    graph: any;
+    /**
+     * Whether this prompt is a workflow.
+     */
+    isWorkflow: boolean;
+    /**
+     * User ID who created this version.
+     */
+    createdBy: string;
+    /**
+     * User ID who last updated this version.
+     */
+    updatedBy: string;
+    /**
+     * User ID who deleted this version, if applicable.
+     */
+    deletedBy: any;
+    /**
+     * ISO timestamp when this version was created.
+     */
+    createdAt: string;
+    /**
+     * ISO timestamp when this version was last updated.
+     */
+    updatedAt: string;
+    /**
+     * ISO timestamp when this version was deleted, if applicable.
+     */
+    deletedAt: any;
+    /**
+     * Messages in the conversation for this prompt version.
+     */
+    messages: Array<{
+        /**
+         * Unique message identifier.
+         */
+        id: string;
+        /**
+         * The raw content of the message.
+         */
+        content: string;
+        /**
+         * The markdown-formatted content of the message.
+         */
+        markdownContent: string;
+        /**
+         * Role of the message sender (e.g., 'user', 'assistant').
+         */
+        role: string;
+        /**
+         * ID of the prompt version this message belongs to.
+         */
+        promptVersionId: string;
+        /**
+         * Order index of this message in the conversation.
+         */
+        index: number;
+        /**
+         * User ID who created this message.
+         */
+        createdBy: string;
+        /**
+         * User ID who last updated this message.
+         */
+        updatedBy: string;
+        /**
+         * ISO timestamp when this message was created.
+         */
+        createdAt: string;
+        /**
+         * ISO timestamp when this message was last updated.
+         */
+        updatedAt: string;
+        /**
+         * ISO timestamp when this message was deleted, if applicable.
+         */
+        deletedAt: any;
+    }>;
+};
+
+/**
+ * Schema validation and matching utilities.
  *
- * This module handles the execution of canvas templates with support for
- * synchronous, asynchronous (with polling), and streaming modes. It also
- * manages file uploads and result validation.
+ * This module provides utilities for validating and comparing client-side
+ * schemas with server-side schemas, detecting mismatches and type differences.
  *
- * @module Resources
+ * @module Utilities
  */
 
+declare const zod: {
+    file: typeof TelaFileSchema;
+    core: typeof z$1.core;
+    globalRegistry: z$1.core.$ZodRegistry<z$1.core.GlobalMeta, z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>>;
+    registry: typeof z$1.core.registry;
+    config: typeof z$1.core.config;
+    $output: typeof z$1.core.$output;
+    $input: typeof z$1.core.$input;
+    $brand: typeof z$1.core.$brand;
+    clone: typeof z$1.core.util.clone;
+    regexes: typeof z$1.core.regexes;
+    treeifyError: typeof z$1.core.treeifyError;
+    prettifyError: typeof z$1.core.prettifyError;
+    formatError: typeof z$1.core.formatError;
+    flattenError: typeof z$1.core.flattenError;
+    toJSONSchema: typeof z$1.core.toJSONSchema;
+    TimePrecision: {
+        readonly Any: null;
+        readonly Minute: -1;
+        readonly Second: 0;
+        readonly Millisecond: 3;
+        readonly Microsecond: 6;
+    };
+    util: typeof z$1.core.util;
+    NEVER: never;
+    locales: typeof z$1.core.locales;
+    ZodISODateTime: z$1.core.$constructor<z$1.ZodISODateTime, z$1.core.$ZodISODateTimeDef>;
+    ZodISODate: z$1.core.$constructor<z$1.ZodISODate, z$1.core.$ZodStringFormatDef<"date">>;
+    ZodISOTime: z$1.core.$constructor<z$1.ZodISOTime, z$1.core.$ZodISOTimeDef>;
+    ZodISODuration: z$1.core.$constructor<z$1.ZodISODuration, z$1.core.$ZodStringFormatDef<"duration">>;
+    iso: typeof z$1.iso;
+    coerce: typeof z$1.coerce;
+    string(params?: string | z$1.core.$ZodStringParams): z$1.ZodString;
+    string<T extends string>(params?: string | z$1.core.$ZodStringParams): z$1.core.$ZodType<T, T>;
+    email(params?: string | z$1.core.$ZodEmailParams): z$1.ZodEmail;
+    guid(params?: string | z$1.core.$ZodGUIDParams): z$1.ZodGUID;
+    uuid(params?: string | z$1.core.$ZodUUIDParams): z$1.ZodUUID;
+    uuidv4(params?: string | z$1.core.$ZodUUIDv4Params): z$1.ZodUUID;
+    uuidv6(params?: string | z$1.core.$ZodUUIDv6Params): z$1.ZodUUID;
+    uuidv7(params?: string | z$1.core.$ZodUUIDv7Params): z$1.ZodUUID;
+    url(params?: string | z$1.core.$ZodURLParams): z$1.ZodURL;
+    httpUrl(params?: string | Omit<z$1.core.$ZodURLParams, "protocol" | "hostname">): z$1.ZodURL;
+    emoji(params?: string | z$1.core.$ZodEmojiParams): z$1.ZodEmoji;
+    nanoid(params?: string | z$1.core.$ZodNanoIDParams): z$1.ZodNanoID;
+    cuid(params?: string | z$1.core.$ZodCUIDParams): z$1.ZodCUID;
+    cuid2(params?: string | z$1.core.$ZodCUID2Params): z$1.ZodCUID2;
+    ulid(params?: string | z$1.core.$ZodULIDParams): z$1.ZodULID;
+    xid(params?: string | z$1.core.$ZodXIDParams): z$1.ZodXID;
+    ksuid(params?: string | z$1.core.$ZodKSUIDParams): z$1.ZodKSUID;
+    ipv4(params?: string | z$1.core.$ZodIPv4Params): z$1.ZodIPv4;
+    ipv6(params?: string | z$1.core.$ZodIPv6Params): z$1.ZodIPv6;
+    cidrv4(params?: string | z$1.core.$ZodCIDRv4Params): z$1.ZodCIDRv4;
+    cidrv6(params?: string | z$1.core.$ZodCIDRv6Params): z$1.ZodCIDRv6;
+    base64(params?: string | z$1.core.$ZodBase64Params): z$1.ZodBase64;
+    base64url(params?: string | z$1.core.$ZodBase64URLParams): z$1.ZodBase64URL;
+    e164(params?: string | z$1.core.$ZodE164Params): z$1.ZodE164;
+    jwt(params?: string | z$1.core.$ZodJWTParams): z$1.ZodJWT;
+    stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => z$1.core.util.MaybeAsync<unknown>) | RegExp, _params?: string | z$1.core.$ZodStringFormatParams): z$1.ZodCustomStringFormat<Format>;
+    hostname(_params?: string | z$1.core.$ZodStringFormatParams): z$1.ZodCustomStringFormat<"hostname">;
+    hex(_params?: string | z$1.core.$ZodStringFormatParams): z$1.ZodCustomStringFormat<"hex">;
+    hash<Alg extends z$1.core.util.HashAlgorithm, Enc extends z$1.core.util.HashEncoding = "hex">(alg: Alg, params?: {
+        enc?: Enc;
+    } & z$1.core.$ZodStringFormatParams): z$1.ZodCustomStringFormat<`${Alg}_${Enc}`>;
+    number(params?: string | z$1.core.$ZodNumberParams): z$1.ZodNumber;
+    int(params?: string | z$1.core.$ZodCheckNumberFormatParams): z$1.ZodInt;
+    float32(params?: string | z$1.core.$ZodCheckNumberFormatParams): z$1.ZodFloat32;
+    float64(params?: string | z$1.core.$ZodCheckNumberFormatParams): z$1.ZodFloat64;
+    int32(params?: string | z$1.core.$ZodCheckNumberFormatParams): z$1.ZodInt32;
+    uint32(params?: string | z$1.core.$ZodCheckNumberFormatParams): z$1.ZodUInt32;
+    boolean(params?: string | z$1.core.$ZodBooleanParams): z$1.ZodBoolean;
+    bigint(params?: string | z$1.core.$ZodBigIntParams): z$1.ZodBigInt;
+    int64(params?: string | z$1.core.$ZodBigIntFormatParams): z$1.ZodBigIntFormat;
+    uint64(params?: string | z$1.core.$ZodBigIntFormatParams): z$1.ZodBigIntFormat;
+    symbol(params?: string | z$1.core.$ZodSymbolParams): z$1.ZodSymbol;
+    any(): z$1.ZodAny;
+    unknown(): z$1.ZodUnknown;
+    never(params?: string | z$1.core.$ZodNeverParams): z$1.ZodNever;
+    date(params?: string | z$1.core.$ZodDateParams): z$1.ZodDate;
+    array<T extends z$1.core.SomeType>(element: T, params?: string | z$1.core.$ZodArrayParams): z$1.ZodArray<T>;
+    keyof<T extends z$1.ZodObject>(schema: T): z$1.ZodEnum<z$1.core.util.KeysEnum<T["_zod"]["output"]>>;
+    object<T extends z$1.core.$ZodLooseShape = Partial<Record<never, z$1.core.SomeType>>>(shape?: T, params?: string | z$1.core.$ZodObjectParams): z$1.ZodObject<z$1.core.util.Writeable<T>, z$1.core.$strip>;
+    strictObject<T extends z$1.core.$ZodLooseShape>(shape: T, params?: string | z$1.core.$ZodObjectParams): z$1.ZodObject<T, z$1.core.$strict>;
+    looseObject<T extends z$1.core.$ZodLooseShape>(shape: T, params?: string | z$1.core.$ZodObjectParams): z$1.ZodObject<T, z$1.core.$loose>;
+    union<const T extends readonly z$1.core.SomeType[]>(options: T, params?: string | z$1.core.$ZodUnionParams): z$1.ZodUnion<T>;
+    discriminatedUnion<Types extends readonly [z$1.core.$ZodTypeDiscriminable, ...z$1.core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | z$1.core.$ZodDiscriminatedUnionParams): z$1.ZodDiscriminatedUnion<Types, Disc>;
+    intersection<T extends z$1.core.SomeType, U extends z$1.core.SomeType>(left: T, right: U): z$1.ZodIntersection<T, U>;
+    tuple<T extends readonly [z$1.core.SomeType, ...z$1.core.SomeType[]]>(items: T, params?: string | z$1.core.$ZodTupleParams): z$1.ZodTuple<T, null>;
+    tuple<T extends readonly [z$1.core.SomeType, ...z$1.core.SomeType[]], Rest extends z$1.core.SomeType>(items: T, rest: Rest, params?: string | z$1.core.$ZodTupleParams): z$1.ZodTuple<T, Rest>;
+    tuple(items: [], params?: string | z$1.core.$ZodTupleParams): z$1.ZodTuple<[], null>;
+    record<Key extends z$1.core.$ZodRecordKey, Value extends z$1.core.SomeType>(keyType: Key, valueType: Value, params?: string | z$1.core.$ZodRecordParams): z$1.ZodRecord<Key, Value>;
+    partialRecord<Key extends z$1.core.$ZodRecordKey, Value extends z$1.core.SomeType>(keyType: Key, valueType: Value, params?: string | z$1.core.$ZodRecordParams): z$1.ZodRecord<Key & z$1.core.$partial, Value>;
+    map<Key extends z$1.core.SomeType, Value extends z$1.core.SomeType>(keyType: Key, valueType: Value, params?: string | z$1.core.$ZodMapParams): z$1.ZodMap<Key, Value>;
+    set<Value extends z$1.core.SomeType>(valueType: Value, params?: string | z$1.core.$ZodSetParams): z$1.ZodSet<Value>;
+    nativeEnum<T extends z$1.core.util.EnumLike>(entries: T, params?: string | z$1.core.$ZodEnumParams): z$1.ZodEnum<T>;
+    literal<const T extends ReadonlyArray<z$1.core.util.Literal>>(value: T, params?: string | z$1.core.$ZodLiteralParams): z$1.ZodLiteral<T[number]>;
+    literal<const T extends z$1.core.util.Literal>(value: T, params?: string | z$1.core.$ZodLiteralParams): z$1.ZodLiteral<T>;
+    transform<I = unknown, O = I>(fn: (input: I, ctx: z$1.core.ParsePayload) => O): z$1.ZodTransform<Awaited<O>, I>;
+    optional<T extends z$1.core.SomeType>(innerType: T): z$1.ZodOptional<T>;
+    nullable<T extends z$1.core.SomeType>(innerType: T): z$1.ZodNullable<T>;
+    nullish<T extends z$1.core.SomeType>(innerType: T): z$1.ZodOptional<z$1.ZodNullable<T>>;
+    _default<T extends z$1.core.SomeType>(innerType: T, defaultValue: z$1.core.util.NoUndefined<z$1.core.output<T>> | (() => z$1.core.util.NoUndefined<z$1.core.output<T>>)): z$1.ZodDefault<T>;
+    prefault<T extends z$1.core.SomeType>(innerType: T, defaultValue: z$1.core.input<T> | (() => z$1.core.input<T>)): z$1.ZodPrefault<T>;
+    nonoptional<T extends z$1.core.SomeType>(innerType: T, params?: string | z$1.core.$ZodNonOptionalParams): z$1.ZodNonOptional<T>;
+    success<T extends z$1.core.SomeType>(innerType: T): z$1.ZodSuccess<T>;
+    nan(params?: string | z$1.core.$ZodNaNParams): z$1.ZodNaN;
+    pipe<const A extends z$1.core.SomeType, B extends z$1.core.$ZodType<unknown, z$1.core.output<A>> = z$1.core.$ZodType<unknown, z$1.core.output<A>, z$1.core.$ZodTypeInternals<unknown, z$1.core.output<A>>>>(in_: A, out: B | z$1.core.$ZodType<unknown, z$1.core.output<A>>): z$1.ZodPipe<A, B>;
+    codec<const A extends z$1.core.SomeType, B extends z$1.core.SomeType = z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>>(in_: A, out: B, params: {
+        decode: (value: z$1.core.output<A>, payload: z$1.core.ParsePayload<z$1.core.output<A>>) => z$1.core.util.MaybeAsync<z$1.core.input<B>>;
+        encode: (value: z$1.core.input<B>, payload: z$1.core.ParsePayload<z$1.core.input<B>>) => z$1.core.util.MaybeAsync<z$1.core.output<A>>;
+    }): z$1.ZodCodec<A, B>;
+    readonly<T extends z$1.core.SomeType>(innerType: T): z$1.ZodReadonly<T>;
+    templateLiteral<const Parts extends z$1.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | z$1.core.$ZodTemplateLiteralParams): z$1.ZodTemplateLiteral<z$1.core.$PartsToTemplateLiteral<Parts>>;
+    lazy<T extends z$1.core.SomeType>(getter: () => T): z$1.ZodLazy<T>;
+    promise<T extends z$1.core.SomeType>(innerType: T): z$1.ZodPromise<T>;
+    _function(): z$1.ZodFunction;
+    _function<const In extends ReadonlyArray<z$1.core.$ZodType>>(params: {
+        input: In;
+    }): z$1.ZodFunction<z$1.ZodTuple<In, null>, z$1.core.$ZodFunctionOut>;
+    _function<const In extends ReadonlyArray<z$1.core.$ZodType>, const Out extends z$1.core.$ZodFunctionOut = z$1.core.$ZodFunctionOut>(params: {
+        input: In;
+        output: Out;
+    }): z$1.ZodFunction<z$1.ZodTuple<In, null>, Out>;
+    _function<const In extends z$1.core.$ZodFunctionIn = z$1.core.$ZodFunctionArgs>(params: {
+        input: In;
+    }): z$1.ZodFunction<In, z$1.core.$ZodFunctionOut>;
+    _function<const Out extends z$1.core.$ZodFunctionOut = z$1.core.$ZodFunctionOut>(params: {
+        output: Out;
+    }): z$1.ZodFunction<z$1.core.$ZodFunctionIn, Out>;
+    _function<In extends z$1.core.$ZodFunctionIn = z$1.core.$ZodFunctionArgs, Out extends z$1.core.$ZodType = z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>>(params?: {
+        input: In;
+        output: Out;
+    }): z$1.ZodFunction<In, Out>;
+    check<O = unknown>(fn: z$1.core.CheckFn<O>): z$1.core.$ZodCheck<O>;
+    custom<O>(fn?: (data: unknown) => unknown, _params?: string | z$1.core.$ZodCustomParams | undefined): z$1.ZodCustom<O, O>;
+    refine<T>(fn: (arg: NoInfer<T>) => z$1.core.util.MaybeAsync<unknown>, _params?: string | z$1.core.$ZodCustomParams): z$1.core.$ZodCheck<T>;
+    superRefine<T>(fn: (arg: T, payload: z$1.core.$RefinementCtx<T>) => void | Promise<void>): z$1.core.$ZodCheck<T>;
+    json(params?: string | z$1.core.$ZodCustomParams): z$1.ZodJSONSchema;
+    preprocess<A, U extends z$1.core.SomeType, B = unknown>(fn: (arg: B, ctx: z$1.core.$RefinementCtx) => A, schema: U): z$1.ZodPipe<z$1.ZodTransform<A, B>, U>;
+    ZodType: z$1.core.$constructor<z$1.ZodType>;
+    _ZodString: z$1.core.$constructor<z$1._ZodString>;
+    ZodString: z$1.core.$constructor<z$1.ZodString>;
+    ZodStringFormat: z$1.core.$constructor<z$1.ZodStringFormat>;
+    ZodEmail: z$1.core.$constructor<z$1.ZodEmail>;
+    ZodGUID: z$1.core.$constructor<z$1.ZodGUID>;
+    ZodUUID: z$1.core.$constructor<z$1.ZodUUID>;
+    ZodURL: z$1.core.$constructor<z$1.ZodURL>;
+    ZodEmoji: z$1.core.$constructor<z$1.ZodEmoji>;
+    ZodNanoID: z$1.core.$constructor<z$1.ZodNanoID>;
+    ZodCUID: z$1.core.$constructor<z$1.ZodCUID>;
+    ZodCUID2: z$1.core.$constructor<z$1.ZodCUID2>;
+    ZodULID: z$1.core.$constructor<z$1.ZodULID>;
+    ZodXID: z$1.core.$constructor<z$1.ZodXID>;
+    ZodKSUID: z$1.core.$constructor<z$1.ZodKSUID>;
+    ZodIPv4: z$1.core.$constructor<z$1.ZodIPv4>;
+    ZodIPv6: z$1.core.$constructor<z$1.ZodIPv6>;
+    ZodCIDRv4: z$1.core.$constructor<z$1.ZodCIDRv4>;
+    ZodCIDRv6: z$1.core.$constructor<z$1.ZodCIDRv6>;
+    ZodBase64: z$1.core.$constructor<z$1.ZodBase64>;
+    ZodBase64URL: z$1.core.$constructor<z$1.ZodBase64URL>;
+    ZodE164: z$1.core.$constructor<z$1.ZodE164>;
+    ZodJWT: z$1.core.$constructor<z$1.ZodJWT>;
+    ZodCustomStringFormat: z$1.core.$constructor<z$1.ZodCustomStringFormat>;
+    ZodNumber: z$1.core.$constructor<z$1.ZodNumber>;
+    ZodNumberFormat: z$1.core.$constructor<z$1.ZodNumberFormat>;
+    ZodBoolean: z$1.core.$constructor<z$1.ZodBoolean>;
+    ZodBigInt: z$1.core.$constructor<z$1.ZodBigInt>;
+    ZodBigIntFormat: z$1.core.$constructor<z$1.ZodBigIntFormat>;
+    ZodSymbol: z$1.core.$constructor<z$1.ZodSymbol>;
+    ZodUndefined: z$1.core.$constructor<z$1.ZodUndefined>;
+    undefined: typeof z$1.undefined;
+    ZodNull: z$1.core.$constructor<z$1.ZodNull>;
+    null: typeof z$1.null;
+    ZodAny: z$1.core.$constructor<z$1.ZodAny>;
+    ZodUnknown: z$1.core.$constructor<z$1.ZodUnknown>;
+    ZodNever: z$1.core.$constructor<z$1.ZodNever>;
+    ZodVoid: z$1.core.$constructor<z$1.ZodVoid>;
+    void: typeof z$1.void;
+    ZodDate: z$1.core.$constructor<z$1.ZodDate>;
+    ZodArray: z$1.core.$constructor<z$1.ZodArray>;
+    ZodObject: z$1.core.$constructor<z$1.ZodObject>;
+    ZodUnion: z$1.core.$constructor<z$1.ZodUnion>;
+    ZodDiscriminatedUnion: z$1.core.$constructor<z$1.ZodDiscriminatedUnion>;
+    ZodIntersection: z$1.core.$constructor<z$1.ZodIntersection>;
+    ZodTuple: z$1.core.$constructor<z$1.ZodTuple>;
+    ZodRecord: z$1.core.$constructor<z$1.ZodRecord>;
+    ZodMap: z$1.core.$constructor<z$1.ZodMap>;
+    ZodSet: z$1.core.$constructor<z$1.ZodSet>;
+    ZodEnum: z$1.core.$constructor<z$1.ZodEnum>;
+    enum: typeof z$1.enum;
+    ZodLiteral: z$1.core.$constructor<z$1.ZodLiteral>;
+    ZodFile: z$1.core.$constructor<z$1.ZodFile>;
+    ZodTransform: z$1.core.$constructor<z$1.ZodTransform>;
+    ZodOptional: z$1.core.$constructor<z$1.ZodOptional>;
+    ZodNullable: z$1.core.$constructor<z$1.ZodNullable>;
+    ZodDefault: z$1.core.$constructor<z$1.ZodDefault>;
+    ZodPrefault: z$1.core.$constructor<z$1.ZodPrefault>;
+    ZodNonOptional: z$1.core.$constructor<z$1.ZodNonOptional>;
+    ZodSuccess: z$1.core.$constructor<z$1.ZodSuccess>;
+    ZodCatch: z$1.core.$constructor<z$1.ZodCatch>;
+    catch: typeof z$1.catch;
+    ZodNaN: z$1.core.$constructor<z$1.ZodNaN>;
+    ZodPipe: z$1.core.$constructor<z$1.ZodPipe>;
+    ZodCodec: z$1.core.$constructor<z$1.ZodCodec>;
+    ZodReadonly: z$1.core.$constructor<z$1.ZodReadonly>;
+    ZodTemplateLiteral: z$1.core.$constructor<z$1.ZodTemplateLiteral>;
+    ZodLazy: z$1.core.$constructor<z$1.ZodLazy>;
+    ZodPromise: z$1.core.$constructor<z$1.ZodPromise>;
+    ZodFunction: z$1.core.$constructor<z$1.ZodFunction>;
+    function: typeof z$1._function;
+    ZodCustom: z$1.core.$constructor<z$1.ZodCustom>;
+    instanceof: typeof z$1.instanceof;
+    stringbool: (_params?: string | z$1.core.$ZodStringBoolParams) => z$1.ZodCodec<z$1.ZodString, z$1.ZodBoolean>;
+    lt: typeof z$1.core._lt;
+    lte: typeof z$1.core._lte;
+    gt: typeof z$1.core._gt;
+    gte: typeof z$1.core._gte;
+    positive: typeof z$1.core._positive;
+    negative: typeof z$1.core._negative;
+    nonpositive: typeof z$1.core._nonpositive;
+    nonnegative: typeof z$1.core._nonnegative;
+    multipleOf: typeof z$1.core._multipleOf;
+    maxSize: typeof z$1.core._maxSize;
+    minSize: typeof z$1.core._minSize;
+    size: typeof z$1.core._size;
+    maxLength: typeof z$1.core._maxLength;
+    minLength: typeof z$1.core._minLength;
+    length: typeof z$1.core._length;
+    regex: typeof z$1.core._regex;
+    lowercase: typeof z$1.core._lowercase;
+    uppercase: typeof z$1.core._uppercase;
+    includes: typeof z$1.core._includes;
+    startsWith: typeof z$1.core._startsWith;
+    endsWith: typeof z$1.core._endsWith;
+    property: typeof z$1.core._property;
+    mime: typeof z$1.core._mime;
+    overwrite: typeof z$1.core._overwrite;
+    normalize: typeof z$1.core._normalize;
+    trim: typeof z$1.core._trim;
+    toLowerCase: typeof z$1.core._toLowerCase;
+    toUpperCase: typeof z$1.core._toUpperCase;
+    ZodError: z$1.core.$constructor<z$1.ZodError>;
+    ZodRealError: z$1.core.$constructor<z$1.ZodError>;
+    parse: <T extends z$1.core.$ZodType>(schema: T, value: unknown, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>, _params?: {
+        callee?: z$1.core.util.AnyFunc;
+        Err?: z$1.core.$ZodErrorClass;
+    }) => z$1.core.output<T>;
+    parseAsync: <T extends z$1.core.$ZodType>(schema: T, value: unknown, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>, _params?: {
+        callee?: z$1.core.util.AnyFunc;
+        Err?: z$1.core.$ZodErrorClass;
+    }) => Promise<z$1.core.output<T>>;
+    safeParse: <T extends z$1.core.$ZodType>(schema: T, value: unknown, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => z$1.ZodSafeParseResult<z$1.core.output<T>>;
+    safeParseAsync: <T extends z$1.core.$ZodType>(schema: T, value: unknown, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => Promise<z$1.ZodSafeParseResult<z$1.core.output<T>>>;
+    encode: <T extends z$1.core.$ZodType>(schema: T, value: z$1.core.output<T>, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => z$1.core.input<T>;
+    decode: <T extends z$1.core.$ZodType>(schema: T, value: z$1.core.input<T>, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => z$1.core.output<T>;
+    encodeAsync: <T extends z$1.core.$ZodType>(schema: T, value: z$1.core.output<T>, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => Promise<z$1.core.input<T>>;
+    decodeAsync: <T extends z$1.core.$ZodType>(schema: T, value: z$1.core.input<T>, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => Promise<z$1.core.output<T>>;
+    safeEncode: <T extends z$1.core.$ZodType>(schema: T, value: z$1.core.output<T>, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => z$1.ZodSafeParseResult<z$1.core.input<T>>;
+    safeDecode: <T extends z$1.core.$ZodType>(schema: T, value: z$1.core.input<T>, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => z$1.ZodSafeParseResult<z$1.core.output<T>>;
+    safeEncodeAsync: <T extends z$1.core.$ZodType>(schema: T, value: z$1.core.output<T>, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => Promise<z$1.ZodSafeParseResult<z$1.core.input<T>>>;
+    safeDecodeAsync: <T extends z$1.core.$ZodType>(schema: T, value: z$1.core.input<T>, _ctx?: z$1.core.ParseContext<z$1.core.$ZodIssue>) => Promise<z$1.ZodSafeParseResult<z$1.core.output<T>>>;
+    setErrorMap(map: z$1.core.$ZodErrorMap): void;
+    getErrorMap(): z$1.core.$ZodErrorMap<z$1.core.$ZodIssue> | undefined;
+    ZodIssueCode: {
+        readonly invalid_type: "invalid_type";
+        readonly too_big: "too_big";
+        readonly too_small: "too_small";
+        readonly invalid_format: "invalid_format";
+        readonly not_multiple_of: "not_multiple_of";
+        readonly unrecognized_keys: "unrecognized_keys";
+        readonly invalid_union: "invalid_union";
+        readonly invalid_key: "invalid_key";
+        readonly invalid_element: "invalid_element";
+        readonly invalid_value: "invalid_value";
+        readonly custom: "custom";
+    };
+    ZodFirstPartyTypeKind: typeof z$1.ZodFirstPartyTypeKind;
+};
+type SchemaBuilder = typeof zod;
+type SchemaFunction<T> = (schema: SchemaBuilder) => T;
+type Output<T> = T extends z$1.ZodType ? z$1.infer<T> : T;
+type ZodTypeOrRecord = z$1.ZodType | Record<string, unknown>;
+
 interface BaseExecutionParams {
     /**
      * The version ID of the canvas to use for this chat completion.
@@ -471,6 +961,99 @@ interface BaseExecutionParams {
      */
     tags?: string[];
 }
+
+/**
+ * Helper type to add request ID to a response type.
+ *
+ * The `requestId` field contains the value from the `x-request-id` HTTP header
+ * returned by the API for that specific request.
+ *
+ * @template T - The base response type.
+ */
+type WithRequestId<T> = T & {
+    requestId?: string;
+};
+
+declare const TaskStatus: z$1.ZodEnum<{
+    created: "created";
+    failed: "failed";
+    running: "running";
+    validating: "validating";
+    completed: "completed";
+    cancelled: "cancelled";
+}>;
+type TaskStatus = z$1.infer<typeof TaskStatus>;
+declare const TaskDefinition: z$1.ZodObject<{
+    id: z$1.ZodString;
+    reference: z$1.ZodNumber;
+    name: z$1.ZodString;
+    status: z$1.ZodEnum<{
+        created: "created";
+        failed: "failed";
+        running: "running";
+        validating: "validating";
+        completed: "completed";
+        cancelled: "cancelled";
+    }>;
+    rawInput: z$1.ZodObject<{
+        async: z$1.ZodBoolean;
+        stream: z$1.ZodBoolean;
+        variables: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
+        applicationId: z$1.ZodString;
+    }, z$1.core.$strip>;
+    inputContent: z$1.ZodAny;
+    outputContent: z$1.ZodObject<{
+        role: z$1.ZodLiteral<"assistant">;
+        content: z$1.ZodUnknown;
+        toolCalls: z$1.ZodArray<z$1.ZodAny>;
+        functionCall: z$1.ZodAny;
+    }, z$1.core.$strip>;
+    originalOutputContent: z$1.ZodObject<{
+        role: z$1.ZodLiteral<"assistant">;
+        content: z$1.ZodUnknown;
+        toolCalls: z$1.ZodArray<z$1.ZodAny>;
+        functionCall: z$1.ZodAny;
+    }, z$1.core.$strip>;
+    createdBy: z$1.ZodString;
+    approvedBy: z$1.ZodAny;
+    approvedAt: z$1.ZodAny;
+    completionRunId: z$1.ZodString;
+    workflowRunId: z$1.ZodAny;
+    promptVersionId: z$1.ZodString;
+    promptApplicationId: z$1.ZodString;
+    workspaceId: z$1.ZodString;
+    metadata: z$1.ZodAny;
+    tags: z$1.ZodArray<z$1.ZodString>;
+    createdAt: z$1.ZodString;
+    updatedAt: z$1.ZodString;
+    deletedAt: z$1.ZodAny;
+    requestId: z$1.ZodString;
+}, z$1.core.$strip>;
+type TaskDefinition<TOutput = unknown> = Omit<z$1.infer<typeof TaskDefinition>, 'outputContent' | 'originalOutputContent'> & {
+    outputContent: {
+        role: 'assistant';
+        content: TOutput;
+        toolCalls: Array<any>;
+        functionCall: any;
+    };
+    originalOutputContent: {
+        role: 'assistant';
+        content: TOutput;
+        toolCalls: Array<any>;
+        functionCall: any;
+    };
+};
+
+/**
+ * Canvas execution module for managing canvas execution lifecycle and modes.
+ *
+ * This module handles the execution of canvas templates with support for
+ * synchronous, asynchronous (with polling), and streaming modes. It also
+ * manages file uploads and result validation.
+ *
+ * @module Resources
+ */
+
 /**
  * Configuration for asynchronous canvas execution with polling.
  * The execution starts immediately but results must be retrieved via polling.
@@ -486,15 +1069,15 @@ interface AsyncExecutionParams extends BaseExecutionParams {
      */
     webhookUrl?: string;
     /**
-     * Time in milliseconds between polling attempts.
+     * Time (in milliseconds if number) between polling attempts (e.g. "1s", "1m", "1h", "1d").
      * @default 1000
      */
-    pollingInterval?: number;
+    pollingInterval?: string | number;
     /**
-     * Maximum time in milliseconds to wait for completion before timing out.
+     * Maximum time (in milliseconds if number) to wait for completion before timing out (e.g. "1s", "1m", "1h", "1d").
      * @default 60000
      */
-    pollingTimeout?: number;
+    pollingTimeout?: string | number;
     /**
      * Stream mode is not available for async executions.
      */
@@ -556,19 +1139,13 @@ type AsyncCompletionCreateResult = {
     inputContent: {
         files: Array<any>;
         messages: Array<any>;
-        variables: {
-            body: string;
-            title: string;
-        };
+        variables: Record<string, unknown>;
     };
     outputContent: null;
     rawInput: {
         async: boolean;
         canvas_id: string;
-        variables: {
-            body: string;
-            title: string;
-        };
+        variables: Record<string, unknown>;
     };
     rawOutput: any;
     compatibilityDate: string;
@@ -615,51 +1192,11 @@ type AsyncCompletionCreateResult = {
     updatedAt: string;
     deletedAt: any;
 };
-type TaskCreationResult = {
-    id: string;
-    reference: number;
-    name: string;
-    status: ExecutionStatus;
-    rawInput: {
-        async: boolean;
-        stream: boolean;
-        variables: Record<string, unknown>;
-        applicationId: string;
-    };
-    inputContent: any;
-    outputContent: any;
-    originalOutputContent: any;
-    createdBy: string;
-    approvedBy: any;
-    approvedAt: any;
-    completionRunId: string;
-    workflowRunId: any;
-    promptVersionId: string;
-    promptApplicationId: string;
-    workspaceId: string;
-    metadata: any;
-    tags: Array<string>;
-    createdAt: string;
-    updatedAt: string;
-    deletedAt: any;
-    requestId: string;
-};
 /**
  * Raw API response type. Represents the unprocessed response from the Tela API.
  * This type will be refined in future versions with proper typing.
  */
 type RawAPIResult = any;
-/**
- * Helper type to add request ID to a response type.
- *
- * The `requestId` field contains the value from the `x-request-id` HTTP header
- * returned by the API for that specific request.
- *
- * @template T - The base response type.
- */
-type WithRequestId<T> = T & {
-    requestId?: string;
-};
 /**
  * Result returned when polling for asynchronous execution status.
  *
@@ -793,7 +1330,7 @@ declare class CanvasExecution<TParams extends ExecutionParams = SyncExecutionPar
      * @param outputSchema - Zod schema or object schema for validating/parsing output.
      * @param client - HTTP client instance for making API requests.
      */
-    constructor(variables: TInput, params: TParams | undefined, outputSchema: _zod__default.ZodType | Record<string, unknown>, client: BaseClient, isTask?: boolean);
+    constructor(variables: TInput, params: TParams | undefined, outputSchema: z.ZodType | Record<string, unknown>, client: BaseClient, isTask?: boolean);
     /**
      * Fetches an existing asynchronous execution by its ID.
      *
@@ -822,9 +1359,9 @@ declare class CanvasExecution<TParams extends ExecutionParams = SyncExecutionPar
      * console.log(execution.status) // 'running' or 'succeeded' or 'failed'
      * ```
      */
-    static fetch<TOutput = unknown>(id: string, outputSchema: _zod__default.ZodType | Record<string, unknown>, client: BaseClient, options?: {
-        pollingInterval?: number;
-        pollingTimeout?: number;
+    static fetch<TOutput = unknown>(id: string, outputSchema: z.ZodType | Record<string, unknown>, client: BaseClient, options?: {
+        pollingInterval?: string | number;
+        pollingTimeout?: string | number;
         isTask?: boolean;
     }): Promise<CanvasExecution<AsyncExecutionParams, unknown, TOutput>>;
     /**
@@ -947,7 +1484,7 @@ declare class CanvasExecution<TParams extends ExecutionParams = SyncExecutionPar
      *
      * @returns The task creation result or undefined.
      */
-    get task(): TaskCreationResult | undefined;
+    get task(): TaskDefinition | undefined;
     /**
      * Gets the raw API response without any processing or validation.
      * Automatically starts execution and waits for completion (including polling for async executions).
@@ -974,7 +1511,58 @@ declare class CanvasExecution<TParams extends ExecutionParams = SyncExecutionPar
      */
     start(): Promise<CanvasExecutionResult<TParams, TOutput> | AsyncGenerator<Partial<TOutput>, any, any> | (AsyncCompletionCreateResult & {
         requestId?: string;
-    }) | (TaskCreationResult & {
+    }) | (Omit<{
+        id: string;
+        reference: number;
+        name: string;
+        status: "created" | "failed" | "running" | "validating" | "completed" | "cancelled";
+        rawInput: {
+            async: boolean;
+            stream: boolean;
+            variables: Record<string, unknown>;
+            applicationId: string;
+        };
+        inputContent: any;
+        outputContent: {
+            role: "assistant";
+            content: unknown;
+            toolCalls: any[];
+            functionCall: any;
+        };
+        originalOutputContent: {
+            role: "assistant";
+            content: unknown;
+            toolCalls: any[];
+            functionCall: any;
+        };
+        createdBy: string;
+        approvedBy: any;
+        approvedAt: any;
+        completionRunId: string;
+        workflowRunId: any;
+        promptVersionId: string;
+        promptApplicationId: string;
+        workspaceId: string;
+        metadata: any;
+        tags: string[];
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: any;
+        requestId: string;
+    }, "outputContent" | "originalOutputContent"> & {
+        outputContent: {
+            role: "assistant";
+            content: unknown;
+            toolCalls: Array<any>;
+            functionCall: any;
+        };
+        originalOutputContent: {
+            role: "assistant";
+            content: unknown;
+            toolCalls: Array<any>;
+            functionCall: any;
+        };
+    } & {
         requestId?: string;
     })>;
     /**
@@ -1124,468 +1712,1717 @@ declare class CanvasExecution<TParams extends ExecutionParams = SyncExecutionPar
     private uploadFiles;
 }
 
-/**
- * Canvas resource for managing prompt templates and their execution.
- *
- * This module provides the core Canvas class for retrieving and executing
- * prompt templates from the Tela API, with support for schema validation,
- * type safety, and multiple execution modes.
- *
- * @module Resources
- */
-
-/**
- * Represents a variable that can be used in a canvas template.
- */
-type CanvasVariable = {
-    /**
-     * The name of the variable.
-     */
-    name: string;
-    /**
-     * The type of the variable (e.g., 'string', 'number', 'file').
+type CompletionRunResult<TOutput> = {
+    id: string;
+    status: string;
+    inputContent: {
+        files: Array<any>;
+        messages: Array<any>;
+        variables: Record<string, unknown>;
+    };
+    outputContent: {
+        role: string;
+        content: TOutput;
+        toolCalls: Array<any>;
+        functionCall: any;
+    };
+    rawInput: {
+        tags: Array<string>;
+        async: boolean;
+        canvasId: string;
+        variables: Record<string, unknown>;
+    };
+    rawOutput: {
+        id: string;
+        usage: {
+            cost: {
+                totalCost: number;
+                promptCost: number;
+                completionCost: number;
+            };
+            totalTokens: number;
+            promptTokens: number;
+            completionTokens: number;
+        };
+        object: string;
+        choices: Array<{
+            message: {
+                role: string;
+                content: TOutput;
+                toolCalls: Array<any>;
+                functionCall: any;
+            };
+        }>;
+        created: number;
+    };
+    compatibilityDate: string;
+    metadata: {
+        promptVersion: {
+            modelConfigurations: {
+                type: string;
+                model: string;
+                temperature: number;
+                structuredOutput: {
+                    schema: {
+                        type: string;
+                        title: string;
+                        required: Array<string>;
+                        properties: Record<string, unknown>;
+                        description: string;
+                    };
+                    enabled: boolean;
+                };
+            };
+            variablesDefinitions: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                processingOptions: {
+                    allowMultimodal: boolean;
+                };
+            }>;
+        };
+    };
+    tags: Array<string>;
+    creditsUsed: number;
+    promptId: string;
+    promptVersionId: string;
+    promptApplicationId: any;
+    workspaceId: string;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: any;
+};
+
+/**
+ * Helper type for accepting either a single value or an array of values.
+ *
+ * @template T - The base type.
+ */
+type MaybeArray<T> = T | T[];
+/**
+ * Canvas identification methods for batch operations.
+ * Use either canvas ID with optional version, or application ID.
+ */
+type CanvasIdentifier = {
+    id: string;
+    versionId?: string;
+} | {
+    applicationId: string;
+};
+/**
+ * Status of a batch execution.
+ *
+ * Lifecycle progression:
+ * - `created` - Batch queued on server (initial state)
+ * - `validating` - Input file validation in progress
+ * - `running` - Batch actively processing executions
+ * - `completed` - All executions finished successfully
+ * - `failed` - Batch failed (validation error or server failure)
+ * - `canceled` - Batch canceled by user
+ *
+ * @see {@link BatchExecution.status} for accessing current status
+ */
+type BatchExecutionStatus = 'created' | 'validating' | 'running' | 'failed' | 'completed' | 'canceled';
+/**
+ * Raw API response for batch execution operations.
+ * Contains batch metadata, status, and progress information.
+ */
+type BatchResponse = {
+    /**
+     * The type of batch task (always 'async-completion').
      */
-    type: string;
+    task: string;
     /**
-     * Whether this variable is required for canvas execution.
+     * Vault URL of the input JSONL file.
      */
-    required: boolean;
+    inputFile: string;
     /**
-     * Description of the variable's purpose.
+     * Webhook URL for completion notifications, if configured.
      */
-    description: string;
+    webhookUrl: string | null;
     /**
-     * Processing options for the variable.
+     * Current status of the batch execution.
      */
-    processingOptions: {
+    status: BatchExecutionStatus;
+    /**
+     * Unique identifier for this batch execution.
+     */
+    id: string;
+    /**
+     * Vault URL of the output JSONL file, available when completed.
+     */
+    outputFile: string | null;
+    /**
+     * Progress statistics, available when running or completed.
+     */
+    state: {
         /**
-         * Whether multimodal content (images, files) is allowed.
+         * Number of failed executions.
          */
-        allowMultimodal: boolean;
-    };
+        failed: number;
+        /**
+         * Number of completed executions.
+         */
+        completed: number;
+        /**
+         * Total number of executions in the batch.
+         */
+        total: number;
+    } | null;
+    /**
+     * ISO timestamp when the batch was created.
+     */
+    createdAt: string;
+    /**
+     * ISO timestamp when the batch was last updated.
+     */
+    updatedAt: string;
+    /**
+     * ISO timestamp when the batch completed, if applicable.
+     */
+    completedAt: string | null;
+    /**
+     * ISO timestamp when the batch was canceled, if applicable.
+     */
+    canceledAt: string | null;
+    /**
+     * ISO timestamp when the batch failed, if applicable.
+     */
+    failedAt: string | null;
 };
-interface CanvasOptions<TInput, TOutput> {
+/**
+ * Represents a single item to be executed in a batch.
+ *
+ * @template TInput - The input variables type for the canvas.
+ */
+interface BatchItem<TInput> {
     /**
-     * Id of the canvas that will be used to create the completion.
+     * Optional unique identifier for this execution.
+     * If not provided, a random UUID will be generated automatically.
+     * Used to retrieve individual results from the batch output.
      */
-    id?: string;
+    referenceId?: string;
     /**
-     * Id of the version of the canvas. If not provided, the latest promoted version will be used.
+     * Input variables for this execution, matching the canvas input schema.
      */
-    versionId?: string;
+    variables: TInput;
+}
+/**
+ * Parameters excluded from batch execution (managed internally).
+ */
+type ExcludedParams = 'versionId' | 'canvasId' | 'applicationId' | 'async' | 'stream' | 'webhookUrl' | 'skipResultValidation';
+/**
+ * Configuration options for batch execution.
+ *
+ * Batch executions are always asynchronous and return results via output file.
+ * Unlike single executions, batches do not support streaming or synchronous modes.
+ *
+ * @category Canvas
+ */
+interface BatchParams extends Omit<BaseExecutionParams, ExcludedParams> {
     /**
-     * Id of the application that the canvas belongs to.
+     * Time (in milliseconds if number) between polling attempts (e.g. "1s", "1m", "1h", "1d").
+     * Controls how frequently the SDK checks batch completion status.
+     * @default "1s"
      */
-    applicationId?: string;
+    pollingInterval?: string | number;
     /**
-     * Name of the canvas. Useful for debugging.
+     * Maximum time (in milliseconds if number) to wait for completion before timing out (e.g. "1s", "1m", "1h", "1d").
+     * After timeout, polling stops but the batch continues processing on the server.
+     * @default "1m"
      */
-    name?: string;
+    pollingTimeout?: string | number;
     /**
-     * Input schema of the canvas.
+     * Optional webhook URL to receive completion notifications.
+     * The server will POST to this URL when the batch completes, fails, or is canceled.
      */
-    input?: SchemaFunction<TInput>;
+    webhookUrl?: string;
+}
+/**
+ * Promise-like wrapper for batch execution that provides direct result access.
+ *
+ * Enables flexible usage patterns:
+ * - Await for execution object: `const exec = await batch.execute()`
+ * - Direct result access: `const result = await batch.execute().result`
+ *
+ * @template TOutput - The output type for batch results.
+ *
+ * @category Canvas
+ */
+type BatchExecutionPromiseLike<TOutput> = PromiseLike<BatchExecution<TOutput>> & {
     /**
-     * Output schema of the canvas.
+     * Direct access to the batch result, automatically starting polling.
      */
-    output?: SchemaFunction<TOutput>;
+    result: Promise<BatchExecutionResult<TOutput>>;
+};
+/**
+ * Wraps the completed batch execution response with convenient result access methods.
+ *
+ * Provides multiple ways to access batch results:
+ * - Download entire output file: `downloadOutputFile()`
+ * - Stream results incrementally: `iterateResults()`
+ * - Get all results as array: `getResults()`
+ * - Fetch individual result by reference ID: `getResult(referenceId)`
+ *
+ * @category Canvas
+ *
+ * @template TOutput - The output type for individual results.
+ *
+ * @example
+ * ```typescript
+ * const execution = await batch.execute()
+ * const result = await execution.result
+ *
+ * // Access batch metadata
+ * console.log(`Status: ${result.status}`)
+ * console.log(`Progress: ${result.state.completed}/${result.state.total}`)
+ *
+ * // Iterate through results
+ * for await (const item of result.iterateResults()) {
+ *   console.log(item)
+ * }
+ * ```
+ */
+declare class BatchExecutionResult<TOutput> {
+    private readonly _client;
+    private readonly _response;
     /**
-     * Base client for making requests to the Tela API.
+     * Creates a new batch execution result wrapper.
+     *
+     * @param client - HTTP client for making API requests.
+     * @param response - Raw batch execution response from the server.
+     * @internal
+     */
+    constructor(client: BaseClient, response: WithRequestId<BatchResponse>);
+    get requestId(): string | undefined;
+    /**
+     * Gets the unique identifier for this batch execution.
+     *
+     * @returns The batch execution ID.
+     */
+    get id(): string;
+    /**
+     * Gets the current status of the batch execution.
+     *
+     * @returns The batch status.
+     */
+    get status(): BatchExecutionStatus;
+    /**
+     * Gets the progress statistics for this batch.
+     *
+     * @returns Object containing completed, failed, and total execution counts, or null if not available.
+     */
+    get state(): {
+        /**
+         * Number of failed executions.
+         */
+        failed: number;
+        /**
+         * Number of completed executions.
+         */
+        completed: number;
+        /**
+         * Total number of executions in the batch.
+         */
+        total: number;
+    } | null;
+    /**
+     * Gets the vault URL of the output JSONL file containing all results.
+     *
+     * @returns The output file URL, or null if batch is not completed.
+     */
+    get outputFile(): string | null;
+    /**
+     * Gets the raw API response without any processing.
+     *
+     * @returns The complete batch response object.
+     */
+    get rawResponse(): WithRequestId<BatchResponse>;
+    /**
+     * Gets the timestamp when this batch was created.
+     *
+     * @returns Creation date.
+     */
+    get createdAt(): Date;
+    /**
+     * Gets the timestamp when this batch was last updated.
+     *
+     * @returns Last update date.
+     */
+    get updatedAt(): Date;
+    /**
+     * Gets the timestamp when this batch completed successfully.
+     *
+     * @returns Completion date, or null if not completed.
+     */
+    get completedAt(): Date | null;
+    /**
+     * Gets the timestamp when this batch was canceled.
+     *
+     * @returns Cancellation date, or null if not canceled.
+     */
+    get canceledAt(): Date | null;
+    /**
+     * Gets the timestamp when this batch failed.
+     *
+     * @returns Failure date, or null if not failed.
+     */
+    get failedAt(): Date | null;
+    /**
+     * Downloads the complete output file as a Blob.
+     *
+     * The output file is a JSONL (JSON Lines) file where each line contains
+     * one execution result with its reference ID, status, and output.
+     *
+     * @throws {Error} If batch is not completed or output file is unavailable.
+     * @returns A promise resolving to the output file as a Blob.
+     *
+     * @example
+     * ```typescript
+     * const file = await result.downloadOutputFile()
+     * const text = await file.text()
+     * console.log(text) // JSONL content
+     * ```
+     */
+    downloadOutputFile(): Promise<Blob>;
+    /**
+     * Streams the output file as a ReadableStream for memory-efficient processing.
+     *
+     * Useful for large batches where loading the entire file into memory is not practical.
+     *
+     * @throws {Error} If batch is not completed or output file is unavailable.
+     * @returns A promise resolving to a ReadableStream of the output file.
+     *
+     * @example
+     * ```typescript
+     * const stream = await result.streamOutputFile()
+     * // Process stream with custom logic
+     * ```
+     */
+    streamOutputFile(): Promise<ReadableStream>;
+    /**
+     * Downloads and parses all results into an array.
+     *
+     * Loads the entire output file into memory, parses each line, and extracts
+     * the output content. For large batches, consider using `iterateResults()` instead.
+     *
+     * @throws {Error} If batch is not completed, output file is unavailable, or parsing fails.
+     * @returns A promise resolving to an array of all execution outputs.
+     *
+     * @example
+     * ```typescript
+     * const results = await result.getResults()
+     * console.log(`Got ${results.length} results`)
+     * results.forEach((output, i) => console.log(`Result ${i}:`, output))
+     * ```
+     */
+    getResults(): Promise<TOutput[]>;
+    /**
+     * Asynchronously iterates over raw result items from the output file.
+     *
+     * Streams and parses the output file line-by-line, yielding raw JSON objects.
+     * Each yielded object contains the full result structure including metadata.
+     *
+     * @param params - Iteration options.
+     * @param params.abortController - Optional AbortController to cancel iteration.
+     * @throws {Error} If batch is not completed or output file is unavailable.
+     * @yields Raw result objects from the JSONL file.
+     *
+     * @example
+     * ```typescript
+     * for await (const rawResult of result.iterateRawResults()) {
+     *   console.log('Reference ID:', rawResult.reference_id)
+     *   console.log('Status:', rawResult.status)
+     *   console.log('Output:', rawResult.result.outputContent.content)
+     * }
+     * ```
+     */
+    iterateRawResults(params?: {
+        abortController?: AbortController;
+    }): AsyncGenerator<unknown, void, unknown>;
+    /**
+     * Asynchronously iterates over parsed output content from the batch results.
+     *
+     * Streams and parses the output file line-by-line, yielding only the output content
+     * (not the full result metadata). Memory-efficient for large batches.
+     *
+     * @param params - Iteration options.
+     * @param params.abortController - Optional AbortController to cancel iteration.
+     * @throws {Error} If batch is not completed, output file is unavailable, or parsing fails.
+     * @yields Parsed output content from each execution.
+     *
+     * @example
+     * ```typescript
+     * const controller = new AbortController()
+     *
+     * for await (const output of result.iterateResults({ abortController: controller })) {
+     *   console.log(output)
+     *   if (someCondition) {
+     *     controller.abort() // Stop iteration early
+     *   }
+     * }
+     * ```
+     */
+    iterateResults(params?: {
+        abortController?: AbortController;
+    }): AsyncGenerator<Awaited<TOutput>, void, unknown>;
+    /**
+     * Fetches the raw result metadata for a specific execution by its reference ID.
+     *
+     * Queries the API for the execution result using the reference ID tag.
+     * Returns the complete execution metadata including input, output, and usage statistics.
+     *
+     * @param referenceId - The reference ID of the execution to retrieve.
+     * @throws {Error} If no result found with the given reference ID.
+     * @returns A promise resolving to the raw execution result object.
+     *
+     * @example
+     * ```typescript
+     * const rawResult = await result.getRawResult('my-ref-id')
+     * console.log('Credits used:', rawResult.creditsUsed)
+     * console.log('Execution status:', rawResult.status)
+     * ```
+     */
+    getRawResult(referenceId: string): Promise<CompletionRunResult<TOutput>>;
+    /**
+     * Fetches the output content for a specific execution by its reference ID.
+     *
+     * Convenience method that retrieves the raw result and extracts just the output content.
+     *
+     * @param referenceId - The reference ID of the execution to retrieve.
+     * @throws {Error} If no result found with the given reference ID.
+     * @returns A promise resolving to the execution output content.
+     *
+     * @example
+     * ```typescript
+     * const output = await result.getResult('my-ref-id')
+     * console.log('Output:', output)
+     * ```
+     */
+    getResult(referenceId: string): Promise<TOutput>;
+    /**
+     * Validates that the output file is available for access.
+     *
+     * @throws {Error} If batch is not completed or output file is missing.
+     * @private
+     */
+    private validateOutputFile;
+}
+/**
+ * Event types emitted by BatchExecution during its lifecycle.
+ *
+ * @template TOutput - The output type.
+ *
+ * @property poll - Emitted during polling with current status and progress. Includes `requestId` from the polling request.
+ * @property success - Emitted when batch completes successfully with the result object. Includes `requestId` from the final request.
+ * @property error - Emitted when batch fails with the error object.
+ * @property statusChange - Emitted when batch status transitions to a new state, includes new status and response.
+ *
+ * @category Canvas
+ */
+type BatchExecutionEvents<TOutput> = {
+    poll: WithRequestId<BatchResponse>;
+    success: BatchExecutionResult<TOutput>;
+    error: BatchExecutionFailedError;
+    statusChange: [BatchExecutionStatus, WithRequestId<BatchResponse>];
+};
+/**
+ * Manages the execution lifecycle of a batch operation.
+ *
+ * Handles polling for batch completion, progress tracking, and result retrieval.
+ * Provides an event-driven API for monitoring batch progress in real-time.
+ *
+ * ## Status Tracking
+ *
+ * The batch status can be accessed via the `status` property and tracks the lifecycle:
+ *
+ * - **Batch executions**: `created` → `validating` → `running` → `completed` or `failed`
+ * - **Can be canceled**: At any time before completion using `cancel()`
+ *
+ * Status is set to `failed` when:
+ * - Input file validation fails
+ * - Batch processing encounters an error
+ * - Server reports failure status
+ *
+ * Status is set to `completed` when:
+ * - All executions in the batch finish processing
+ * - Output file is generated and available
+ *
+ * ## Event System
+ *
+ * Events are emitted during polling to track progress:
+ * - `statusChange` - Status transitions (created → validating → running → completed)
+ * - `poll` - Each polling attempt with current progress
+ * - `success` - Completion with the BatchExecutionResult
+ * - `error` - Failure notification
+ *
+ * **Important:** Events are only emitted while polling is active. You must either call `poll()` or
+ * await `execution.result` to start polling.
+ *
+ * @category Canvas
+ *
+ * @typeParam TOutput - The output result type for individual executions
+ *
+ * @fires poll - Emitted during polling with current status and progress. Includes `requestId` from the polling request.
+ * @fires success - Emitted when batch completes successfully with the result object. Includes `requestId` from the final request.
+ * @fires error - Emitted when batch fails (only if error listeners are registered, otherwise throws)
+ * @fires statusChange - Emitted when batch status transitions to a new state
+ *
+ * @example
+ * ```typescript
+ * const execution = await batch.execute()
+ *
+ * // Track progress with events
+ * execution.on('statusChange', ([status, response]) => {
+ *   console.log(`Status: ${status}`)
+ *   if (response.state) {
+ *     console.log(`Progress: ${response.state.completed}/${response.state.total}`)
+ *   }
+ * })
+ *
+ * execution.on('success', (result) => {
+ *   console.log('Batch completed!')
+ *   console.log('Request ID:', result.requestId)
+ * })
+ *
+ * // Start polling without waiting
+ * execution.poll()
+ * ```
+ */
+declare class BatchExecution<TOutput> extends Emittery<BatchExecutionEvents<TOutput>> {
+    private readonly _client;
+    private readonly _id;
+    private readonly _params;
+    private readonly _abortController;
+    private readonly _creationResponse;
+    private _status;
+    private _resultPromise;
+    /**
+     * Creates a new batch execution instance.
+     *
+     * @param id - Unique identifier for this batch execution.
+     * @param client - HTTP client for making API requests.
+     * @param params - Batch execution parameters.
+     * @param creationResponse - Initial response from batch creation.
+     * @internal
+     */
+    constructor(id: string, client: BaseClient, params: BatchParams | undefined, creationResponse: WithRequestId<BatchResponse>);
+    /**
+     * Gets the latest known status of the batch execution.
+     *
+     * Status values and transitions:
+     * - `created` → `validating` → `running` → `completed` or `failed`
+     * - Can transition to `canceled` from any non-terminal state
+     *
+     * Use the `statusChange` event to track status transitions in real-time.
+     *
+     * @returns The current status of the batch execution.
+     *
+     * @example
+     * ```typescript
+     * const execution = await batch.execute()
+     * console.log(execution.status) // 'created'
+     *
+     * execution.on('statusChange', ([status]) => {
+     *   console.log('New status:', status)
+     * })
+     *
+     * await execution.result
+     * console.log(execution.status) // 'completed' or 'failed'
+     * ```
+     */
+    get status(): BatchExecutionStatus;
+    /**
+     * Gets the unique identifier for this batch execution.
+     *
+     * @returns The batch execution ID.
+     */
+    get id(): string;
+    /**
+     * Gets the batch execution parameters.
+     *
+     * @returns The batch parameters.
+     */
+    get params(): BatchParams;
+    /**
+     * Cancels the batch execution.
+     *
+     * Sends a cancellation request to the server and aborts any ongoing polling.
+     * The batch will stop processing, but already-completed executions remain available.
+     *
+     * @returns A promise that resolves when the cancellation request completes.
+     *
+     * @example
+     * ```typescript
+     * const execution = await batch.execute()
+     * execution.poll()
+     *
+     * // Cancel after some condition
+     * if (shouldCancel) {
+     *   await execution.cancel()
+     *   console.log(execution.status) // 'canceled'
+     * }
+     * ```
+     */
+    cancel(): Promise<void>;
+    /**
+     * Starts polling for the batch result without waiting for the promise to resolve.
+     * This allows users to track batch progress via events rather than awaiting a promise.
+     *
+     * The following events will be emitted during polling:
+     * - `statusChange`: Emitted when the batch status changes (e.g., 'created' → 'running' → 'completed')
+     * - `poll`: Emitted on each polling attempt with the server response
+     * - `success`: Emitted when the batch completes successfully with the final result
+     * - `error`: Emitted if the batch fails
+     *
+     * **Important:** Events are only emitted while polling is active. You must call `poll()` or
+     * await `execution.result` to start polling. Simply setting up event listeners without starting
+     * polling will not trigger any events.
+     *
+     * @example
+     * ```typescript
+     * const execution = await batch.execute()
+     *
+     * // Set up event listeners
+     * execution.on('statusChange', ([status, response]) => {
+     *   console.log(`Status: ${status}`)
+     *   if (response.state) {
+     *     const { completed, total } = response.state
+     *     console.log(`Progress: ${completed}/${total}`)
+     *   }
+     * })
+     *
+     * execution.on('success', (result) => {
+     *   console.log('Batch completed!')
+     *   console.log('Request ID:', result.requestId)
+     * })
+     *
+     * execution.on('error', (error) => {
+     *   console.error('Batch failed:', error)
+     * })
+     *
+     * // Start polling without waiting
+     * execution.poll()
+     * ```
+     */
+    poll(): void;
+    /**
+     * Sets the batch status and emits statusChange event if changed.
+     *
+     * @param status - The new status.
+     * @param response - The response containing the status.
+     * @private
+     */
+    private setStatus;
+    /**
+     * Starts polling the server for batch completion.
+     * Continues polling until the batch completes, fails, or times out.
+     *
+     * @throws {BatchExecutionFailedError} If the batch fails on the server.
+     * @throws {Error} If the polling operation times out.
+     * @returns A promise resolving to the final batch result.
+     * @private
+     */
+    private startPolling;
+    /**
+     * Gets the batch execution result. Automatically starts polling if not already started.
+     *
+     * @returns A promise resolving to the batch execution result.
+     *
+     * @example
+     * ```typescript
+     * const execution = await batch.execute()
+     * const result = await execution.result
+     *
+     * // Access results
+     * const outputs = await result.getResults()
+     * console.log(`Got ${outputs.length} results`)
+     * ```
+     */
+    get result(): Promise<BatchExecutionResult<TOutput>>;
+}
+/**
+ * Builder class for creating and executing batch operations on a canvas.
+ *
+ * The Batch class provides a fluent API for building up a collection of executions
+ * to be processed in parallel. Items can be added incrementally, and the batch is
+ * executed only when `execute()` is called.
+ *
+ * ## Usage Pattern
+ *
+ * 1. Create batch via `canvas.createBatch()`
+ * 2. Add items via `add()` method (can be called multiple times)
+ * 3. Execute batch via `execute()` method
+ * 4. Monitor progress via events or await result
+ *
+ * ## Reference IDs
+ *
+ * Each batch item can have an optional reference ID for later retrieval.
+ * If not provided, UUIDs are generated automatically. Reference IDs are useful
+ * for correlating results with input data.
+ *
+ * @category Canvas
+ *
+ * @typeParam TInput - The input variables type for the canvas
+ * @typeParam TOutput - The output result type for individual executions
+ *
+ * @example
+ * ```typescript
+ * const batch = canvas.createBatch({
+ *   pollingInterval: '1s',
+ *   pollingTimeout: '5m',
+ * })
+ *
+ * // Add items individually
+ * batch.add({
+ *   referenceId: 'item-1',
+ *   variables: { query: 'First query' }
+ * })
+ *
+ * // Or add multiple items at once
+ * batch.add([
+ *   { variables: { query: 'Second query' } },
+ *   { variables: { query: 'Third query' } }
+ * ])
+ *
+ * // Execute and track progress
+ * const execution = await batch.execute()
+ * execution.on('statusChange', ([status, response]) => {
+ *   if (response.state) {
+ *     console.log(`Progress: ${response.state.completed}/${response.state.total}`)
+ *   }
+ * })
+ *
+ * const result = await execution.result
+ * const outputs = await result.getResults()
+ * ```
+ */
+declare class Batch<TInput, TOutput> {
+    private readonly _client;
+    private readonly _canvasIdentifier;
+    private readonly _items;
+    private readonly _params;
+    /**
+     * Creates a new batch builder.
+     *
+     * @param client - HTTP client for making API requests.
+     * @param canvasIdentifier - Canvas identification (ID + version or application ID).
+     * @param params - Optional batch execution parameters.
+     * @internal
+     */
+    constructor(client: BaseClient, canvasIdentifier: CanvasIdentifier, params?: BatchParams);
+    /**
+     * Gets the current list of items in this batch.
+     *
+     * @returns Array of batch items.
+     */
+    get items(): BatchItem<TInput>[];
+    /**
+     * Gets the batch execution parameters.
+     *
+     * @returns The batch parameters.
+     */
+    get params(): BatchParams;
+    /**
+     * Gets the canvas identifier in the format expected by the API.
+     *
+     * @returns Canvas identifier object.
+     * @private
+     */
+    private get canvasIdentifier();
+    /**
+     * Adds one or more items to the batch.
+     *
+     * Items without a reference ID will have UUIDs generated automatically.
+     * This method can be called multiple times to build up the batch incrementally.
+     *
+     * @param item - Single item or array of items to add to the batch.
+     *
+     * @example
+     * ```typescript
+     * // Add single item
+     * batch.add({
+     *   referenceId: 'my-custom-id',
+     *   variables: { query: 'Hello' }
+     * })
+     *
+     * // Add multiple items
+     * batch.add([
+     *   { variables: { query: 'First' } },
+     *   { variables: { query: 'Second' } },
+     *   { variables: { query: 'Third' } }
+     * ])
+     *
+     * console.log(`Batch has ${batch.items.length} items`)
+     * ```
+     */
+    add(item: MaybeArray<BatchItem<TInput>>): void;
+    /**
+     * Executes the batch by uploading the input file and creating a batch execution on the server.
+     *
+     * Returns a promise-like object that allows flexible usage patterns:
+     * - Await for execution object: `const exec = await batch.execute()`
+     * - Direct result access: `const result = await batch.execute().result`
+     *
+     * The batch items are serialized to JSONL format, uploaded to vault storage,
+     * and submitted to the batch API for processing.
+     *
+     * @returns A promise-like object with a `result` property for direct result access.
+     *
+     * @example
+     * ```typescript
+     * // Direct result access (recommended for simple cases)
+     * const result = await batch.execute().result
+     * const outputs = await result.getResults()
+     *
+     * // Get execution object for event monitoring
+     * const execution = await batch.execute()
+     *
+     * execution.on('statusChange', ([status, response]) => {
+     *   console.log(`Status: ${status}`)
+     *   if (response.state) {
+     *     console.log(`Progress: ${response.state.completed}/${response.state.total}`)
+     *   }
+     * })
+     *
+     * execution.on('success', (result) => {
+     *   console.log('Batch completed!', result.requestId)
+     * })
+     *
+     * const result = await execution.result
+     *
+     * // Iterate through results
+     * for await (const output of result.iterateResults()) {
+     *   console.log(output)
+     * }
+     * ```
+     */
+    execute(): BatchExecutionPromiseLike<TOutput>;
+}
+
+/**
+ * Canvas resource for managing prompt templates and their execution.
+ *
+ * This module provides the core Canvas class for retrieving and executing
+ * prompt templates from the Tela API, with support for schema validation,
+ * type safety, and multiple execution modes.
+ *
+ * @module Resources
+ */
+
+interface CanvasOptions<TInput, TOutput> {
+    /**
+     * Id of the canvas that will be used to create the completion.
+     */
+    id?: string;
+    /**
+     * Id of the version of the canvas. If not provided, the latest promoted version will be used.
+     */
+    versionId?: string;
+    /**
+     * Id of the application that the canvas belongs to.
+     */
+    applicationId?: string;
+    /**
+     * Name of the canvas. Useful for debugging.
+     */
+    name?: string;
+    /**
+     * Input schema of the canvas.
+     */
+    input?: SchemaFunction<TInput>;
+    /**
+     * Output schema of the canvas.
+     */
+    output?: SchemaFunction<TOutput>;
+    /**
+     * Base client for making requests to the Tela API.
+     */
+    client: BaseClient;
+    /**
+     * Variables of the canvas.
+     */
+    variables: Array<CanvasVariable>;
+    /**
+     * Whether the canvas is a workflow.
+     */
+    isWorkflow: boolean;
+}
+type CanvasGetOptions<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord> = Omit<CanvasOptions<TInput, TOutput>, 'client' | 'variables' | 'isWorkflow'> & {
+    /**
+     * Whether to skip schema validation warnings during canvas retrieval.
+     * When true, no warnings will be logged for schema mismatches.
+     * @default false
+     */
+    skipSchemaValidation?: boolean;
+};
+type CanvasExecutionPromiseLike<TParams extends ExecutionParams = SyncExecutionParams, TInput = unknown, TOutput = unknown> = PromiseLike<CanvasExecution<TParams, TInput, TOutput>> & {
+    result: Promise<CanvasExecutionResult<TParams, TOutput>>;
+};
+/**
+ * Represents a canvas (prompt template) from the Tela API.
+ *
+ * Canvas instances are retrieved using `tela.canvas.get()` and provide methods
+ * for executing prompts with various modes (sync, async, streaming).
+ *
+ * @category Canvas
+ *
+ * @typeParam TInput - The input schema type (Zod schema or plain object type)
+ * @typeParam TOutput - The output schema type (Zod schema or plain object type)
+ */
+declare class Canvas<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord> {
+    private readonly _id;
+    private readonly _versionId;
+    private readonly _applicationId;
+    private readonly _name;
+    private readonly _input;
+    private readonly _output;
+    private readonly _client;
+    private readonly _variables;
+    private readonly _isWorkflow;
+    /**
+     * Creates a new instance of the Canvas class. Usage of this constructor is not recommended.
+     * Use the `tela.getCanvas` method instead.
+     *
+     * @private
+     */
+    private constructor();
+    /**
+     * Gets a canvas by its ID.
+     *
+     * @param options - The options to use to get the canvas.
+     * @param options.id - The ID of the canvas to get.
+     * @param options.versionId - The version ID of the canvas to get.
+     * @param options.applicationId - The application ID of the canvas to get.
+     * @param options.client - The client to use to make the request.
+     * @param options.input - The input schema of the canvas to get.
+     * @param options.output - The output schema of the canvas to get.
+     * @returns The canvas.
+     */
+    static get<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord>(options: CanvasGetOptions<TInput, TOutput> & {
+        client: BaseClient;
+    }): Promise<Canvas<TInput, TOutput>>;
+    /**
+     * Gets the unique identifier of this canvas.
+     *
+     * @returns The canvas ID.
+     */
+    get id(): string;
+    /**
+     * Gets the name of this canvas, if provided.
+     *
+     * @returns The canvas name or undefined.
+     */
+    get name(): string;
+    /**
+     * Gets the version identifier of this canvas, if specified.
+     * When undefined, the latest promoted version is used.
+     *
+     * @returns The version ID or undefined.
+     */
+    get versionId(): string;
+    get applicationId(): string;
+    /**
+     * Gets the variables of this canvas.
+     *
+     * @returns The variables of the canvas.
+     */
+    get variables(): Array<CanvasVariable>;
+    /**
+     * Gets whether this canvas is a workflow.
+     *
+     * @returns True if the canvas is a workflow.
+     */
+    get isWorkflow(): boolean;
+    /**
+     * Gets whether this canvas is a workstation.
+     * This is true if an application ID is provided.
+     *
+     * @returns True if the canvas is a workstation.
+     */
+    get isWorkstation(): boolean;
+    /**
+     * Validates and parses input variables using the canvas input schema.
+     *
+     * @param variables - Raw input variables to validate.
+     * @returns Parsed and validated variables.
+     * @throws {ZodError} If validation fails when a Zod schema is configured.
+     */
+    private parseVariables;
+    /**
+     * Executes this canvas with the provided input variables.
+     * Creates and starts a canvas execution, handling variable validation and schema parsing.
+     *
+     * Returns a promise-like object that allows flexible usage patterns:
+     * - Await for the execution object: `const exec = await canvas.execute(vars)`
+     * - Direct result access: `const result = await canvas.execute(vars).result`
+     * - Stream iteration: `for await (const chunk of canvas.execute(vars, { stream: true }).result)`
+     *
+     * @param variables - Input variables to pass to the canvas template.
+     * @param params - Optional execution parameters (sync/async/stream configuration).
+     * @returns A promise-like object with a `result` property for direct result access.
+     *
+     * @example
+     * ```typescript
+     * // Direct result access (recommended for simple cases)
+     * const result = await canvas.execute({ query: "Hello" }).result;
+     *
+     * // Get execution object for control (e.g., to abort)
+     * const execution = await canvas.execute({ query: "Hello" });
+     * const result = await execution.result;
+     *
+     * // Asynchronous execution with polling
+     * const result = await canvas.execute(
+     *   { query: "Hello" },
+     *   { async: true, pollingInterval: 500 }
+     * ).result;
+     *
+     * // Streaming execution
+     * for await (const chunk of canvas.execute(
+     *   { query: "Hello" },
+     *   { stream: true }
+     * ).result) {
+     *   console.log(chunk);
+     * }
+     *
+     * // Execution with tags
+     * const result = await canvas.execute(
+     *   { query: "Hello" },
+     *   { tags: ["production", "analytics"] }
+     * ).result;
+     * ```
+     */
+    execute(variables: z$1.input<TInput>, params?: SyncExecutionParams): CanvasExecutionPromiseLike<SyncExecutionParams, Output<TInput>, Output<TOutput>>;
+    execute(variables: z$1.input<TInput>, params?: AsyncExecutionParams): CanvasExecutionPromiseLike<AsyncExecutionParams, Output<TInput>, Output<TOutput>>;
+    execute(variables: z$1.input<TInput>, params?: StreamExecutionParams): CanvasExecutionPromiseLike<StreamExecutionParams, Output<TInput>, Output<TOutput>>;
+    /**
+     * Fetches an existing async execution by its ID.
+     *
+     * This method retrieves the current state of an async execution that was previously
+     * started on this canvas. Only async executions can be fetched, as they are the only
+     * ones with persistent UUIDs on the server.
+     *
+     * @param id - The UUID of the async execution to fetch.
+     * @param options - Optional configuration for polling behavior.
+     * @param options.pollingInterval - Time in milliseconds between polling attempts (default: 1000).
+     * @param options.pollingTimeout - Maximum time in milliseconds to wait for completion (default: 60000).
+     * @throws {InvalidExecutionModeError} If the provided ID is not a valid UUID.
+     * @returns A promise resolving to a CanvasExecution instance with the fetched state.
+     *
+     * @example
+     * ```typescript
+     * // Start an async execution
+     * const execution = await canvas.execute({ query: 'test' }, { async: true })
+     * const executionId = execution.id
+     *
+     * // Later, fetch the execution by ID
+     * const fetched = await canvas.getExecution(executionId)
+     * console.log(fetched.status) // 'running', 'succeeded', or 'failed'
+     *
+     * // Use poll() for event-driven progress tracking
+     * fetched.on('statusChange', (status) => console.log('Status:', status))
+     * fetched.poll()
+     * ```
+     */
+    getExecution(id: string, options?: {
+        pollingInterval?: string | number;
+        pollingTimeout?: string | number;
+    }): Promise<CanvasExecution<AsyncExecutionParams, unknown, Output<TOutput>>>;
+    /**
+     * Prepares to execute this canvas in batch.
+     *
+     * @param params - The parameters for the batch.
+     * @param params.pollingInterval - The interval between polling attempts.
+     * @param params.pollingTimeout - The timeout for the batch.
+     * @param params.webhookUrl - The webhook URL for the batch.
+     *
+     * @example
+     * ```typescript
+     * const batch = canvas.createBatch({
+     *   pollingInterval: '1s',
+     *   pollingTimeout: '1m',
+     *   webhookUrl: 'https://example.com/webhook',
+     * })
+     *
+     * batch.add({
+     *   referenceId: crypto.randomUUID(), // Optional
+     *   variables: { query: 'Hello' },
+     * })
+     *
+     * const execution = await batch.execute()
+     * const result = await execution.result
+     * const resultFile = await execution.downloadOutputFile()
+     * ```
+     *
+     * @returns The batch instance that can be used to manage the batch.
+     */
+    createBatch(params?: BatchParams): Batch<Output<TInput>, Output<TOutput>>;
+}
+
+/**
+ * Parameters for creating a task.
+ *
+ * @category Workstation
+ */
+type TaskParams = {
+    label?: string;
+    tags?: string[];
+};
+/**
+ * A promise-like object that resolves to a Task instance and provides direct access to the result.
+ *
+ * @template TInput - The input variables type
+ * @template TOutput - The output result type
+ *
+ * @category Workstation
+ */
+type TaskPromiseLike<TInput = unknown, TOutput = unknown> = PromiseLike<Task<TInput, TOutput>> & {
+    result: Promise<TOutput>;
+};
+/**
+ * Event types emitted by Task during its lifecycle.
+ *
+ * @template TOutput - The output type.
+ *
+ * @property poll - Emitted during polling with current status and output. Includes `requestId` from the polling request.
+ * @property success - Emitted when task completes successfully with the final result.
+ * @property error - Emitted when task fails with the error object.
+ * @property statusChange - Emitted when task status transitions to a new state.
+ *
+ * @category Workstation
+ */
+type TaskEvents<TOutput = unknown> = {
+    poll: WithRequestId<TaskDefinition<TOutput>>;
+    success: TOutput;
+    error: TaskFailedError;
+    statusChange: TaskStatus;
+};
+/**
+ * Represents a workstation task with event-driven status tracking and result polling.
+ *
+ * Tasks are always asynchronous and require polling to retrieve results. The Task class
+ * provides an event system for monitoring task lifecycle and automatic output validation.
+ *
+ * ## Status Tracking
+ *
+ * Task status can be accessed via the `status` property and tracks the lifecycle:
+ * - `created` → `running` → `completed` or `failed`
+ *
+ * Status is set to `failed` when:
+ * - API request fails
+ * - Validation fails
+ * - Polling reports failure status
+ *
+ * Status is set to `completed` only after:
+ * - API request succeeds AND
+ * - Output validation passes (if schema provided)
+ *
+ * @category Workstation
+ *
+ * @typeParam TInput - The input variables type
+ * @typeParam TOutput - The output result type
+ *
+ * @fires poll - Emitted during polling with current status and output. Includes `requestId` from the polling request.
+ * @fires success - Emitted when task completes successfully with the final result. Includes `requestId` from the final request.
+ * @fires error - Emitted when task fails (only if error listeners are registered, otherwise throws)
+ * @fires statusChange - Emitted when task status transitions to a new state
+ *
+ * @example
+ * ```typescript
+ * const task = await workstation.createTask({ query: 'test' })
+ *
+ * // Track status changes
+ * task.on('statusChange', (status) => {
+ *   console.log(`Status: ${status}`) // created → running → completed
+ * })
+ *
+ * // Monitor polling progress
+ * task.on('poll', (pollResult) => {
+ *   console.log('Polling...', pollResult.requestId)
+ * })
+ *
+ * // Handle success
+ * task.on('success', (result) => {
+ *   console.log('Result:', result)
+ * })
+ *
+ * // Handle errors
+ * task.on('error', (error) => {
+ *   console.error('Failed:', error)
+ * })
+ *
+ * // Start polling without waiting
+ * task.poll()
+ * ```
+ */
+declare class Task<TInput = unknown, TOutput = unknown> extends Emittery<TaskEvents<TOutput>> {
+    private readonly _variables;
+    private readonly _task;
+    private readonly _abortController;
+    private readonly _client;
+    private readonly _outputSchema;
+    private readonly _skipResultValidation;
+    private _resultPromise;
+    private _status;
+    private _requestId;
+    constructor(client: BaseClient, variables: TInput, task: TaskDefinition, requestId?: string, outputSchema?: z.ZodType | Record<string, unknown>, skipResultValidation?: boolean);
+    /**
+     * Gets the unique task ID assigned by the server.
+     *
+     * @returns The task ID.
+     */
+    get id(): string;
+    /**
+     * Gets the request ID from the `x-request-id` header of the task creation request.
+     *
+     * This is the request ID from the initial POST /task request that created the task.
+     * Each API request has its own unique request ID.
+     *
+     * For polling operations, different request IDs are available:
+     * - `task.requestId` - ID from the task creation request
+     * - `pollResult.requestId` - ID from each polling request (in poll events)
+     * - `result.requestId` - ID from the final successful polling request (in success events)
+     *
+     * @returns A promise that resolves to the request ID from the task creation request.
+     *
+     * @example
+     * ```typescript
+     * const task = await workstation.createTask({ query: 'test' })
+     * const requestId = await task.requestId
+     * console.log('Request ID:', requestId)
+     * ```
+     */
+    get requestId(): string | undefined;
+    /**
+     * Gets the latest known status of the task.
+     *
+     * Status values and transitions:
+     * - `created` → `running` → `completed` or `failed`
+     *
+     * **Important:** Status is set to `completed` only after successful validation.
+     * If validation fails, status will be `failed` even if the API request succeeded.
+     *
+     * Use the `statusChange` event to track status transitions in real-time.
+     *
+     * @returns The current status of the task.
+     *
+     * @example
+     * ```typescript
+     * const task = await workstation.createTask({ query: 'test' })
+     * console.log(task.status) // 'created'
+     *
+     * await task.result
+     * console.log(task.status) // 'completed' or 'failed'
+     * ```
+     */
+    get status(): TaskStatus;
+    /**
+     * Sets the status of the task and emits statusChange event.
+     *
+     * @param status - The new status of the task.
+     * @private
+     */
+    private set status(value);
+    /**
+     * Gets the input variables provided to this task.
+     *
+     * @returns The variables object.
+     */
+    get variables(): TInput;
+    /**
+     * Gets the task label (alias for name).
+     *
+     * @returns The task name.
+     */
+    get label(): string;
+    /**
+     * Gets the task name.
+     *
+     * @returns The task name.
+     */
+    get name(): string;
+    /**
+     * Gets the task tags.
+     *
+     * @returns The task tags.
+     */
+    get tags(): string[];
+    /**
+     * Gets the raw task definition from the server.
+     *
+     * @returns The raw task definition.
+     */
+    get rawTask(): TaskDefinition;
+    /**
+     * Starts polling for the task result without waiting for the promise to resolve.
+     * This allows users to track task progress via events rather than awaiting a promise.
+     *
+     * The following events will be emitted during polling:
+     * - `statusChange`: Emitted when the task status changes (e.g., 'created' → 'running' → 'completed')
+     * - `poll`: Emitted on each polling attempt with the server response
+     * - `success`: Emitted when the task completes successfully with the final result
+     * - `error`: Emitted if the task fails
+     *
+     * **Important:** Events are only emitted while polling is active. You must call `poll()` or
+     * await `task.result` to start polling. Simply setting up event listeners without starting
+     * polling will not trigger any events.
+     *
+     * @example
+     * ```typescript
+     * const task = await workstation.createTask({ query: 'test' })
+     *
+     * // Set up event listeners
+     * task.on('statusChange', (status) => {
+     *   console.log('Status:', status)
+     * })
+     *
+     * task.on('success', (result) => {
+     *   console.log('Completed:', result)
+     * })
+     *
+     * task.on('error', (error) => {
+     *   console.error('Failed:', error)
+     * })
+     *
+     * // Start polling without waiting
+     * task.poll()
+     * ```
      */
-    client: BaseClient;
+    poll(): void;
     /**
-     * Variables of the canvas.
+     * Gets the task result. Automatically starts polling if not already started.
+     *
+     * @returns A promise that resolves to the validated task output.
+     *
+     * @example
+     * ```typescript
+     * const task = await workstation.createTask({ query: 'test' })
+     * const result = await task.result
+     * console.log(result)
+     * ```
      */
-    variables: Array<CanvasVariable>;
+    get result(): Promise<TOutput>;
     /**
-     * Whether the canvas is a workflow.
+     * Starts the polling process to retrieve task results.
+     * Emits events during the polling lifecycle and validates output before resolving.
+     *
+     * @returns A promise that resolves to the validated task output.
+     * @private
      */
-    isWorkflow: boolean;
+    private startPolling;
 }
-type CanvasGetOptions<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord> = Omit<CanvasOptions<TInput, TOutput>, 'client' | 'variables' | 'isWorkflow'> & {
-    /**
-     * Whether to skip schema validation warnings during canvas retrieval.
-     * When true, no warnings will be logged for schema mismatches.
-     * @default false
-     */
-    skipSchemaValidation?: boolean;
+
+/**
+ * Internal configuration options for creating a Workstation instance.
+ *
+ * @internal
+ */
+type WorkstationOptions<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord> = {
+    client: BaseClient;
+    applicationId: string;
+    promptVersion: PromptVersion;
+    input?: SchemaFunction<TInput>;
+    output?: SchemaFunction<TOutput>;
 };
-declare const zod: {
-    file: typeof TelaFileSchema;
-    z: typeof _zod.z;
-    default: typeof _zod.z;
-    core: typeof _zod.core;
-    globalRegistry: _zod.core.$ZodRegistry<_zod.core.GlobalMeta, _zod.core.$ZodType<unknown, unknown, _zod.core.$ZodTypeInternals<unknown, unknown>>>;
-    registry: typeof _zod.core.registry;
-    config: typeof _zod.core.config;
-    $output: typeof _zod.core.$output;
-    $input: typeof _zod.core.$input;
-    $brand: typeof _zod.core.$brand;
-    clone: typeof _zod.core.util.clone;
-    regexes: typeof _zod.core.regexes;
-    treeifyError: typeof _zod.core.treeifyError;
-    prettifyError: typeof _zod.core.prettifyError;
-    formatError: typeof _zod.core.formatError;
-    flattenError: typeof _zod.core.flattenError;
-    toJSONSchema: typeof _zod.core.toJSONSchema;
-    TimePrecision: {
-        readonly Any: null;
-        readonly Minute: -1;
-        readonly Second: 0;
-        readonly Millisecond: 3;
-        readonly Microsecond: 6;
-    };
-    util: typeof _zod.core.util;
-    NEVER: never;
-    locales: typeof _zod.core.locales;
-    ZodISODateTime: _zod.core.$constructor<_zod.ZodISODateTime, _zod.core.$ZodISODateTimeDef>;
-    ZodISODate: _zod.core.$constructor<_zod.ZodISODate, _zod.core.$ZodStringFormatDef<"date">>;
-    ZodISOTime: _zod.core.$constructor<_zod.ZodISOTime, _zod.core.$ZodISOTimeDef>;
-    ZodISODuration: _zod.core.$constructor<_zod.ZodISODuration, _zod.core.$ZodStringFormatDef<"duration">>;
-    iso: typeof _zod.iso;
-    coerce: typeof _zod.coerce;
-    string(params?: string | _zod.core.$ZodStringParams): _zod.ZodString;
-    string<T extends string>(params?: string | _zod.core.$ZodStringParams): _zod.core.$ZodType<T, T>;
-    email(params?: string | _zod.core.$ZodEmailParams): _zod.ZodEmail;
-    guid(params?: string | _zod.core.$ZodGUIDParams): _zod.ZodGUID;
-    uuid(params?: string | _zod.core.$ZodUUIDParams): _zod.ZodUUID;
-    uuidv4(params?: string | _zod.core.$ZodUUIDv4Params): _zod.ZodUUID;
-    uuidv6(params?: string | _zod.core.$ZodUUIDv6Params): _zod.ZodUUID;
-    uuidv7(params?: string | _zod.core.$ZodUUIDv7Params): _zod.ZodUUID;
-    url(params?: string | _zod.core.$ZodURLParams): _zod.ZodURL;
-    httpUrl(params?: string | Omit<_zod.core.$ZodURLParams, "protocol" | "hostname">): _zod.ZodURL;
-    emoji(params?: string | _zod.core.$ZodEmojiParams): _zod.ZodEmoji;
-    nanoid(params?: string | _zod.core.$ZodNanoIDParams): _zod.ZodNanoID;
-    cuid(params?: string | _zod.core.$ZodCUIDParams): _zod.ZodCUID;
-    cuid2(params?: string | _zod.core.$ZodCUID2Params): _zod.ZodCUID2;
-    ulid(params?: string | _zod.core.$ZodULIDParams): _zod.ZodULID;
-    xid(params?: string | _zod.core.$ZodXIDParams): _zod.ZodXID;
-    ksuid(params?: string | _zod.core.$ZodKSUIDParams): _zod.ZodKSUID;
-    ipv4(params?: string | _zod.core.$ZodIPv4Params): _zod.ZodIPv4;
-    ipv6(params?: string | _zod.core.$ZodIPv6Params): _zod.ZodIPv6;
-    cidrv4(params?: string | _zod.core.$ZodCIDRv4Params): _zod.ZodCIDRv4;
-    cidrv6(params?: string | _zod.core.$ZodCIDRv6Params): _zod.ZodCIDRv6;
-    base64(params?: string | _zod.core.$ZodBase64Params): _zod.ZodBase64;
-    base64url(params?: string | _zod.core.$ZodBase64URLParams): _zod.ZodBase64URL;
-    e164(params?: string | _zod.core.$ZodE164Params): _zod.ZodE164;
-    jwt(params?: string | _zod.core.$ZodJWTParams): _zod.ZodJWT;
-    stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => _zod.core.util.MaybeAsync<unknown>) | RegExp, _params?: string | _zod.core.$ZodStringFormatParams): _zod.ZodCustomStringFormat<Format>;
-    hostname(_params?: string | _zod.core.$ZodStringFormatParams): _zod.ZodCustomStringFormat<"hostname">;
-    hex(_params?: string | _zod.core.$ZodStringFormatParams): _zod.ZodCustomStringFormat<"hex">;
-    hash<Alg extends _zod.core.util.HashAlgorithm, Enc extends _zod.core.util.HashEncoding = "hex">(alg: Alg, params?: {
-        enc?: Enc;
-    } & _zod.core.$ZodStringFormatParams): _zod.ZodCustomStringFormat<`${Alg}_${Enc}`>;
-    number(params?: string | _zod.core.$ZodNumberParams): _zod.ZodNumber;
-    int(params?: string | _zod.core.$ZodCheckNumberFormatParams): _zod.ZodInt;
-    float32(params?: string | _zod.core.$ZodCheckNumberFormatParams): _zod.ZodFloat32;
-    float64(params?: string | _zod.core.$ZodCheckNumberFormatParams): _zod.ZodFloat64;
-    int32(params?: string | _zod.core.$ZodCheckNumberFormatParams): _zod.ZodInt32;
-    uint32(params?: string | _zod.core.$ZodCheckNumberFormatParams): _zod.ZodUInt32;
-    boolean(params?: string | _zod.core.$ZodBooleanParams): _zod.ZodBoolean;
-    bigint(params?: string | _zod.core.$ZodBigIntParams): _zod.ZodBigInt;
-    int64(params?: string | _zod.core.$ZodBigIntFormatParams): _zod.ZodBigIntFormat;
-    uint64(params?: string | _zod.core.$ZodBigIntFormatParams): _zod.ZodBigIntFormat;
-    symbol(params?: string | _zod.core.$ZodSymbolParams): _zod.ZodSymbol;
-    any(): _zod.ZodAny;
-    unknown(): _zod.ZodUnknown;
-    never(params?: string | _zod.core.$ZodNeverParams): _zod.ZodNever;
-    date(params?: string | _zod.core.$ZodDateParams): _zod.ZodDate;
-    array<T extends _zod.core.SomeType>(element: T, params?: string | _zod.core.$ZodArrayParams): _zod.ZodArray<T>;
-    keyof<T extends _zod.ZodObject>(schema: T): _zod.ZodEnum<_zod.core.util.KeysEnum<T["_zod"]["output"]>>;
-    object<T extends _zod.core.$ZodLooseShape = Partial<Record<never, _zod.core.SomeType>>>(shape?: T, params?: string | _zod.core.$ZodObjectParams): _zod.ZodObject<_zod.core.util.Writeable<T>, _zod.core.$strip>;
-    strictObject<T extends _zod.core.$ZodLooseShape>(shape: T, params?: string | _zod.core.$ZodObjectParams): _zod.ZodObject<T, _zod.core.$strict>;
-    looseObject<T extends _zod.core.$ZodLooseShape>(shape: T, params?: string | _zod.core.$ZodObjectParams): _zod.ZodObject<T, _zod.core.$loose>;
-    union<const T extends readonly _zod.core.SomeType[]>(options: T, params?: string | _zod.core.$ZodUnionParams): _zod.ZodUnion<T>;
-    discriminatedUnion<Types extends readonly [_zod.core.$ZodTypeDiscriminable, ..._zod.core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | _zod.core.$ZodDiscriminatedUnionParams): _zod.ZodDiscriminatedUnion<Types, Disc>;
-    intersection<T extends _zod.core.SomeType, U extends _zod.core.SomeType>(left: T, right: U): _zod.ZodIntersection<T, U>;
-    tuple<T extends readonly [_zod.core.SomeType, ..._zod.core.SomeType[]]>(items: T, params?: string | _zod.core.$ZodTupleParams): _zod.ZodTuple<T, null>;
-    tuple<T extends readonly [_zod.core.SomeType, ..._zod.core.SomeType[]], Rest extends _zod.core.SomeType>(items: T, rest: Rest, params?: string | _zod.core.$ZodTupleParams): _zod.ZodTuple<T, Rest>;
-    tuple(items: [], params?: string | _zod.core.$ZodTupleParams): _zod.ZodTuple<[], null>;
-    record<Key extends _zod.core.$ZodRecordKey, Value extends _zod.core.SomeType>(keyType: Key, valueType: Value, params?: string | _zod.core.$ZodRecordParams): _zod.ZodRecord<Key, Value>;
-    partialRecord<Key extends _zod.core.$ZodRecordKey, Value extends _zod.core.SomeType>(keyType: Key, valueType: Value, params?: string | _zod.core.$ZodRecordParams): _zod.ZodRecord<Key & _zod.core.$partial, Value>;
-    map<Key extends _zod.core.SomeType, Value extends _zod.core.SomeType>(keyType: Key, valueType: Value, params?: string | _zod.core.$ZodMapParams): _zod.ZodMap<Key, Value>;
-    set<Value extends _zod.core.SomeType>(valueType: Value, params?: string | _zod.core.$ZodSetParams): _zod.ZodSet<Value>;
-    nativeEnum<T extends _zod.core.util.EnumLike>(entries: T, params?: string | _zod.core.$ZodEnumParams): _zod.ZodEnum<T>;
-    literal<const T extends ReadonlyArray<_zod.core.util.Literal>>(value: T, params?: string | _zod.core.$ZodLiteralParams): _zod.ZodLiteral<T[number]>;
-    literal<const T extends _zod.core.util.Literal>(value: T, params?: string | _zod.core.$ZodLiteralParams): _zod.ZodLiteral<T>;
-    transform<I = unknown, O = I>(fn: (input: I, ctx: _zod.core.ParsePayload) => O): _zod.ZodTransform<Awaited<O>, I>;
-    optional<T extends _zod.core.SomeType>(innerType: T): _zod.ZodOptional<T>;
-    nullable<T extends _zod.core.SomeType>(innerType: T): _zod.ZodNullable<T>;
-    nullish<T extends _zod.core.SomeType>(innerType: T): _zod.ZodOptional<_zod.ZodNullable<T>>;
-    _default<T extends _zod.core.SomeType>(innerType: T, defaultValue: _zod.core.util.NoUndefined<_zod.core.output<T>> | (() => _zod.core.util.NoUndefined<_zod.core.output<T>>)): _zod.ZodDefault<T>;
-    prefault<T extends _zod.core.SomeType>(innerType: T, defaultValue: _zod.core.input<T> | (() => _zod.core.input<T>)): _zod.ZodPrefault<T>;
-    nonoptional<T extends _zod.core.SomeType>(innerType: T, params?: string | _zod.core.$ZodNonOptionalParams): _zod.ZodNonOptional<T>;
-    success<T extends _zod.core.SomeType>(innerType: T): _zod.ZodSuccess<T>;
-    nan(params?: string | _zod.core.$ZodNaNParams): _zod.ZodNaN;
-    pipe<const A extends _zod.core.SomeType, B extends _zod.core.$ZodType<unknown, _zod.core.output<A>> = _zod.core.$ZodType<unknown, _zod.core.output<A>, _zod.core.$ZodTypeInternals<unknown, _zod.core.output<A>>>>(in_: A, out: B | _zod.core.$ZodType<unknown, _zod.core.output<A>>): _zod.ZodPipe<A, B>;
-    codec<const A extends _zod.core.SomeType, B extends _zod.core.SomeType = _zod.core.$ZodType<unknown, unknown, _zod.core.$ZodTypeInternals<unknown, unknown>>>(in_: A, out: B, params: {
-        decode: (value: _zod.core.output<A>, payload: _zod.core.ParsePayload<_zod.core.output<A>>) => _zod.core.util.MaybeAsync<_zod.core.input<B>>;
-        encode: (value: _zod.core.input<B>, payload: _zod.core.ParsePayload<_zod.core.input<B>>) => _zod.core.util.MaybeAsync<_zod.core.output<A>>;
-    }): _zod.ZodCodec<A, B>;
-    readonly<T extends _zod.core.SomeType>(innerType: T): _zod.ZodReadonly<T>;
-    templateLiteral<const Parts extends _zod.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | _zod.core.$ZodTemplateLiteralParams): _zod.ZodTemplateLiteral<_zod.core.$PartsToTemplateLiteral<Parts>>;
-    lazy<T extends _zod.core.SomeType>(getter: () => T): _zod.ZodLazy<T>;
-    promise<T extends _zod.core.SomeType>(innerType: T): _zod.ZodPromise<T>;
-    _function(): _zod.ZodFunction;
-    _function<const In extends ReadonlyArray<_zod.core.$ZodType>>(params: {
-        input: In;
-    }): _zod.ZodFunction<_zod.ZodTuple<In, null>, _zod.core.$ZodFunctionOut>;
-    _function<const In extends ReadonlyArray<_zod.core.$ZodType>, const Out extends _zod.core.$ZodFunctionOut = _zod.core.$ZodFunctionOut>(params: {
-        input: In;
-        output: Out;
-    }): _zod.ZodFunction<_zod.ZodTuple<In, null>, Out>;
-    _function<const In extends _zod.core.$ZodFunctionIn = _zod.core.$ZodFunctionArgs>(params: {
-        input: In;
-    }): _zod.ZodFunction<In, _zod.core.$ZodFunctionOut>;
-    _function<const Out extends _zod.core.$ZodFunctionOut = _zod.core.$ZodFunctionOut>(params: {
-        output: Out;
-    }): _zod.ZodFunction<_zod.core.$ZodFunctionIn, Out>;
-    _function<In extends _zod.core.$ZodFunctionIn = _zod.core.$ZodFunctionArgs, Out extends _zod.core.$ZodType = _zod.core.$ZodType<unknown, unknown, _zod.core.$ZodTypeInternals<unknown, unknown>>>(params?: {
-        input: In;
-        output: Out;
-    }): _zod.ZodFunction<In, Out>;
-    check<O = unknown>(fn: _zod.core.CheckFn<O>): _zod.core.$ZodCheck<O>;
-    custom<O>(fn?: (data: unknown) => unknown, _params?: string | _zod.core.$ZodCustomParams | undefined): _zod.ZodCustom<O, O>;
-    refine<T>(fn: (arg: NoInfer<T>) => _zod.core.util.MaybeAsync<unknown>, _params?: string | _zod.core.$ZodCustomParams): _zod.core.$ZodCheck<T>;
-    superRefine<T>(fn: (arg: T, payload: _zod.core.$RefinementCtx<T>) => void | Promise<void>): _zod.core.$ZodCheck<T>;
-    json(params?: string | _zod.core.$ZodCustomParams): _zod.ZodJSONSchema;
-    preprocess<A, U extends _zod.core.SomeType, B = unknown>(fn: (arg: B, ctx: _zod.core.$RefinementCtx) => A, schema: U): _zod.ZodPipe<_zod.ZodTransform<A, B>, U>;
-    ZodType: _zod.core.$constructor<_zod.ZodType>;
-    _ZodString: _zod.core.$constructor<_zod._ZodString>;
-    ZodString: _zod.core.$constructor<_zod.ZodString>;
-    ZodStringFormat: _zod.core.$constructor<_zod.ZodStringFormat>;
-    ZodEmail: _zod.core.$constructor<_zod.ZodEmail>;
-    ZodGUID: _zod.core.$constructor<_zod.ZodGUID>;
-    ZodUUID: _zod.core.$constructor<_zod.ZodUUID>;
-    ZodURL: _zod.core.$constructor<_zod.ZodURL>;
-    ZodEmoji: _zod.core.$constructor<_zod.ZodEmoji>;
-    ZodNanoID: _zod.core.$constructor<_zod.ZodNanoID>;
-    ZodCUID: _zod.core.$constructor<_zod.ZodCUID>;
-    ZodCUID2: _zod.core.$constructor<_zod.ZodCUID2>;
-    ZodULID: _zod.core.$constructor<_zod.ZodULID>;
-    ZodXID: _zod.core.$constructor<_zod.ZodXID>;
-    ZodKSUID: _zod.core.$constructor<_zod.ZodKSUID>;
-    ZodIPv4: _zod.core.$constructor<_zod.ZodIPv4>;
-    ZodIPv6: _zod.core.$constructor<_zod.ZodIPv6>;
-    ZodCIDRv4: _zod.core.$constructor<_zod.ZodCIDRv4>;
-    ZodCIDRv6: _zod.core.$constructor<_zod.ZodCIDRv6>;
-    ZodBase64: _zod.core.$constructor<_zod.ZodBase64>;
-    ZodBase64URL: _zod.core.$constructor<_zod.ZodBase64URL>;
-    ZodE164: _zod.core.$constructor<_zod.ZodE164>;
-    ZodJWT: _zod.core.$constructor<_zod.ZodJWT>;
-    ZodCustomStringFormat: _zod.core.$constructor<_zod.ZodCustomStringFormat>;
-    ZodNumber: _zod.core.$constructor<_zod.ZodNumber>;
-    ZodNumberFormat: _zod.core.$constructor<_zod.ZodNumberFormat>;
-    ZodBoolean: _zod.core.$constructor<_zod.ZodBoolean>;
-    ZodBigInt: _zod.core.$constructor<_zod.ZodBigInt>;
-    ZodBigIntFormat: _zod.core.$constructor<_zod.ZodBigIntFormat>;
-    ZodSymbol: _zod.core.$constructor<_zod.ZodSymbol>;
-    ZodUndefined: _zod.core.$constructor<_zod.ZodUndefined>;
-    undefined: typeof _zod.undefined;
-    ZodNull: _zod.core.$constructor<_zod.ZodNull>;
-    null: typeof _zod.null;
-    ZodAny: _zod.core.$constructor<_zod.ZodAny>;
-    ZodUnknown: _zod.core.$constructor<_zod.ZodUnknown>;
-    ZodNever: _zod.core.$constructor<_zod.ZodNever>;
-    ZodVoid: _zod.core.$constructor<_zod.ZodVoid>;
-    void: typeof _zod.void;
-    ZodDate: _zod.core.$constructor<_zod.ZodDate>;
-    ZodArray: _zod.core.$constructor<_zod.ZodArray>;
-    ZodObject: _zod.core.$constructor<_zod.ZodObject>;
-    ZodUnion: _zod.core.$constructor<_zod.ZodUnion>;
-    ZodDiscriminatedUnion: _zod.core.$constructor<_zod.ZodDiscriminatedUnion>;
-    ZodIntersection: _zod.core.$constructor<_zod.ZodIntersection>;
-    ZodTuple: _zod.core.$constructor<_zod.ZodTuple>;
-    ZodRecord: _zod.core.$constructor<_zod.ZodRecord>;
-    ZodMap: _zod.core.$constructor<_zod.ZodMap>;
-    ZodSet: _zod.core.$constructor<_zod.ZodSet>;
-    ZodEnum: _zod.core.$constructor<_zod.ZodEnum>;
-    enum: typeof _zod.enum;
-    ZodLiteral: _zod.core.$constructor<_zod.ZodLiteral>;
-    ZodFile: _zod.core.$constructor<_zod.ZodFile>;
-    ZodTransform: _zod.core.$constructor<_zod.ZodTransform>;
-    ZodOptional: _zod.core.$constructor<_zod.ZodOptional>;
-    ZodNullable: _zod.core.$constructor<_zod.ZodNullable>;
-    ZodDefault: _zod.core.$constructor<_zod.ZodDefault>;
-    ZodPrefault: _zod.core.$constructor<_zod.ZodPrefault>;
-    ZodNonOptional: _zod.core.$constructor<_zod.ZodNonOptional>;
-    ZodSuccess: _zod.core.$constructor<_zod.ZodSuccess>;
-    ZodCatch: _zod.core.$constructor<_zod.ZodCatch>;
-    catch: typeof _zod.catch;
-    ZodNaN: _zod.core.$constructor<_zod.ZodNaN>;
-    ZodPipe: _zod.core.$constructor<_zod.ZodPipe>;
-    ZodCodec: _zod.core.$constructor<_zod.ZodCodec>;
-    ZodReadonly: _zod.core.$constructor<_zod.ZodReadonly>;
-    ZodTemplateLiteral: _zod.core.$constructor<_zod.ZodTemplateLiteral>;
-    ZodLazy: _zod.core.$constructor<_zod.ZodLazy>;
-    ZodPromise: _zod.core.$constructor<_zod.ZodPromise>;
-    ZodFunction: _zod.core.$constructor<_zod.ZodFunction>;
-    function: typeof _zod._function;
-    ZodCustom: _zod.core.$constructor<_zod.ZodCustom>;
-    instanceof: typeof _zod.instanceof;
-    stringbool: (_params?: string | _zod.core.$ZodStringBoolParams) => _zod.ZodCodec<_zod.ZodString, _zod.ZodBoolean>;
-    lt: typeof _zod.core._lt;
-    lte: typeof _zod.core._lte;
-    gt: typeof _zod.core._gt;
-    gte: typeof _zod.core._gte;
-    positive: typeof _zod.core._positive;
-    negative: typeof _zod.core._negative;
-    nonpositive: typeof _zod.core._nonpositive;
-    nonnegative: typeof _zod.core._nonnegative;
-    multipleOf: typeof _zod.core._multipleOf;
-    maxSize: typeof _zod.core._maxSize;
-    minSize: typeof _zod.core._minSize;
-    size: typeof _zod.core._size;
-    maxLength: typeof _zod.core._maxLength;
-    minLength: typeof _zod.core._minLength;
-    length: typeof _zod.core._length;
-    regex: typeof _zod.core._regex;
-    lowercase: typeof _zod.core._lowercase;
-    uppercase: typeof _zod.core._uppercase;
-    includes: typeof _zod.core._includes;
-    startsWith: typeof _zod.core._startsWith;
-    endsWith: typeof _zod.core._endsWith;
-    property: typeof _zod.core._property;
-    mime: typeof _zod.core._mime;
-    overwrite: typeof _zod.core._overwrite;
-    normalize: typeof _zod.core._normalize;
-    trim: typeof _zod.core._trim;
-    toLowerCase: typeof _zod.core._toLowerCase;
-    toUpperCase: typeof _zod.core._toUpperCase;
-    ZodError: _zod.core.$constructor<ZodError>;
-    ZodRealError: _zod.core.$constructor<ZodError>;
-    parse: <T extends _zod.core.$ZodType>(schema: T, value: unknown, _ctx?: _zod.core.ParseContext<_zod.core.$ZodIssue>, _params?: {
-        callee?: _zod.core.util.AnyFunc;
-        Err?: _zod.core.$ZodErrorClass;
-    }) => _zod.core.output<T>;
-    parseAsync: <T extends _zod.core.$ZodType>(schema: T, value: unknown, _ctx?: _zod.core.ParseContext<_zod.core.$ZodIssue>, _params?: {
-        callee?: _zod.core.util.AnyFunc;
-        Err?: _zod.core.$ZodErrorClass;
-    }) => Promise<_zod.core.output<T>>;
-    safeParse: <T extends _zod.core.$ZodType>(schema: T, value: unknown, _ctx?: _zod.core.ParseContext<_zod.core.$ZodIssue>) => _zod.ZodSafeParseResult<_zod.core.output<T>>;
-    safeParseAsync: <T extends _zod.core.$ZodType>(schema: T, value: unknown, _ctx?: _zod.core.ParseContext<_zod.core.$ZodIssue>) => Promise<_zod.ZodSafeParseResult<_zod.core.output<T>>>;
-    encode: <T extends _zod.core.$ZodType>(schema: T, value: _zod.core.output<T>, _ctx?: _zod.core.ParseContext<_zod.core.$ZodIssue>) => _zod.core.input<T>;
-    decode: <T extends _zod.core.$ZodType>(schema: T, value: _zod.core.input<T>, _ctx?: _zod.core.ParseContext<_zod.core.$ZodIssue>) => _zod.core.output<T>;
-    encodeAsync: <T extends _zod.core.$ZodType>(schema: T, value: _zod.core.output<T>, _ctx? /**
-     * Unique identifier for this prompt version.
-     */: _zod.core.ParseContext<_zod.core.$ZodIssue>) => Promise<_zod.core.input<T>>;
-    decodeAsync: <T extends _zod.core.$ZodType>(schema: T, value: _zod.core.input<T>, _ctx?: _zod.core.ParseContext<_zod.core.$ZodIssue>) => Promise<_zod.core.output<T>>;
-    safeEncode: <T extends _zod.core.$ZodType>(schema: T, value: _zod.core.output<T>, _ctx? /**
-     * Variables available in this prompt version.
-     */: _zod.core.ParseContext<_zod.core.$ZodIssue>) => _zod.ZodSafeParseResult<_zod.core.input<T>>;
-    safeDecode: <T extends _zod.core.$ZodType>(schema: T, value: _zod.core.input<T>, _ctx? /**
-     * Configuration settings for this prompt version.
-     */: _zod.core.ParseContext<_zod.core.$ZodIssue>) => _zod.ZodSafeParseResult<_zod.core.output<T>>;
-    safeEncodeAsync: <T extends _zod.core.$ZodType>(schema: T, value: _zod.core.output<T>, _ctx?: _zod.core.ParseContext<_zod.core.$ZodIssue>) => Promise<_zod.ZodSafeParseResult<_zod.core.input<T>>>;
-    safeDecodeAsync: <T extends _zod.core.$ZodType>(schema: T, value: _zod.core.input<T>, _ctx?: _zod.core.ParseContext<_zod.core.$ZodIssue>) => Promise<_zod.ZodSafeParseResult<_zod.core.output<T>>>;
-    setErrorMap(map: _zod.core.$ZodErrorMap): void;
-    getErrorMap(): _zod.core.$ZodErrorMap<_zod.core.$ZodIssue> | undefined;
-    ZodIssueCode: {
-        readonly invalid_type: "invalid_type";
-        readonly too_big: "too_big";
-        readonly too_small: "too_small";
-        readonly invalid_format: "invalid_format";
-        readonly not_multiple_of: "not_multiple_of";
-        readonly unrecognized_keys: "unrecognized_keys";
-        readonly invalid_union: "invalid_union";
-        readonly invalid_key: "invalid_key";
-        readonly invalid_element: "invalid_element";
-        readonly invalid_value: "invalid_value";
-        readonly custom: "custom";
-    };
-    ZodFirstPartyTypeKind: typeof _zod.ZodFirstPartyTypeKind;
+/**
+ * Zod schema for task list filtering options.
+ *
+ * Filters tasks by various criteria including ID, name, status, and timestamps.
+ * Date ranges can be specified using `since` and `until` fields.
+ */
+declare const TaskListFilters: z.ZodPipe<z.ZodObject<{
+    id: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    name: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        created: "created";
+        failed: "failed";
+        running: "running";
+        validating: "validating";
+        completed: "completed";
+        cancelled: "cancelled";
+    }>>>;
+    approvedAt: z.ZodOptional<z.ZodObject<{
+        since: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>, z.ZodISODateTime]>>;
+        until: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>, z.ZodISODateTime]>>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodOptional<z.ZodObject<{
+        since: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>, z.ZodISODateTime]>>;
+        until: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>, z.ZodISODateTime]>>;
+    }, z.core.$strip>>;
+    updatedAt: z.ZodOptional<z.ZodObject<{
+        since: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>, z.ZodISODateTime]>>;
+        until: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>, z.ZodISODateTime]>>;
+    }, z.core.$strip>>;
+    approvedBy: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    completionRunId: z.ZodOptional<z.ZodUUID>;
+    promptVersionId: z.ZodOptional<z.ZodUUID>;
+}, z.core.$loose>, z.ZodTransform<{
+    id?: string[] | undefined;
+    status?: ("created" | "failed" | "running" | "validating" | "completed" | "cancelled")[] | undefined;
+    approvedBy?: string | undefined;
+    createdBy?: string | undefined;
+    completionRunId?: string | undefined;
+    promptVersionId?: string | undefined;
+    updatedAtSince?: string | undefined;
+    updatedAtUntil?: string | undefined;
+    createdAtSince?: string | undefined;
+    createdAtUntil?: string | undefined;
+    approvedAtSince?: string | undefined;
+    approvedAtUntil?: string | undefined;
+    taskName: string | undefined;
+}, {
+    [x: string]: unknown;
+    id?: string[] | undefined;
+    name?: string | undefined;
+    status?: ("created" | "failed" | "running" | "validating" | "completed" | "cancelled")[] | undefined;
+    approvedAt?: {
+        since?: string | undefined;
+        until?: string | undefined;
+    } | undefined;
+    createdAt?: {
+        since?: string | undefined;
+        until?: string | undefined;
+    } | undefined;
+    updatedAt?: {
+        since?: string | undefined;
+        until?: string | undefined;
+    } | undefined;
+    approvedBy?: string | undefined;
+    createdBy?: string | undefined;
+    completionRunId?: string | undefined;
+    promptVersionId?: string | undefined;
+}>>;
+/**
+ * Type definition for task list filters (input form).
+ *
+ * @see {@link TaskListFilters} for the Zod schema
+ */
+type TaskListFilters = z.input<typeof TaskListFilters>;
+/**
+ * Zod schema for task list pagination and sorting options.
+ *
+ * Controls the number of results, offset, and sort order.
+ */
+declare const TaskListOptions: z.ZodPipe<z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    order: z.ZodOptional<z.ZodObject<{
+        by: z.ZodEnum<{
+            name: "name";
+            status: "status";
+            reference: "reference";
+            approvedAt: "approvedAt";
+            createdAt: "createdAt";
+            updatedAt: "updatedAt";
+        }>;
+        direction: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$loose>, z.ZodTransform<{
+    limit?: number | undefined;
+    offset?: number | undefined;
+    orderBy: "name" | "status" | "reference" | "approvedAt" | "createdAt" | "updatedAt" | undefined;
+    orderDirection: "asc" | "desc" | undefined;
+}, {
+    [x: string]: unknown;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    order?: {
+        by: "name" | "status" | "reference" | "approvedAt" | "createdAt" | "updatedAt";
+        direction: "asc" | "desc";
+    } | undefined;
+}>>;
+/**
+ * Type definition for task list options (input form).
+ *
+ * @see {@link TaskListOptions} for the Zod schema
+ */
+type TaskListOptions = z.input<typeof TaskListOptions>;
+/**
+ * Metadata returned with task list queries, including pagination information.
+ */
+type TaskListMeta = {
+    /** Total number of tasks matching the filter criteria */
+    totalCount: number;
+    /** Maximum number of tasks returned per page */
+    limit: number;
+    /** Starting position in the result set */
+    offset: number;
+    /** Current page number (1-indexed) */
+    currentPage: number;
+    /** Total number of pages available */
+    totalPages: number;
+    /** The reference number of the last task in the current page */
+    lastReference: number;
+    /** Navigation links for pagination */
+    links: Links;
 };
-type SchemaBuilder = typeof zod;
-type SchemaFunction<T> = (schema: SchemaBuilder) => T;
-type Output<T> = T extends z.ZodType ? z.infer<T> : T;
-type ZodTypeOrRecord = z.ZodType | Record<string, unknown>;
-type CanvasExecutionPromiseLike<TParams extends ExecutionParams = SyncExecutionParams, TInput = unknown, TOutput = unknown> = PromiseLike<CanvasExecution<TParams, TInput, TOutput>> & {
-    result: Promise<CanvasExecutionResult<TParams, TOutput>>;
+/**
+ * Parameters included in pagination links.
+ */
+type LinkParams = {
+    /** The workstation application ID */
+    promptApplicationId: string;
+    /** Number of items per page */
+    limit: number;
+    /** Starting offset for the page */
+    offset: number;
 };
 /**
- * Represents a canvas (prompt template) from the Tela API.
+ * Navigation links for paginated task lists.
+ */
+type Links = {
+    /** Parameters for the first page */
+    first: LinkParams;
+    /** Parameters for the last page */
+    last: LinkParams;
+    /** Parameters for the next page, or null if on last page */
+    next: LinkParams | null;
+    /** Parameters for the previous page, or null if on first page */
+    previous: LinkParams | null;
+};
+/**
+ * Options for retrieving a workstation instance.
+ */
+type WorkstationGetOptions<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord> = Omit<WorkstationOptions<TInput, TOutput>, 'client' | 'promptVersion'> & {
+    /** Whether to skip schema validation against the server configuration. Defaults to false. */
+    skipSchemaValidation?: boolean;
+};
+/**
+ * Represents a workstation (prompt application) in the Tela platform.
  *
- * Canvas instances are retrieved using `tela.canvas.get()` and provide methods
- * for executing prompts with various modes (sync, async, streaming).
+ * A Workstation enables creating and managing tasks (async workflow executions)
+ * with input/output schema validation using Zod.
  *
- * @category Canvas
+ * @template TInput - Zod schema type for task input variables
+ * @template TOutput - Zod schema type for task output results
  *
- * @typeParam TInput - The input schema type (Zod schema or plain object type)
- * @typeParam TOutput - The output schema type (Zod schema or plain object type)
+ * @example
+ * ```typescript
+ * // Get a workstation with schemas
+ * const workstation = await tela.workstation.get({
+ *   applicationId: 'app-id',
+ *   input: schema => schema.object({
+ *     query: schema.string(),
+ *   }),
+ *   output: schema => schema.object({
+ *     result: schema.string(),
+ *   }),
+ * })
+ *
+ * // Create a task
+ * const task = await workstation.createTask({ query: 'test' })
+ *
+ * // Get the result
+ * const result = await task.result
+ * ```
  */
-declare class Canvas<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord> {
+declare class Workstation<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord> {
     private readonly _id;
-    private readonly _versionId;
-    private readonly _applicationId;
-    private readonly _name;
+    private readonly _promptVersion;
+    private readonly _client;
     private readonly _input;
     private readonly _output;
-    private readonly _client;
-    private readonly _variables;
-    private readonly _isWorkflow;
-    /**
-     * Creates a new instance of the Canvas class. Usage of this constructor is not recommended.
-     * Use the `tela.getCanvas` method instead.
-     *
-     * @private
-     */
-    private constructor();
     /**
-     * Gets a canvas by its ID.
+     * Creates a new Workstation instance.
      *
-     * @param options - The options to use to get the canvas.
-     * @param options.id - The ID of the canvas to get.
-     * @param options.versionId - The version ID of the canvas to get.
-     * @param options.applicationId - The application ID of the canvas to get.
-     * @param options.client - The client to use to make the request.
-     * @param options.input - The input schema of the canvas to get.
-     * @param options.output - The output schema of the canvas to get.
-     * @returns The canvas.
+     * Use {@link Workstation.get} instead.
+     * @internal
      */
-    static get<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord>(options: CanvasGetOptions<TInput, TOutput> & {
-        client: BaseClient;
-    }): Promise<Canvas<TInput, TOutput>>;
+    constructor({ client, applicationId, promptVersion, input, output }: WorkstationOptions<TInput, TOutput>);
     /**
-     * Gets the unique identifier of this canvas.
-     *
-     * @returns The canvas ID.
+     * The unique identifier for this workstation (application ID).
      */
     get id(): string;
     /**
-     * Gets the name of this canvas, if provided.
-     *
-     * @returns The canvas name or undefined.
+     * The prompt version configuration for this workstation.
      */
-    get name(): string;
+    get promptVersion(): PromptVersion;
     /**
-     * Gets the version identifier of this canvas, if specified.
-     * When undefined, the latest promoted version is used.
+     * Retrieves a workstation by application ID and optionally validates schemas.
      *
-     * @returns The version ID or undefined.
-     */
-    get versionId(): string;
-    get applicationId(): string;
-    /**
-     * Gets the variables of this canvas.
+     * This is the recommended way to create a Workstation instance.
      *
-     * @returns The variables of the canvas.
+     * @param options - Configuration options
+     * @param options.client - The BaseClient instance for API communication
+     * @param options.applicationId - The unique ID of the workstation
+     * @param options.input - Optional input schema function
+     * @param options.output - Optional output schema function
+     * @param options.skipSchemaValidation - Whether to skip schema validation (defaults to false)
+     * @returns A promise that resolves to a Workstation instance
+     *
+     * @throws {Error} If schema validation fails (when schemas are provided and skipSchemaValidation is false)
+     *
+     * @example
+     * ```typescript
+     * const workstation = await Workstation.get({
+     *   client,
+     *   applicationId: 'app-123',
+     *   input: schema => schema.object({
+     *     query: schema.string(),
+     *   }),
+     *   output: schema => schema.object({
+     *     answer: schema.string(),
+     *   }),
+     * })
+     * ```
      */
-    get variables(): Array<CanvasVariable>;
+    static get<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRecord>(options: WorkstationGetOptions<TInput, TOutput> & {
+        client: BaseClient;
+    }): Promise<Workstation<TInput, TOutput>>;
     /**
-     * Gets whether this canvas is a workflow.
+     * Creates a new task for this workstation and returns a promise-like object.
      *
-     * @returns True if the canvas is a workflow.
+     * The returned object can be awaited directly to get the Task instance, or you can
+     * access `.result` to get the final task output directly.
+     *
+     * @param variables - Input variables for the task (must match the input schema)
+     * @param params - Optional task parameters (label, tags, skipResultValidation)
+     * @returns A promise-like object that resolves to the Task instance
+     *
+     * @example
+     * ```typescript
+     * // Get the task instance
+     * const task = await workstation.createTask({ query: 'test' })
+     *
+     * // Or get the result directly
+     * const result = await workstation.createTask({ query: 'test' }).result
+     * ```
      */
-    get isWorkflow(): boolean;
+    createTask(variables: z.input<TInput>, params?: TaskParams & {
+        skipResultValidation?: boolean;
+    }): TaskPromiseLike<TInput, TOutput>;
     /**
-     * Gets whether this canvas is a workstation.
-     * This is true if an application ID is provided.
+     * Retrieves an existing task by its ID.
      *
-     * @returns True if the canvas is a workstation.
+     * This is useful for resuming monitoring of a task that was created earlier.
+     *
+     * @param id - The task ID to retrieve
+     * @param options - Optional configuration
+     * @param options.skipResultValidation - Whether to skip output validation
+     * @returns A promise that resolves to the Task instance
+     *
+     * @example
+     * ```typescript
+     * const task = await workstation.getTask('task-id')
+     *
+     * // Set up event listeners
+     * task.on('statusChange', (status) => console.log('Status:', status))
+     * task.on('success', (result) => console.log('Result:', result))
+     *
+     * // Start polling
+     * task.poll()
+     * ```
      */
-    get isWorkstation(): boolean;
+    getTask(id: string, options?: {
+        skipResultValidation?: boolean;
+    }): Promise<Task<TInput, TOutput>>;
     /**
-     * Validates and parses input variables using the canvas input schema.
+     * Validates and parses input variables using the workstation input schema.
      *
      * @param variables - Raw input variables to validate.
      * @returns Parsed and validated variables.
@@ -1593,84 +3430,82 @@ declare class Canvas<TInput extends ZodTypeOrRecord, TOutput extends ZodTypeOrRe
      */
     private parseVariables;
     /**
-     * Executes this canvas with the provided input variables.
-     * Creates and starts a canvas execution, handling variable validation and schema parsing.
+     * Processes variables and uploads any TelaFile instances to the server.
+     * Replaces TelaFile objects with their uploaded URLs while preserving other values.
      *
-     * Returns a promise-like object that allows flexible usage patterns:
-     * - Await for the execution object: `const exec = await canvas.execute(vars)`
-     * - Direct result access: `const result = await canvas.execute(vars).result`
-     * - Stream iteration: `for await (const chunk of canvas.execute(vars, { stream: true }).result)`
+     * @returns A promise resolving to the processed variables object.
+     */
+    private resolveVariables;
+    /**
+     * Lists tasks for this workstation with optional filtering and pagination.
      *
-     * @param variables - Input variables to pass to the canvas template.
-     * @param params - Optional execution parameters (sync/async/stream configuration).
-     * @returns A promise-like object with a `result` property for direct result access.
+     * Returns a page of tasks matching the specified filters, along with metadata
+     * for pagination.
+     *
+     * @param params - Query parameters
+     * @param params.filters - Optional filters to apply (ID, name, status, dates, etc.)
+     * @param params.options - Optional pagination and sorting options
+     * @param params.rawQuery - Raw query object (internal use, overrides filters/options)
+     * @returns A promise that resolves to an object containing tasks and pagination metadata
      *
      * @example
      * ```typescript
-     * // Direct result access (recommended for simple cases)
-     * const result = await canvas.execute({ query: "Hello" }).result;
-     *
-     * // Get execution object for control (e.g., to abort)
-     * const execution = await canvas.execute({ query: "Hello" });
-     * const result = await execution.result;
-     *
-     * // Asynchronous execution with polling
-     * const result = await canvas.execute(
-     *   { query: "Hello" },
-     *   { async: true, pollingInterval: 500 }
-     * ).result;
-     *
-     * // Streaming execution
-     * for await (const chunk of canvas.execute(
-     *   { query: "Hello" },
-     *   { stream: true }
-     * ).result) {
-     *   console.log(chunk);
-     * }
+     * // Get first 10 completed tasks
+     * const { tasks, meta } = await workstation.listTasks({
+     *   filters: { status: ['completed'] },
+     *   options: { limit: 10, offset: 0 },
+     * })
      *
-     * // Execution with tags
-     * const result = await canvas.execute(
-     *   { query: "Hello" },
-     *   { tags: ["production", "analytics"] }
-     * ).result;
+     * // Sort by creation date
+     * const { tasks, meta } = await workstation.listTasks({
+     *   options: {
+     *     order: { by: 'createdAt', direction: 'desc' },
+     *     limit: 20,
+     *   },
+     * })
      * ```
      */
-    execute(variables: z.input<TInput>, params?: SyncExecutionParams): CanvasExecutionPromiseLike<SyncExecutionParams, Output<TInput>, Output<TOutput>>;
-    execute(variables: z.input<TInput>, params?: AsyncExecutionParams): CanvasExecutionPromiseLike<AsyncExecutionParams, Output<TInput>, Output<TOutput>>;
-    execute(variables: z.input<TInput>, params?: StreamExecutionParams): CanvasExecutionPromiseLike<StreamExecutionParams, Output<TInput>, Output<TOutput>>;
+    listTasks({ filters, options, rawQuery }: {
+        filters?: TaskListFilters;
+        options?: TaskListOptions;
+        rawQuery?: Record<string, any>;
+    }): Promise<{
+        tasks: Task<TInput, TOutput>[];
+        meta: TaskListMeta;
+    }>;
     /**
-     * Fetches an existing async execution by its ID.
+     * Asynchronously iterates through all tasks matching the specified filters.
      *
-     * This method retrieves the current state of an async execution that was previously
-     * started on this canvas. Only async executions can be fetched, as they are the only
-     * ones with persistent UUIDs on the server.
+     * This generator automatically handles pagination, fetching additional pages
+     * as needed. Each iteration yields a task and the current page metadata.
      *
-     * @param id - The UUID of the async execution to fetch.
-     * @param options - Optional configuration for polling behavior.
-     * @param options.pollingInterval - Time in milliseconds between polling attempts (default: 1000).
-     * @param options.pollingTimeout - Maximum time in milliseconds to wait for completion (default: 60000).
-     * @throws {InvalidExecutionModeError} If the provided ID is not a valid UUID.
-     * @returns A promise resolving to a CanvasExecution instance with the fetched state.
+     * @param params - Query parameters
+     * @param params.filters - Optional filters to apply (ID, name, status, dates, etc.)
+     * @param params.options - Optional initial pagination and sorting options
+     * @yields A tuple of [task, metadata] for each task
      *
      * @example
      * ```typescript
-     * // Start an async execution
-     * const execution = await canvas.execute({ query: 'test' }, { async: true })
-     * const executionId = execution.id
-     *
-     * // Later, fetch the execution by ID
-     * const fetched = await canvas.getExecution(executionId)
-     * console.log(fetched.status) // 'running', 'succeeded', or 'failed'
+     * // Iterate through all pending tasks
+     * for await (const [task, meta] of workstation.iterateTasks({
+     *   filters: { status: ['pending'] },
+     * })) {
+     *   console.log(`Task ${task.id}: ${task.status}`)
+     *   console.log(`Page ${meta.currentPage} of ${meta.totalPages}`)
+     * }
      *
-     * // Use poll() for event-driven progress tracking
-     * fetched.on('statusChange', (status) => console.log('Status:', status))
-     * fetched.poll()
+     * // Process tasks in batches
+     * for await (const [task, meta] of workstation.iterateTasks({
+     *   options: { limit: 50 },
+     * })) {
+     *   await processTask(task)
+     * }
      * ```
      */
-    getExecution(id: string, options?: {
-        pollingInterval?: number;
-        pollingTimeout?: number;
-    }): Promise<CanvasExecution<AsyncExecutionParams, unknown, Output<TOutput>>>;
+    iterateTasks({ filters, options }: {
+        filters?: TaskListFilters;
+        options?: TaskListOptions;
+    }): AsyncGenerator<readonly [Task<TInput, TOutput>, TaskListMeta], void, unknown>;
 }
 
 /**
@@ -1769,7 +3604,10 @@ declare class TelaSDK extends BaseClient {
      * ```
      */
     canvas: {
-        get: <TInput extends z.ZodType | Record<string, unknown> = Record<string, unknown>, TOutput extends z.ZodType | Record<string, unknown> = Record<string, unknown>>(options: CanvasGetOptions<TInput, TOutput>) => Promise<Canvas<TInput, TOutput>>;
+        get: <TInput extends z$1.ZodType | Record<string, unknown> = Record<string, unknown>, TOutput extends z$1.ZodType | Record<string, unknown> = Record<string, unknown>>(options: CanvasGetOptions<TInput, TOutput>) => Promise<Canvas<TInput, TOutput>>;
+    };
+    workstation: {
+        get: <TInput extends z$1.ZodType | Record<string, unknown> = Record<string, unknown>, TOutput extends z$1.ZodType | Record<string, unknown> = Record<string, unknown>>(options: WorkstationGetOptions<TInput, TOutput>) => Promise<Workstation<TInput, TOutput>>;
     };
     static TelaSDK: typeof TelaSDK;
     static DEFAULT_TIMEOUT: number;
@@ -1807,6 +3645,10 @@ declare class TelaSDK extends BaseClient {
     static MissingApiKeyOrJWTError: typeof MissingApiKeyOrJWTError;
     /** Thrown when both an API key and a JWT are provided. */
     static ConflictApiKeyAndJWTError: typeof ConflictApiKeyAndJWTError;
+    /** Thrown when a canvas execution fails on the server. */
+    static ExecutionFailedError: typeof ExecutionFailedError;
+    /** Thrown when a workstation task fails on the server. */
+    static TaskFailedError: typeof TaskFailedError;
 }
 /**
  * Creates a new instance of the TelaSDK.
@@ -1816,4 +3658,4 @@ declare class TelaSDK extends BaseClient {
  */
 declare function createTelaClient(opts: TelaSDKOptions): TelaSDK;
 
-export { APIError, AuthenticationError, AuthorizationError, BadRequestError, BaseClient, type BaseClientOptions, type BaseTelaFileOptions, ConflictApiKeyAndJWTError, ConflictError, ConnectionError, ConnectionTimeout, EmptyFileError, ExecutionFailedError, ExecutionNotStartedError, FileUploadError, type HTTPMethods, InternalServerError, InvalidExecutionModeError, InvalidFileURL, MissingApiKeyOrJWTError, NotFoundError, RateLimitError, type RequestOptions, type SchemaBuilder, TelaError, TelaFile, type TelaFileInput, type TelaFileOptions, type TelaFileOptionsWithMimeType, TelaFileSchema, TelaSDK, type TelaSDKOptions, UnprocessableEntityError, UserAbortError, createTelaClient, toError };
+export { APIError, AuthenticationError, AuthorizationError, BadRequestError, BaseClient, type BaseClientOptions, type BaseTelaFileOptions, BatchExecutionFailedError, ConflictApiKeyAndJWTError, ConflictError, ConnectionError, ConnectionTimeout, EmptyFileError, ExecutionFailedError, ExecutionNotStartedError, FileUploadError, type HTTPMethods, InternalServerError, InvalidExecutionModeError, InvalidFileURL, MissingApiKeyOrJWTError, NotFoundError, RateLimitError, type RequestOptions, type SchemaBuilder, TaskFailedError, TelaError, TelaFile, type TelaFileInput, type TelaFileOptions, type TelaFileOptionsWithMimeType, TelaFileSchema, TelaSDK, type TelaSDKOptions, UnprocessableEntityError, UserAbortError, createTelaClient, isTelaFile, isTelaFileArray, toError };