@cadraos/sdk 0.1.2

package/dist/index.d.cts

@@ -0,0 +1,1904 @@
+/**
+ * Retry utility with exponential backoff
+ */
+/**
+ * Retry configuration
+ */
+interface RetryConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries: number;
+    /** Base delay in milliseconds (default: 1000) */
+    baseDelayMs: number;
+    /** Maximum delay in milliseconds (default: 30000) */
+    maxDelayMs: number;
+    /** Jitter factor (0-1, default: 0.1) */
+    jitterFactor: number;
+}
+
+/**
+ * HTTP Client
+ *
+ * Handles all HTTP requests with authentication, retry logic, and error handling.
+ */
+
+/**
+ * HTTP Client configuration
+ */
+interface HttpClientConfig {
+    /** Base URL for API requests */
+    baseUrl: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** OAuth token for authentication */
+    token?: string;
+    /** Token provider callback (called before each request) */
+    tokenProvider?: () => Promise<string>;
+    /** Organization ID */
+    orgId: number;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout: number;
+    /** Retry configuration */
+    retry: RetryConfig;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Request options
+ */
+interface RequestOptions {
+    /** HTTP method */
+    method: 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'PUT';
+    /** Request path (appended to base URL) */
+    path: string;
+    /** Request body */
+    body?: unknown;
+    /** Query parameters */
+    query?: Record<string, string | number | boolean | undefined>;
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** Skip retry (for non-idempotent operations) */
+    skipRetry?: boolean;
+    /** Idempotency key */
+    idempotencyKey?: string;
+}
+/**
+ * HTTP Client class
+ */
+declare class HttpClient {
+    private config;
+    private tokenRefreshAttempts;
+    private readonly maxTokenRefreshAttempts;
+    constructor(config: HttpClientConfig);
+    /**
+     * Get authorization header value
+     */
+    private getAuthHeader;
+    /**
+     * Build full URL with query parameters
+     */
+    private buildUrl;
+    /**
+     * Make an HTTP request
+     */
+    request<T>(options: RequestOptions): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+        skipRetry?: boolean;
+    }): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T>(path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+    }): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(path: string): Promise<T>;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<HttpClientConfig>): void;
+}
+
+/**
+ * Common types shared across all resources
+ */
+/**
+ * JSON Schema type for tool input/output schemas
+ */
+type JSONSchema = {
+    type: string;
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    items?: JSONSchema;
+    description?: string;
+    [key: string]: unknown;
+};
+/**
+ * Pagination options for list operations
+ */
+interface ListOptions {
+    /** Maximum number of items to return (default: 20) */
+    limit?: number;
+    /** Number of items to skip (pagination offset) */
+    offset?: number;
+    /** Field to sort by (e.g., 'createdAt') */
+    sort?: string;
+    /** Sort order */
+    order?: 'asc' | 'desc';
+}
+/**
+ * Pagination metadata in list responses
+ */
+interface PaginationInfo {
+    /** Total number of items */
+    total: number;
+    /** Number of items returned */
+    limit: number;
+    /** Number of items skipped */
+    offset: number;
+    /** Whether there are more items */
+    hasMore: boolean;
+}
+/**
+ * Paginated list response
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: PaginationInfo;
+}
+/**
+ * Execute operation options
+ */
+interface ExecuteOptions {
+    /** Maximum number of agent iterations */
+    maxIterations?: number;
+    /** Maximum tokens for the response */
+    maxTokens?: number;
+    /** Execution timeout in milliseconds */
+    timeout?: number;
+    /** Idempotency key for retry safety */
+    idempotencyKey?: string;
+}
+/**
+ * Execute input for agent/skill operations
+ */
+interface ExecuteInput {
+    /** The task or prompt to execute */
+    task: string;
+    /** Additional context for the execution */
+    context?: Record<string, unknown>;
+    /** Execution options */
+    options?: ExecuteOptions;
+}
+/**
+ * Execution status
+ */
+type ExecutionStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Token usage information
+ */
+interface TokenUsage {
+    /** Input tokens consumed */
+    input: number;
+    /** Output tokens generated */
+    output: number;
+    /** Total tokens */
+    total: number;
+}
+
+/**
+ * Agent types
+ */
+
+/**
+ * Agent type
+ */
+type AgentType = 'simple' | 'workflow' | 'orchestrator';
+/**
+ * Agent status
+ */
+type AgentStatus = 'active' | 'inactive' | 'draft';
+/**
+ * Agent configuration
+ */
+interface AgentConfig {
+    /** LLM model to use */
+    model?: string;
+    /** Temperature for generation */
+    temperature?: number;
+    /** Maximum iterations for agent loop */
+    maxIterations?: number;
+    /** System prompt for the agent */
+    systemPrompt?: string;
+}
+/**
+ * Agent resource
+ */
+interface Agent {
+    /** Unique identifier */
+    uuid: string;
+    /** Agent name */
+    name: string;
+    /** Agent description */
+    description: string | null;
+    /** Agent type */
+    type: AgentType;
+    /** Agent status */
+    status: AgentStatus;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+    /** Agent configuration (included in get, not list) */
+    config?: AgentConfig;
+}
+/**
+ * Agent list options
+ */
+interface AgentListOptions extends ListOptions {
+    /** Filter by status */
+    status?: AgentStatus;
+    /** Filter by type */
+    type?: AgentType;
+}
+/**
+ * Execution log entry
+ */
+interface ExecutionLog {
+    /** Unique identifier */
+    uuid: string;
+    /** Log type */
+    type: 'info' | 'think' | 'tool_call' | 'tool_result' | 'error' | 'system';
+    /** Log title/summary */
+    title: string;
+    /** Log content/details */
+    content?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Timestamp */
+    timestamp: string;
+    /** Duration in milliseconds (if applicable) */
+    durationMs?: number;
+}
+/**
+ * Agent execution result
+ */
+interface AgentExecution {
+    /** Execution ID */
+    uuid: string;
+    /** Agent ID */
+    agentUuid: string;
+    /** Execution status */
+    status: ExecutionStatus;
+    /** Input provided */
+    input: {
+        task: string;
+        context?: Record<string, unknown>;
+    };
+    /** Output result */
+    output?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Execution logs */
+    logs: ExecutionLog[];
+    /** Token usage */
+    tokenUsage?: TokenUsage;
+    /** Cost in USD */
+    cost?: number;
+    /** Number of iterations */
+    iterations?: number;
+    /** When execution was queued */
+    queuedAt: string;
+    /** When execution started */
+    startedAt?: string;
+    /** When execution completed */
+    completedAt?: string;
+    /** Total duration in milliseconds */
+    durationMs?: number;
+}
+/**
+ * Agent update input
+ */
+interface AgentUpdateInput {
+    /** New name */
+    name?: string;
+    /** New description */
+    description?: string;
+    /** New status */
+    status?: AgentStatus;
+}
+/**
+ * Agent config update input
+ */
+interface AgentConfigUpdateInput {
+    /** LLM model */
+    model?: string;
+    /** Temperature */
+    temperature?: number;
+    /** Max iterations */
+    maxIterations?: number;
+    /** System prompt */
+    systemPrompt?: string;
+}
+/**
+ * Execute response (async)
+ */
+interface ExecuteResponse {
+    /** Execution ID */
+    executionId: string;
+    /** Initial status */
+    status: ExecutionStatus;
+}
+
+/**
+ * Skill types
+ */
+
+/**
+ * Skill tool reference
+ */
+interface SkillTool {
+    /** Tool UUID */
+    uuid: string;
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+}
+/**
+ * Skill variable definition
+ */
+interface SkillVariable {
+    /** Variable name */
+    name: string;
+    /** Variable type */
+    type: 'string' | 'number' | 'boolean' | 'object';
+    /** Variable description */
+    description: string;
+    /** Whether the variable is required */
+    required: boolean;
+    /** Default value */
+    default?: unknown;
+}
+/**
+ * Skill resource (list view)
+ */
+interface Skill {
+    /** Unique identifier */
+    uuid: string;
+    /** Skill name */
+    name: string;
+    /** Skill description */
+    description: string | null;
+    /** Category */
+    category: string | null;
+    /** Tags */
+    tags: string[];
+    /** Version string */
+    version: string;
+    /** Whether skill is public */
+    isPublic: boolean;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+/**
+ * Skill details (get view, includes prompt template)
+ */
+interface SkillDetails extends Skill {
+    /** Prompt template */
+    promptTemplate: string;
+    /** Associated tools */
+    tools: SkillTool[];
+    /** Variable definitions */
+    variables: SkillVariable[];
+}
+/**
+ * Skill list options
+ */
+interface SkillListOptions extends ListOptions {
+    /** Filter by category */
+    category?: string;
+    /** Filter by tags (any match) */
+    tags?: string[];
+}
+/**
+ * Skill execute input
+ */
+interface SkillExecuteInput {
+    /** Variable values for the prompt template */
+    variables?: Record<string, unknown>;
+    /** Additional context */
+    context?: Record<string, unknown>;
+}
+/**
+ * Skill execution result
+ */
+interface SkillExecution {
+    /** Execution ID */
+    uuid: string;
+    /** Skill ID */
+    skillUuid: string;
+    /** Execution status */
+    status: 'success' | 'error';
+    /** Input variables */
+    input: Record<string, unknown>;
+    /** Generated prompt output */
+    output?: string;
+    /** Error message */
+    error?: string;
+    /** Execution timestamp */
+    executedAt: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+}
+/**
+ * Skill update input
+ */
+interface SkillUpdateInput {
+    /** New name */
+    name?: string;
+    /** New description */
+    description?: string;
+    /** New category */
+    category?: string;
+    /** New tags */
+    tags?: string[];
+}
+
+/**
+ * Tool types
+ */
+
+/**
+ * Tool resource
+ */
+interface Tool {
+    /** Unique identifier */
+    uuid: string;
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** Category */
+    category: string | null;
+    /** Input JSON schema */
+    inputSchema: JSONSchema;
+    /** Output JSON schema */
+    outputSchema?: JSONSchema;
+    /** Whether tool is enabled */
+    isEnabled: boolean;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+/**
+ * Tool list options
+ */
+interface ToolListOptions extends ListOptions {
+    /** Filter by category */
+    category?: string;
+    /** Filter by enabled status */
+    isEnabled?: boolean;
+}
+/**
+ * Tool execution result
+ */
+interface ToolExecution {
+    /** Execution ID */
+    uuid: string;
+    /** Tool ID */
+    toolUuid: string;
+    /** Execution status */
+    status: 'success' | 'error';
+    /** Input provided */
+    input: Record<string, unknown>;
+    /** Output result */
+    output?: unknown;
+    /** Error message */
+    error?: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Execution timestamp */
+    executedAt: string;
+}
+/**
+ * Tool input validation result
+ */
+interface ToolValidationResult {
+    /** Whether the input is valid */
+    valid: boolean;
+    /** Validation errors (if invalid) */
+    errors?: Array<{
+        field: string;
+        message: string;
+    }>;
+}
+/**
+ * Tool update input
+ */
+interface ToolUpdateInput {
+    /** New name */
+    name?: string;
+    /** New description */
+    description?: string;
+    /** New category */
+    category?: string;
+}
+/**
+ * Tool config update input
+ */
+interface ToolConfigUpdateInput {
+    /** Tool-specific configuration */
+    config?: Record<string, unknown>;
+    /** Enable/disable tool */
+    isEnabled?: boolean;
+}
+
+/**
+ * Artifact types
+ */
+
+/**
+ * Artifact type
+ */
+type ArtifactType = 'file' | 'data' | 'log';
+/**
+ * Artifact resource
+ */
+interface Artifact {
+    /** Unique identifier */
+    uuid: string;
+    /** Associated execution ID */
+    executionUuid: string;
+    /** Artifact name */
+    name: string;
+    /** Artifact type */
+    type: ArtifactType;
+    /** MIME type */
+    mimeType: string;
+    /** Size in bytes */
+    size: number;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Artifact list options
+ */
+interface ArtifactListOptions extends ListOptions {
+    /** Filter by type */
+    type?: ArtifactType;
+}
+/**
+ * Artifact download options
+ */
+interface ArtifactDownloadOptions {
+    /** Response format (only for getSignedUrl) */
+    format?: 'buffer' | 'stream' | 'url';
+    /** Expiration time in seconds for signed URL (default: 3600) */
+    expiresIn?: number;
+}
+/**
+ * Signed URL response
+ */
+interface SignedUrlResponse {
+    /** The signed URL */
+    url: string;
+    /** When the URL expires */
+    expiresAt: string;
+}
+/**
+ * Artifact upload input
+ */
+interface ArtifactUploadInput {
+    /** File name */
+    name: string;
+    /** File content (Buffer in Node.js, Blob in browser) */
+    content: Buffer | Blob | ReadableStream<Uint8Array>;
+    /** MIME type */
+    mimeType?: string;
+    /** Artifact type */
+    type?: ArtifactType;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * Session types
+ */
+
+/**
+ * Session resource
+ */
+interface Session {
+    /** Session ID */
+    id: string;
+    /** Associated agent ID */
+    agentUuid: string;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last message timestamp */
+    lastMessageAt: string;
+    /** Number of messages in session */
+    messageCount: number;
+    /** Last user message (for session list preview) */
+    lastUserMessage?: string | null;
+}
+/**
+ * Session message
+ */
+interface SessionMessage {
+    /** Message ID */
+    id: string;
+    /** Message role */
+    role: 'user' | 'assistant' | 'system';
+    /** Message content */
+    content: string;
+    /** Associated execution ID (for assistant messages) */
+    executionUuid?: string;
+    /** Message timestamp */
+    timestamp: string;
+}
+/**
+ * Session history with messages
+ */
+interface SessionHistory {
+    /** Session info */
+    session: Session;
+    /** Messages in chronological order */
+    messages: SessionMessage[];
+}
+/**
+ * Session list options
+ */
+interface SessionListOptions extends ListOptions {
+    /** Filter by agent */
+    agentUuid?: string;
+}
+/**
+ * Session create input
+ */
+interface SessionCreateInput {
+    /** Agent to associate with the session */
+    agentUuid: string;
+    /** Initial system message (optional) */
+    systemMessage?: string;
+}
+/**
+ * Send message input
+ */
+interface SendMessageInput {
+    /** Message content */
+    message: string;
+    /** Additional context */
+    context?: Record<string, unknown>;
+}
+/**
+ * Session artifact type
+ */
+type SessionArtifactType = 'file' | 'image' | 'code' | 'data' | 'log' | 'report';
+/**
+ * Session artifact variant type
+ */
+type SessionArtifactVariantType = 'original' | 'thumbnail';
+/**
+ * Session artifact resource
+ * Represents an artifact generated during a session execution
+ */
+interface SessionArtifact {
+    /** Unique identifier */
+    uuid: string;
+    /** Associated execution ID */
+    executionId: string;
+    /** Artifact type */
+    type: SessionArtifactType;
+    /** Variant type (original or thumbnail) */
+    variantType: SessionArtifactVariantType;
+    /** Original filename */
+    filename: string;
+    /** MIME type */
+    mimeType: string;
+    /** Size in bytes */
+    size: number;
+    /** Pre-signed URL for accessing the artifact */
+    url: string;
+    /** Thumbnail URL (for images) */
+    thumbnailUrl?: string;
+    /** Image dimensions (for images) */
+    dimensions?: {
+        width: number;
+        height: number;
+    };
+    /** Description */
+    description?: string | null;
+    /** Additional metadata */
+    metadata?: Record<string, unknown> | null;
+    /** Creation timestamp */
+    createdAt: string;
+}
+/**
+ * Session artifact list options
+ */
+interface SessionArtifactListOptions extends ListOptions {
+    /** Filter by artifact type */
+    type?: SessionArtifactType;
+    /** Include thumbnail variants (default: false) */
+    includeVariants?: boolean;
+}
+
+/**
+ * Streaming types
+ */
+
+/**
+ * Tool call event
+ */
+interface ToolCallEvent {
+    /** Tool call ID */
+    toolCallId: string;
+    /** Tool name */
+    toolName: string;
+    /** Tool inputs */
+    inputs: Record<string, unknown>;
+    /** Step/iteration index */
+    stepIndex: number;
+}
+/**
+ * Tool result event
+ */
+interface ToolResultEvent {
+    /** Tool call ID */
+    toolCallId: string;
+    /** Tool name */
+    toolName: string;
+    /** Tool result */
+    result: unknown;
+    /** Duration in milliseconds */
+    durationMs: number;
+}
+/**
+ * Plan event
+ */
+interface PlanEvent {
+    /** Planned tasks */
+    tasks: Array<{
+        title: string;
+        status: 'pending' | 'in_progress' | 'completed' | 'failed';
+    }>;
+}
+/**
+ * Complete event
+ */
+interface CompleteEvent {
+    /** Final execution result */
+    execution: AgentExecution;
+}
+/**
+ * Error event
+ */
+interface ErrorEvent {
+    /** Error message */
+    error: string;
+    /** Error code */
+    errorCode?: string;
+}
+/**
+ * Connection change event
+ */
+interface ConnectionChangeEvent {
+    /** Whether connected */
+    connected: boolean;
+    /** Whether using fallback polling */
+    usingFallback?: boolean;
+}
+/**
+ * Stream event map for type-safe event handlers
+ */
+interface StreamEventMap {
+    log: ExecutionLog;
+    toolCall: ToolCallEvent;
+    toolResult: ToolResultEvent;
+    plan: PlanEvent;
+    complete: CompleteEvent;
+    error: ErrorEvent;
+    connectionChange: ConnectionChangeEvent;
+}
+/**
+ * Stream controller interface
+ */
+interface StreamController {
+    /** Listen for log events */
+    on(event: 'log', callback: (log: ExecutionLog) => void): void;
+    /** Listen for tool call events */
+    on(event: 'toolCall', callback: (data: ToolCallEvent) => void): void;
+    /** Listen for tool result events */
+    on(event: 'toolResult', callback: (data: ToolResultEvent) => void): void;
+    /** Listen for plan updates */
+    on(event: 'plan', callback: (data: PlanEvent) => void): void;
+    /** Listen for completion */
+    on(event: 'complete', callback: (data: CompleteEvent) => void): void;
+    /** Listen for errors */
+    on(event: 'error', callback: (error: ErrorEvent) => void): void;
+    /** Listen for connection state changes */
+    on(event: 'connectionChange', callback: (data: ConnectionChangeEvent) => void): void;
+    /** Cancel the stream */
+    cancel(): void;
+    /** Wait for completion, returns final execution result */
+    wait(): Promise<AgentExecution>;
+}
+/**
+ * Streaming configuration
+ */
+interface StreamingConfig {
+    /** Maximum reconnection attempts */
+    maxReconnectAttempts: number;
+    /** Base delay for reconnection (ms) */
+    reconnectBaseDelayMs: number;
+    /** Maximum delay for reconnection (ms) */
+    reconnectMaxDelayMs: number;
+    /** Activity timeout - no events for this long triggers reconnect (ms) */
+    activityTimeoutMs: number;
+    /** Polling interval for fallback mode (ms) */
+    pollingIntervalMs: number;
+}
+
+/**
+ * Base Resource API
+ *
+ * Abstract base class for all resource APIs.
+ * Provides common HTTP methods and path handling.
+ */
+
+/**
+ * Base Resource API class
+ */
+declare abstract class BaseResourceAPI {
+    protected readonly http: HttpClient;
+    protected readonly basePath: string;
+    constructor(http: HttpClient, basePath: string);
+    /**
+     * Build query parameters from list options
+     */
+    protected buildListQuery(options?: ListOptions): Record<string, string | number | boolean | undefined>;
+    /**
+     * HTTP GET request helper
+     */
+    protected httpGet<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    /**
+     * HTTP POST request helper
+     */
+    protected httpPost<T>(path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+        skipRetry?: boolean;
+    }): Promise<T>;
+    /**
+     * HTTP PATCH request helper
+     */
+    protected httpPatch<T>(path: string, body?: unknown, options?: {
+        idempotencyKey?: string;
+    }): Promise<T>;
+    /**
+     * HTTP DELETE request helper
+     */
+    protected httpDelete<T>(path: string): Promise<T>;
+    /**
+     * List resources with pagination
+     */
+    protected listResources<T>(path: string, options?: ListOptions): Promise<PaginatedResponse<T>>;
+}
+
+/**
+ * Stream Controller
+ *
+ * Manages execution streaming with automatic reconnection and fallback to polling.
+ * Implements the StreamController interface for type-safe event handling.
+ */
+
+/**
+ * Stream controller creation options
+ */
+interface ExecutionStreamControllerOptions {
+    /** Execution ID to stream */
+    executionId: string;
+    /** Base URL for API */
+    baseUrl: string;
+    /** API key or token */
+    apiKey?: string;
+    /** Organization ID */
+    orgId: number;
+    /** Function to get execution status (for polling fallback) */
+    getExecution: (executionId: string) => Promise<AgentExecution>;
+    /** Streaming configuration */
+    config?: Partial<StreamingConfig>;
+}
+/**
+ * Execution Stream Controller
+ *
+ * Manages the lifecycle of an execution stream, including:
+ * - SSE connection management
+ * - Automatic reconnection with exponential backoff
+ * - Fallback to polling on connection failure
+ * - Event deduplication
+ */
+interface ExecutionStreamController extends StreamController {
+    /** Connect to the stream */
+    connect(): Promise<void>;
+}
+
+/**
+ * Agents Resource API
+ *
+ * Provides all agent-related operations:
+ * - List: list(), get()
+ * - Execute: execute(), executeSync(), stream()
+ * - Receive: getExecution()
+ * - Edit: update(), updateConfig(), cancelExecution()
+ */
+
+/**
+ * Agents API class
+ */
+declare class AgentsAPI extends BaseResourceAPI {
+    private readonly getStreamConfig;
+    constructor(http: HttpClient, getStreamConfig: () => StreamConfig);
+    /**
+     * List all agents in the organization
+     *
+     * @param options - List options (pagination, filtering)
+     * @returns Paginated list of agents
+     *
+     * @example
+     * ```typescript
+     * const { data: agents, pagination } = await client.agents.list({ limit: 10 });
+     * ```
+     */
+    list(options?: AgentListOptions): Promise<PaginatedResponse<Agent>>;
+    /**
+     * Get a single agent by UUID
+     *
+     * @param uuid - Agent UUID
+     * @returns Agent with configuration
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.get('agent-uuid');
+     * console.log(agent.config);
+     * ```
+     */
+    get(uuid: string): Promise<Agent>;
+    /**
+     * Start an agent execution (async)
+     *
+     * Returns immediately with execution ID. Use getExecution() to poll
+     * for results, or use stream() for real-time updates.
+     *
+     * @param uuid - Agent UUID
+     * @param input - Execution input (task, context, options)
+     * @returns Execution ID and initial status
+     *
+     * @example
+     * ```typescript
+     * const { executionId, status } = await client.agents.execute('agent-uuid', {
+     *   task: 'Summarize the latest news about AI',
+     * });
+     * ```
+     */
+    execute(uuid: string, input: ExecuteInput): Promise<ExecuteResponse>;
+    /**
+     * Execute an agent and wait for completion (sync)
+     *
+     * Polls the execution status until completion or failure.
+     *
+     * @param uuid - Agent UUID
+     * @param input - Execution input
+     * @param pollInterval - Polling interval in ms (default: 1000)
+     * @returns Final execution result
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.agents.executeSync('agent-uuid', {
+     *   task: 'Write a haiku about coding',
+     * });
+     * console.log(execution.output);
+     * ```
+     */
+    executeSync(uuid: string, input: ExecuteInput, pollInterval?: number): Promise<AgentExecution>;
+    /**
+     * Stream an agent execution
+     *
+     * Returns a StreamController for real-time event handling.
+     *
+     * @param uuid - Agent UUID
+     * @param input - Execution input
+     * @returns Stream controller for event handling
+     *
+     * @example
+     * ```typescript
+     * const stream = await client.agents.stream('agent-uuid', {
+     *   task: 'Research climate change',
+     * });
+     *
+     * stream.on('log', (log) => console.log(log.title));
+     * stream.on('toolCall', ({ toolName }) => console.log(`Calling ${toolName}`));
+     * stream.on('complete', ({ execution }) => console.log(execution.output));
+     *
+     * const result = await stream.wait();
+     * ```
+     */
+    stream(uuid: string, input: ExecuteInput): Promise<ExecutionStreamController>;
+    /**
+     * Get execution result by ID
+     *
+     * @param executionId - Execution UUID
+     * @returns Execution details including status, output, logs
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.agents.getExecution('exec-uuid');
+     * if (execution.status === 'completed') {
+     *   console.log(execution.output);
+     * }
+     * ```
+     */
+    getExecution(executionId: string): Promise<AgentExecution>;
+    /**
+     * Update agent details
+     *
+     * @param uuid - Agent UUID
+     * @param data - Fields to update
+     * @returns Updated agent
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.update('agent-uuid', {
+     *   name: 'My Updated Agent',
+     *   description: 'New description',
+     * });
+     * ```
+     */
+    update(uuid: string, data: AgentUpdateInput): Promise<Agent>;
+    /**
+     * Update agent configuration
+     *
+     * @param uuid - Agent UUID
+     * @param config - Configuration fields to update
+     * @returns Updated agent
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.updateConfig('agent-uuid', {
+     *   temperature: 0.7,
+     *   maxIterations: 5,
+     * });
+     * ```
+     */
+    updateConfig(uuid: string, config: AgentConfigUpdateInput): Promise<Agent>;
+    /**
+     * Cancel a running execution
+     *
+     * @param executionId - Execution UUID
+     * @returns Updated execution with cancelled status
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.agents.cancelExecution('exec-uuid');
+     * console.log(execution.status); // 'cancelled'
+     * ```
+     */
+    cancelExecution(executionId: string): Promise<AgentExecution>;
+    /**
+     * Poll execution until completion
+     */
+    private pollExecution;
+}
+/**
+ * Stream configuration passed from client
+ */
+interface StreamConfig {
+    baseUrl: string;
+    apiKey?: string;
+    token?: string;
+    orgId: number;
+}
+
+/**
+ * Skills Resource API
+ *
+ * Provides all skill-related operations:
+ * - List: list(), get(), getTools()
+ * - Execute: execute()
+ * - Receive: getExecution()
+ * - Edit: update(), updatePrompt()
+ */
+
+/**
+ * Skills API class
+ */
+declare class SkillsAPI extends BaseResourceAPI {
+    constructor(http: HttpClient);
+    /**
+     * List all skills in the organization
+     *
+     * @param options - List options (pagination, filtering by category/tags)
+     * @returns Paginated list of skills
+     *
+     * @example
+     * ```typescript
+     * const { data: skills } = await client.skills.list({
+     *   category: 'writing',
+     *   tags: ['seo', 'blog'],
+     * });
+     * ```
+     */
+    list(options?: SkillListOptions): Promise<PaginatedResponse<Skill>>;
+    /**
+     * Get a single skill by UUID with full details
+     *
+     * @param uuid - Skill UUID
+     * @returns Skill with prompt template and tools
+     *
+     * @example
+     * ```typescript
+     * const skill = await client.skills.get('skill-uuid');
+     * console.log(skill.promptTemplate);
+     * ```
+     */
+    get(uuid: string): Promise<SkillDetails>;
+    /**
+     * Get tools associated with a skill
+     *
+     * @param uuid - Skill UUID
+     * @returns Array of tools used by the skill
+     *
+     * @example
+     * ```typescript
+     * const tools = await client.skills.getTools('skill-uuid');
+     * tools.forEach(tool => console.log(tool.name));
+     * ```
+     */
+    getTools(uuid: string): Promise<SkillTool[]>;
+    /**
+     * Execute a skill with variables
+     *
+     * @param uuid - Skill UUID
+     * @param input - Variables and context for execution
+     * @returns Skill execution result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.skills.execute('skill-uuid', {
+     *   variables: {
+     *     topic: 'AI in healthcare',
+     *     tone: 'professional',
+     *   },
+     * });
+     * console.log(result.output);
+     * ```
+     */
+    execute(uuid: string, input: SkillExecuteInput): Promise<SkillExecution>;
+    /**
+     * Get skill execution result by ID
+     *
+     * @param executionId - Execution UUID
+     * @returns Skill execution details
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.skills.getExecution('exec-uuid');
+     * ```
+     */
+    getExecution(executionId: string): Promise<SkillExecution>;
+    /**
+     * Update skill details
+     *
+     * @param uuid - Skill UUID
+     * @param data - Fields to update
+     * @returns Updated skill
+     *
+     * @example
+     * ```typescript
+     * const skill = await client.skills.update('skill-uuid', {
+     *   name: 'Updated Skill Name',
+     *   tags: ['new-tag'],
+     * });
+     * ```
+     */
+    update(uuid: string, data: SkillUpdateInput): Promise<Skill>;
+    /**
+     * Update skill prompt template
+     *
+     * @param uuid - Skill UUID
+     * @param prompt - New prompt template
+     * @returns Updated skill with new version
+     *
+     * @example
+     * ```typescript
+     * const skill = await client.skills.updatePrompt('skill-uuid',
+     *   'Write a {{tone}} article about {{topic}}...'
+     * );
+     * console.log(skill.version); // Version incremented
+     * ```
+     */
+    updatePrompt(uuid: string, prompt: string): Promise<SkillDetails>;
+}
+
+/**
+ * Tools Resource API
+ *
+ * Provides all tool-related operations:
+ * - List: list(), get()
+ * - Execute: execute(), validateInput()
+ * - Receive: getExecution()
+ * - Edit: update(), updateConfig()
+ */
+
+/**
+ * Tools API class
+ */
+declare class ToolsAPI extends BaseResourceAPI {
+    constructor(http: HttpClient);
+    /**
+     * List all tools in the organization
+     *
+     * @param options - List options (pagination, filtering)
+     * @returns Paginated list of tools
+     *
+     * @example
+     * ```typescript
+     * const { data: tools } = await client.tools.list({
+     *   category: 'data',
+     *   isEnabled: true,
+     * });
+     * ```
+     */
+    list(options?: ToolListOptions): Promise<PaginatedResponse<Tool>>;
+    /**
+     * Get a single tool by UUID with schema
+     *
+     * @param uuid - Tool UUID
+     * @returns Tool with input/output schemas
+     *
+     * @example
+     * ```typescript
+     * const tool = await client.tools.get('tool-uuid');
+     * console.log(tool.inputSchema);
+     * ```
+     */
+    get(uuid: string): Promise<Tool>;
+    /**
+     * Execute a tool directly
+     *
+     * @param uuid - Tool UUID
+     * @param input - Tool input (validated against inputSchema)
+     * @returns Tool execution result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.tools.execute('tool-uuid', {
+     *   query: 'weather in London',
+     *   limit: 5,
+     * });
+     * console.log(result.output);
+     * ```
+     */
+    execute(uuid: string, input: Record<string, unknown>): Promise<ToolExecution>;
+    /**
+     * Validate input against tool schema
+     *
+     * @param uuid - Tool UUID
+     * @param input - Input to validate
+     * @returns Validation result with errors if invalid
+     *
+     * @example
+     * ```typescript
+     * const validation = await client.tools.validateInput('tool-uuid', {
+     *   query: 'test',
+     * });
+     * if (!validation.valid) {
+     *   console.log(validation.errors);
+     * }
+     * ```
+     */
+    validateInput(uuid: string, input: Record<string, unknown>): Promise<ToolValidationResult>;
+    /**
+     * Get tool execution result by ID
+     *
+     * @param executionId - Execution UUID
+     * @returns Tool execution details
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.tools.getExecution('exec-uuid');
+     * ```
+     */
+    getExecution(executionId: string): Promise<ToolExecution>;
+    /**
+     * Update tool details
+     *
+     * @param uuid - Tool UUID
+     * @param data - Fields to update
+     * @returns Updated tool
+     *
+     * @example
+     * ```typescript
+     * const tool = await client.tools.update('tool-uuid', {
+     *   name: 'Updated Tool Name',
+     *   description: 'New description',
+     * });
+     * ```
+     */
+    update(uuid: string, data: ToolUpdateInput): Promise<Tool>;
+    /**
+     * Update tool configuration
+     *
+     * @param uuid - Tool UUID
+     * @param config - Configuration to update
+     * @returns Updated tool
+     *
+     * @example
+     * ```typescript
+     * const tool = await client.tools.updateConfig('tool-uuid', {
+     *   isEnabled: false,
+     *   config: { apiKey: 'new-key' },
+     * });
+     * ```
+     */
+    updateConfig(uuid: string, config: ToolConfigUpdateInput): Promise<Tool>;
+}
+
+/**
+ * Artifacts Resource API
+ *
+ * Provides all artifact-related operations:
+ * - List: list(), get()
+ * - Receive: download(), downloadStream(), getSignedUrl()
+ * - Edit: upload(), delete()
+ */
+
+/**
+ * Artifacts API class
+ */
+declare class ArtifactsAPI extends BaseResourceAPI {
+    constructor(http: HttpClient);
+    /**
+     * List artifacts for an execution
+     *
+     * @param executionId - Execution UUID
+     * @param options - List options (pagination, filtering by type)
+     * @returns Paginated list of artifacts
+     *
+     * @example
+     * ```typescript
+     * const { data: artifacts } = await client.artifacts.list('exec-uuid', {
+     *   type: 'file',
+     * });
+     * ```
+     */
+    list(executionId: string, options?: ArtifactListOptions): Promise<PaginatedResponse<Artifact>>;
+    /**
+     * Get artifact metadata by UUID
+     *
+     * @param uuid - Artifact UUID
+     * @returns Artifact metadata
+     *
+     * @example
+     * ```typescript
+     * const artifact = await client.artifacts.get('artifact-uuid');
+     * console.log(artifact.name, artifact.size);
+     * ```
+     */
+    get(uuid: string): Promise<Artifact>;
+    /**
+     * Download artifact content
+     *
+     * In Node.js returns Buffer, in browser returns Blob.
+     *
+     * @param uuid - Artifact UUID
+     * @returns Artifact content as Buffer (Node.js) or Blob (browser)
+     *
+     * @example
+     * ```typescript
+     * const content = await client.artifacts.download('artifact-uuid');
+     * // Node.js: Buffer
+     * // Browser: Blob
+     * ```
+     */
+    download(uuid: string): Promise<Buffer | Blob>;
+    /**
+     * Download artifact as a stream
+     *
+     * In Node.js returns Readable stream, in browser returns ReadableStream.
+     *
+     * @param uuid - Artifact UUID
+     * @returns Readable stream
+     *
+     * @example
+     * ```typescript
+     * const stream = await client.artifacts.downloadStream('artifact-uuid');
+     * // Pipe to file or process incrementally
+     * ```
+     */
+    downloadStream(uuid: string): Promise<ReadableStream<Uint8Array>>;
+    /**
+     * Get a signed URL for direct download
+     *
+     * @param uuid - Artifact UUID
+     * @param options - Options including expiration time
+     * @returns Signed URL and expiration time
+     *
+     * @example
+     * ```typescript
+     * const { url, expiresAt } = await client.artifacts.getSignedUrl('artifact-uuid', {
+     *   expiresIn: 3600, // 1 hour
+     * });
+     * // Use URL for direct download
+     * ```
+     */
+    getSignedUrl(uuid: string, options?: ArtifactDownloadOptions): Promise<SignedUrlResponse>;
+    /**
+     * Upload a new artifact for an execution
+     *
+     * @param executionId - Execution UUID
+     * @param input - Upload input (name, content, mime type)
+     * @returns Created artifact metadata
+     *
+     * @example
+     * ```typescript
+     * const artifact = await client.artifacts.upload('exec-uuid', {
+     *   name: 'report.pdf',
+     *   content: fileBuffer,
+     *   mimeType: 'application/pdf',
+     * });
+     * ```
+     */
+    upload(executionId: string, input: ArtifactUploadInput): Promise<Artifact>;
+    /**
+     * Delete an artifact
+     *
+     * @param uuid - Artifact UUID
+     *
+     * @example
+     * ```typescript
+     * await client.artifacts.delete('artifact-uuid');
+     * ```
+     */
+    delete(uuid: string): Promise<void>;
+}
+
+/**
+ * Sessions Resource API
+ *
+ * Provides all session-related operations:
+ * - List: list(), get()
+ * - Execute: sendMessage(), stream()
+ * - Receive: getHistory(), listArtifacts()
+ * - Edit: create(), delete()
+ */
+
+/**
+ * Sessions API class
+ */
+declare class SessionsAPI extends BaseResourceAPI {
+    private readonly getStreamConfig;
+    constructor(http: HttpClient, getStreamConfig: () => StreamConfig);
+    /**
+     * List all sessions in the organization
+     *
+     * @param options - List options (pagination, filtering by agent)
+     * @returns Paginated list of sessions
+     *
+     * @example
+     * ```typescript
+     * const { data: sessions } = await client.sessions.list({
+     *   agentUuid: 'agent-uuid',
+     * });
+     * ```
+     */
+    list(options?: SessionListOptions): Promise<PaginatedResponse<Session>>;
+    /**
+     * Get session details by ID
+     *
+     * @param sessionId - Session ID
+     * @returns Session details
+     *
+     * @example
+     * ```typescript
+     * const session = await client.sessions.get('session-id');
+     * console.log(session.messageCount);
+     * ```
+     */
+    get(sessionId: string): Promise<Session>;
+    /**
+     * Send a message to a session
+     *
+     * Triggers an agent execution in the context of the session.
+     * Returns immediately with execution ID. Use getHistory() to get
+     * the response, or use stream() for real-time updates.
+     *
+     * @param sessionId - Session ID
+     * @param input - Message content and optional context
+     * @returns Execution ID and status
+     *
+     * @example
+     * ```typescript
+     * const { executionId } = await client.sessions.sendMessage('session-id', {
+     *   message: 'What is the capital of France?',
+     * });
+     * ```
+     */
+    sendMessage(sessionId: string, input: SendMessageInput): Promise<ExecuteResponse>;
+    /**
+     * Send a message and wait for response (sync)
+     *
+     * @param sessionId - Session ID
+     * @param input - Message content and optional context
+     * @param pollInterval - Polling interval in ms (default: 1000)
+     * @returns Final execution result
+     *
+     * @example
+     * ```typescript
+     * const execution = await client.sessions.sendMessageSync('session-id', {
+     *   message: 'What is the capital of France?',
+     * });
+     * console.log(execution.output);
+     * ```
+     */
+    sendMessageSync(sessionId: string, input: SendMessageInput, pollInterval?: number): Promise<AgentExecution>;
+    /**
+     * Stream a message response
+     *
+     * Returns a StreamController for real-time event handling.
+     *
+     * @param sessionId - Session ID
+     * @param input - Message content and optional context
+     * @returns Stream controller
+     *
+     * @example
+     * ```typescript
+     * const stream = await client.sessions.stream('session-id', {
+     *   message: 'Tell me more about that',
+     * });
+     *
+     * stream.on('log', (log) => console.log(log.title));
+     * stream.on('complete', ({ execution }) => console.log(execution.output));
+     *
+     * const result = await stream.wait();
+     * ```
+     */
+    stream(sessionId: string, input: SendMessageInput): Promise<ExecutionStreamController>;
+    /**
+     * Get session conversation history
+     *
+     * @param sessionId - Session ID
+     * @returns Session with all messages
+     *
+     * @example
+     * ```typescript
+     * const history = await client.sessions.getHistory('session-id');
+     * history.messages.forEach(msg => {
+     *   console.log(`${msg.role}: ${msg.content}`);
+     * });
+     * ```
+     */
+    getHistory(sessionId: string): Promise<SessionHistory>;
+    /**
+     * List artifacts for a session
+     *
+     * Returns all artifacts generated across all executions in the session.
+     * Useful for retrieving images, files, and other outputs created during
+     * agent interactions.
+     *
+     * @param sessionId - Session ID
+     * @param options - List options (filtering by type, pagination)
+     * @returns Paginated list of session artifacts
+     *
+     * @example
+     * ```typescript
+     * // Get all images from a session
+     * const { data: artifacts } = await client.sessions.listArtifacts('session-id', {
+     *   type: 'image',
+     * });
+     *
+     * artifacts.forEach(artifact => {
+     *   console.log(artifact.filename, artifact.url);
+     * });
+     * ```
+     */
+    listArtifacts(sessionId: string, options?: SessionArtifactListOptions): Promise<PaginatedResponse<SessionArtifact>>;
+    /**
+     * Get execution result
+     */
+    private getExecution;
+    /**
+     * Create a new session for an agent
+     *
+     * @param agentUuid - Agent UUID to associate with session
+     * @param options - Optional system message
+     * @returns Created session
+     *
+     * @example
+     * ```typescript
+     * const session = await client.sessions.create({
+     *   agentUuid: 'agent-uuid',
+     *   systemMessage: 'You are a helpful assistant.',
+     * });
+     * console.log(session.id);
+     * ```
+     */
+    create(input: SessionCreateInput): Promise<Session>;
+    /**
+     * Delete a session and all its messages
+     *
+     * @param sessionId - Session ID
+     *
+     * @example
+     * ```typescript
+     * await client.sessions.delete('session-id');
+     * ```
+     */
+    delete(sessionId: string): Promise<void>;
+    /**
+     * Poll execution until completion
+     */
+    private pollExecution;
+}
+
+/**
+ * AI SaaS Client
+ *
+ * Main entry point for the SDK. Provides access to all resource APIs.
+ *
+ * @example
+ * ```typescript
+ * import { AISaaSClient } from '@cadraos/sdk';
+ *
+ * const client = new AISaaSClient({
+ *   apiKey: process.env.AISAAS_API_KEY,
+ *   orgId: Number(process.env.AISAAS_ORG_ID),
+ * });
+ *
+ * // List agents
+ * const { data: agents } = await client.agents.list();
+ *
+ * // Execute an agent
+ * const execution = await client.agents.executeSync(agents[0].uuid, {
+ *   task: 'Summarize the latest news',
+ * });
+ *
+ * // Stream an agent execution
+ * const stream = await client.agents.stream(agents[0].uuid, {
+ *   task: 'Research climate change',
+ * });
+ *
+ * stream.on('log', (log) => console.log(log.title));
+ * stream.on('complete', ({ execution }) => console.log(execution.output));
+ *
+ * const result = await stream.wait();
+ * ```
+ */
+
+/**
+ * Client options for API key authentication
+ */
+interface AISaaSClientOptionsApiKey {
+    /** API key for authentication */
+    apiKey: string;
+    /** Organization ID */
+    orgId: number;
+    /** Base URL for API (default: https://api.aisaas.com/v1) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
+}
+/**
+ * Client options for OAuth token authentication
+ */
+interface AISaaSClientOptionsToken {
+    /** OAuth token for authentication */
+    token: string;
+    /** Organization ID */
+    orgId: number;
+    /** Base URL for API (default: https://api.aisaas.com/v1) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
+}
+/**
+ * Client options for token provider authentication
+ */
+interface AISaaSClientOptionsTokenProvider {
+    /** Token provider callback (called before each request) */
+    tokenProvider: () => Promise<string>;
+    /** Organization ID */
+    orgId: number;
+    /** Base URL for API (default: https://api.aisaas.com/v1) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
+}
+/**
+ * All client options
+ */
+type AISaaSClientOptions = AISaaSClientOptionsApiKey | AISaaSClientOptionsToken | AISaaSClientOptionsTokenProvider;
+/**
+ * AI SaaS Client
+ *
+ * Main class for interacting with the AI SaaS API.
+ * Provides access to all resource APIs (agents, skills, tools, artifacts, sessions).
+ */
+declare class AISaaSClient {
+    private readonly httpClient;
+    private readonly config;
+    /**
+     * Agent operations (list, execute, stream, update)
+     */
+    readonly agents: AgentsAPI;
+    /**
+     * Skill operations (list, get, execute, update)
+     */
+    readonly skills: SkillsAPI;
+    /**
+     * Tool operations (list, get, execute, validate, update)
+     */
+    readonly tools: ToolsAPI;
+    /**
+     * Artifact operations (list, get, download, upload, delete)
+     */
+    readonly artifacts: ArtifactsAPI;
+    /**
+     * Session operations (list, get, create, message, delete)
+     */
+    readonly sessions: SessionsAPI;
+    /**
+     * Create a new AI SaaS client
+     *
+     * @param options - Client configuration options
+     *
+     * @example
+     * ```typescript
+     * // API key authentication
+     * const client = new AISaaSClient({
+     *   apiKey: 'sk_...',
+     *   orgId: 123,
+     * });
+     *
+     * // OAuth token authentication
+     * const client = new AISaaSClient({
+     *   token: 'eyJ...',
+     *   orgId: 123,
+     * });
+     *
+     * // Token provider (for automatic refresh)
+     * const client = new AISaaSClient({
+     *   tokenProvider: async () => myAuth.getAccessToken(),
+     *   orgId: 123,
+     * });
+     * ```
+     */
+    constructor(options: AISaaSClientOptions);
+    /**
+     * Validate client options
+     */
+    private validateOptions;
+}
+
+/**
+ * SDK Error Classes
+ *
+ * Typed error hierarchy for all SDK operations.
+ * All errors extend AISaaSError and include code, status, and optional details.
+ */
+/**
+ * Base error class for all SDK errors
+ */
+declare class AISaaSError extends Error {
+    /** Error code */
+    readonly code: string;
+    /** HTTP status code */
+    readonly status: number;
+    /** Additional error details */
+    readonly details?: Record<string, unknown>;
+    /** Request ID from server (for debugging) */
+    readonly requestId?: string;
+    constructor(message: string, code: string, status: number, details?: Record<string, unknown>, requestId?: string);
+}
+/**
+ * Authentication error (401)
+ * Thrown when API key is invalid, expired, or missing
+ */
+declare class AuthenticationError extends AISaaSError {
+    constructor(message?: string, code?: string, details?: Record<string, unknown>, requestId?: string);
+}
+/**
+ * Authorization error (403)
+ * Thrown when user lacks permission for the requested operation
+ */
+declare class AuthorizationError extends AISaaSError {
+    constructor(message?: string, code?: string, details?: Record<string, unknown>, requestId?: string);
+}
+/**
+ * Not found error (404)
+ * Thrown when requested resource does not exist
+ */
+declare class NotFoundError extends AISaaSError {
+    constructor(message?: string, code?: string, details?: Record<string, unknown>, requestId?: string);
+}
+/**
+ * Validation error (400/422)
+ * Thrown when request input is invalid
+ */
+declare class ValidationError extends AISaaSError {
+    /** Field-level validation errors */
+    readonly errors: Array<{
+        field: string;
+        message: string;
+    }>;
+    constructor(message?: string, errors?: Array<{
+        field: string;
+        message: string;
+    }>, details?: Record<string, unknown>, requestId?: string);
+}
+/**
+ * Rate limit error (429)
+ * Thrown when rate limit is exceeded
+ */
+declare class RateLimitError extends AISaaSError {
+    /** Seconds until rate limit resets */
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number, details?: Record<string, unknown>, requestId?: string);
+}
+/**
+ * Server error (5xx)
+ * Thrown for server-side errors
+ */
+declare class ServerError extends AISaaSError {
+    constructor(message?: string, status?: number, details?: Record<string, unknown>, requestId?: string);
+}
+/**
+ * Conflict error (409)
+ * Thrown when there is a resource conflict
+ */
+declare class ConflictError extends AISaaSError {
+    constructor(message?: string, details?: Record<string, unknown>, requestId?: string);
+}
+/**
+ * Timeout error
+ * Thrown when a request or operation times out
+ */
+declare class TimeoutError extends AISaaSError {
+    constructor(message?: string, details?: Record<string, unknown>, requestId?: string);
+}
+/**
+ * Network error
+ * Thrown when there is a network connectivity issue
+ */
+declare class NetworkError extends AISaaSError {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+
+export { AISaaSClient, type AISaaSClientOptions, AISaaSError, type Agent, type AgentConfig, type AgentConfigUpdateInput, type AgentExecution, type AgentListOptions, type AgentStatus, type AgentType, type AgentUpdateInput, type Artifact, type ArtifactDownloadOptions, type ArtifactListOptions, type ArtifactType, type ArtifactUploadInput, AuthenticationError, AuthorizationError, type CompleteEvent, ConflictError, type ConnectionChangeEvent, type ErrorEvent, type ExecuteInput, type ExecuteOptions, type ExecuteResponse, type ExecutionLog, type ExecutionStatus, type ExecutionStreamController, type ExecutionStreamControllerOptions, type JSONSchema, type ListOptions, NetworkError, NotFoundError, type PaginatedResponse, type PaginationInfo, type PlanEvent, RateLimitError, type SendMessageInput, ServerError, type Session, type SessionArtifact, type SessionArtifactListOptions, type SessionArtifactType, type SessionArtifactVariantType, type SessionCreateInput, type SessionHistory, type SessionListOptions, type SessionMessage, type SignedUrlResponse, type Skill, type SkillDetails, type SkillExecuteInput, type SkillExecution, type SkillListOptions, type SkillTool, type SkillUpdateInput, type SkillVariable, type StreamController, type StreamEventMap, TimeoutError, type TokenUsage, type Tool, type ToolCallEvent, type ToolConfigUpdateInput, type ToolExecution, type ToolListOptions, type ToolResultEvent, type ToolUpdateInput, type ToolValidationResult, ValidationError };