@anyway-sh/node-server-sdk 0.22.8

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Traceloop Node Server SDK
+ *
+ * For the full documentation, visit the {@link https://traceloop.com/docs/js-sdk | Traceloop Docs}.
+ *
+ * @packageDocumentation
+ */
+export * from "./lib/node-server-sdk";
+export * from "./lib/images";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/associations/associations.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Standard association properties for tracing.
+ * Use these with withAssociationProperties() or decorator associationProperties config.
+ *
+ * @example
+ * ```typescript
+ * // With withAssociationProperties
+ * await traceloop.withAssociationProperties(
+ *   {
+ *     [traceloop.AssociationProperty.USER_ID]: "12345",
+ *     [traceloop.AssociationProperty.SESSION_ID]: "session-abc"
+ *   },
+ *   async () => {
+ *     await chat();
+ *   }
+ * );
+ *
+ * // With decorator
+ * @traceloop.workflow((thisArg) => ({
+ *   name: "my_workflow",
+ *   associationProperties: {
+ *     [traceloop.AssociationProperty.USER_ID]: (thisArg as MyClass).userId,
+ *   },
+ * }))
+ * ```
+ */
+export declare enum AssociationProperty {
+    CUSTOMER_ID = "customer_id",
+    USER_ID = "user_id",
+    SESSION_ID = "session_id"
+}
+//# sourceMappingURL=associations.d.ts.map

package/dist/src/lib/client/annotation/base-annotation.d.ts

@@ -0,0 +1,20 @@
+import { TraceloopClient } from "../traceloop-client";
+import { AnnotationCreateOptions } from "../../interfaces/annotations.interface";
+export type AnnotationFlow = "user_feedback";
+/**
+ * Base class for handling annotation operations with the Traceloop API.
+ * @internal
+ */
+export declare class BaseAnnotation {
+    protected client: TraceloopClient;
+    protected flow: AnnotationFlow;
+    constructor(client: TraceloopClient, flow: AnnotationFlow);
+    /**
+     * Creates a new annotation.
+     *
+     * @param options - The annotation creation options
+     * @returns Promise resolving to the fetch Response
+     */
+    create(options: AnnotationCreateOptions): Promise<Response>;
+}
+//# sourceMappingURL=base-annotation.d.ts.map

package/dist/src/lib/client/annotation/user-feedback.d.ts

@@ -0,0 +1,32 @@
+import { BaseAnnotation } from "./base-annotation";
+import { TraceloopClient } from "../traceloop-client";
+import { AnnotationCreateOptions } from "../../interfaces/annotations.interface";
+/**
+ * Handles user feedback annotations with the Traceloop API.
+ */
+export declare class UserFeedback extends BaseAnnotation {
+    constructor(client: TraceloopClient);
+    /**
+     * Creates a new annotation for a specific task and entity.
+     *
+     * @param options - The options for creating an annotation
+     * @returns Promise resolving to the fetch Response
+     *
+     * @example
+     * ```typescript
+     * await client.annotation.create({
+     *   annotationTask: 'sample-annotation-task',
+     *   entity: {
+     *     id: '123456',
+     *   },
+     *   tags: {
+     *     sentiment: 'positive',
+     *     score: 0.85,
+     *     tones: ['happy', 'surprised']
+     *   }
+     * });
+     * ```
+     */
+    create(options: AnnotationCreateOptions): Promise<Response>;
+}
+//# sourceMappingURL=user-feedback.d.ts.map

package/dist/src/lib/client/dataset/attachment-uploader.d.ts

@@ -0,0 +1,50 @@
+import { TraceloopClient } from "../traceloop-client";
+import { Attachment, ExternalAttachment, AttachmentReference, FileCellType, AttachmentMetadata } from "./attachment";
+/**
+ * Response from the upload URL endpoint
+ */
+export interface UploadUrlResponse {
+    uploadUrl: string;
+    storageKey: string;
+    expiresAt?: string;
+    method?: string;
+}
+/**
+ * Handles attachment upload and registration operations
+ */
+export declare class AttachmentUploader {
+    private client;
+    constructor(client: TraceloopClient);
+    /**
+     * Requests a presigned upload URL from the API
+     */
+    getUploadUrl(datasetSlug: string, rowId: string, columnSlug: string, fileName: string, contentType: string, fileType: FileCellType, metadata?: AttachmentMetadata): Promise<UploadUrlResponse>;
+    /**
+     * Uploads file data directly to S3 using the presigned URL
+     */
+    uploadToS3(uploadUrl: string, data: Buffer, contentType: string): Promise<void>;
+    /**
+     * Confirms the upload status with the API
+     */
+    confirmUpload(datasetSlug: string, rowId: string, columnSlug: string, status: "success" | "failed", metadata?: AttachmentMetadata): Promise<void>;
+    /**
+     * Registers an external URL as an attachment
+     */
+    registerExternalUrl(datasetSlug: string, rowId: string, columnSlug: string, url: string, fileType: FileCellType, metadata?: AttachmentMetadata): Promise<AttachmentReference>;
+    /**
+     * Uploads an Attachment through the full flow:
+     * 1. Get presigned URL
+     * 2. Upload to S3
+     * 3. Confirm upload
+     */
+    uploadAttachment(datasetSlug: string, rowId: string, columnSlug: string, attachment: Attachment): Promise<AttachmentReference>;
+    /**
+     * Processes an ExternalAttachment by registering the URL
+     */
+    processExternalAttachment(datasetSlug: string, rowId: string, columnSlug: string, attachment: ExternalAttachment): Promise<AttachmentReference>;
+    /**
+     * Processes any attachment type (Attachment or ExternalAttachment)
+     */
+    processAnyAttachment(datasetSlug: string, rowId: string, columnSlug: string, attachmentObj: Attachment | ExternalAttachment): Promise<AttachmentReference>;
+}
+//# sourceMappingURL=attachment-uploader.d.ts.map

package/dist/src/lib/client/dataset/attachment.d.ts

@@ -0,0 +1,84 @@
+export type FileCellType = "image" | "video" | "audio" | "file";
+export type FileStorageType = "internal" | "external";
+export interface AttachmentMetadata {
+    [key: string]: string | number | boolean;
+}
+export interface AttachmentOptions {
+    filePath?: string;
+    data?: Buffer | Uint8Array;
+    filename?: string;
+    contentType?: string;
+    fileType?: FileCellType;
+    metadata?: AttachmentMetadata;
+}
+export declare class Attachment {
+    readonly type: "attachment";
+    private _filePath?;
+    private _data?;
+    private _filename?;
+    private _contentType?;
+    private _fileType?;
+    private _metadata?;
+    constructor(options: AttachmentOptions);
+    getData(): Promise<Buffer>;
+    getFileName(): string;
+    getContentType(): string;
+    get fileType(): FileCellType;
+    get metadata(): AttachmentMetadata | undefined;
+}
+export interface ExternalAttachmentOptions {
+    url: string;
+    filename?: string;
+    contentType?: string;
+    fileType?: FileCellType;
+    metadata?: AttachmentMetadata;
+}
+export declare class ExternalAttachment {
+    readonly type: "external";
+    private _url;
+    private _filename?;
+    private _contentType?;
+    private _fileType;
+    private _metadata?;
+    constructor(options: ExternalAttachmentOptions);
+    get url(): string;
+    get filename(): string | undefined;
+    get contentType(): string | undefined;
+    get fileType(): FileCellType;
+    get metadata(): AttachmentMetadata | undefined;
+}
+export declare class AttachmentReference {
+    readonly storageType: FileStorageType;
+    readonly storageKey: string;
+    readonly url: string | undefined;
+    readonly fileType: FileCellType;
+    readonly metadata?: AttachmentMetadata | undefined;
+    constructor(storageType: FileStorageType, storageKey: string, url: string | undefined, fileType: FileCellType, metadata?: AttachmentMetadata | undefined);
+    download(filePath?: string): Promise<Buffer | void>;
+    getUrl(): string | undefined;
+    toJSON(): Record<string, unknown>;
+}
+export declare function isAttachment(value: unknown): value is Attachment;
+export declare function isExternalAttachment(value: unknown): value is ExternalAttachment;
+export declare function isAttachmentReference(value: unknown): value is AttachmentReference;
+export declare function isAnyAttachment(value: unknown): value is Attachment | ExternalAttachment;
+export declare const attachment: {
+    file: (filePath: string, options?: {
+        filename?: string;
+        contentType?: string;
+        fileType?: FileCellType;
+        metadata?: AttachmentMetadata;
+    }) => Attachment;
+    buffer: (data: Buffer | Uint8Array, filename: string, options?: {
+        contentType?: string;
+        fileType?: FileCellType;
+        metadata?: AttachmentMetadata;
+    }) => Attachment;
+    url: (url: string, options?: {
+        filename?: string;
+        contentType?: string;
+        fileType?: FileCellType;
+        metadata?: AttachmentMetadata;
+    }) => ExternalAttachment;
+};
+//# sourceMappingURL=attachment.d.ts.map

package/dist/src/lib/client/dataset/base-dataset.d.ts

@@ -0,0 +1,10 @@
+import { TraceloopClient } from "../traceloop-client";
+export declare abstract class BaseDatasetEntity {
+    protected client: TraceloopClient;
+    constructor(client: TraceloopClient);
+    protected handleResponse(response: Response): Promise<any>;
+    protected validateDatasetId(id: string): void;
+    protected validateDatasetSlug(slug: string): void;
+    protected validateDatasetName(name: string): void;
+}
+//# sourceMappingURL=base-dataset.d.ts.map

package/dist/src/lib/client/dataset/column.d.ts

@@ -0,0 +1,23 @@
+import { TraceloopClient } from "../traceloop-client";
+import { BaseDatasetEntity } from "./base-dataset";
+import { ColumnResponse, ColumnUpdateOptions, DatasetColumnValue } from "../../interfaces";
+export declare class Column extends BaseDatasetEntity {
+    private _data;
+    private _deleted;
+    constructor(client: TraceloopClient, data: ColumnResponse);
+    get slug(): string;
+    get name(): string;
+    get type(): "string" | "number" | "boolean" | "date" | "file";
+    get required(): boolean;
+    get description(): string | undefined;
+    get datasetId(): string;
+    get datasetSlug(): string;
+    get createdAt(): string;
+    get updatedAt(): string;
+    get deleted(): boolean;
+    update(options: ColumnUpdateOptions): Promise<void>;
+    delete(): Promise<void>;
+    validateValue(value: DatasetColumnValue): boolean;
+    convertValue(value: unknown): DatasetColumnValue;
+}
+//# sourceMappingURL=column.d.ts.map

package/dist/src/lib/client/dataset/dataset.d.ts

@@ -0,0 +1,43 @@
+import { TraceloopClient } from "../traceloop-client";
+import { BaseDatasetEntity } from "./base-dataset";
+import { Row } from "./row";
+import { Column } from "./column";
+import { DatasetResponse, DatasetUpdateOptions, ColumnDefinition, RowData, DatasetPublishOptions, CSVImportOptions, DatasetVersionsResponse, DatasetVersion } from "../../interfaces";
+export declare class Dataset extends BaseDatasetEntity {
+    private _data;
+    private _deleted;
+    private _attachmentUploader;
+    constructor(client: TraceloopClient, data: DatasetResponse);
+    get id(): string;
+    get slug(): string;
+    get name(): string;
+    get description(): string | undefined;
+    get version(): string | undefined;
+    get published(): boolean;
+    get createdAt(): string;
+    get updatedAt(): string;
+    get deleted(): boolean;
+    update(options: DatasetUpdateOptions): Promise<void>;
+    delete(): Promise<void>;
+    publish(options?: DatasetPublishOptions): Promise<void>;
+    addColumn(columns: ColumnDefinition[]): Promise<Column[]>;
+    getColumns(): Promise<Column[]>;
+    addRow(rowData: RowData): Promise<Row>;
+    addRows(rows: RowData[]): Promise<Row[]>;
+    /**
+     * Extracts attachments from rows and returns clean rows with null values
+     */
+    private extractAttachments;
+    /**
+     * Processes attachments for created rows
+     */
+    private processAttachments;
+    private transformValuesBackToNames;
+    getRows(limit?: number, offset?: number): Promise<Row[]>;
+    fromCSV(csvContent: string, options?: CSVImportOptions): Promise<void>;
+    getVersions(): Promise<DatasetVersionsResponse>;
+    getVersion(version: string): Promise<DatasetVersion | null>;
+    private parseCSV;
+    private parseValue;
+}
+//# sourceMappingURL=dataset.d.ts.map

package/dist/src/lib/client/dataset/datasets.d.ts

@@ -0,0 +1,14 @@
+import { TraceloopClient } from "../traceloop-client";
+import { BaseDatasetEntity } from "./base-dataset";
+import { Dataset } from "./dataset";
+import { DatasetCreateOptions, DatasetListResponse } from "../../interfaces";
+export declare class Datasets extends BaseDatasetEntity {
+    constructor(client: TraceloopClient);
+    create(options: DatasetCreateOptions): Promise<Dataset>;
+    get(slug: string): Promise<Dataset>;
+    list(): Promise<DatasetListResponse>;
+    delete(slug: string): Promise<void>;
+    getVersionCSV(slug: string, version: string): Promise<string>;
+    getVersionAsJsonl(slug: string, version: string): Promise<string>;
+}
+//# sourceMappingURL=datasets.d.ts.map

package/dist/src/lib/client/dataset/index.d.ts

@@ -0,0 +1,8 @@
+export { BaseDatasetEntity as BaseDataset } from "./base-dataset";
+export { Dataset } from "./dataset";
+export { Datasets } from "./datasets";
+export { Column } from "./column";
+export { Row } from "./row";
+export { Attachment, ExternalAttachment, AttachmentReference, attachment, isAttachment, isExternalAttachment, isAttachmentReference, isAnyAttachment, FileCellType, FileStorageType, AttachmentMetadata, AttachmentOptions, ExternalAttachmentOptions, } from "./attachment";
+export { AttachmentUploader, UploadUrlResponse } from "./attachment-uploader";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/client/dataset/row.d.ts

@@ -0,0 +1,73 @@
+import { TraceloopClient } from "../traceloop-client";
+import { BaseDatasetEntity } from "./base-dataset";
+import { RowResponse, RowData, RowUpdateOptions } from "../../interfaces";
+import { Attachment, ExternalAttachment, AttachmentReference } from "./attachment";
+export declare class Row extends BaseDatasetEntity {
+    private _data;
+    private _deleted;
+    constructor(client: TraceloopClient, data: RowResponse);
+    get id(): string;
+    get datasetId(): string;
+    get datasetSlug(): string;
+    get data(): RowData;
+    get createdAt(): string;
+    get updatedAt(): string;
+    get deleted(): boolean;
+    getValue(columnName: string): string | number | boolean | Date | null | object;
+    hasColumn(columnName: string): boolean;
+    getColumns(): string[];
+    update(options: RowUpdateOptions): Promise<void>;
+    partialUpdate(updates: Partial<RowData>): Promise<void>;
+    delete(): Promise<void>;
+    toJSON(): RowData;
+    toCSVRow(columns?: string[], delimiter?: string): string;
+    validate(columnValidators?: {
+        [columnName: string]: (value: any) => boolean;
+    }): {
+        valid: boolean;
+        errors: string[];
+    };
+    clone(): Row;
+    /**
+     * Gets an attachment reference from a column
+     * @param columnName The name of the column containing the attachment
+     * @returns AttachmentReference if the column contains an attachment, null otherwise
+     */
+    getAttachment(columnName: string): AttachmentReference | null;
+    /**
+     * Checks if a column contains an attachment
+     * @param columnName The name of the column to check
+     */
+    hasAttachment(columnName: string): boolean;
+    /**
+     * Sets/uploads an attachment to a column
+     * @param columnSlug The slug of the column to set the attachment in
+     * @param attachment The attachment to upload (Attachment or ExternalAttachment)
+     * @returns The created AttachmentReference
+     *
+     * @example
+     * // Upload from file
+     * await row.setAttachment("image", new Attachment({ filePath: "./photo.jpg" }));
+     *
+     * @example
+     * // Set external URL
+     * await row.setAttachment("document", new ExternalAttachment({ url: "https://example.com/doc.pdf" }));
+     */
+    setAttachment(columnSlug: string, attachment: Attachment | ExternalAttachment): Promise<AttachmentReference>;
+    /**
+     * Downloads an attachment from a column
+     * @param columnName The name of the column containing the attachment
+     * @param outputPath Optional file path to save the downloaded file
+     * @returns Buffer if no outputPath provided, void if saved to file
+     *
+     * @example
+     * // Get as buffer
+     * const data = await row.downloadAttachment("image");
+     *
+     * @example
+     * // Save to file
+     * await row.downloadAttachment("image", "./downloaded-image.png");
+     */
+    downloadAttachment(columnName: string, outputPath?: string): Promise<Buffer | void>;
+}
+//# sourceMappingURL=row.d.ts.map

package/dist/src/lib/client/evaluator/evaluator.d.ts

@@ -0,0 +1,28 @@
+import { TraceloopClient } from "../traceloop-client";
+import { BaseDatasetEntity } from "../dataset/base-dataset";
+import type { EvaluatorRunOptions, TriggerEvaluatorRequest, TriggerEvaluatorResponse } from "../../interfaces/evaluator.interface";
+import type { ExecutionResponse } from "../../interfaces/experiment.interface";
+export declare class Evaluator extends BaseDatasetEntity {
+    constructor(client: TraceloopClient);
+    /**
+     * Run evaluators on experiment task results and wait for completion
+     */
+    runExperimentEvaluator(options: EvaluatorRunOptions): Promise<ExecutionResponse[]>;
+    /**
+     * Trigger evaluator execution without waiting for results
+     */
+    triggerExperimentEvaluator(request: TriggerEvaluatorRequest): Promise<TriggerEvaluatorResponse>;
+    /**
+     * Wait for execution result via stream URL (actually JSON endpoint)
+     */
+    waitForResult(executionId: string, streamUrl: string): Promise<ExecutionResponse[]>;
+    /**
+     * Validate evaluator run options
+     */
+    private validateEvaluatorOptions;
+    /**
+     * Create InputSchemaMapping from input object
+     */
+    private createInputSchemaMapping;
+}
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/src/lib/client/evaluator/index.d.ts

@@ -0,0 +1,2 @@
+export { Evaluator } from "./evaluator";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/client/experiment/experiment.d.ts

@@ -0,0 +1,76 @@
+import { TraceloopClient } from "../traceloop-client";
+import type { ExperimentTaskFunction, ExperimentRunOptions, ExperimentRunResult, InitExperimentRequest, ExperimentInitResponse, CreateTaskResponse, RunInGithubOptions, RunInGithubResponse } from "../../interfaces/experiment.interface";
+export declare class Experiment {
+    private client;
+    private evaluator;
+    private datasets;
+    private _lastExperimentSlug?;
+    private _lastRunId?;
+    constructor(client: TraceloopClient);
+    /**
+     * Generate a unique experiment slug
+     */
+    private generateExperimentSlug;
+    private handleResponse;
+    /**
+     * Run an experiment with the given task function and options
+     */
+    run<TInput, TOutput>(task: ExperimentTaskFunction<TInput, TOutput>, options?: ExperimentRunOptions | RunInGithubOptions): Promise<ExperimentRunResult | RunInGithubResponse>;
+    /**
+     * Run an experiment locally (not in GitHub Actions)
+     */
+    private runLocally;
+    /**
+     * Create a task for the experiment
+     */
+    createTask(experimentSlug: string, experimentRunId: string, taskInput: Record<string, any>, taskOutput: Record<string, any>): Promise<CreateTaskResponse>;
+    /**
+     * Initialize a new experiment
+     */
+    initializeExperiment(request: InitExperimentRequest): Promise<ExperimentInitResponse>;
+    /**
+     * Parse JSONL string into list of {col_name: col_value} dictionaries
+     * Skips the first line (columns definition)
+     */
+    private parseJsonlToRows;
+    /**
+     * Get dataset rows for experiment execution
+     */
+    private getDatasetRows;
+    /**
+     * Validate experiment run options
+     */
+    private validateRunOptions;
+    /**
+     * Extract GitHub Actions context from environment variables
+     */
+    private getGithubContext;
+    /**
+     * Execute tasks locally and capture results
+     */
+    private executeTasksLocally;
+    /**
+     * Run an experiment in GitHub Actions environment
+     * This method executes tasks locally and submits results to the backend for evaluation
+     */
+    runInGithub<TInput, TOutput>(task: ExperimentTaskFunction<TInput, TOutput>, options: RunInGithubOptions): Promise<RunInGithubResponse>;
+    /**
+     * Resolve export parameters by falling back to last used values
+     */
+    private resolveExportParams;
+    /**
+     * Export experiment results as CSV string
+     * @param experimentSlug - Optional experiment slug (uses last run if not provided)
+     * @param runId - Optional run ID (uses last run if not provided)
+     * @returns CSV string of experiment results
+     */
+    toCsvString(experimentSlug?: string, runId?: string): Promise<string>;
+    /**
+     * Export experiment results as JSON string
+     * @param experimentSlug - Optional experiment slug (uses last run if not provided)
+     * @param runId - Optional run ID (uses last run if not provided)
+     * @returns JSON string of experiment results
+     */
+    toJsonString(experimentSlug?: string, runId?: string): Promise<string>;
+}
+//# sourceMappingURL=experiment.d.ts.map

package/dist/src/lib/client/experiment/index.d.ts

@@ -0,0 +1,2 @@
+export { Experiment } from "./experiment";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/client/traceloop-client.d.ts

@@ -0,0 +1,40 @@
+import { TraceloopClientOptions } from "../interfaces";
+import { UserFeedback } from "./annotation/user-feedback";
+import { Datasets } from "./dataset/datasets";
+import { Experiment } from "./experiment/experiment";
+import { Evaluator } from "./evaluator/evaluator";
+/**
+ * The main client for interacting with Traceloop's API.
+ * This client can be used either directly or through the singleton pattern via configuration.
+ *
+ * @example
+ * // Direct usage
+ * const client = new TraceloopClient('your-api-key');
+ *
+ * @example
+ * // Through configuration (recommended)
+ * initialize({ apiKey: 'your-api-key', appName: 'your-app' });
+ * const client = getClient();
+ */
+export declare class TraceloopClient {
+    private version;
+    appName: string;
+    private baseUrl;
+    private apiKey;
+    experimentSlug?: string;
+    userFeedback: UserFeedback;
+    datasets: Datasets;
+    experiment: Experiment;
+    evaluator: Evaluator;
+    /**
+     * Creates a new instance of the TraceloopClient.
+     *
+     * @param options - Configuration options for the client
+     */
+    constructor(options: TraceloopClientOptions);
+    post(path: string, body: Record<string, unknown> | any): Promise<Response>;
+    get(path: string): Promise<Response>;
+    put(path: string, body: Record<string, unknown> | any): Promise<Response>;
+    delete(path: string): Promise<Response>;
+}
+//# sourceMappingURL=traceloop-client.d.ts.map

package/dist/src/lib/configuration/index.d.ts

@@ -0,0 +1,35 @@
+import { InitializeOptions } from "../interfaces";
+import { TraceloopClient } from "../client/traceloop-client";
+export declare let _configuration: InitializeOptions | undefined;
+/**
+ * Initializes the Traceloop SDK and creates a singleton client instance if API key is provided.
+ * Must be called once before any other SDK methods.
+ *
+ * @param options - The options to initialize the SDK. See the {@link InitializeOptions} for details.
+ * @returns TraceloopClient - The singleton client instance if API key is provided, otherwise undefined.
+ * @throws {InitializationError} if the configuration is invalid or if failed to fetch feature data.
+ *
+ * @example
+ * ```typescript
+ * initialize({
+ *   apiKey: 'your-api-key',
+ *   appName: 'your-app',
+ * });
+ * ```
+ */
+export declare const initialize: (options?: InitializeOptions) => TraceloopClient | undefined;
+/**
+ * Gets the singleton instance of the TraceloopClient.
+ * The SDK must be initialized with an API key before calling this function.
+ *
+ * @returns The TraceloopClient singleton instance
+ * @throws {Error} if the SDK hasn't been initialized or was initialized without an API key
+ *
+ * @example
+ * ```typescript
+ * const client = getClient();
+ * await client.annotation.create({ annotationTask: 'taskId', entityInstanceId: 'entityId', tags: { score: 0.9 } });
+ * ```
+ */
+export declare const getClient: () => TraceloopClient;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/configuration/validation.d.ts

@@ -0,0 +1,3 @@
+import { InitializeOptions } from "../interfaces";
+export declare const validateConfiguration: (options: InitializeOptions) => void;
+//# sourceMappingURL=validation.d.ts.map

package/dist/src/lib/errors/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The severity of an error.
+ */
+export declare const SEVERITY: {
+    readonly Warning: "Warning";
+    readonly Error: "Error";
+    readonly Critical: "Critical";
+};
+export type Severity = (typeof SEVERITY)[keyof typeof SEVERITY];
+/**
+ * Base class for all Traceloop errors.
+ */
+export declare class TraceloopError extends Error {
+    /**
+     * The severity of the error.
+     */
+    severity: Severity;
+    /**
+     * The underlying cause of the error.
+     */
+    underlyingCause?: Error;
+    constructor(message: string, severity?: Severity);
+}
+export declare class NotInitializedError extends TraceloopError {
+    constructor();
+}
+export declare class InitializationError extends TraceloopError {
+    constructor(message?: string, cause?: Error);
+}
+export declare class ArgumentNotProvidedError extends TraceloopError {
+    constructor(argumentName: string);
+}
+export declare class PromptNotFoundError extends TraceloopError {
+    constructor(key: string);
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/generated/evaluators/index.d.ts

@@ -0,0 +1,5 @@
+export { EVALUATOR_SLUGS, EVALUATOR_SCHEMAS, getEvaluatorSchema, isValidEvaluatorSlug, } from './registry';
+export type { EvaluatorSlug, EvaluatorSchema } from './registry';
+export { EvaluatorMadeByTraceloop, createEvaluator, validateEvaluatorInput, getAvailableEvaluatorSlugs, getEvaluatorSchemaInfo, } from './mbt-evaluators';
+export type * from './mbt-evaluators';
+//# sourceMappingURL=index.d.ts.map