@meistrari/tela-sdk-js 0.0.3 → 0.0.4

package/dist/index.d.cts

@@ -0,0 +1,897 @@
+import { ReadStream } from 'node:fs';
+import { ReadableStream } from 'node:stream/web';
+
+type HTTPMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type RequestOptions<Req = unknown | Record<string, unknown>> = {
+    method?: HTTPMethods;
+    path?: string;
+    query?: Req | undefined;
+    body?: Req | null | undefined;
+    headers?: Headers | undefined;
+    maxRetries?: number;
+    stream?: boolean | undefined;
+    timeout?: number;
+    signal?: AbortSignal | undefined | null;
+};
+interface BaseClientOptions {
+    baseURL: string;
+    maxRetries?: number;
+    timeout?: number;
+}
+declare abstract class BaseClient {
+    baseURL: string;
+    maxRetries: number;
+    timeout: number;
+    fetch: typeof fetch;
+    constructor({ baseURL, maxRetries, timeout }: BaseClientOptions);
+    protected createHeaders(opts?: Record<string, string>): Headers;
+    protected getUserAgent(): string;
+    protected getAuthHeaders(): Record<string, string>;
+    get<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
+    post<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
+    put<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
+    patch<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
+    delete<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
+    private methodRequest;
+    private request;
+    private makeRequest;
+    private shouldRetry;
+    private retryRequest;
+    private calculateDefaultRetryTimeoutMillis;
+    fetchWithTimeout(url: string, _options: RequestInit, timeout: number, controller: AbortController): Promise<Response>;
+    protected buildRequest<Req>(options: RequestOptions<Req>): {
+        req: RequestInit;
+        url: string;
+        timeout: number;
+    };
+    protected buildURL<Req>(path: string, query: Req | null | undefined): string;
+    protected stringifyQuery(query: Record<string, unknown>): string;
+}
+
+declare class TelaError extends Error {
+}
+declare class ConflictApiKeyAndJWTError extends TelaError {
+    constructor();
+}
+declare class MissingApiKeyOrJWTError extends TelaError {
+    constructor();
+}
+declare class EmptyFileError extends TelaError {
+    constructor();
+}
+declare class InvalidFileURL extends TelaError {
+    constructor(url: string);
+}
+declare class FileUploadError extends TelaError {
+    constructor(message: string);
+}
+declare class APIError extends TelaError {
+    readonly statusCode: number | undefined;
+    readonly error: any;
+    constructor(statusCode: number | undefined, error: any, _message: string | undefined);
+    static from(statusCode: number, responseError: object | undefined, message: string | undefined): APIError;
+}
+declare class UserAbortError extends APIError {
+    readonly statusCode: undefined;
+    constructor({ message }?: {
+        message?: string;
+    });
+}
+declare class ConnectionError extends APIError {
+    readonly statusCode: undefined;
+    constructor({ message, cause, }: {
+        message?: string | undefined;
+        cause?: Error | undefined;
+    });
+}
+declare class ConnectionTimeout extends APIError {
+    readonly statusCode: undefined;
+    constructor({ message, }?: {
+        message?: string | undefined;
+    });
+}
+declare class BadRequestError extends APIError {
+    readonly statusCode = 400;
+}
+declare class AuthenticationError extends APIError {
+    readonly statusCode = 401;
+}
+declare class AuthorizationError extends APIError {
+    readonly statusCode = 403;
+}
+declare class NotFoundError extends APIError {
+    readonly statusCode = 404;
+}
+declare class ConflictError extends APIError {
+    readonly statusCode = 409;
+}
+declare class UnprocessableEntityError extends APIError {
+    readonly statusCode = 422;
+}
+declare class RateLimitError extends APIError {
+    readonly statusCode = 429;
+}
+declare class InternalServerError extends APIError {
+    readonly statusCode = 500;
+}
+
+/**
+ * Configuration options for `TelaFile`.
+ */
+type TelaFileOptions = {
+    /**
+     * Defines the page range of the document to be processed.
+     *
+     * Specifies the range of pages to process, starting from `startPage` to `endPage`, inclusive, 0-indexed.
+     *
+     * @example
+     * ```typescript
+     * const file = new TelaFile(fileStream, {
+     *     range: [0, 1],
+     * })
+     * ```
+     */
+    range?: [number, number];
+    /**
+     * Defines the parser provider to be used for the file.
+     */
+    parserType?: string;
+};
+/**
+ * Represents the possible types for a file input,
+ * which can be a URL string, Uint8Array, ReadableStream, ReadStream, Blob, or File.
+ */
+type TelaFileInput = string | Uint8Array | ReadableStream | ReadStream | Blob | File;
+/**
+ * Represents a file with support for various types including URLs, binary data, streams, and Blobs.
+ *
+ * @example
+ * ```typescript
+ * // Using a URL string
+ * const urlFile = new TelaFile("https://example.com/file.png", { range: { start: 0, end: 1024 } })
+ *
+ * // Using a Uint8Array (buffer)
+ * const buffer = new Uint8Array([/* binary data * /])
+ * const bufferFile = new TelaFile(buffer)
+ *
+ * // Using a ReadStream
+ * import { createReadStream } from 'fs'
+ * const readStream = createReadStream('path/to/file')
+ * const streamFile = new TelaFile(readStream)
+ *
+ * // Using a ReadableStream
+ * const readableStream = new ReadableStream({
+ *     start(controller) {
+ *         controller.enqueue(new TextEncoder().encode('Hello, world!'))
+ *         controller.close()
+ *     }
+ * })
+ * const readableStreamFile = new TelaFile(readableStream)
+ *
+ * // Using a Blob (in environments that support Blob)
+ * const blob = new Blob(['file content'], { type: 'text/plain' })
+ * const blobFile = new TelaFile(blob)
+ *
+ * // Using a File (in browser environments)
+ * const file = new File(['file content'], 'filename.txt', { type: 'text/plain' })
+ * const fileInstance = new TelaFile(file)
+ * ```
+ */
+declare class TelaFile {
+    private _file;
+    private _options;
+    private _size;
+    /**
+     * Creates an instance of `TelaFile`.
+     *
+     * @param file - The source of the file. Can be a URL string, Uint8Array, ReadableStream, ReadStream, Blob, or File.
+     * @param options - Optional configuration options such as byte range.
+     * @throws {InvalidFileURL} If the provided URL is not valid.
+     * @throws {EmptyFileError} If the provided file is empty.
+     */
+    constructor(file: string | Uint8Array | ReadableStream | ReadStream | Blob | File, options?: TelaFileOptions);
+    /**
+     * Retrieves the options provided during instantiation.
+     *
+     * @returns The `TelaFileOptions` or an empty object if none were provided.
+     */
+    get options(): TelaFileOptions;
+    /**
+     * Determines whether the file source is a valid URL.
+     *
+     * @returns `true` if the file source is a valid URL string, otherwise `false`.
+     */
+    get isURL(): boolean;
+    /**
+     * Gets the size of the file in bytes.
+     *
+     * @returns The size of the file if available, otherwise `null`.
+     */
+    get size(): number | null;
+    /**
+     * Retrieves the content of the file in a format suitable for uploading.
+     *
+     * - If the file is a URL, it returns the URL string.
+     * - If the file is a `Uint8Array`, it converts it to a `File` object.
+     * - If the file is a `ReadStream` or `ReadableStream`, it calculates the size and returns a stream.
+     *
+     * @returns A promise that resolves to the uploadable content.
+     */
+    getUploadableContent(): Promise<string | File | Blob | ReadableStream>;
+    /**
+     * Validates the provided file based on its type.
+     *
+     * @throws {InvalidFileURL} If the file is a string but not a valid URL.
+     * @throws {EmptyFileError} If the file is empty.
+     */
+    private validateFile;
+    /**
+     * Checks if the provided string is a valid URL.
+     *
+     * @param url - The URL string to validate.
+     * @returns `true` if the URL is valid, otherwise `false`.
+     */
+    private isValidURL;
+}
+/**
+ * Creates a new `TelaFile` instance from the provided file input.
+ *
+ * @param file - The file input to create a `TelaFile` instance from.
+ * @returns A new `TelaFile` instance.
+ */
+declare function createTelaFile(file: TelaFileInput, options?: TelaFileOptions): TelaFile;
+
+/**
+ * Represents a stream of items that can be asynchronously iterated over.
+ */
+declare class Stream<Item> implements AsyncIterable<Item> {
+    private iterator;
+    /**
+     * The AbortController associated with this stream.
+     */
+    controller: AbortController;
+    /**
+     * Creates a new Stream instance.
+     *
+     * @param iterator - A function that returns an AsyncIterator<Item>.
+     * @param controller - The AbortController for this stream.
+     */
+    constructor(iterator: () => AsyncIterator<Item>, controller: AbortController);
+    /**
+     * Creates a Stream from a server-sent events (SSE) Response.
+     *
+     * @param response - The Response object containing the SSE data.
+     * @param controller - The AbortController for this stream.
+     * @returns A new Stream instance.
+     * @throws {Error} If the stream is consumed more than once.
+     * @throws {APIError} If the SSE data contains an error.
+     */
+    static fromSSEResponse<Item>(response: Response, controller: AbortController): Stream<Item>;
+    /**
+     * Creates a Stream from a newline-separated ReadableStream where each item is a JSON value.
+     *
+     * @param readableStream - The ReadableStream containing newline-separated JSON data.
+     * @param controller - The AbortController for this stream.
+     * @returns A new Stream instance.
+     * @throws {Error} If the stream is consumed more than once.
+     */
+    static fromReadableStream<Item>(readableStream: ReadableStream, controller: AbortController): Stream<Item>;
+    /**
+     * Implements the AsyncIterable interface, allowing the Stream to be used in a for-await-of loop.
+     *
+     * @returns An AsyncIterator for the stream items.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<Item>;
+    /**
+     * Splits the stream into two streams which can be independently read from at different speeds.
+     *
+     * @returns A tuple containing two new Stream instances.
+     */
+    tee(): [Stream<Item>, Stream<Item>];
+    /**
+     * Converts this stream to a newline-separated ReadableStream of JSON stringified values.
+     * The resulting stream can be converted back to a Stream using `Stream.fromReadableStream()`.
+     *
+     * @returns A ReadableStream containing newline-separated JSON data.
+     */
+    toReadableStream(): ReadableStream;
+}
+
+/**
+ * Base class for all resources.
+ */
+declare class Resource {
+    protected _client: BaseClient;
+    constructor(client: BaseClient);
+}
+
+/**
+ * Manages chat completion operations.
+ *
+ * Provides methods to create chat completions, handle streaming responses,
+ * and manage file uploads associated with chat completions.
+ *
+ * @example
+ * ```typescript
+ * const tela = new TelaSDK({
+ *   apiKey: 'your-api-key',
+ * });
+ * const response = await tela.completions.create({
+ *   canvasId: "your-canvas-id",
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ * console.log(response.choices[0].message.content);
+ * ```
+ */
+declare class ChatCompletions extends Resource {
+    /**
+     * Creates a chat completion with various input options and response formats.
+     *
+     * This method supports synchronous responses, streaming responses, and webhook-based asynchronous processing.
+     *
+     * @param body - The parameters for creating a chat completion.
+     * @param opts - Additional request options.
+     * @returns A Promise that resolves to either a stream of chat completion responses,
+     *          a single chat completion response, or a webhook response, depending on the input parameters.
+     *
+     * @example
+     * ```typescript
+     * // Synchronous response
+     * const response = await tela.completions.create({
+     *   canvasId: "your-canvas-id",
+     *   messages: [{ role: "user", content: "Tell me a joke." }],
+     * });
+     *
+     * // Streaming response
+     * const stream = await tela.completions.create({
+     *   canvasId: "your-canvas-id",
+     *   messages: [{ role: "user", content: "Tell me a story." }],
+     *   stream: true,
+     * });
+     *
+     * // Webhook response
+     * const webhookResponse = await tela.completions.create({
+     *   canvasId: "your-canvas-id",
+     *   messages: [{ role: "user", content: "Generate a report." }],
+     *   webhookUrl: "https://example.com/webhook",
+     * });
+     * ```
+     */
+    create<Variables = ChatCompletionVariables, CompletionContent = string>(body: ChatCompletionCreateWebhookParams<Variables>, opts?: RequestOptions<ChatCompletionCreateParams<Variables>>): Promise<ChatCompletionWebhookResponse<CompletionContent>>;
+    create<Variables = ChatCompletionVariables, CompletionContent = string>(body: CompletionCreateParamsNonStreaming<Variables>, opts?: RequestOptions<ChatCompletionCreateParams<Variables>>): Promise<ChatCompletionCreateResponse<CompletionContent>>;
+    create<Variables = ChatCompletionVariables, CompletionContent = string>(body: CompletionCreateParamsStreaming<Variables>, opts?: RequestOptions<ChatCompletionCreateParams<Variables>>): Promise<Stream<ChatCompletionCreateStreamingResponse<CompletionContent>>>;
+    create<Variables = ChatCompletionVariables, CompletionContent = string>(body: ChatCompletionCreateParamsBase<Variables>, opts?: RequestOptions<ChatCompletionCreateParams<Variables>>): Promise<Stream<ChatCompletionCreateStreamingResponse<CompletionContent>> | ChatCompletionCreateResponse<CompletionContent> | ChatCompletionWebhookResponse<CompletionContent>>;
+    /**
+     * Uploads a file and returns its URL and options.
+     *
+     * This is used internally to handle file uploads associated with chat completions.
+     *
+     * @param file - The TelaFile to be uploaded.
+     * @returns A Promise that resolves to an object containing the file URL and options.
+     * @throws {FileUploadError} If the file upload fails.
+     *
+     * @example
+     * ```typescript
+     * const file = new TelaFile({ /* file options *\/ });
+     * const uploadedFile = await this.uploadFile(file);
+     * console.log(uploadedFile.file_url);
+     * ```
+     */
+    private uploadFile;
+}
+type ChatCompletionVariablesValue = string | number | boolean | TelaFile;
+/**
+ * Represents the variables available in the canvas.
+ * Keys are strings, and values can be strings, numbers, booleans, or TelaFile instances.
+ */
+type ChatCompletionVariables = Record<string, ChatCompletionVariablesValue>;
+/**
+ * Represents the processed variables with file URLs.
+ * Similar to ChatCompletionVariables, but TelaFile instances are replaced with their URLs.
+ */
+type ChatCompletionVariablesWithFileURL = Record<string, string | number | boolean | {
+    fileUrl: string;
+}>;
+/**
+ * Base parameters for creating a chat completion.
+ */
+interface ChatCompletionCreateParamsBase<Variables = ChatCompletionVariables> {
+    /**
+     * The version ID of the canvas to use for this chat completion.
+     * If not provided, the latest version of the specified canvas will be used.
+     */
+    versionId?: string;
+    /**
+     * The ID of the canvas to use for this chat completion.
+     * This is required if an applicationId is not provided.
+     */
+    canvasId?: string;
+    /**
+     * The ID of the deployed application to use for this chat completion.
+     * This is required if a canvasId is not provided.
+     */
+    applicationId?: string;
+    /**
+     * The URL to receive a webhook notification when the chat completion is finished.
+     * If provided, the completion will be processed asynchronously.
+     */
+    webhookUrl?: string | null | undefined;
+    /**
+     * Variables to be passed to the canvas for this chat completion.
+     * These can be used to customize the behavior of the canvas for this specific request.
+     */
+    variables?: Variables;
+    /**
+     * An array of previous messages in the conversation.
+     * Each message should have a 'role' (e.g., 'user', 'assistant') and 'content'.
+     */
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    /**
+     * Override default settings specified in the canvas.
+     * This allows for fine-tuning the completion behavior for this specific request.
+     */
+    override?: {
+        /**
+         * The specific model to use for this completion.
+         * If not specified, the default model set in the canvas will be used.
+         */
+        model?: string;
+        /**
+         * Controls randomness in the output. Values between 0 and 1.
+         * Lower values make the output more focused and deterministic.
+         */
+        temperature?: number;
+        /**
+         * Specifies whether to use a chat or completion model.
+         */
+        type: 'chat' | 'completion';
+        /**
+         * An array of functions that the model can call.
+         * This allows for more structured and interactive completions.
+         */
+        functions?: Array<{
+            id: string;
+            name: string;
+            description?: string;
+            parameters?: {
+                type: 'object';
+                properties: Record<string, unknown>;
+                required?: string[];
+            };
+        }>;
+        /**
+         * Configuration for generating structured output.
+         */
+        structuredOutput?: {
+            /**
+             * Whether to enable structured output for this completion.
+             */
+            enabled: boolean;
+            /**
+             * The schema defining the structure of the output.
+             * This is used when structured output is enabled.
+             */
+            schema?: {
+                properties: Record<string, unknown>;
+                type: 'object';
+                title: string;
+                description: string;
+                required: string[];
+            };
+        };
+    };
+}
+/**
+ * Parameters for creating a streaming chat completion.
+ */
+interface CompletionCreateParamsStreaming<T> extends ChatCompletionCreateParamsBase<T> {
+    /**
+     * Whether the response should be streamed.
+     */
+    stream: true;
+    /**
+     * The webhook URL, if you want to receive a webhook when the completion is completed.
+     */
+    webhookUrl?: undefined | null;
+}
+/**
+ * Parameters for creating a non-streaming chat completion.
+ */
+interface CompletionCreateParamsNonStreaming<T> extends ChatCompletionCreateParamsBase<T> {
+    /**
+     * Whether the response should be streamed.
+     */
+    stream?: false | undefined | null;
+}
+/**
+ * Parameters for creating a chat completion with a webhook.
+ */
+interface ChatCompletionCreateWebhookParams<T> extends CompletionCreateParamsNonStreaming<T> {
+    /**
+     * The webhook URL, if you want to receive a webhook when the completion is completed.
+     */
+    webhookUrl: string;
+}
+/**
+ * Union type for all possible chat completion creation parameters.
+ */
+type ChatCompletionCreateParams<T> = CompletionCreateParamsStreaming<T> | CompletionCreateParamsNonStreaming<T> | ChatCompletionCreateWebhookParams<T>;
+/**
+ * Response structure for a created chat completion.
+ */
+type ChatCompletionCreateResponse<T> = {
+    /**
+     * The ID of the completion.
+     */
+    id: string;
+    /**
+     * The object of the completion.
+     */
+    object: string;
+    /**
+     * The created time of the completion.
+     */
+    created: number;
+    /**
+     * The choices of the completion.
+     */
+    choices: Array<{
+        message: {
+            role: string;
+            content: T;
+        };
+    }>;
+};
+/**
+ * Response structure for a chat completion streaming response.
+ */
+type ChatCompletionCreateStreamingResponse<T> = {
+    /**
+     * The ID of the completion.
+     */
+    id: string;
+    /**
+     * The object of the completion.
+     */
+    object: string;
+    /**
+     * The created time of the completion.
+     */
+    created: number;
+    /**
+     * The model of the completion.
+     */
+    model: string;
+    /**
+     * The choices of the completion.
+     */
+    choices: Array<{
+        delta: {
+            role: string | null;
+            content: string | null;
+            functionCall: {
+                name: string | null;
+                arguments: string | null;
+            } | null;
+        };
+        finishReason: string | null;
+        index: number;
+        logprobs: number | null;
+    }>;
+    /**
+     * The message of the completion.
+     */
+    message: {
+        role: string;
+        content: string | null;
+        functionCall: {
+            name: string | null;
+            arguments: string | null;
+        } | null;
+        toolCalls: Array<{
+            name: string;
+            arguments: string;
+        }>;
+        structuredContent: T;
+    };
+};
+/**
+ * Response structure for a chat completion webhook.
+ * This interface represents the data sent to the webhook URL when a chat completion is finished.
+ */
+interface ChatCompletionWebhookResponse<T> {
+    /**
+     * Unique identifier for this chat completion response.
+     */
+    id: string;
+    /**
+     * The current status of the chat completion.
+     * - 'created': The request has been received but processing hasn't started.
+     * - 'running': The chat completion is currently being processed.
+     * - 'succeeded': The chat completion has finished successfully.
+     * - 'failed': The chat completion encountered an error and couldn't complete.
+     */
+    status: 'created' | 'failed' | 'running' | 'succeeded';
+    /**
+     * Contains information about the input provided for this chat completion.
+     */
+    inputContent: {
+        /**
+         * Variables passed to the chat completion, including any file URLs.
+         */
+        variables: ChatCompletionVariablesWithFileURL;
+        /**
+         * Array of messages that were part of the input.
+         */
+        messages: Array<{
+            /**
+             * The role of the message sender (e.g., 'user', 'assistant', 'system').
+             */
+            role: string;
+            /**
+             * The content of the message. Can be a string for text messages,
+             * or an object for more complex content types like images.
+             */
+            content: string | {
+                type: 'text';
+                text: string;
+            } | {
+                type: 'image_url';
+                imageUrl: {
+                    url: string;
+                    detail?: 'auto' | 'high' | 'low';
+                };
+            };
+            /**
+             * Optional. Information about a function call, if applicable.
+             */
+            functionCall?: {
+                name: string;
+                arguments: string;
+            };
+        }>;
+        /**
+         * Information about files used in the chat completion.
+         */
+        files: Array<{
+            name: string;
+            usedAt: 'variables' | 'messages';
+            parsedContent: string;
+            url: string;
+            type: 'image' | 'file';
+        }>;
+    };
+    /**
+     * Contains the output generated by the chat completion.
+     */
+    outputContent: {
+        /**
+         * The role of the entity providing the output.
+         */
+        role: 'system' | 'user' | 'assistant' | 'function';
+        /**
+         * Optional. Information about tool calls made during the completion.
+         */
+        toolCalls?: Array<{
+            name: string;
+            arguments: string;
+        }>;
+        /**
+         * Optional. Additional information about the completion process.
+         */
+        information?: {
+            duration: number;
+            cost?: number;
+            inputTokens?: number;
+            outputTokens?: number;
+        };
+        /**
+         * Indicates whether the output has a structured format.
+         */
+        hasStructuredOutput?: boolean;
+        /**
+         * The main content of the chat completion output.
+         */
+        content: T;
+        /**
+         * Optional. The input messages in a string format.
+         */
+        inputMessages?: string | undefined;
+    };
+    /**
+     * The original input parameters provided for this chat completion.
+     */
+    rawInput: {
+        versionId?: string;
+        canvasId?: string;
+        applicationId?: string;
+        webhookUrl?: string;
+        variables?: ChatCompletionVariablesWithFileURL;
+        messages?: Array<{
+            role: string;
+            content: string | {
+                type: 'text';
+                text: string;
+            } | {
+                type: 'image_url';
+                imageUrl: {
+                    url: string;
+                    detail?: 'auto' | 'high' | 'low';
+                };
+            };
+        }>;
+        override?: {
+            model?: string;
+            temperature?: number;
+            type: 'chat' | 'completion';
+            functions?: Array<{
+                id: string;
+                name: string;
+                description?: string;
+                parameters?: {
+                    type: 'object';
+                    properties: Record<string, unknown>;
+                    required?: string[];
+                };
+            }>;
+            structuredOutput?: {
+                enabled: boolean;
+                schema?: {
+                    properties: Record<string, unknown>;
+                    type: 'object';
+                    title: string;
+                    description: string;
+                    required: string[];
+                };
+            };
+        };
+    } | null;
+    /**
+     * The raw output from the chat completion process.
+     */
+    rawOutput: Record<string, unknown>;
+    /**
+     * The date used for compatibility checks.
+     */
+    compatibilityDate: Date;
+    /**
+     * The ID of the prompt version used for this chat completion.
+     */
+    promptVersionId: string;
+    /**
+     * The ID of the prompt application, if applicable.
+     */
+    promptApplicationId: string | null;
+    /**
+     * The ID of the workspace where this chat completion was executed.
+     */
+    workspaceId: string;
+    /**
+     * The timestamp when this chat completion was created.
+     */
+    createdAt: string;
+    /**
+     * The timestamp when this chat completion was last updated.
+     */
+    updatedAt: string;
+    /**
+     * The timestamp when this chat completion was deleted, if applicable.
+     */
+    deletedAt: string | null;
+}
+
+/**
+ * Configuration options for the TelaSDK.
+ *
+ * @property {string} [apiKey] - The API key for authentication. Required if `jwt` is not provided.
+ * @property {string} [jwt] - The JWT token for authentication. Required if `apiKey` is not provided.
+ * @property {string} [baseURL] - The base URL for the Tela API. Defaults to 'https://api.tela.com'.
+ */
+interface TelaSDKOptions extends Omit<BaseClientOptions, 'baseURL'> {
+    /**
+     * The API key for authentication. Required if `jwt` is not provided.
+     */
+    apiKey?: string;
+    /**
+     * The JWT token for authentication. Required if `apiKey` is not provided.
+     */
+    jwt?: string;
+    /**
+     * The base URL for the Tela API. Defaults to 'https://api.tela.com'.
+     */
+    baseURL?: string;
+}
+/**
+ * The main class for interacting with the Tela API.
+ *
+ * Provides methods to access various Tela API resources.
+ *
+ * @example
+ * ```typescript
+ * const tela = new TelaSDK({ apiKey: 'your-api-key' });
+ * const completion = await tela.completions.create({
+ *   canvasId: "your-canvas-id",
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ * ```
+ */
+declare class TelaSDK extends BaseClient {
+    private opts;
+    private apiKey;
+    private jwt;
+    /**
+     * Creates a new instance of the TelaSDK.
+     */
+    constructor({ baseURL, apiKey, jwt, ...rest }: TelaSDKOptions);
+    private validateAuth;
+    protected getAuthHeaders(): Record<string, string>;
+    /**
+     * The ChatCompletions resource for interacting with Tela's chat completion API.
+     *
+     * Use this to generate chat completions based on provided messages.
+     *
+     * @example
+     * ```typescript
+     * const completion = await tela.completions.create({
+     *   canvasId: "your-canvas-id",
+     *   messages: [{ role: "user", content: "Hello!" }],
+     * });
+     * ```
+     */
+    completions: ChatCompletions;
+    /**
+     * Creates a new `TelaFile` instance from the provided file input.
+     *
+     * @param file - The file input to create a `TelaFile` instance from.
+     * @returns A new `TelaFile` instance.
+     */
+    createFile: typeof createTelaFile;
+    static TelaSDK: typeof TelaSDK;
+    static DEFAULT_TIMEOUT: number;
+    /** Thrown when an API request fails. */
+    static APIError: typeof APIError;
+    /** Thrown when a request is aborted by the user. */
+    static UserAbortError: typeof UserAbortError;
+    /** Thrown when there's a network connection error. */
+    static ConnectionError: typeof ConnectionError;
+    /** Thrown when a request times out. */
+    static ConnectionTimeout: typeof ConnectionTimeout;
+    /** Thrown when the API returns a 400 Bad Request error. */
+    static BadRequestError: typeof BadRequestError;
+    /** Thrown when authentication fails (e.g., invalid API key). */
+    static AuthenticationError: typeof AuthenticationError;
+    /** Thrown when the authenticated user doesn't have permission for the requested operation. */
+    static AuthorizationError: typeof AuthorizationError;
+    /** Thrown when the requested resource is not found. */
+    static NotFoundError: typeof NotFoundError;
+    /** Thrown when there's a conflict with the current state of the resource. */
+    static ConflictError: typeof ConflictError;
+    /** Thrown when the request is well-formed but unable to be processed due to semantic errors. */
+    static UnprocessableEntityError: typeof UnprocessableEntityError;
+    /** Thrown when the API rate limit is exceeded. */
+    static RateLimitError: typeof RateLimitError;
+    /** Thrown when an unexpected server error occurs. */
+    static InternalServerError: typeof InternalServerError;
+    /** Thrown when attempting to upload an empty file. */
+    static EmptyFileError: typeof EmptyFileError;
+    /** Thrown when an invalid file URL is provided. */
+    static InvalidFileURL: typeof InvalidFileURL;
+    /** Thrown when there's an error during file upload. */
+    static FileUploadError: typeof FileUploadError;
+    /** Thrown when neither an API key nor a JWT is provided. */
+    static MissingApiKeyOrJWTError: typeof MissingApiKeyOrJWTError;
+    /** Thrown when both an API key and a JWT are provided. */
+    static ConflictApiKeyAndJWTError: typeof ConflictApiKeyAndJWTError;
+}
+/**
+ * Creates a new instance of the TelaSDK.
+ *
+ * @param opts - The options for configuring the TelaSDK.
+ * @returns A new instance of the TelaSDK.
+ */
+declare function createTelaClient(opts: TelaSDKOptions): TelaSDK;
+
+export { TelaFile, TelaSDK, type TelaSDKOptions, createTelaClient };