@agent-nexus/sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,3336 @@
+/** Pagination query parameters accepted by list endpoints. */
+interface PaginationParams {
+    /** Page number (1-based). */
+    page?: number;
+    /** Items per page. */
+    limit?: number;
+}
+/** Pagination metadata returned alongside list results. */
+interface PaginationMeta {
+    /** Total number of items across all pages. */
+    total: number;
+    /** Current page number (1-based). */
+    page: number;
+    /** Whether more pages exist after the current one. */
+    hasMore: boolean;
+}
+/** Paginated response wrapper returned by list methods. */
+interface PageResponse<T> {
+    /** Items on the current page. */
+    data: T[];
+    /** Pagination metadata. */
+    meta: PaginationMeta;
+}
+/** Response returned after successfully deleting a resource. */
+interface DeleteResponse {
+    /** ID of the deleted resource. */
+    id: string;
+    /** Always `true` on successful deletion. */
+    deleted: true;
+}
+/** Agent lifecycle status. `"ACTIVE"` agents are deployed; `"DRAFT"` agents are in development. */
+type AgentStatus = "ACTIVE" | "DRAFT";
+/** Model provider. */
+type ModelProvider = "OPEN_AI" | "ANTHROPIC" | "GOOGLE_AI";
+/**
+ * Model configuration — the modern way to set an agent's model.
+ *
+ * Use `client.models.list()` to get available models. The `modelId` from the
+ * response goes into `modelName`, and `provider` goes into `modelProvider`.
+ */
+interface ModelConfig {
+    /** Model ID from the catalog (e.g. "claude-sonnet-4-6", "gpt-4.1"). */
+    modelName: string;
+    /** Provider: "OPEN_AI", "ANTHROPIC", or "GOOGLE_AI". */
+    modelProvider: ModelProvider;
+    /** Anthropic thinking level: "fast", "detailed", or "extended". */
+    thinkingLevel?: "fast" | "detailed" | "extended";
+    /** OpenAI reasoning effort: "none", "auto", "low", "medium", "high", "xhigh". */
+    reasoningEffort?: "none" | "auto" | "low" | "medium" | "high" | "xhigh";
+    /** Google AI thinking level: "dynamic", "minimal", "low", "medium", "high". */
+    geminiThinkingLevel?: "dynamic" | "minimal" | "low" | "medium" | "high";
+    /** Sampling temperature (0-1). */
+    temperature?: number;
+}
+/**
+ * Valid agent model identifiers. These map to the `AgentModel` Prisma enum.
+ *
+ * Use `client.models.list()` to retrieve all enabled models from the database
+ * with their display names, providers, and capabilities.
+ */
+type AgentModel = "DEFAULT" | "GPT_4_TURBO" | "GPT_4" | "GPT_4_5" | "GPT_4_1" | "GPT_4_1_MINI" | "GPT_4_1_NANO" | "GPT_3_5_TURBO" | "GPT_3_5_TURBO_16K" | "MISTRAL_LARGE" | "OPENAI_O1" | "OPENAI_O1_MINI" | "OPENAI_O3_MINI" | "OPENAI_O3" | "OPENAI_O3_PRO" | "OPENAI_O4_MINI";
+/**
+ * The type of tool configuration attached to an agent.
+ *
+ * - `"PLUGIN"` — Pipedream marketplace tool (external API integration).
+ * - `"WORKFLOW"` — An organization-owned automation workflow.
+ * - `"TASK"` — An organization-owned AI task.
+ * - `"COLLECTION"` — A knowledge collection the agent can query.
+ * - `"DOCUMENT_TEMPLATE"` — A document generation template.
+ */
+type AgentToolConfigType = "WORKFLOW" | "PLUGIN" | "TASK" | "COLLECTION" | "DOCUMENT_TEMPLATE";
+/** Prompt version type. `"AUTO"` versions are created automatically on prompt changes; `"CHECKPOINT"` versions are manually named snapshots. */
+type VersionType = "AUTO" | "CHECKPOINT";
+
+/** Configuration options for the HTTP client. */
+interface HttpClientOptions {
+    /** Base URL of the Nexus API (e.g. `"https://api.nexusgpt.io"`). */
+    baseUrl: string;
+    /** API key for authentication. */
+    apiKey: string;
+    /** Custom `fetch` implementation. Defaults to the global `fetch`. */
+    fetch?: typeof globalThis.fetch;
+    /** Additional headers sent with every request. */
+    defaultHeaders?: Record<string, string>;
+    /** Request timeout in milliseconds (default 30 000). */
+    timeout?: number;
+}
+/** Options for a single HTTP request. */
+interface RequestOptions {
+    /** Request body (will be JSON-serialized unless it's a `FormData` instance). */
+    body?: unknown;
+    /** Query string parameters. `undefined` values are omitted. */
+    query?: Record<string, string | number | boolean | undefined>;
+    /** Additional headers for this request. */
+    headers?: Record<string, string>;
+}
+/**
+ * Low-level HTTP client for the Nexus Public API.
+ *
+ * Most users should use `NexusClient` instead, which provides typed resource
+ * methods. The `HttpClient` is exported for advanced use cases (e.g. calling
+ * endpoints not yet covered by the SDK).
+ *
+ * All requests are sent to `{baseUrl}/api/public/v1{path}` with the API key
+ * in the `api-key` header. Responses are expected to follow the envelope format:
+ * `{ success: true, data: T, meta?: PaginationMeta }`.
+ */
+declare class HttpClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly fetchFn;
+    private readonly defaultHeaders;
+    private readonly timeout;
+    constructor(opts: HttpClientOptions);
+    /**
+     * Make a request and return the unwrapped `data` field.
+     *
+     * @param method - HTTP method (GET, POST, PATCH, DELETE).
+     * @param path - API path relative to `/api/public/v1` (e.g. `"/agents"`).
+     * @param opts - Optional body, query params, and headers.
+     * @returns The response `data` field, typed as `T`.
+     * @throws {NexusAuthenticationError} On 401 responses.
+     * @throws {NexusApiError} On other error responses.
+     * @throws {NexusConnectionError} On network failures or timeouts.
+     */
+    request<T>(method: string, path: string, opts?: RequestOptions): Promise<T>;
+    /**
+     * Make a request and return `{ data, meta }` (useful for paginated lists).
+     *
+     * @param method - HTTP method.
+     * @param path - API path relative to `/api/public/v1`.
+     * @param opts - Optional body, query params, and headers.
+     * @returns The response `data` and optional pagination `meta`.
+     * @throws {NexusAuthenticationError} On 401 responses.
+     * @throws {NexusApiError} On other error responses.
+     * @throws {NexusConnectionError} On network failures or timeouts.
+     */
+    requestWithMeta<T>(method: string, path: string, opts?: RequestOptions): Promise<{
+        data: T;
+        meta?: PaginationMeta;
+    }>;
+}
+
+/** Base class for all SDK resource classes. Provides access to the HTTP client. */
+declare abstract class BaseResource {
+    protected readonly http: HttpClient;
+    constructor(http: HttpClient);
+}
+
+declare class AgentCollectionsResource extends BaseResource {
+    list(agentId: string): Promise<any[]>;
+    attach(agentId: string, body: {
+        collectionIds: string[];
+    }): Promise<any>;
+    detach(agentId: string, body: {
+        collectionIds: string[];
+    }): Promise<any>;
+}
+
+/** Agent summary returned by `client.agents.list()`. */
+interface AgentSummary {
+    /** Unique agent UUID. */
+    id: string;
+    /** Agent's first name. */
+    firstName: string;
+    /** Agent's last name. */
+    lastName: string;
+    /** Agent's role or job title (e.g. "Customer Support Agent"). */
+    role: string;
+    /** Short biography displayed in agent cards. */
+    shortBio: string | null;
+    /** URL to the agent's profile picture. */
+    profilePicture: string | null;
+    /** Agent lifecycle status. */
+    status: AgentStatus;
+    /** Model identifier. Must be a valid `AgentModel` enum value (e.g. "GPT_4_1", "DEFAULT"). Use `client.models.list()` to get all available models. */
+    model: AgentModel | null;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** ISO 8601 last-updated timestamp. */
+    updatedAt: string | null;
+}
+/** Full agent detail returned by `client.agents.get()` and `client.agents.create()`. */
+interface AgentDetail extends AgentSummary {
+    /** Full biography / background information. */
+    bio: string | null;
+    /** The agent's objective or mission statement. */
+    objective: string | null;
+    /** Communication tone (e.g. "professional", "friendly"). */
+    tone: string | null;
+    /** Additional explanation or context for the agent. */
+    explanation: string | null;
+    /** Behaviour rules the agent must follow. */
+    behaviour: string[];
+    /** Comma-separated tags for categorization. */
+    tags: string | null;
+    /** Agent's gender (used for avatar/persona). */
+    gender: string | null;
+    /** Unified model configuration. Use `client.models.list()` to get available models. Preferred over legacy `model` field. */
+    modelConfig: ModelConfig | null;
+    /** Human-readable model name derived from modelConfig (e.g. "claude-sonnet-4-6"). */
+    modelName: string | null;
+    /** Model provider derived from modelConfig (e.g. "ANTHROPIC", "OPEN_AI"). */
+    modelProvider: string | null;
+    /** First message displayed when opening the agent playground. */
+    playgroundFirstMessage: string | null;
+    /** The agent's system prompt in markdown format. */
+    prompt: string | null;
+}
+/** Request body for `client.agents.create()`. */
+interface CreateAgentBody {
+    /** Agent's first name (required). */
+    firstName: string;
+    /** Agent's last name (required). */
+    lastName: string;
+    /** Agent's role or job title (required). */
+    role: string;
+    /** Short biography displayed in agent cards. */
+    shortBio?: string;
+    /** Full biography / background information. */
+    bio?: string;
+    /** The agent's objective or mission statement. */
+    objective?: string;
+    /** Communication tone (e.g. "professional", "friendly"). */
+    tone?: string;
+    /** Additional explanation or context for the agent. */
+    explanation?: string;
+    /** Behaviour rules the agent must follow. */
+    behaviour?: string[];
+    /** Comma-separated tags for categorization. */
+    tags?: string;
+    /** Agent's gender (used for avatar/persona). */
+    gender?: string;
+    /** Legacy model enum field. Prefer `modelConfig` instead for full provider support (Claude, Gemini, etc.). */
+    model?: AgentModel;
+    /** Unified model configuration. Use `client.models.list()` to get available models. */
+    modelConfig?: ModelConfig;
+    /** Human-readable model name (e.g. "Claude Sonnet 4.5"). */
+    modelName?: string;
+    /** Model provider (e.g. "anthropic", "openai"). */
+    modelProvider?: string;
+    /** First message displayed when opening the agent playground. Set to `null` to clear. */
+    playgroundFirstMessage?: string | null;
+}
+/** Request body for `client.agents.update()`. All fields are optional — only provided fields are updated. */
+interface UpdateAgentBody {
+    /** Agent's first name. */
+    firstName?: string;
+    /** Agent's last name. */
+    lastName?: string;
+    /** Agent's role or job title. */
+    role?: string;
+    /** Short biography displayed in agent cards. */
+    shortBio?: string;
+    /** Full biography / background information. */
+    bio?: string;
+    /** The agent's objective or mission statement. */
+    objective?: string;
+    /** Communication tone (e.g. "professional", "friendly"). */
+    tone?: string;
+    /** Additional explanation or context for the agent. */
+    explanation?: string;
+    /** Behaviour rules the agent must follow. */
+    behaviour?: string[];
+    /** Comma-separated tags for categorization. */
+    tags?: string;
+    /** Agent's gender (used for avatar/persona). */
+    gender?: string;
+    /** Legacy model enum field. Prefer `modelConfig` instead for full provider support (Claude, Gemini, etc.). */
+    model?: AgentModel;
+    /** Unified model configuration. Use `client.models.list()` to get available models. */
+    modelConfig?: ModelConfig;
+    /** Human-readable model name. */
+    modelName?: string;
+    /** Model provider. */
+    modelProvider?: string;
+    /** The agent's system prompt in markdown format. */
+    prompt?: string;
+    /** First message displayed when opening the agent playground. Set to `null` to clear. */
+    playgroundFirstMessage?: string | null;
+}
+/** Query parameters for `client.agents.list()`. */
+interface ListAgentsParams {
+    /** Page number (1-based, default 1). */
+    page?: number;
+    /** Items per page (default 20). */
+    limit?: number;
+    /** Filter by agent status. */
+    status?: AgentStatus;
+    /** Free-text search across agent names and roles. */
+    search?: string;
+}
+/** Response from `client.agents.uploadProfilePicture()`. */
+interface UploadProfilePictureResponse {
+    /** URL to the uploaded profile picture. */
+    profilePicture: string;
+}
+
+/** A tool configuration attached to an agent. Returned by `client.agents.tools.list()` and related methods. */
+interface AgentToolConfig {
+    /** Unique tool config UUID. */
+    id: string;
+    /** Display name for the tool (e.g. "Gmail - Send Email"). */
+    label: string;
+    /** Description of what this tool does. */
+    description: string | null;
+    /** URL to the tool's icon. */
+    iconUrl: string | null;
+    /** Icon type identifier. */
+    iconType: string | null;
+    /**
+     * Tool type.
+     *
+     * - `"PLUGIN"` — Pipedream marketplace tool (use `client.tools` to discover and configure).
+     * - `"WORKFLOW"` — Organization workflow.
+     * - `"TASK"` — Organization AI task.
+     * - `"COLLECTION"` — Knowledge collection.
+     * - `"DOCUMENT_TEMPLATE"` — Document generation template.
+     */
+    type: AgentToolConfigType;
+    /**
+     * JSON Schema defining the input the agent must provide when invoking this tool.
+     * For PLUGIN tools, this is typically auto-generated from the action's parameter schema.
+     */
+    agentInputSchema: unknown | null;
+    /**
+     * Internal tool configuration. For PLUGIN tools this contains:
+     * - `toolId` — Marketplace tool ID
+     * - `toolCredentialId` — Credential UUID
+     * - `parametersSetup` — Pre-configured parameter values
+     * - Action selection and other provider-specific settings
+     */
+    config: unknown | null;
+    /** Whether this tool is enabled. Disabled tools are not available to the agent at runtime. */
+    isActive: boolean;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** ISO 8601 last-updated timestamp. */
+    updatedAt: string | null;
+}
+/** Request body for `client.agents.tools.create()`. */
+interface CreateAgentToolBody {
+    /** Display name for the tool (required). */
+    label: string;
+    /** Description of what this tool does. */
+    description?: string;
+    /** URL to the tool's icon. */
+    iconUrl?: string;
+    /** Icon type identifier. */
+    iconType?: string;
+    /** Tool type (required). */
+    type: AgentToolConfigType;
+    /**
+     * JSON Schema defining the input the agent must provide when invoking this tool (required).
+     * Use `{ type: "object", properties: { ... } }` or `{}` if no input is needed.
+     */
+    agentInputSchema: unknown;
+    /** Internal tool configuration (provider-specific). */
+    config?: unknown;
+    /** Whether this tool is enabled (default `true`). */
+    isActive?: boolean;
+}
+/** Request body for `client.agents.tools.attachCollection()`. */
+interface AttachCollectionBody {
+    /** The collection's UUID (required). */
+    collectionId: string;
+    /** Display name for the tool. Defaults to the collection name if omitted. */
+    label?: string;
+    /** Description of what the tool does. Defaults to the collection description if omitted. */
+    description?: string;
+    /** Optional instructions for how the agent should use this collection. */
+    instructions?: string;
+}
+/** Request body for `client.agents.tools.update()`. All fields are optional. */
+interface UpdateAgentToolBody {
+    /** Display name for the tool. */
+    label?: string;
+    /** Description of what this tool does. */
+    description?: string;
+    /** URL to the tool's icon. */
+    iconUrl?: string;
+    /** Icon type identifier. */
+    iconType?: string;
+    /** Tool type. */
+    type?: AgentToolConfigType;
+    /** JSON Schema defining the input the agent must provide when invoking this tool. */
+    agentInputSchema?: unknown;
+    /** Internal tool configuration (provider-specific). */
+    config?: unknown;
+    /** Whether this tool is enabled. */
+    isActive?: boolean;
+}
+
+/**
+ * Agent tool configuration resource. Accessed via `client.agents.tools`.
+ *
+ * Manages the tools attached to an agent. Each tool config represents a
+ * configured integration (e.g. "Gmail - Send Email" with saved credentials
+ * and parameter defaults).
+ *
+ * To discover available marketplace tools before creating a config, use
+ * `client.tools.search()` and `client.tools.get()`.
+ */
+declare class AgentToolsResource extends BaseResource {
+    /**
+     * List all tool configurations for an agent.
+     *
+     * @param agentId - Agent UUID.
+     * @returns Array of tool configurations.
+     */
+    list(agentId: string): Promise<AgentToolConfig[]>;
+    /**
+     * Get a specific tool configuration.
+     *
+     * @param agentId - Agent UUID.
+     * @param toolId - Tool config UUID.
+     * @returns Tool configuration detail.
+     */
+    get(agentId: string, toolId: string): Promise<AgentToolConfig>;
+    /**
+     * Add a new tool configuration to an agent.
+     *
+     * @param agentId - Agent UUID.
+     * @param body - Tool configuration. `label` and `type` are required.
+     * @returns The created tool configuration.
+     */
+    create(agentId: string, body: CreateAgentToolBody): Promise<AgentToolConfig>;
+    /**
+     * Update an existing tool configuration. Only provided fields are updated.
+     *
+     * @param agentId - Agent UUID.
+     * @param toolId - Tool config UUID.
+     * @param body - Fields to update.
+     * @returns The updated tool configuration.
+     */
+    update(agentId: string, toolId: string, body: UpdateAgentToolBody): Promise<AgentToolConfig>;
+    /**
+     * Remove a tool configuration from an agent.
+     *
+     * @param agentId - Agent UUID.
+     * @param toolId - Tool config UUID.
+     * @returns Confirmation with the deleted tool config's ID.
+     */
+    delete(agentId: string, toolId: string): Promise<DeleteResponse>;
+    /**
+     * Attach a knowledge collection to an agent.
+     *
+     * Creates a COLLECTION-type tool that allows the agent to search the
+     * collection during conversations. If `label` is omitted, the collection
+     * name is used.
+     *
+     * @param agentId - Agent UUID.
+     * @param body - Collection ID and optional label/description/instructions.
+     * @returns The created tool configuration.
+     *
+     * @example
+     * ```ts
+     * const tool = await client.agents.tools.attachCollection("agent-uuid", {
+     *   collectionId: "collection-uuid"
+     * });
+     * ```
+     */
+    attachCollection(agentId: string, body: AttachCollectionBody): Promise<AgentToolConfig>;
+}
+
+/** The user who created a prompt version. */
+interface VersionCreator {
+    /** User UUID. */
+    id: string;
+    /** User's first name. */
+    firstName: string | null;
+    /** User's last name. */
+    lastName: string | null;
+}
+/** Prompt version summary returned by `client.agents.versions.list()`. */
+interface VersionSummary {
+    /** Unique version UUID. */
+    id: string;
+    /** Version type: `"AUTO"` (created on prompt changes) or `"CHECKPOINT"` (manually named snapshot). */
+    type: VersionType;
+    /** Version name (only set for checkpoints). */
+    name: string | null;
+    /** Version description. */
+    description: string | null;
+    /** Whether this version is currently deployed to production. */
+    isProduction: boolean;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** User UUID who created this version. */
+    createdBy: string | null;
+    /** Creator's name details. */
+    creator: VersionCreator | null;
+}
+/** Full version detail including the prompt content. Returned by `client.agents.versions.get()`. */
+interface VersionDetail extends VersionSummary {
+    /** The full agent system prompt at this version, in markdown format. */
+    prompt: string | null;
+}
+/** Query parameters for `client.agents.versions.list()`. */
+interface ListVersionsParams {
+    /** Page number (1-based, default 1). */
+    page?: number;
+    /** Items per page (default 20). */
+    limit?: number;
+    /** Filter by version type. */
+    type?: VersionType;
+}
+/** Request body for `client.agents.versions.createCheckpoint()`. */
+interface CreateCheckpointBody {
+    /** Checkpoint name (e.g. "v1.0", "before-refactor"). */
+    name?: string;
+    /** Description of what this checkpoint captures. */
+    description?: string;
+}
+/** Request body for `client.agents.versions.update()`. */
+interface UpdateVersionBody {
+    /** New version name. */
+    name?: string;
+    /** New version description. */
+    description?: string;
+}
+/** Response from `client.agents.versions.restore()`. */
+interface RestoreVersionResponse {
+    /** The restored prompt content. */
+    prompt: string | null;
+    /** Confirmation message. */
+    message: string;
+}
+
+/**
+ * Agent prompt version resource. Accessed via `client.agents.versions`.
+ *
+ * Versions track changes to an agent's system prompt over time.
+ * - `AUTO` versions are created automatically when the prompt changes.
+ * - `CHECKPOINT` versions are manually named snapshots (e.g. "v1.0").
+ *
+ * Use `restore()` to revert an agent's prompt to a previous version,
+ * and `publish()` to deploy a version to production.
+ */
+declare class VersionsResource extends BaseResource {
+    /**
+     * List prompt versions for an agent (paginated).
+     *
+     * @param agentId - Agent UUID.
+     * @param params - Optional type filter and pagination.
+     * @returns Paginated list of version summaries.
+     */
+    list(agentId: string, params?: ListVersionsParams): Promise<PageResponse<VersionSummary>>;
+    /**
+     * Get detailed information about a specific version, including the full prompt content.
+     *
+     * @param agentId - Agent UUID.
+     * @param versionId - Version UUID.
+     * @returns Version detail with the prompt text.
+     */
+    get(agentId: string, versionId: string): Promise<VersionDetail>;
+    /**
+     * Create a named checkpoint of the agent's current prompt.
+     *
+     * @param agentId - Agent UUID.
+     * @param body - Optional name and description for the checkpoint.
+     * @returns The created checkpoint version.
+     */
+    createCheckpoint(agentId: string, body?: CreateCheckpointBody): Promise<VersionDetail>;
+    /**
+     * Update a version's metadata (name or description).
+     *
+     * @param agentId - Agent UUID.
+     * @param versionId - Version UUID.
+     * @param body - Fields to update.
+     * @returns The updated version detail.
+     */
+    update(agentId: string, versionId: string, body: UpdateVersionBody): Promise<VersionDetail>;
+    /**
+     * Delete a prompt version. Cannot delete the current production version.
+     *
+     * @param agentId - Agent UUID.
+     * @param versionId - Version UUID.
+     * @returns Confirmation with the deleted version's ID.
+     */
+    delete(agentId: string, versionId: string): Promise<DeleteResponse>;
+    /**
+     * Restore the agent's prompt to a specific version. This overwrites the
+     * agent's current prompt with the content from the specified version.
+     *
+     * @param agentId - Agent UUID.
+     * @param versionId - Version UUID to restore.
+     * @returns The restored prompt content and a confirmation message.
+     */
+    restore(agentId: string, versionId: string): Promise<RestoreVersionResponse>;
+    /**
+     * Publish a version to production. This marks the version as the active
+     * production version for the agent.
+     *
+     * @param agentId - Agent UUID.
+     * @param versionId - Version UUID to publish.
+     * @returns The published version detail with `isProduction: true`.
+     */
+    publish(agentId: string, versionId: string): Promise<VersionDetail>;
+}
+
+/**
+ * Agent management resource. Accessed via `client.agents`.
+ *
+ * Provides CRUD operations for agents plus sub-resources for
+ * tool configurations (`client.agents.tools`) and prompt versions
+ * (`client.agents.versions`).
+ */
+declare class AgentsResource extends BaseResource {
+    /** Sub-resource for managing agent tool configurations. */
+    readonly tools: AgentToolsResource;
+    /** Sub-resource for managing agent prompt versions. */
+    readonly versions: VersionsResource;
+    constructor(http: HttpClient);
+    /**
+     * List agents with optional filtering and pagination.
+     *
+     * @param params - Optional filters and pagination.
+     * @returns Paginated list of agent summaries.
+     */
+    list(params?: ListAgentsParams): Promise<PageResponse<AgentSummary>>;
+    /**
+     * Get detailed information about a specific agent.
+     *
+     * @param agentId - Agent UUID.
+     * @returns Full agent detail including prompt, behaviour rules, and model configuration.
+     */
+    get(agentId: string): Promise<AgentDetail>;
+    /**
+     * Create a new agent.
+     *
+     * @param body - Agent properties. `firstName`, `lastName`, and `role` are required.
+     * @returns The created agent detail.
+     */
+    create(body: CreateAgentBody): Promise<AgentDetail>;
+    /**
+     * Update an existing agent's properties. Only provided fields are updated.
+     *
+     * @param agentId - Agent UUID.
+     * @param body - Fields to update.
+     * @returns The updated agent detail.
+     */
+    update(agentId: string, body: UpdateAgentBody): Promise<AgentDetail>;
+    /**
+     * Permanently delete an agent and all its tool configurations and versions.
+     *
+     * @param agentId - Agent UUID.
+     * @returns Confirmation with the deleted agent's ID.
+     */
+    delete(agentId: string): Promise<DeleteResponse>;
+    /**
+     * Create a copy of an existing agent, including its configuration and tools.
+     *
+     * @param agentId - Agent UUID to duplicate.
+     * @returns The newly created agent detail.
+     */
+    duplicate(agentId: string): Promise<AgentDetail>;
+    /**
+     * Upload a profile picture for an agent.
+     *
+     * @param agentId - Agent UUID.
+     * @param file - Image file as a Blob or File.
+     * @returns URL to the uploaded profile picture.
+     */
+    uploadProfilePicture(agentId: string, file: Blob | File): Promise<UploadProfilePictureResponse>;
+    /**
+     * Generate an AI profile picture for an agent using its name and role.
+     *
+     * @param agentId - Agent UUID.
+     * @param body - Optional custom prompt to guide image style.
+     * @returns URLs of the generated profile picture in multiple sizes.
+     */
+    generateProfilePicture(agentId: string, body?: {
+        customPrompt?: string;
+    }): Promise<{
+        profilePicture: string;
+        sizes: Record<string, string>;
+    }>;
+}
+
+declare class AnalyticsResource extends BaseResource {
+    getOverview(params?: {
+        timePeriod?: string;
+        deploymentId?: string;
+    }): Promise<any>;
+    exportCsv(params?: {
+        timePeriod?: string;
+        deploymentId?: string;
+    }): Promise<any>;
+    listFeedback(params?: {
+        timePeriod?: string;
+        deploymentId?: string;
+        score?: number;
+        page?: number;
+        limit?: number;
+    }): Promise<any>;
+}
+
+declare class CloudImportsResource extends BaseResource {
+    googleDriveAuth(body: {
+        code: string;
+        redirectUri: string;
+    }): Promise<any>;
+    googleDriveRefresh(body: {
+        refreshToken: string;
+    }): Promise<any>;
+    listGoogleDriveFiles(params: {
+        accessToken: string;
+        folderId?: string;
+        pageToken?: string;
+    }): Promise<any>;
+    importGoogleDrive(body: {
+        accessToken: string;
+        fileIds: string[];
+        parentId?: string;
+    }): Promise<any>;
+    sharePointAuth(body: {
+        code: string;
+        redirectUri: string;
+    }): Promise<any>;
+    sharePointRefresh(body: {
+        refreshToken: string;
+    }): Promise<any>;
+    listSharePointSites(params: {
+        connectionId: string;
+    }): Promise<any>;
+    listSharePointFiles(params: {
+        connectionId: string;
+        siteId: string;
+        folderId?: string;
+    }): Promise<any>;
+    importSharePoint(body: {
+        connectionId: string;
+        siteId: string;
+        fileIds: string[];
+        parentId?: string;
+    }): Promise<any>;
+    notionAuth(body: {
+        code: string;
+        redirectUri: string;
+    }): Promise<any>;
+    searchNotion(params: {
+        connectionId: string;
+        query?: string;
+        filter?: string;
+        cursor?: string;
+    }): Promise<any>;
+    importNotion(body: {
+        connectionId: string;
+        pageIds?: string[];
+        databaseIds?: string[];
+        parentId?: string;
+    }): Promise<any>;
+}
+
+declare class DeploymentFoldersResource extends BaseResource {
+    list(): Promise<any>;
+    create(body: {
+        name: string;
+        parentId?: string;
+    }): Promise<any>;
+    update(folderId: string, body: {
+        name?: string;
+        parentId?: string | null;
+    }): Promise<any>;
+    delete(folderId: string): Promise<any>;
+    assign(body: {
+        deploymentId: string;
+        folderId: string | null;
+    }): Promise<any>;
+}
+
+declare class DeploymentsResource extends BaseResource {
+    list(params?: {
+        page?: number;
+        limit?: number;
+        search?: string;
+        type?: string;
+        isActive?: boolean;
+    }): Promise<PageResponse<any>>;
+    create(body: {
+        name: string;
+        type: string;
+        agentId?: string;
+        description?: string;
+        settings?: Record<string, unknown>;
+    }): Promise<any>;
+    get(deploymentId: string): Promise<any>;
+    update(deploymentId: string, body: {
+        name?: string;
+        description?: string | null;
+        agentId?: string | null;
+        settings?: Record<string, unknown>;
+        isActive?: boolean;
+    }): Promise<any>;
+    delete(deploymentId: string): Promise<any>;
+    duplicate(deploymentId: string): Promise<any>;
+    getStatistics(deploymentId: string): Promise<any>;
+    getEmbedConfig(deploymentId: string): Promise<any>;
+    updateEmbedConfig(deploymentId: string, body: Record<string, unknown>): Promise<any>;
+}
+
+declare class DocumentTemplateFoldersResource extends BaseResource {
+    list(): Promise<any>;
+    create(body: {
+        name: string;
+        parentId?: string;
+    }): Promise<any>;
+    update(folderId: string, body: {
+        name?: string;
+        parentId?: string | null;
+    }): Promise<any>;
+    delete(folderId: string): Promise<any>;
+    assign(body: {
+        templateId: string;
+        folderId: string | null;
+    }): Promise<any>;
+}
+
+/** A document returned from creation endpoints. */
+interface DocumentInfo {
+    /** Unique document ID. */
+    id: string;
+    /** Document name. */
+    name: string;
+    /** Document type (e.g. "FILE", "TEXT", "WEBSITE", "GOOGLE_SHEET"). */
+    type: string;
+    /** Processing status (e.g. "PROCESSING", "READY", "ERROR"). */
+    status: string;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+}
+/** Detailed document information returned from the get endpoint. */
+interface DocumentDetail {
+    /** Unique document ID. */
+    id: string;
+    /** Document name. */
+    name: string;
+    /** Optional description. */
+    description: string | null;
+    /** Document type (e.g. "FILE", "TEXT", "WEBSITE", "GOOGLE_SHEET"). */
+    type: string;
+    /** Source type (e.g. "UPLOAD", "CRAWL", "SITEMAP"). */
+    sourceType: string | null;
+    /** MIME type of the document. */
+    mimeType: string | null;
+    /** Processing status (e.g. "PROCESSING", "READY", "ERROR"). */
+    status: string;
+    /** Whether this document is a folder. */
+    isFolder: boolean;
+    /** Source URL (for websites or Google Sheets). */
+    sourceUrl: string | null;
+    /** File size in bytes. */
+    size: number | null;
+    /** Total number of child documents. */
+    totalChildren: number;
+    /** Number of children with READY status. */
+    readyChildren: number;
+    /** Number of children currently processing. */
+    processingChildren: number;
+    /** Number of children pending processing. */
+    pendingChildren: number;
+    /** Number of children with errors. */
+    errorChildren: number;
+    /** Processing progress (0-100). */
+    processingProgress: number;
+    /** Document tags. */
+    tags: string[];
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** ISO 8601 last update timestamp. */
+    updatedAt: string | null;
+}
+/** Result from creating a Google Sheet document. */
+interface GoogleSheetResult {
+    /** The parent folder document. */
+    folder: DocumentInfo;
+    /** Individual sheet documents. */
+    sheets: DocumentInfo[];
+    /** Human-readable status message. */
+    message: string;
+}
+/** Body for `client.documents.createText()`. */
+interface CreateTextDocumentBody {
+    /** Document name. */
+    name: string;
+    /** Text content. */
+    content: string;
+    /** Optional description. */
+    description?: string;
+}
+/** Body for `client.documents.addWebsite()`. */
+interface AddWebsiteDocumentBody {
+    /** Website URL to crawl. */
+    url: string;
+    /** Crawl mode. */
+    mode: "sitemap" | "crawl";
+    /** Optional crawl configuration. */
+    config?: {
+        urls?: string[];
+        max_depth?: number;
+        max_pages?: number;
+    };
+    /** Optional description. */
+    description?: string;
+}
+/** Body for `client.documents.createGoogleSheet()`. */
+interface CreateGoogleSheetDocumentBody {
+    /** Document name. */
+    name: string;
+    /** Google Sheet URL. */
+    url: string;
+    /** Optional metadata. */
+    metadata?: {
+        hasHeaderRow?: boolean;
+    };
+}
+/** Body for `client.skills.attachDocumentsToCollection()`. */
+interface AttachCollectionDocumentsBody {
+    /** Array of document IDs to link to the collection. */
+    documentIds: string[];
+}
+/** Response from `client.skills.attachDocumentsToCollection()`. */
+interface AttachCollectionDocumentsResponse {
+    /** Status message. */
+    message: string;
+}
+
+/**
+ * Document resource.
+ *
+ * Provides endpoints to retrieve, create documents via file upload, text,
+ * website crawling, or Google Sheet import. Documents can then be attached to
+ * knowledge collections using `client.skills.attachDocumentsToCollection()`.
+ *
+ * Accessed via `client.documents`.
+ */
+declare class DocumentsResource extends BaseResource {
+    /**
+     * Get a document by ID.
+     *
+     * @param documentId - The document's UUID.
+     * @returns Detailed document information.
+     *
+     * @example
+     * ```ts
+     * const doc = await client.documents.get("doc-uuid");
+     * console.log(doc.name, doc.status, doc.processingProgress);
+     * ```
+     */
+    get(documentId: string): Promise<DocumentDetail>;
+    /**
+     * Upload a file as a new document.
+     *
+     * @param file - File as a `Blob`, `File`, or `Buffer`.
+     * @param fileName - File name (required when passing a `Blob` or `Buffer`).
+     * @param description - Optional description.
+     * @returns Created document info.
+     *
+     * @example
+     * ```ts
+     * import fs from "fs";
+     *
+     * const buffer = fs.readFileSync("report.pdf");
+     * const doc = await client.documents.uploadFile(
+     *   new Blob([buffer]),
+     *   "report.pdf",
+     *   "Q4 financial report"
+     * );
+     * console.log(doc.id, doc.status);
+     * ```
+     */
+    uploadFile(file: Blob, fileName?: string, description?: string): Promise<DocumentInfo>;
+    /**
+     * Create a new document from inline text content.
+     *
+     * @param body - Document name, content, and optional description.
+     * @returns Created document info.
+     *
+     * @example
+     * ```ts
+     * const doc = await client.documents.createText({
+     *   name: "Meeting Notes",
+     *   content: "Key decisions from today's meeting..."
+     * });
+     * ```
+     */
+    createText(body: CreateTextDocumentBody): Promise<DocumentInfo>;
+    /**
+     * Crawl a website and create document(s) from the content.
+     *
+     * @param body - URL, crawl mode, optional config and description.
+     * @returns Created document info (folder for crawled pages).
+     *
+     * @example
+     * ```ts
+     * const doc = await client.documents.addWebsite({
+     *   url: "https://docs.example.com",
+     *   mode: "sitemap"
+     * });
+     * ```
+     */
+    addWebsite(body: AddWebsiteDocumentBody): Promise<DocumentInfo>;
+    /**
+     * Import a Google Sheet as document(s).
+     *
+     * @param body - Sheet name, URL, and optional metadata.
+     * @returns Folder document, individual sheet documents, and status message.
+     *
+     * @example
+     * ```ts
+     * const result = await client.documents.createGoogleSheet({
+     *   name: "Product Catalog",
+     *   url: "https://docs.google.com/spreadsheets/d/..."
+     * });
+     * console.log(result.folder.id, result.sheets.length);
+     * ```
+     */
+    createGoogleSheet(body: CreateGoogleSheetDocumentBody): Promise<GoogleSheetResult>;
+    list(params?: {
+        page?: number;
+        limit?: number;
+        type?: string;
+        status?: string;
+        parentId?: string;
+        collectionId?: string;
+        search?: string;
+        isFolder?: boolean;
+    }): Promise<PageResponse<any>>;
+    update(documentId: string, body: {
+        name?: string;
+        description?: string;
+        tags?: string[];
+    }): Promise<any>;
+    delete(documentId: string): Promise<any>;
+    getDownloadUrl(documentId: string): Promise<{
+        url: string;
+        expiresAt?: string;
+    }>;
+    listChildren(documentId: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PageResponse<any>>;
+    reprocess(documentId: string): Promise<any>;
+    createFolder(body: {
+        name: string;
+        parentId?: string;
+    }): Promise<any>;
+}
+
+/** A participant in an emulator session. */
+interface EmulatorParticipant {
+    id: string;
+    identifier: string;
+    displayName?: string;
+}
+/** File attached to an emulator message. */
+interface EmulatorMessageFile {
+    id: string;
+    url: string;
+    name?: string;
+    mimeType?: string;
+}
+/** A message within an emulator session. */
+interface EmulatorMessage {
+    id: string;
+    content: string | null;
+    type: string | null;
+    createdAt: string;
+    participantId?: string;
+    files?: EmulatorMessageFile[];
+}
+/** Summary of an emulator session (returned by list). */
+interface EmulatorSession {
+    id: string;
+    deploymentId: string;
+    chatId: string | null;
+    participants: EmulatorParticipant[];
+    emulatedChannelType: string;
+    createdAt: string;
+}
+/** Detailed emulator session with messages (returned by get). */
+interface EmulatorSessionDetail extends EmulatorSession {
+    messages: EmulatorMessage[];
+}
+/** Debug information returned after sending a message. */
+interface EmulatorDebugInfo {
+    agentId: string | null;
+    modelUsed: string | null;
+    tokensUsed: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    latencyMs: number;
+    toolsInvoked: string[];
+    traceId?: string;
+    runId?: string;
+    runStatus?: string;
+}
+/** Result of sending a message in an emulator session. */
+interface EmulatorSendMessageResult {
+    chatId: string;
+    messageId: string;
+    sessionId: string;
+    debug?: EmulatorDebugInfo;
+}
+/** Summary of a scenario (returned by list). */
+interface EmulatorScenario {
+    id: string;
+    name: string;
+    description: string | null;
+    deploymentId: string;
+    messageCount: number;
+    createdAt: string;
+}
+/** A message within a scenario. */
+interface EmulatorScenarioMessage {
+    id: string;
+    sequenceOrder: number;
+    participantId: string;
+    participantName: string | null;
+    content: string;
+    attachments: unknown;
+    delayMs: number;
+}
+/** Detailed scenario with messages (returned by get). */
+interface EmulatorScenarioDetail extends EmulatorScenario {
+    messages: EmulatorScenarioMessage[];
+}
+interface CreateEmulatorSessionBody {
+    participants?: Array<{
+        identifier?: string;
+        displayName?: string;
+    }>;
+}
+interface SendEmulatorMessageBody {
+    content: string;
+    participantId?: string;
+    knowledgeIds?: string[];
+    images?: string[];
+}
+interface SaveEmulatorScenarioBody {
+    name: string;
+    description?: string;
+    sessionId: string;
+    deploymentId: string;
+}
+interface ReplayEmulatorScenarioBody {
+    deploymentId: string;
+}
+interface ListEmulatorScenariosParams {
+    deploymentId?: string;
+}
+
+/**
+ * Emulator resource. Accessed via `client.emulator`.
+ *
+ * Test deployments without real external channels by creating emulator sessions,
+ * sending messages, and managing replayable scenarios.
+ */
+declare class EmulatorResource extends BaseResource {
+    /** Create a new emulator session for a deployment. */
+    createSession(deploymentId: string, body?: CreateEmulatorSessionBody): Promise<EmulatorSession>;
+    /** List emulator sessions for a deployment. */
+    listSessions(deploymentId: string): Promise<EmulatorSession[]>;
+    /** Get detailed information about an emulator session, including messages. */
+    getSession(deploymentId: string, sessionId: string): Promise<EmulatorSessionDetail>;
+    /** Send a message in an emulator session. Returns debug info about agent execution. */
+    sendMessage(deploymentId: string, sessionId: string, body: SendEmulatorMessageBody): Promise<EmulatorSendMessageResult>;
+    /** Delete an emulator session. */
+    deleteSession(deploymentId: string, sessionId: string): Promise<void>;
+    /** Save a scenario from an existing emulator session. */
+    saveScenario(body: SaveEmulatorScenarioBody): Promise<EmulatorScenario>;
+    /** List scenarios, optionally filtered by deployment. */
+    listScenarios(params?: ListEmulatorScenariosParams): Promise<EmulatorScenario[]>;
+    /** Get detailed information about a scenario, including its messages. */
+    getScenario(scenarioId: string): Promise<EmulatorScenarioDetail>;
+    /** Replay a scenario against a deployment. Runs asynchronously. */
+    replayScenario(scenarioId: string, body: ReplayEmulatorScenarioBody): Promise<unknown>;
+    /** Delete a scenario. */
+    deleteScenario(scenarioId: string): Promise<void>;
+}
+
+declare class EvaluationsResource extends BaseResource {
+    createSession(taskId: string, body: {
+        name: string;
+        description?: string;
+    }): Promise<any>;
+    listSessions(taskId: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PageResponse<any>>;
+    getSession(taskId: string, sessionId: string): Promise<any>;
+    deleteSession(taskId: string, sessionId: string): Promise<any>;
+    getDatasetRows(taskId: string, sessionId: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PageResponse<any>>;
+    addDatasetRow(taskId: string, sessionId: string, body: {
+        input: unknown;
+        expectedOutput?: unknown;
+    }): Promise<any>;
+    execute(taskId: string, sessionId: string): Promise<any>;
+    judge(taskId: string, sessionId: string, body?: {
+        judgeModel?: string;
+        judgePrompt?: string;
+    }): Promise<any>;
+    getResults(taskId: string, sessionId: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PageResponse<any>>;
+    listFormats(): Promise<any[]>;
+    listJudges(): Promise<any[]>;
+}
+
+/** A folder for organizing agents. Folders can be nested via `parentId`. */
+interface AgentFolder {
+    /** Unique folder UUID. */
+    id: string;
+    /** Folder display name. */
+    name: string;
+    /** URL to the folder's icon. */
+    iconUrl: string | null;
+    /** Parent folder ID for nesting, or `null` for root-level folders. */
+    parentId: string | null;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** ISO 8601 last-updated timestamp. */
+    updatedAt: string | null;
+}
+/** Represents an agent's assignment to a folder. */
+interface FolderAssignment {
+    /** Agent UUID. */
+    agentId: string;
+    /** Folder UUID the agent is assigned to. */
+    folderId: string;
+}
+/** Response from `client.folders.list()`. */
+interface ListFoldersResponse {
+    /** All folders in the organization. */
+    folders: AgentFolder[];
+    /** All agent-to-folder assignments. */
+    assignments: FolderAssignment[];
+}
+/** Request body for `client.folders.create()`. */
+interface CreateFolderBody {
+    /** Folder display name (required). */
+    name: string;
+    /** Parent folder UUID for nesting. Omit for a root-level folder. */
+    parentId?: string;
+}
+/** Request body for `client.folders.update()`. All fields are optional. */
+interface UpdateFolderBody {
+    /** New folder display name. */
+    name?: string;
+    /** New parent folder UUID. Set to `null` to move to root level. */
+    parentId?: string | null;
+}
+/** Request body for `client.folders.assignAgent()`. */
+interface AssignAgentToFolderBody {
+    /** Agent UUID to assign. */
+    agentId: string;
+    /** Target folder UUID, or `null` to remove the agent from its folder. */
+    folderId: string | null;
+}
+/** Response from `client.folders.assignAgent()`. */
+interface AssignAgentToFolderResponse {
+    /** Agent UUID. */
+    agentId: string;
+    /** Folder UUID the agent was assigned to, or `null` if removed. */
+    folderId: string | null;
+    /** Whether the assignment was successful. */
+    assigned: boolean;
+}
+
+/**
+ * Folder management resource. Accessed via `client.folders`.
+ *
+ * Folders organize agents into groups. They support nesting via `parentId`.
+ * Agents are assigned to folders via `assignAgent()`.
+ */
+declare class FoldersResource extends BaseResource {
+    /**
+     * List all folders and their agent assignments.
+     *
+     * @returns All folders and a flat list of agent-to-folder assignments.
+     */
+    list(): Promise<ListFoldersResponse>;
+    /**
+     * Create a new folder for organizing agents.
+     *
+     * @param body - Folder properties. `name` is required. Set `parentId` for nesting.
+     * @returns The created folder.
+     */
+    create(body: CreateFolderBody): Promise<AgentFolder>;
+    /**
+     * Update a folder's properties.
+     *
+     * @param folderId - Folder UUID.
+     * @param body - Fields to update. Set `parentId` to `null` to move to root level.
+     * @returns The updated folder.
+     */
+    update(folderId: string, body: UpdateFolderBody): Promise<AgentFolder>;
+    /**
+     * Delete a folder. Agents in the folder are unassigned, not deleted.
+     *
+     * @param folderId - Folder UUID.
+     * @returns Confirmation with the deleted folder's ID.
+     */
+    delete(folderId: string): Promise<DeleteResponse>;
+    /**
+     * Assign an agent to a folder, or remove from folder.
+     *
+     * @param body - Agent ID and target folder ID. Set `folderId` to `null` to remove the agent from its folder.
+     * @returns Confirmation of the assignment.
+     */
+    assignAgent(body: AssignAgentToFolderBody): Promise<AssignAgentToFolderResponse>;
+}
+
+/** Model summary returned by `client.models.list()`. */
+interface ModelSummary {
+    /** Unique model UUID. */
+    id: string;
+    /** Model identifier used in agent create/update (e.g. "GPT_4_1"). */
+    modelId: string;
+    /** Model provider (e.g. "OPEN_AI", "ANTHROPIC", "GOOGLE_AI"). */
+    provider: string;
+    /** Human-readable display name (e.g. "GPT-4.1"). */
+    displayName: string;
+    /** API model name sent to the provider. */
+    modelName: string;
+    /** Context window size in tokens, or null if unknown. */
+    contextSize: number | null;
+    /** Whether the model supports streaming responses. */
+    streaming: boolean;
+    /** Whether the model supports Anthropic extended thinking. */
+    supportsThinking: boolean;
+    /** Whether the model supports OpenAI reasoning (o3, o4-mini, etc.). */
+    supportsReasoning: boolean;
+    /** Whether the model is deprecated. */
+    deprecated: boolean;
+}
+
+/**
+ * Models resource. Accessed via `client.models`.
+ *
+ * Provides read-only access to the available AI models that can be
+ * used when creating or updating agents.
+ */
+declare class ModelsResource extends BaseResource {
+    constructor(http: HttpClient);
+    /**
+     * List all enabled AI models available for agents.
+     *
+     * @returns Array of model summaries with identifiers, providers, and capabilities.
+     */
+    list(): Promise<{
+        models: ModelSummary[];
+    }>;
+}
+
+interface PromptAssistantChatBody {
+    message: string;
+    threadId?: string;
+    mode: "agent" | "ai-task";
+}
+interface PromptAssistantChatResponse {
+    threadId: string;
+    response: string;
+    status: "in_progress" | "generating" | "completed" | "failed";
+}
+interface PromptAssistantThreadMessage {
+    role: string;
+    content: string;
+    timestamp: string;
+}
+interface PromptResult {
+    prompt: string;
+    name: string;
+    description: string;
+    input?: {
+        type: "json" | "text";
+        schema?: Record<string, unknown>;
+    };
+    output?: {
+        type: "json" | "text";
+        schema?: Record<string, unknown>;
+    };
+    agentFields?: Record<string, unknown>;
+}
+interface PromptAssistantThreadResponse {
+    threadId: string;
+    status: "in_progress" | "generating" | "completed" | "failed";
+    messages: PromptAssistantThreadMessage[];
+    promptResult?: PromptResult;
+}
+declare class PromptAssistantResource extends BaseResource {
+    chat(body: PromptAssistantChatBody): Promise<PromptAssistantChatResponse>;
+    getThread(threadId: string): Promise<PromptAssistantThreadResponse>;
+    deleteThread(threadId: string): Promise<{
+        deleted: boolean;
+    }>;
+}
+
+/** Common query parameters for all skills list endpoints. */
+interface ListSkillsCommonParams {
+    /** Free-text search within names and descriptions. */
+    search?: string;
+    /** Max results to return (default 20, max 100). */
+    limit?: number;
+    /** Offset for pagination (default 0). */
+    offset?: number;
+}
+/** A workflow (automation) that can be attached to an agent as a WORKFLOW tool. */
+interface WorkflowSummary {
+    /** Unique workflow ID. */
+    id: string;
+    /** Display name. */
+    name: string;
+    /** Description of what the workflow does. */
+    description: string | null;
+    /** Workflow status: "DRAFT", "PUBLISHED", or "ARCHIVED". */
+    status: string;
+    /** Trigger type: "AGENT", "WEBHOOK", "SCHEDULE", or "UNDETERMINED". */
+    triggerType: string;
+    /** URL to the workflow's icon, if any. */
+    iconUrl: string | null;
+    /**
+     * JSON Schema describing the input the agent must provide when triggering
+     * this workflow. `null` if the workflow takes no structured input.
+     */
+    agentInputSchema: unknown | null;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** ISO 8601 last-updated timestamp. */
+    updatedAt: string;
+}
+/** Response from `client.skills.listWorkflows()`. */
+interface ListWorkflowsResponse {
+    /** Matching workflows (paginated). */
+    items: WorkflowSummary[];
+    /** Total number of matching workflows. */
+    total: number;
+}
+/** An AI task summary (list view). */
+interface TaskSummary {
+    /** Unique task ID. */
+    id: string;
+    /** Display name. */
+    name: string;
+    /** Description of what the task does. */
+    description: string | null;
+    /** Task category (e.g. "GENERATION", "CLASSIFICATION", "EXTRACTION"). */
+    category: string;
+    /** Input format: "TEXT" or "JSON". */
+    inputFormat: string;
+    /** Output format: "TEXT", "JSON", or "TEMPLATE". */
+    outputFormat: string;
+    /** Model provider (e.g. "openai", "anthropic"). */
+    modelProvider: string;
+    /** Model name (e.g. "gpt-4o"). */
+    modelName: string;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** ISO 8601 last-updated timestamp. */
+    updatedAt: string;
+}
+/** Full AI task detail (extends summary with schemas). */
+interface TaskDetail extends TaskSummary {
+    /**
+     * JSON Schema describing the structured input when `inputFormat === "JSON"`.
+     * `null` for text-only input tasks.
+     */
+    jsonInputSchema: unknown | null;
+    /**
+     * JSON Schema describing the structured output when `outputFormat === "JSON"`.
+     * `null` for text/template output tasks.
+     */
+    jsonOutputSchema: unknown | null;
+    /** Whether the task supports multimodal (image) input. */
+    multimodal: boolean;
+    /**
+     * Document template ID when `outputFormat === "TEMPLATE"`.
+     * `null` otherwise.
+     */
+    documentTemplateId: string | null;
+}
+/** Response from `client.skills.listTasks()`. */
+interface ListTasksResponse {
+    /** Matching AI tasks (paginated). */
+    items: TaskSummary[];
+    /** Total number of matching tasks. */
+    total: number;
+}
+/** A knowledge collection summary (list view). */
+interface CollectionSummary {
+    /** Unique collection ID. */
+    id: string;
+    /** Internal name. */
+    name: string;
+    /** Human-readable display name. */
+    displayName: string | null;
+    /** Description of the collection's contents. */
+    description: string | null;
+    /** Number of documents in the collection. */
+    documentCount: number;
+    /** Whether the collection is active. */
+    isActive: boolean;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** ISO 8601 last-updated timestamp. */
+    updatedAt: string;
+}
+/** Full collection detail (extends summary with retrieval settings). */
+interface CollectionDetail extends CollectionSummary {
+    /** Number of chunks to retrieve per query. */
+    k: number;
+    /** Reranker model name, if configured. */
+    reranker: string | null;
+    /** Whether to use precise (exact) responses vs. generative answers. */
+    preciseResponses: boolean;
+    /** Whether to include document metadata in retrieval results. */
+    includeMetadata: boolean;
+}
+/** Response from `client.skills.listCollections()`. */
+interface ListCollectionsResponse {
+    /** Matching collections (paginated). */
+    items: CollectionSummary[];
+    /** Total number of matching collections. */
+    total: number;
+}
+/** A document template summary (list view). */
+interface DocumentTemplateSummary {
+    /** Unique template ID. */
+    id: string;
+    /** Display name. */
+    name: string;
+    /** Description of the template. */
+    description: string | null;
+    /** Template type: "WORD_FORMAT", "WORD_TEMPLATE", "POWERPOINT_TEMPLATE", etc. */
+    type: string;
+    /** Template status: "DRAFT" or "SAVED". */
+    status: string;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** ISO 8601 last-updated timestamp. */
+    updatedAt: string;
+}
+/** Full document template detail (extends summary with input schema). */
+interface DocumentTemplateDetail extends DocumentTemplateSummary {
+    /** JSON schema describing the inputs needed to generate a document. */
+    inputFormat: unknown | null;
+    /** Per-slide input formats (for presentation templates). */
+    slidesInputFormat: unknown[];
+    /** URL to download the template file. */
+    fileUrl: string | null;
+    /** URL to preview the template. */
+    previewFileUrl: string | null;
+}
+/** Response from `client.skills.listDocumentTemplates()`. */
+interface ListDocumentTemplatesResponse {
+    /** Matching document templates (paginated). */
+    items: DocumentTemplateSummary[];
+    /** Total number of matching templates. */
+    total: number;
+}
+/** Body for `client.skills.createDocumentTemplate()`. */
+interface CreateDocumentTemplateBody {
+    /** Display name. */
+    name: string;
+    /** Description of the template. */
+    description?: string;
+    /** Template type. */
+    type: "WORD_FORMAT" | "WORD_TEMPLATE" | "WORD_CONTENT" | "POWERPOINT_TEMPLATE" | "EXCEL_TEMPLATE";
+}
+/** Body for `client.skills.createTask()`. */
+interface CreateTaskBody {
+    /** Display name. */
+    name: string;
+    /** Description of the task. */
+    description?: string;
+    /** Model name (must be a valid AI_MODELS key). */
+    modelName: string;
+    /** Model provider. */
+    modelProvider: "OPEN_AI" | "ANTHROPIC" | "GOOGLE_AI";
+    /** Prompt template. */
+    prompt?: string;
+    /** Temperature (0-2, default 0.7). */
+    temperature?: number;
+    /** Input format (default "text"). */
+    inputFormat?: "text" | "json";
+    /** Output format (default "text"). */
+    outputFormat?: "text" | "json" | "template";
+    /** Generation-specific settings (required). */
+    generation: {
+        /** Whether the task supports multimodal input. */
+        multimodal?: boolean;
+        /** Expected input description (required when inputFormat is "text"). */
+        expectedInput?: string;
+        /** JSON input schema (required when inputFormat is "json"). */
+        jsonInputSchema?: unknown;
+        /** Expected output description (required when outputFormat is "text"). */
+        expectedOutput?: string;
+        /** JSON output schema (required when outputFormat is "json"). */
+        jsonOutputSchema?: unknown;
+        /** Document template ID (required when outputFormat is "template"). */
+        documentTemplateId?: string;
+    };
+}
+/** Body for `client.skills.generateDocumentTemplate()`. */
+interface GenerateDocumentTemplateBody {
+    /** Template variables to fill in. */
+    variables: Record<string, unknown>;
+}
+/** Response from `client.skills.generateDocumentTemplate()`. */
+interface GenerateDocumentTemplateResponse {
+    /** URL to the generated document. */
+    url: string;
+}
+/** Body for `client.skills.executeTask()`. */
+interface ExecuteTaskBody {
+    /** Input to the task — text string or structured JSON object. */
+    input: string | Record<string, unknown>;
+}
+/** Response from `client.skills.executeTask()`. */
+interface ExecuteTaskResponse {
+    /** Task output. */
+    output: unknown;
+    /** Output type (e.g. "TEXT", "JSON", "TEMPLATE"). */
+    outputType: string;
+}
+/** An external tool (CUSTOM_MANIFEST) detail. */
+interface ExternalToolDetail {
+    /** Unique external tool ID. */
+    id: string;
+    /** Display name. */
+    name: string;
+    /** Description. */
+    description: string | null;
+    /** Always "CUSTOM_MANIFEST". */
+    type: "CUSTOM_MANIFEST";
+    /** Base endpoint URL. */
+    endpointUrl: string | null;
+    /** Status (e.g. "PUBLISHED"). */
+    status: string;
+    /** Number of actions extracted from the OpenAPI spec. */
+    actionsCount: number;
+    /** Auth type (e.g. "none", "service_http", "oauth"). */
+    authType: string;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+}
+/** Response from `client.skills.listExternalTools()`. */
+interface ListExternalToolsResponse {
+    /** Matching external tools (paginated). */
+    items: ExternalToolDetail[];
+    /** Total number of matching external tools. */
+    total: number;
+}
+/** Auth configuration for external tools (discriminated union on `type`). */
+type ExternalToolAuth = {
+    type: "none";
+} | {
+    type: "service_http";
+    apiKey: string;
+    authorization_type: "basic" | "bearer" | "custom";
+    custom_header_name?: string;
+    custom_header_prefix?: string;
+} | {
+    type: "user_http";
+    authorization_type: "basic" | "bearer" | "custom";
+    custom_header_name?: string;
+    custom_header_prefix?: string;
+} | {
+    type: "oauth";
+    grant_type: string;
+    client_id: string;
+    client_secret: string;
+    client_url: string;
+    authorization_url: string;
+    scope?: string;
+    tokenExchangeMethod?: string;
+} | {
+    type: "user_oauth";
+    grant_type: string;
+    authorization_type?: "basic" | "bearer" | "custom";
+    custom_header_name?: string;
+    custom_header_prefix?: string;
+} | {
+    type: "keys";
+};
+/** Body for `client.skills.createExternalTool()`. */
+interface CreateExternalToolBody {
+    /** Display name. */
+    name: string;
+    /** Description. */
+    description?: string;
+    /** OpenAPI spec as a JSON or YAML string. */
+    openApiSpec: string;
+    /** Base endpoint URL. */
+    endpointUrl: string;
+    /** Auth configuration. */
+    auth: ExternalToolAuth;
+}
+/** Body for `client.skills.testExternalTool()`. */
+interface TestExternalToolBody {
+    /** Which action (operationId) to call. */
+    operationId: string;
+    /** Flat key-value input parameters. */
+    input: Record<string, unknown>;
+    /** Optional stored credential ID for auth. */
+    toolCredentialId?: string;
+}
+/** Response from `client.skills.testExternalTool()`. */
+interface TestExternalToolResponse {
+    /** Whether the execution succeeded or failed. */
+    status: "success" | "error";
+    /** Execution output (null on error). */
+    output: unknown;
+    /** Error message when status is "error". */
+    error?: string;
+    /** How long the execution took in milliseconds. */
+    executionTimeMs: number;
+}
+/** Body for `client.skills.createCollection()`. */
+interface CreateCollectionBody {
+    /** Internal name (unique per org). */
+    name: string;
+    /** Human-readable display name. */
+    displayName?: string;
+    /** Description of the collection. */
+    description?: string;
+    /** Number of chunks to retrieve per query (default 10). */
+    k?: number;
+    /** Reranker model name. */
+    reranker?: string;
+    /** Whether to use precise responses (default false). */
+    preciseResponses?: boolean;
+    /** Whether to include metadata (default false). */
+    includeMetadata?: boolean;
+}
+
+/**
+ * Skills discovery resource.
+ *
+ * Provides read-only access to the four skill types that can be attached
+ * to agents: workflows, AI tasks, knowledge collections, and document
+ * templates.
+ *
+ * ```
+ * client.skills.listWorkflows()          — List org's workflows
+ * client.skills.getWorkflow(id)          — Get workflow detail
+ * client.skills.listTasks()              — List org's AI tasks
+ * client.skills.getTask(id)              — Get task detail with schemas
+ * client.skills.listCollections()        — List org's knowledge collections
+ * client.skills.getCollection(id)        — Get collection detail
+ * client.skills.listDocumentTemplates()  — List org's document templates
+ * client.skills.getDocumentTemplate(id)  — Get template detail with inputFormat
+ * ```
+ *
+ * Accessed via `client.skills`.
+ */
+declare class SkillsResource extends BaseResource {
+    /**
+     * List the organization's workflows.
+     *
+     * @param params - Optional search, limit, and offset.
+     * @returns Matching workflows with `agentInputSchema` and total count.
+     *
+     * @example
+     * ```ts
+     * const { items, total } = await client.skills.listWorkflows({ search: "onboarding" });
+     * for (const wf of items) {
+     *   console.log(`${wf.name} (${wf.status}) - trigger: ${wf.triggerType}`);
+     * }
+     * ```
+     */
+    listWorkflows(params?: ListSkillsCommonParams): Promise<ListWorkflowsResponse>;
+    /**
+     * Get a single workflow by ID.
+     *
+     * @param workflowId - Workflow UUID.
+     * @returns Full workflow detail including `agentInputSchema`.
+     *
+     * @example
+     * ```ts
+     * const wf = await client.skills.getWorkflow("workflow-uuid");
+     * console.log(wf.agentInputSchema); // JSON Schema the agent fills
+     * ```
+     */
+    getWorkflow(workflowId: string): Promise<WorkflowSummary>;
+    /**
+     * List the organization's AI tasks.
+     *
+     * @param params - Optional search, limit, and offset.
+     * @returns Matching tasks (summary view) and total count.
+     *
+     * @example
+     * ```ts
+     * const { items, total } = await client.skills.listTasks({ limit: 50 });
+     * for (const task of items) {
+     *   console.log(`${task.name} (${task.category}) - ${task.inputFormat} → ${task.outputFormat}`);
+     * }
+     * ```
+     */
+    listTasks(params?: ListSkillsCommonParams): Promise<ListTasksResponse>;
+    /**
+     * Get a single AI task by ID with full detail.
+     *
+     * Includes `jsonInputSchema` and `jsonOutputSchema` when the task uses
+     * structured JSON input/output.
+     *
+     * @param taskId - AI Task UUID.
+     * @returns Full task detail.
+     *
+     * @example
+     * ```ts
+     * const task = await client.skills.getTask("task-uuid");
+     * if (task.jsonInputSchema) {
+     *   console.log("Input schema:", task.jsonInputSchema);
+     * }
+     * ```
+     */
+    getTask(taskId: string): Promise<TaskDetail>;
+    /**
+     * List the organization's knowledge collections.
+     *
+     * @param params - Optional search, limit, and offset.
+     * @returns Matching collections (summary view) and total count.
+     *
+     * @example
+     * ```ts
+     * const { items } = await client.skills.listCollections();
+     * for (const col of items) {
+     *   console.log(`${col.name}: ${col.documentCount} documents`);
+     * }
+     * ```
+     */
+    listCollections(params?: ListSkillsCommonParams): Promise<ListCollectionsResponse>;
+    /**
+     * Get a single knowledge collection by ID with retrieval settings.
+     *
+     * @param collectionId - Collection UUID.
+     * @returns Full collection detail with `k`, `reranker`, etc.
+     *
+     * @example
+     * ```ts
+     * const col = await client.skills.getCollection("collection-uuid");
+     * console.log(`k=${col.k}, reranker=${col.reranker}`);
+     * ```
+     */
+    getCollection(collectionId: string): Promise<CollectionDetail>;
+    /**
+     * List the organization's document templates.
+     *
+     * @param params - Optional search, limit, and offset.
+     * @returns Matching templates (summary view) and total count.
+     *
+     * @example
+     * ```ts
+     * const { items } = await client.skills.listDocumentTemplates({ search: "invoice" });
+     * for (const tpl of items) {
+     *   console.log(`${tpl.name} (${tpl.type}) - ${tpl.status}`);
+     * }
+     * ```
+     */
+    listDocumentTemplates(params?: ListSkillsCommonParams): Promise<ListDocumentTemplatesResponse>;
+    /**
+     * Get a single document template by ID with full detail.
+     *
+     * Includes `inputFormat` (JSON schema of required inputs) and
+     * `slidesInputFormat` (per-slide schemas for presentations).
+     *
+     * @param templateId - Document template UUID.
+     * @returns Full template detail.
+     *
+     * @example
+     * ```ts
+     * const tpl = await client.skills.getDocumentTemplate("template-uuid");
+     * console.log("Input format:", tpl.inputFormat);
+     * ```
+     */
+    getDocumentTemplate(templateId: string): Promise<DocumentTemplateDetail>;
+    /**
+     * Create a new document template (metadata only).
+     *
+     * Upload a file separately with `uploadDocumentTemplateFile`.
+     *
+     * @param body - Template name, optional description, and type.
+     * @returns Created template detail.
+     *
+     * @example
+     * ```ts
+     * const tpl = await client.skills.createDocumentTemplate({
+     *   name: "Invoice",
+     *   type: "WORD_FORMAT"
+     * });
+     * ```
+     */
+    createDocumentTemplate(body: CreateDocumentTemplateBody): Promise<DocumentTemplateDetail>;
+    /**
+     * Upload a file and link it to an existing document template.
+     *
+     * @param templateId - Document template UUID.
+     * @param file - File as a `Blob`, `File`, or `Buffer`.
+     * @param fileName - File name (required when passing a `Blob` or `Buffer`).
+     * @returns Updated template detail with `fileUrl` populated.
+     *
+     * @example
+     * ```ts
+     * import fs from "fs";
+     *
+     * const buffer = fs.readFileSync("template.docx");
+     * const tpl = await client.skills.uploadDocumentTemplateFile(
+     *   "template-uuid",
+     *   new Blob([buffer]),
+     *   "template.docx"
+     * );
+     * console.log(tpl.fileUrl);
+     * ```
+     */
+    uploadDocumentTemplateFile(templateId: string, file: Blob, fileName?: string): Promise<DocumentTemplateDetail>;
+    /**
+     * Create a new GENERATION AI task.
+     *
+     * The category is hardcoded to "GENERATION". The `modelName` is validated
+     * against the available AI models — on invalid model, returns 400 with
+     * the list of valid model names.
+     *
+     * @param body - Task definition.
+     * @returns Created task detail.
+     *
+     * @example
+     * ```ts
+     * const task = await client.skills.createTask({
+     *   name: "Summarize Email",
+     *   modelName: "gpt-4o",
+     *   modelProvider: "OPEN_AI",
+     *   generation: {
+     *     expectedInput: "Raw email text",
+     *     expectedOutput: "A concise 2-sentence summary"
+     *   }
+     * });
+     * ```
+     */
+    createTask(body: CreateTaskBody): Promise<TaskDetail>;
+    /**
+     * Create a new knowledge collection.
+     *
+     * @param body - Collection name and optional settings.
+     * @returns Created collection detail.
+     *
+     * @example
+     * ```ts
+     * const col = await client.skills.createCollection({
+     *   name: "product-docs",
+     *   displayName: "Product Documentation",
+     *   k: 15
+     * });
+     * ```
+     */
+    createCollection(body: CreateCollectionBody): Promise<CollectionDetail>;
+    /**
+     * List the organization's external tools (CUSTOM_MANIFEST).
+     *
+     * @param params - Optional search, limit, and offset.
+     * @returns Matching external tools and total count.
+     *
+     * @example
+     * ```ts
+     * const { items, total } = await client.skills.listExternalTools({ search: "weather" });
+     * for (const tool of items) {
+     *   console.log(`${tool.name} (${tool.actionsCount} actions) - auth: ${tool.authType}`);
+     * }
+     * ```
+     */
+    listExternalTools(params?: ListSkillsCommonParams): Promise<ListExternalToolsResponse>;
+    /**
+     * Get a single external tool by ID.
+     *
+     * @param externalToolId - External tool UUID.
+     * @returns Full external tool detail.
+     *
+     * @example
+     * ```ts
+     * const tool = await client.skills.getExternalTool("tool-uuid");
+     * console.log(`${tool.name}: ${tool.actionsCount} actions, auth: ${tool.authType}`);
+     * ```
+     */
+    getExternalTool(externalToolId: string): Promise<ExternalToolDetail>;
+    /**
+     * Create a new external tool from an OpenAPI spec.
+     *
+     * Parses the provided OpenAPI spec (JSON or YAML), extracts actions,
+     * and creates the tool with the specified auth configuration.
+     *
+     * @param body - Tool name, OpenAPI spec, endpoint URL, and auth config.
+     * @returns Created external tool detail with `actionsCount`.
+     *
+     * @example
+     * ```ts
+     * const tool = await client.skills.createExternalTool({
+     *   name: "Weather API",
+     *   openApiSpec: '{"openapi":"3.0.0",...}',
+     *   endpointUrl: "https://api.weather.com",
+     *   auth: { type: "service_http", apiKey: "sk-...", authorization_type: "bearer" }
+     * });
+     * console.log(`Created: ${tool.name} with ${tool.actionsCount} actions`);
+     * ```
+     */
+    createExternalTool(body: CreateExternalToolBody): Promise<ExternalToolDetail>;
+    /**
+     * Test an external tool action by operationId with input parameters.
+     *
+     * Executes a specific action on an external tool and returns the result.
+     * Optionally uses stored credentials for authentication.
+     *
+     * @param externalToolId - External tool UUID.
+     * @param body - operationId, input params, and optional toolCredentialId.
+     * @returns Execution result with status, output, and timing.
+     *
+     * @example
+     * ```ts
+     * const result = await client.skills.testExternalTool("tool-uuid", {
+     *   operationId: "getWeather",
+     *   input: { city: "London" }
+     * });
+     * console.log(`${result.status} in ${result.executionTimeMs}ms:`, result.output);
+     * ```
+     */
+    testExternalTool(externalToolId: string, body: TestExternalToolBody): Promise<TestExternalToolResponse>;
+    /**
+     * Attach existing documents to a knowledge collection.
+     *
+     * @param collectionId - Collection UUID.
+     * @param body - Array of document IDs to link.
+     * @returns Status message.
+     *
+     * @example
+     * ```ts
+     * await client.skills.attachDocumentsToCollection("collection-uuid", {
+     *   documentIds: ["doc-1", "doc-2"]
+     * });
+     * ```
+     */
+    attachDocumentsToCollection(collectionId: string, body: AttachCollectionDocumentsBody): Promise<AttachCollectionDocumentsResponse>;
+    /**
+     * Generate a document from a template with variable values.
+     *
+     * @param templateId - Document template UUID.
+     * @param body - Variables to fill in the template.
+     * @returns URL to the generated document.
+     *
+     * @example
+     * ```ts
+     * const { url } = await client.skills.generateDocumentTemplate("template-uuid", {
+     *   variables: { name: "John", date: "2025-01-01" }
+     * });
+     * console.log("Generated document:", url);
+     * ```
+     */
+    generateDocumentTemplate(templateId: string, body: GenerateDocumentTemplateBody): Promise<GenerateDocumentTemplateResponse>;
+    /**
+     * Execute an AI task with input and get the output.
+     *
+     * @param taskId - AI Task UUID.
+     * @param body - Input to the task.
+     * @returns Task output and output type.
+     *
+     * @example
+     * ```ts
+     * const { output, outputType } = await client.skills.executeTask("task-uuid", {
+     *   input: "Summarize this document"
+     * });
+     * console.log(`Output (${outputType}):`, output);
+     * ```
+     */
+    executeTask(taskId: string, body: ExecuteTaskBody): Promise<ExecuteTaskResponse>;
+    listCollectionDocuments(collectionId: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PageResponse<any>>;
+    removeCollectionDocument(collectionId: string, documentId: string): Promise<any>;
+    getCollectionStatistics(collectionId: string): Promise<any>;
+    searchCollection(collectionId: string, body: {
+        query: string;
+        limit?: number;
+        includeMetadata?: boolean;
+    }): Promise<any>;
+    searchMultipleCollections(body: {
+        query: string;
+        collectionIds: string[];
+        limit?: number;
+    }): Promise<any>;
+    updateCollection(collectionId: string, body: {
+        displayName?: string;
+        description?: string;
+        k?: number;
+        reranker?: boolean;
+        preciseResponses?: boolean;
+        includeMetadata?: boolean;
+    }): Promise<any>;
+    deleteCollection(collectionId: string): Promise<any>;
+}
+
+type TicketType = "BUG" | "FEATURE_REQUEST" | "IMPROVEMENT";
+type TicketPriority = "NONE" | "URGENT" | "HIGH" | "MEDIUM" | "LOW";
+interface TicketContext {
+    endpoint?: string;
+    method?: string;
+    statusCode?: number;
+    errorCode?: string;
+    requestBody?: string;
+    responseBody?: string;
+    reproductionSteps?: string;
+    expectedBehavior?: string;
+    actualBehavior?: string;
+    environment?: string;
+    sdkVersion?: string;
+    agentId?: string;
+}
+interface TicketSummary {
+    id: string;
+    identifier: string;
+    title: string;
+    type: TicketType | null;
+    priority: TicketPriority;
+    status: string;
+    url: string;
+    createdAt: string;
+    updatedAt: string | null;
+}
+interface TicketDetail extends TicketSummary {
+    description: string | null;
+    context: TicketContext | null;
+}
+interface TicketComment {
+    id: string;
+    body: string;
+    authorName: string | null;
+    createdAt: string;
+}
+interface CreateTicketBody {
+    title: string;
+    description?: string;
+    type?: TicketType;
+    priority?: TicketPriority;
+    context?: TicketContext;
+}
+interface UpdateTicketBody {
+    title?: string;
+    description?: string;
+    type?: TicketType;
+    priority?: TicketPriority;
+}
+interface CreateTicketCommentBody {
+    body: string;
+}
+interface ListTicketsParams {
+    page?: number;
+    limit?: number;
+    type?: TicketType;
+    priority?: TicketPriority;
+    status?: string;
+    search?: string;
+}
+interface TicketAttachment {
+    id: string;
+    filename: string;
+    url: string;
+    contentType: string | null;
+    size: number | null;
+    createdAt: string;
+}
+
+declare class TicketsResource extends BaseResource {
+    constructor(http: HttpClient);
+    list(params?: ListTicketsParams): Promise<PageResponse<TicketSummary>>;
+    get(ticketId: string): Promise<TicketDetail>;
+    create(body: CreateTicketBody): Promise<TicketDetail>;
+    update(ticketId: string, body: UpdateTicketBody): Promise<TicketDetail>;
+    addComment(ticketId: string, body: CreateTicketCommentBody): Promise<TicketComment>;
+    listComments(ticketId: string): Promise<{
+        comments: TicketComment[];
+    }>;
+    uploadAttachment(ticketId: string, file: Blob | File): Promise<TicketAttachment>;
+    listAttachments(ticketId: string): Promise<{
+        attachments: TicketAttachment[];
+    }>;
+}
+
+/** Body for connecting a tool via OAuth. */
+interface ConnectToolOAuthBody {
+    authType: "oauth";
+    service: string;
+}
+/** Body for connecting a tool via HTTP API key. */
+interface ConnectToolHttpBody {
+    authType: "http";
+    apiKey: string;
+    name?: string;
+}
+/** Union body for connecting a tool (OAuth or HTTP). */
+type ConnectToolBody = ConnectToolOAuthBody | ConnectToolHttpBody;
+/** Response when initiating an OAuth connection flow. */
+interface ConnectToolOAuthResponse {
+    authorizationUrl: string;
+    handshakeId: string;
+    expiresAt: string;
+}
+/** Response when creating an HTTP credential directly. */
+interface ConnectToolHttpResponse {
+    id: string;
+    name: string | null;
+    type: string;
+    status: string;
+    createdAt: string;
+}
+/** Status of an OAuth handshake polling request. */
+interface HandshakeStatusResponse {
+    status: "PENDING" | "COMPLETED" | "FAILED" | "EXPIRED";
+    connectionId: string | null;
+    errorMessage: string | null;
+    expiresAt: string | null;
+}
+
+/**
+ * Tool connection resource. Accessed via `client.toolConnection`.
+ *
+ * Provides endpoints to connect marketplace tools via OAuth or HTTP
+ * credentials, poll OAuth handshake status, and delete credentials.
+ *
+ * ```
+ * // OAuth flow
+ * const result = await client.toolConnection.connect(toolId, { authType: "oauth", service: "GOOGLE_SHEETS" });
+ * console.log("Open:", result.authorizationUrl);
+ * const status = await client.toolConnection.waitForConnection(result.handshakeId);
+ *
+ * // HTTP credential
+ * const cred = await client.toolConnection.connect(toolId, { authType: "http", apiKey: "sk-..." });
+ * ```
+ */
+declare class ToolConnectionResource extends BaseResource {
+    /**
+     * Initiate a tool connection via OAuth or create an HTTP credential directly.
+     *
+     * For OAuth, returns an `authorizationUrl` the user must visit, plus a
+     * `handshakeId` for polling. For HTTP, creates the credential immediately.
+     *
+     * @param toolId - Marketplace tool ID.
+     * @param body - Connection type and parameters.
+     * @returns OAuth authorization details or the created HTTP credential.
+     */
+    connect(toolId: string, body: ConnectToolBody): Promise<ConnectToolOAuthResponse | ConnectToolHttpResponse>;
+    /**
+     * Poll the status of an OAuth handshake.
+     *
+     * @param handshakeId - Handshake UUID returned by `connect()`.
+     * @returns Current handshake status and connection ID if completed.
+     */
+    pollStatus(handshakeId: string): Promise<HandshakeStatusResponse>;
+    /**
+     * Wait for an OAuth handshake to complete by polling at regular intervals.
+     *
+     * Resolves when the status changes from `PENDING` to any terminal state
+     * (`COMPLETED`, `FAILED`, or `EXPIRED`), or when the timeout is reached.
+     *
+     * @param handshakeId - Handshake UUID returned by `connect()`.
+     * @param opts - Optional timeout (default 5 min) and polling interval (default 2 s).
+     * @returns Final handshake status.
+     */
+    waitForConnection(handshakeId: string, opts?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }): Promise<HandshakeStatusResponse>;
+    /**
+     * Delete a credential (connected account) from a tool.
+     *
+     * @param toolId - Marketplace tool ID.
+     * @param credentialId - Credential UUID to delete.
+     */
+    deleteCredential(toolId: string, credentialId: string): Promise<void>;
+}
+
+/** A marketplace tool summary returned from search results. */
+interface MarketplaceToolItem {
+    /** Unique tool ID. Use with `client.tools.get(id)` for full details. */
+    id: string;
+    /** Display name of the tool (e.g. "Gmail", "Slack"). */
+    name: string;
+    /** Short description of what the tool does. */
+    description: string;
+    /** Tool type (e.g. "PLUGIN" for Pipedream-backed tools). */
+    type: string;
+    /** URL to the tool's icon/logo, if available. */
+    imageUrl: string | null;
+    /** Category for faceted filtering (e.g. "Communication", "Productivity"). */
+    category: string | null;
+}
+/** Query parameters for `client.tools.search()`. */
+interface SearchMarketplaceToolsParams {
+    /** Free-text search query (e.g. "gmail", "send email"). */
+    q?: string;
+    /** Filter by category (e.g. "Communication"). */
+    category?: string;
+    /** Filter by tool type (e.g. "PLUGIN"). */
+    type?: string;
+    /** Max results to return (default 20, max 100). */
+    limit?: number;
+    /** Offset for pagination (default 0). */
+    offset?: number;
+}
+/** Response from `client.tools.search()`. */
+interface SearchMarketplaceToolsResponse {
+    /** Matching tools (paginated). */
+    tools: MarketplaceToolItem[];
+    /** Category facets with counts for building filter UIs. */
+    facets: {
+        category: string;
+        count: number;
+    }[];
+    /** Total number of matching tools across all pages. */
+    total: number;
+}
+/**
+ * A parameter on a tool action. Parameters describe the inputs an action accepts.
+ *
+ * When `remoteOptions` is `true`, the parameter's allowed values must be fetched
+ * dynamically via `client.tools.resolveOptions()` — e.g. a Gmail label dropdown
+ * whose values depend on the authenticated user's account.
+ */
+interface ToolActionParameter {
+    /** Parameter name (used as the key in `configuredProps`). */
+    name: string;
+    /** Data type (e.g. "string", "boolean", "integer", "string[]"). */
+    type: string;
+    /** Human-readable label for the parameter. */
+    label: string | null;
+    /** Description of what this parameter controls. */
+    description: string | null;
+    /** Whether this parameter must be provided for the action to execute. */
+    required: boolean;
+    /** Default value, if any. */
+    default: unknown;
+    /**
+     * If `true`, the allowed values for this parameter must be fetched at runtime
+     * via `client.tools.resolveOptions(toolId, { componentId, propName, credentialId })`.
+     * This is common for fields like "select a Gmail label" or "pick a Slack channel"
+     * whose options depend on the user's connected account.
+     */
+    remoteOptions: boolean;
+}
+/**
+ * An action exposed by a marketplace tool. Each action represents a discrete operation
+ * (e.g. "Send Email", "Create Draft", "List Labels").
+ */
+interface ToolAction {
+    /**
+     * Unique component key identifying this action (e.g. "gmail-send-email").
+     * Use this as `componentId` when calling `client.tools.resolveOptions()`.
+     */
+    key: string;
+    /** Human-readable action name. */
+    name: string;
+    /** Description of what this action does. */
+    description: string | null;
+    /** Input parameters this action accepts. */
+    parameters: ToolActionParameter[];
+}
+/** Query parameters for `client.tools.get()` to paginate/filter actions. */
+interface GetToolDetailParams {
+    /** Max actions to return (1-200). Omit to return all. */
+    actionsLimit?: number;
+    /** Offset for action pagination (default 0). */
+    actionsOffset?: number;
+    /** Filter actions by key, name, or description (case-insensitive substring match). */
+    actionsSearch?: string;
+}
+/**
+ * Full marketplace tool detail including actions and their parameter schemas.
+ * Returned by `client.tools.get(toolId)`.
+ */
+interface MarketplaceToolDetail {
+    /** Unique tool ID. */
+    id: string;
+    /** Display name. */
+    name: string | null;
+    /** Description of the tool. */
+    description: string;
+    /** Tool type (e.g. "PLUGIN"). */
+    type: string;
+    /** URL to the tool's icon/logo. */
+    imageUrl: string | null;
+    /** Authentication type required (e.g. "oauth", "keys", "none"). */
+    authType: string | null;
+    /**
+     * Actions (operations) this tool exposes. Each action has its own set of
+     * parameters. For Pipedream tools, these are enriched with full parameter
+     * schemas from the Pipedream component registry.
+     *
+     * May be paginated — check `totalActions` for the full count.
+     */
+    actions: ToolAction[];
+    /** Total number of actions available (before pagination). */
+    totalActions: number;
+}
+/** An existing credential (connected account) for a marketplace tool. */
+interface ToolCredential {
+    /**
+     * Credential UUID. Pass this as `credentialId` to
+     * `client.tools.resolveOptions()` or when configuring an agent tool.
+     */
+    id: string;
+    /** Display name of the credential (e.g. "john@company.com"). */
+    name: string | null;
+    /** Credential/auth type. */
+    type: string | null;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+}
+/** Response from `client.tools.credentials(toolId)`. */
+interface ListToolCredentialsResponse {
+    /** Existing credentials for this tool in the organization. */
+    credentials: ToolCredential[];
+}
+/**
+ * Request body for `client.tools.resolveOptions()`.
+ *
+ * This resolves dynamic dropdown values for a parameter that has `remoteOptions: true`.
+ * For example, fetching the list of Gmail labels or Slack channels for the
+ * authenticated user.
+ */
+interface ResolveRemoteOptionsBody {
+    /**
+     * The action's component key (from `ToolAction.key`),
+     * e.g. "gmail-send-email".
+     */
+    componentId: string;
+    /**
+     * The parameter name to resolve options for (from `ToolActionParameter.name`),
+     * e.g. "label" or "channel".
+     */
+    propName: string;
+    /**
+     * Credential UUID (from `ToolCredential.id`). The credential provides the
+     * authenticated account context needed to fetch options.
+     */
+    credentialId: string;
+    /**
+     * Already-selected parameter values. Some parameters depend on others
+     * (cascading dropdowns) — for example, selecting a Google Drive folder before
+     * listing files in that folder. Pass previously selected values here so the
+     * API can resolve the correct options.
+     */
+    configuredProps?: Record<string, unknown>;
+}
+/** A single option in a dynamic dropdown. */
+interface RemoteOption {
+    /** Human-readable display label. */
+    label: string;
+    /** The value to use when configuring this parameter. */
+    value: string | number | boolean;
+}
+/** Response from `client.tools.resolveOptions()`. */
+interface ResolveRemoteOptionsResponse {
+    /** The available options for the requested parameter. */
+    options: RemoteOption[];
+}
+/**
+ * A skill is an organization-owned asset that can be attached to an agent:
+ * a workflow (automation), an AI task, or a knowledge collection.
+ */
+interface SkillItem {
+    /** Unique skill ID. */
+    id: string;
+    /** Display name. */
+    name: string | null;
+    /** Description of what this skill does. */
+    description: string | null;
+    /** Skill type: "TASK", "WORKFLOW", or "COLLECTION". */
+    type: string;
+    /** ISO 8601 creation timestamp. */
+    createdAt: string;
+    /** ISO 8601 last-updated timestamp. */
+    updatedAt: string;
+}
+/** Query parameters for `client.tools.skills()`. */
+interface ListSkillsParams {
+    /** Filter by skill type. */
+    type?: "TASK" | "WORKFLOW" | "COLLECTION";
+    /** Free-text search within skill names and descriptions. */
+    search?: string;
+    /** Max results to return (default 20, max 100). */
+    limit?: number;
+    /** Offset for pagination (default 0). */
+    offset?: number;
+}
+/** Response from `client.tools.skills()`. */
+interface ListSkillsResponse {
+    /** Matching skills (paginated). */
+    skills: SkillItem[];
+    /** Total number of matching skills. */
+    total: number;
+}
+/**
+ * Request body for `client.tools.test()`.
+ * Provide sample input values to test-execute a configured agent tool.
+ */
+interface TestAgentToolBody {
+    /** Key-value pairs matching the tool's expected parameters. */
+    input: Record<string, unknown>;
+}
+/** Response from `client.tools.test()`. */
+interface TestAgentToolResponse {
+    /** Whether the tool executed successfully. */
+    status: "success" | "error";
+    /** The tool's output data (shape depends on the specific tool/action). */
+    output: unknown;
+    /** Error message if `status` is "error". */
+    error?: string;
+    /** How long the execution took in milliseconds. */
+    executionTimeMs: number;
+}
+
+/**
+ * Tool discovery and configuration resource.
+ *
+ * Provides the full LLM tool-configuration workflow:
+ *
+ * ```
+ * 1. search()         — Find marketplace tools (e.g. "gmail")
+ * 2. get()            — Get full tool detail with actions & parameter schemas
+ * 3. credentials()    — List existing connected accounts for the tool
+ * 4. resolveOptions() — Fetch dynamic dropdown values for parameters with remoteOptions
+ * 5. skills()         — List org's workflows, AI tasks, and collections
+ * 6. test()           — Test-execute a configured agent tool
+ * ```
+ *
+ * Typical workflow: search → get detail → list credentials → resolve dynamic
+ * fields → configure tool on agent (via `client.agents.tools.create()`) → test.
+ *
+ * Accessed via `client.tools`.
+ */
+declare class ToolDiscoveryResource extends BaseResource {
+    /**
+     * Search marketplace tools by keyword with optional category and type filters.
+     * Uses Typesense full-text search with SQL fallback.
+     *
+     * @param params - Search query and filters.
+     * @returns Matching tools, category facets, and total count.
+     *
+     * @example
+     * ```ts
+     * const result = await client.tools.search({ q: "gmail", limit: 5 });
+     * console.log(`Found ${result.total} tools`);
+     * for (const tool of result.tools) {
+     *   console.log(`${tool.name} (${tool.type}): ${tool.description}`);
+     * }
+     * ```
+     */
+    search(params?: SearchMarketplaceToolsParams): Promise<SearchMarketplaceToolsResponse>;
+    /**
+     * Get full marketplace tool detail including actions and their parameter schemas.
+     *
+     * For Pipedream tools, each action's parameters are enriched with the full
+     * component definition including types, descriptions, defaults, and
+     * `remoteOptions` flags indicating which fields need dynamic option resolution.
+     *
+     * @param toolId - Marketplace tool ID (from search results).
+     * @param params - Optional pagination/filter params for actions.
+     * @returns Full tool detail with actions and parameter schemas.
+     *
+     * @example
+     * ```ts
+     * // Get all actions
+     * const detail = await client.tools.get("tool-uuid");
+     * console.log(`${detail.totalActions} total actions`);
+     *
+     * // Paginate actions
+     * const page = await client.tools.get("tool-uuid", { actionsLimit: 10, actionsOffset: 20 });
+     *
+     * // Search for a specific action
+     * const filtered = await client.tools.get("tool-uuid", { actionsSearch: "get-values" });
+     * ```
+     */
+    get(toolId: string, params?: GetToolDetailParams): Promise<MarketplaceToolDetail>;
+    /**
+     * List existing credentials (connected accounts) for a marketplace tool.
+     *
+     * Credentials represent authenticated connections (e.g. a Gmail OAuth token).
+     * They are read-only through this endpoint — users create credentials via the
+     * Nexus dashboard. Use the credential `id` when calling `resolveOptions()` or
+     * when configuring an agent tool.
+     *
+     * @param toolId - Marketplace tool ID.
+     * @returns List of credentials for this tool in the organization.
+     *
+     * @example
+     * ```ts
+     * const { credentials } = await client.tools.credentials("tool-uuid");
+     * if (credentials.length === 0) {
+     *   console.log("No credentials — user must connect account in dashboard first");
+     * }
+     * ```
+     */
+    credentials(toolId: string): Promise<ListToolCredentialsResponse>;
+    /**
+     * Resolve dynamic dropdown options for a tool action parameter.
+     *
+     * Some parameters (those with `remoteOptions: true` in the tool detail) have
+     * values that depend on the user's connected account — for example, a list of
+     * Gmail labels or Slack channels. This method fetches those options at runtime.
+     *
+     * For cascading dependencies (e.g. "select folder" → "select file in folder"),
+     * pass previously selected values in `configuredProps`.
+     *
+     * @param toolId - Marketplace tool ID.
+     * @param body - Component ID, parameter name, credential, and current values.
+     * @returns Available options for the specified parameter.
+     *
+     * @example
+     * ```ts
+     * const { options } = await client.tools.resolveOptions("tool-uuid", {
+     *   componentId: "gmail-send-email",   // from ToolAction.key
+     *   propName: "label",                  // from ToolActionParameter.name
+     *   credentialId: "cred-uuid",          // from ToolCredential.id
+     *   configuredProps: {}                  // previously selected values
+     * });
+     * for (const opt of options) {
+     *   console.log(`${opt.label}: ${opt.value}`);
+     * }
+     * ```
+     */
+    resolveOptions(toolId: string, body: ResolveRemoteOptionsBody): Promise<ResolveRemoteOptionsResponse>;
+    /**
+     * List the organization's skills — workflows, AI tasks, and collections.
+     *
+     * Skills are org-owned assets that can be attached to agents as tool
+     * configurations of type WORKFLOW, TASK, or COLLECTION (as opposed to
+     * marketplace PLUGIN tools).
+     *
+     * @param params - Optional type filter, search, and pagination.
+     * @returns Matching skills and total count.
+     *
+     * @example
+     * ```ts
+     * // List all workflows
+     * const { skills, total } = await client.tools.skills({ type: "WORKFLOW" });
+     * console.log(`${total} workflows found`);
+     *
+     * // Search across all skill types
+     * const result = await client.tools.skills({ search: "onboarding", limit: 10 });
+     * ```
+     */
+    skills(params?: ListSkillsParams): Promise<ListSkillsResponse>;
+    /**
+     * Test-execute a configured agent tool with sample input.
+     *
+     * This runs the tool using its saved configuration (action, credentials,
+     * parameter setup) and returns the execution result. Use this to verify a
+     * tool is correctly configured before deploying the agent.
+     *
+     * @param agentId - Agent UUID that owns the tool config.
+     * @param toolConfigId - Agent tool configuration UUID (from `client.agents.tools.list()`).
+     * @param body - Sample input values to pass to the tool.
+     * @returns Execution result with status, output, and timing.
+     *
+     * @example
+     * ```ts
+     * const result = await client.tools.test("agent-uuid", "tool-config-uuid", {
+     *   input: { to: "test@example.com", subject: "Hello", body: "Test email" }
+     * });
+     * if (result.status === "success") {
+     *   console.log(`Executed in ${result.executionTimeMs}ms`, result.output);
+     * } else {
+     *   console.error(`Tool error: ${result.error}`);
+     * }
+     * ```
+     */
+    test(agentId: string, toolConfigId: string, body: TestAgentToolBody): Promise<TestAgentToolResponse>;
+}
+
+declare class WorkflowExecutionsResource extends BaseResource {
+    list(params?: {
+        workflowId?: string;
+        status?: string;
+        startDate?: string;
+        endDate?: string;
+        page?: number;
+        limit?: number;
+        sortBy?: string;
+        order?: string;
+    }): Promise<PageResponse<any>>;
+    listByWorkflow(workflowId: string, params?: {
+        page?: number;
+        limit?: number;
+        status?: string;
+    }): Promise<PageResponse<any>>;
+    get(executionId: string): Promise<any>;
+    getGraph(executionId: string): Promise<any>;
+    getNodeResult(executionId: string, nodeId: string): Promise<any>;
+    getOutput(executionId: string): Promise<any>;
+    retryNode(executionId: string, nodeId: string): Promise<any>;
+    export(executionId: string): Promise<any>;
+}
+
+/** Workflow lifecycle status. */
+type WorkflowStatus = "DRAFT" | "PUBLISHED" | "ARCHIVED";
+/** Summary view of a workflow returned by list endpoints. */
+interface WfSummary {
+    id: string;
+    name: string;
+    description: string | null;
+    status: WorkflowStatus;
+    triggerType: string | null;
+    nodeCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/** A single node in a workflow graph. */
+interface WorkflowNode {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    position: {
+        x: number;
+        y: number;
+    };
+    parentId: string | null;
+    configStatus: "complete" | "incomplete" | "error";
+    missingFields: string[];
+    errors: string[];
+}
+/** A single edge connecting two nodes in a workflow graph. */
+interface WorkflowEdge {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle: string | null;
+    type: string;
+}
+/** Full workflow detail including nodes and edges. */
+interface WorkflowDetail extends WfSummary {
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+}
+/** Body for creating a new workflow. */
+interface CreateWorkflowBody {
+    name: string;
+    description?: string;
+}
+/** Body for updating an existing workflow. */
+interface UpdateWorkflowBody {
+    name?: string;
+    description?: string;
+}
+/** Query parameters for listing workflows. */
+interface ListWorkflowsParams {
+    page?: number;
+    limit?: number;
+    status?: WorkflowStatus;
+    search?: string;
+}
+/** Body for creating a new node in a workflow. */
+interface CreateNodeBody {
+    type: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+    data?: Record<string, unknown>;
+    parentId?: string;
+}
+/** Body for updating an existing node. */
+interface UpdateNodeBody {
+    data: Record<string, unknown>;
+}
+/** Body for replacing the trigger node of a workflow. */
+interface ReplaceTriggerBody {
+    type: "webhookTrigger" | "agentInputTrigger" | "scheduleTrigger" | "pluginTrigger";
+}
+/** Body for reloading dynamic properties of a node. */
+interface ReloadPropsBody {
+    configuredProps?: Record<string, unknown>;
+    dynamicPropsId?: string;
+}
+/** Response from reloading dynamic properties. */
+interface ReloadPropsResponse {
+    parametersSetup: unknown[];
+    dynamicPropsId: string | null;
+    errors: string[];
+}
+/** A branch within a conditional or router node. */
+interface Branch {
+    id: string;
+    name: string;
+    description: string | null;
+}
+/** Body for creating a new branch on a node. */
+interface CreateBranchBody {
+    name: string;
+    description?: string;
+}
+/** Body for updating an existing branch. */
+interface UpdateBranchBody {
+    name?: string;
+    description?: string;
+}
+/** Body for creating a new edge between nodes. */
+interface CreateEdgeBody {
+    source: string;
+    target: string;
+    sourceHandle?: string;
+    type?: "main" | "rewind";
+}
+/** High-level overview of a workflow with node summaries. */
+interface WorkflowOverview {
+    id: string;
+    name: string;
+    status: string;
+    nodes: Array<{
+        id: string;
+        type: string;
+        label: string;
+        configStatus: "complete" | "incomplete" | "error";
+        missingFields: string[];
+        errors: string[];
+    }>;
+    edges: WorkflowEdge[];
+}
+/** Variables available to a node from upstream nodes. */
+interface AvailableVariable {
+    nodeId: string;
+    nodeLabel: string;
+    nodeType: string;
+    properties: Array<{
+        key: string;
+        label: string;
+        type: string;
+    }>;
+}
+/** Output format definition for a node. */
+interface OutputFormat {
+    format: unknown;
+    source: "manual" | "lastExecution" | "default";
+}
+/** Validation report for a workflow. */
+interface ValidationReport {
+    isValid: boolean;
+    readyToPublish: boolean;
+    readyToTest: boolean;
+    nodeIssues: Array<{
+        nodeId: string;
+        nodeType: string;
+        configStatus: string;
+        missingFields: string[];
+        errors: string[];
+    }>;
+    graphIssues: string[];
+}
+/** Summary of a node type available in the workflow builder. */
+interface NodeTypeSummary {
+    type: string;
+    label: string;
+    description: string;
+    category: string;
+}
+/** Full schema for a node type including fields and connection rules. */
+interface NodeTypeSchema {
+    type: string;
+    label: string;
+    description: string;
+    category: string;
+    fields: unknown[];
+    configurationSteps: unknown[];
+    connectionRules: {
+        maxInputs: number;
+        maxOutputs: number;
+        canLoop: boolean;
+        canMask: boolean;
+    };
+    defaultData: Record<string, unknown>;
+}
+/** Body for testing a single node. */
+interface TestNodeBody {
+    input?: Record<string, unknown>;
+}
+/** Body for testing an entire workflow. */
+interface TestWorkflowBody {
+    triggerData?: Record<string, unknown>;
+}
+/** Result of starting a test execution. */
+interface TestResult {
+    executionId: string;
+}
+/** Status of a workflow execution. */
+interface ExecutionStatus {
+    id: string;
+    status: "PENDING" | "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED";
+    nodes: Array<{
+        id: string;
+        nodeId: string;
+        status: string;
+        startedAt: string | null;
+        completedAt: string | null;
+    }>;
+    startedAt: string;
+    completedAt: string | null;
+}
+/** Execution result for a single node. */
+interface NodeExecutionResult {
+    nodeId: string;
+    status: string;
+    input: unknown;
+    output: unknown;
+    error: string | null;
+    logs: string[];
+    startedAt: string | null;
+    completedAt: string | null;
+}
+/** Result of publishing a workflow. */
+interface PublishResult {
+    id: string;
+    status: "PUBLISHED";
+}
+/** Result of unpublishing a workflow. */
+interface UnpublishResult {
+    id: string;
+    status: "DRAFT";
+}
+/** Result of uploading a workflow icon. */
+interface IconResult {
+    iconUrl: string;
+}
+
+/**
+ * Workflow management resource. Accessed via `client.workflows`.
+ *
+ * Provides full CRUD for workflows plus sub-operations for nodes, edges,
+ * branches, overview/validation, builder node-types, and test executions.
+ *
+ * ```
+ * client.workflows.list()                          — List workflows
+ * client.workflows.create({ name: "My Flow" })     — Create workflow
+ * client.workflows.createNode(wfId, { type })       — Add a node
+ * client.workflows.testWorkflow(wfId, { ... })      — Run a test
+ * client.workflows.publish(wfId)                    — Publish workflow
+ * ```
+ */
+declare class WorkflowsResource extends BaseResource {
+    /**
+     * List workflows with optional filtering and pagination.
+     *
+     * @param params - Optional status filter, search, and pagination.
+     * @returns Paginated list of workflow summaries.
+     */
+    list(params?: ListWorkflowsParams): Promise<PageResponse<WfSummary>>;
+    /**
+     * Create a new workflow.
+     *
+     * @param body - Workflow name and optional description.
+     * @returns The created workflow detail.
+     */
+    create(body: CreateWorkflowBody): Promise<WorkflowDetail>;
+    /**
+     * Get detailed information about a specific workflow, including nodes and edges.
+     *
+     * @param workflowId - Workflow UUID.
+     * @returns Full workflow detail.
+     */
+    get(workflowId: string): Promise<WorkflowDetail>;
+    /**
+     * Update an existing workflow's properties. Only provided fields are updated.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param body - Fields to update.
+     * @returns The updated workflow detail.
+     */
+    update(workflowId: string, body: UpdateWorkflowBody): Promise<WorkflowDetail>;
+    /**
+     * Permanently delete a workflow and all its nodes, edges, and executions.
+     *
+     * @param workflowId - Workflow UUID.
+     * @returns Confirmation with the deleted workflow's ID.
+     */
+    delete(workflowId: string): Promise<DeleteResponse>;
+    /**
+     * Create a copy of an existing workflow.
+     *
+     * @param workflowId - Workflow UUID to duplicate.
+     * @returns The newly created workflow detail.
+     */
+    duplicate(workflowId: string): Promise<WorkflowDetail>;
+    /**
+     * Publish a workflow, making it available for execution.
+     *
+     * @param workflowId - Workflow UUID.
+     * @returns Publish confirmation with updated status.
+     */
+    publish(workflowId: string): Promise<PublishResult>;
+    /**
+     * Unpublish a workflow, reverting it to draft status.
+     *
+     * @param workflowId - Workflow UUID.
+     * @returns Unpublish confirmation with updated status.
+     */
+    unpublish(workflowId: string): Promise<UnpublishResult>;
+    /**
+     * Upload an icon image for a workflow.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param file - Image file as a Blob or File.
+     * @returns URL of the uploaded icon.
+     */
+    uploadIcon(workflowId: string, file: Blob | File): Promise<IconResult>;
+    /**
+     * List all available node types for the workflow builder.
+     *
+     * @returns Array of node type summaries.
+     */
+    listNodeTypes(): Promise<NodeTypeSummary[]>;
+    /**
+     * Get the full schema for a specific node type, including fields and connection rules.
+     *
+     * @param nodeType - Node type identifier.
+     * @returns Node type schema with fields, configuration steps, and defaults.
+     */
+    getNodeTypeSchema(nodeType: string): Promise<NodeTypeSchema>;
+    /**
+     * Create a new node in a workflow.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param body - Node type, position, data, and optional parent.
+     * @returns The created node.
+     */
+    createNode(workflowId: string, body: CreateNodeBody): Promise<WorkflowNode>;
+    /**
+     * Get a specific node within a workflow.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @returns The node detail.
+     */
+    getNode(workflowId: string, nodeId: string): Promise<WorkflowNode>;
+    /**
+     * Update a node's data. Only the `data` field is replaced.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @param body - New data for the node.
+     * @returns The updated node.
+     */
+    updateNode(workflowId: string, nodeId: string, body: UpdateNodeBody): Promise<WorkflowNode>;
+    /**
+     * Delete a node from a workflow. Connected edges are also removed.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @returns Confirmation with the deleted node's ID.
+     */
+    deleteNode(workflowId: string, nodeId: string): Promise<DeleteResponse>;
+    /**
+     * Reload dynamic properties for a node (e.g. after selecting a tool or action).
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @param body - Currently configured props and optional dynamic props ID.
+     * @returns Updated parameters setup and any errors.
+     */
+    reloadProps(workflowId: string, nodeId: string, body: ReloadPropsBody): Promise<ReloadPropsResponse>;
+    /**
+     * Replace the trigger node of a workflow with a different trigger type.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param body - New trigger type.
+     * @returns The updated workflow detail.
+     */
+    replaceTrigger(workflowId: string, body: ReplaceTriggerBody): Promise<WorkflowDetail>;
+    /**
+     * List branches on a conditional or router node.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @returns Array of branches.
+     */
+    listBranches(workflowId: string, nodeId: string): Promise<Branch[]>;
+    /**
+     * Create a new branch on a conditional or router node.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @param body - Branch name and optional description.
+     * @returns The created branch.
+     */
+    createBranch(workflowId: string, nodeId: string, body: CreateBranchBody): Promise<Branch>;
+    /**
+     * Update a branch on a node.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @param branchId - Branch UUID.
+     * @param body - Fields to update.
+     * @returns The updated branch.
+     */
+    updateBranch(workflowId: string, nodeId: string, branchId: string, body: UpdateBranchBody): Promise<Branch>;
+    /**
+     * Delete a branch from a node.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @param branchId - Branch UUID.
+     * @returns Confirmation with the deleted branch's ID.
+     */
+    deleteBranch(workflowId: string, nodeId: string, branchId: string): Promise<DeleteResponse>;
+    /**
+     * Create an edge between two nodes in a workflow.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param body - Source node, target node, optional handle and type.
+     * @returns The created edge.
+     */
+    createEdge(workflowId: string, body: CreateEdgeBody): Promise<WorkflowEdge>;
+    /**
+     * Delete an edge from a workflow.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param edgeId - Edge UUID.
+     * @returns Confirmation with the deleted edge's ID.
+     */
+    deleteEdge(workflowId: string, edgeId: string): Promise<DeleteResponse>;
+    /**
+     * Get a high-level overview of a workflow with node summaries.
+     *
+     * @param workflowId - Workflow UUID.
+     * @returns Workflow overview with node labels and config statuses.
+     */
+    getOverview(workflowId: string): Promise<WorkflowOverview>;
+    /**
+     * Auto-layout the nodes in a workflow graph.
+     *
+     * @param workflowId - Workflow UUID.
+     * @returns The updated workflow detail with new node positions.
+     */
+    layout(workflowId: string): Promise<WorkflowDetail>;
+    /**
+     * Get variables available to a specific node from upstream nodes.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @returns Array of available variables grouped by source node.
+     */
+    getAvailableVariables(workflowId: string, nodeId: string): Promise<AvailableVariable[]>;
+    /**
+     * Get the output format definition for a specific node.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @returns Output format with source indicator.
+     */
+    getOutputFormat(workflowId: string, nodeId: string): Promise<OutputFormat>;
+    /**
+     * Validate a workflow for completeness and correctness.
+     *
+     * @param workflowId - Workflow UUID.
+     * @returns Validation report with node issues and graph issues.
+     */
+    validate(workflowId: string): Promise<ValidationReport>;
+    /**
+     * Test-execute a single node with optional input.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param nodeId - Node UUID.
+     * @param body - Optional input data for the node.
+     * @returns Execution ID for polling status.
+     */
+    testNode(workflowId: string, nodeId: string, body?: TestNodeBody): Promise<TestResult>;
+    /**
+     * Test-execute an entire workflow with optional trigger data.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param body - Optional trigger data to start the workflow.
+     * @returns Execution ID for polling status.
+     */
+    testWorkflow(workflowId: string, body?: TestWorkflowBody): Promise<TestResult>;
+    /**
+     * Get the status of a workflow execution.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param executionId - Execution UUID.
+     * @returns Execution status with per-node statuses.
+     */
+    getExecutionStatus(workflowId: string, executionId: string): Promise<ExecutionStatus>;
+    /**
+     * Get the execution result for a specific node within a workflow execution.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param executionId - Execution UUID.
+     * @param nodeId - Node UUID.
+     * @returns Node execution result with input, output, and logs.
+     */
+    getNodeExecutionResult(workflowId: string, executionId: string, nodeId: string): Promise<NodeExecutionResult>;
+    /**
+     * Stop a running workflow execution.
+     *
+     * @param workflowId - Workflow UUID.
+     * @param executionId - Execution UUID.
+     * @returns Updated execution status.
+     */
+    stopExecution(workflowId: string, executionId: string): Promise<ExecutionStatus>;
+}
+
+interface NexusClientOptions {
+    /**
+     * API key for authentication. Falls back to `NEXUS_API_KEY` env var.
+     * Generate one in the Nexus dashboard under Settings > API Keys.
+     */
+    apiKey?: string;
+    /**
+     * Base URL of the Nexus API. Falls back to `NEXUS_BASE_URL` env var,
+     * then defaults to `https://api.nexusgpt.io`.
+     */
+    baseUrl?: string;
+    /**
+     * Custom `fetch` implementation (e.g., for testing or non-standard runtimes).
+     * Defaults to the global `fetch`.
+     */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * Additional headers sent with every request.
+     */
+    defaultHeaders?: Record<string, string>;
+    /**
+     * Request timeout in milliseconds. Defaults to 30 000 (30 s).
+     */
+    timeout?: number;
+}
+/**
+ * Main entry point for the Nexus SDK.
+ *
+ * ```ts
+ * import { NexusClient } from "@agent-nexus/sdk";
+ *
+ * const client = new NexusClient({ apiKey: "nxs_..." });
+ *
+ * // Agents
+ * const { data: agents } = await client.agents.list();
+ * const agent = await client.agents.create({ firstName: "A", lastName: "B", role: "Assistant" });
+ *
+ * // Agent tools (sub-resource)
+ * const tools = await client.agents.tools.list(agent.id);
+ *
+ * // Prompt versions (sub-resource)
+ * const { data: versions } = await client.agents.versions.list(agent.id);
+ *
+ * // Folders
+ * const { folders } = await client.folders.list();
+ *
+ * // Tool discovery (search, detail, credentials, dynamic options, skills, test)
+ * const results = await client.tools.search({ q: "gmail" });
+ * const detail = await client.tools.get(results.tools[0].id);
+ * ```
+ */
+declare class NexusClient {
+    /** Manage agents, their tool configurations, and prompt versions. */
+    readonly agents: AgentsResource;
+    /** Create documents via file upload, text, website, or Google Sheet import. */
+    readonly documents: DocumentsResource;
+    /** Manage folders and agent-folder assignments. */
+    readonly folders: FoldersResource;
+    /** List available AI models for agents. */
+    readonly models: ModelsResource;
+    /** Discover marketplace tools, resolve dynamic options, list skills, and test configured tools. */
+    readonly tools: ToolDiscoveryResource;
+    /** Browse workflows, AI tasks, collections, and document templates. */
+    readonly skills: SkillsResource;
+    /** Manage workflows, nodes, edges, and test executions. */
+    readonly workflows: WorkflowsResource;
+    /** Connect tools via OAuth or HTTP credentials. */
+    readonly toolConnection: ToolConnectionResource;
+    /** Deploy agents to channels (web widget, WhatsApp, Telegram, etc.). */
+    readonly deployments: DeploymentsResource;
+    /** Test deployments with the emulator — sessions, messages, and replayable scenarios. */
+    readonly emulator: EmulatorResource;
+    /** Organize deployments into folders. */
+    readonly deploymentFolders: DeploymentFoldersResource;
+    /** Organize document templates into folders. */
+    readonly documentTemplateFolders: DocumentTemplateFoldersResource;
+    /** Organization analytics and metrics. */
+    readonly analytics: AnalyticsResource;
+    /** Attach knowledge collections to agents. */
+    readonly agentCollections: AgentCollectionsResource;
+    /** View and debug workflow execution history. */
+    readonly workflowExecutions: WorkflowExecutionsResource;
+    /** Evaluate and benchmark AI tasks. */
+    readonly evaluations: EvaluationsResource;
+    /** Import documents from Google Drive, SharePoint, Notion. */
+    readonly cloudImports: CloudImportsResource;
+    /** Chat with AI to generate high-quality prompts for agents and AI tasks. */
+    readonly promptAssistant: PromptAssistantResource;
+    /** Create and manage support tickets. */
+    readonly tickets: TicketsResource;
+    constructor(opts?: NexusClientOptions);
+}
+
+/** Base error class for all Nexus SDK errors. */
+declare class NexusError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when the Nexus API returns an error response (`{ success: false }`).
+ *
+ * Check `status` for the HTTP status code and `code` for the machine-readable
+ * error code (e.g. `"NOT_FOUND"`, `"VALIDATION_ERROR"`).
+ */
+declare class NexusApiError extends NexusError {
+    /** Machine-readable error code (e.g. `"NOT_FOUND"`, `"VALIDATION_ERROR"`). */
+    readonly code: string;
+    /** HTTP status code (e.g. 400, 404, 500). */
+    readonly status: number;
+    /** Additional error details (e.g. validation errors per field). */
+    readonly details?: unknown;
+    constructor(code: string, message: string, status: number, details?: unknown);
+}
+/** Thrown when the API returns a 401 status (invalid or missing API key). */
+declare class NexusAuthenticationError extends NexusApiError {
+    constructor(message?: string);
+}
+/** Thrown when the request fails due to network issues or timeout. */
+declare class NexusConnectionError extends NexusError {
+    /** The underlying error that caused the connection failure. */
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+}
+
+export { type AddWebsiteDocumentBody, AgentCollectionsResource, type AgentDetail, type AgentFolder, type AgentModel, type AgentStatus, type AgentSummary, type AgentToolConfig, type AgentToolConfigType, AgentToolsResource, AgentsResource, AnalyticsResource, type AssignAgentToFolderBody, type AssignAgentToFolderResponse, type AttachCollectionDocumentsBody, type AttachCollectionDocumentsResponse, type AvailableVariable, type Branch, CloudImportsResource, type CollectionDetail, type CollectionSummary, type ConnectToolBody, type ConnectToolHttpBody, type ConnectToolHttpResponse, type ConnectToolOAuthBody, type ConnectToolOAuthResponse, type CreateAgentBody, type CreateAgentToolBody, type CreateBranchBody, type CreateCheckpointBody, type CreateEdgeBody, type CreateEmulatorSessionBody, type CreateFolderBody, type CreateGoogleSheetDocumentBody, type CreateNodeBody, type CreateTextDocumentBody, type CreateTicketBody, type CreateTicketCommentBody, type CreateWorkflowBody, type DeleteResponse, DeploymentFoldersResource, DeploymentsResource, type DocumentInfo, type DocumentTemplateDetail, DocumentTemplateFoldersResource, type DocumentTemplateSummary, DocumentsResource, type EmulatorDebugInfo, type EmulatorMessage, type EmulatorMessageFile, type EmulatorParticipant, EmulatorResource, type EmulatorScenario, type EmulatorScenarioDetail, type EmulatorScenarioMessage, type EmulatorSendMessageResult, type EmulatorSession, type EmulatorSessionDetail, EvaluationsResource, type ExecutionStatus, type FolderAssignment, FoldersResource, type GetToolDetailParams, type GoogleSheetResult, type HandshakeStatusResponse, HttpClient, type HttpClientOptions, type IconResult, type ListAgentsParams, type ListCollectionsResponse, type ListDocumentTemplatesResponse, type ListEmulatorScenariosParams, type ListFoldersResponse, type ListSkillsCommonParams, type ListSkillsParams, type ListSkillsResponse, type ListTasksResponse, type ListTicketsParams, type ListToolCredentialsResponse, type ListVersionsParams, type ListWorkflowsParams, type ListWorkflowsResponse, type MarketplaceToolDetail, type MarketplaceToolItem, type ModelConfig, type ModelProvider, type ModelSummary, ModelsResource, NexusApiError, NexusAuthenticationError, NexusClient, type NexusClientOptions, NexusConnectionError, NexusError, type NodeExecutionResult, type NodeTypeSchema, type NodeTypeSummary, type OutputFormat, type PageResponse, type PaginationMeta, type PaginationParams, type PromptAssistantChatBody, type PromptAssistantChatResponse, PromptAssistantResource, type PromptAssistantThreadMessage, type PromptAssistantThreadResponse, type PromptResult, type PublishResult, type ReloadPropsBody, type ReloadPropsResponse, type RemoteOption, type ReplaceTriggerBody, type ReplayEmulatorScenarioBody, type RequestOptions, type ResolveRemoteOptionsBody, type ResolveRemoteOptionsResponse, type RestoreVersionResponse, type SaveEmulatorScenarioBody, type SearchMarketplaceToolsParams, type SearchMarketplaceToolsResponse, type SendEmulatorMessageBody, type SkillItem, SkillsResource, type TaskDetail, type TaskSummary, type TestAgentToolBody, type TestAgentToolResponse, type TestNodeBody, type TestResult, type TestWorkflowBody, type TicketAttachment, type TicketComment, type TicketContext, type TicketDetail, type TicketPriority, type TicketSummary, type TicketType, TicketsResource, type ToolAction, type ToolActionParameter, ToolConnectionResource, type ToolCredential, ToolDiscoveryResource, type UnpublishResult, type UpdateAgentBody, type UpdateAgentToolBody, type UpdateBranchBody, type UpdateFolderBody, type UpdateNodeBody, type UpdateTicketBody, type UpdateVersionBody, type UpdateWorkflowBody, type UploadProfilePictureResponse, type ValidationReport, type VersionCreator, type VersionDetail, type VersionSummary, type VersionType, VersionsResource, type WfSummary, type WorkflowDetail, type WorkflowEdge, WorkflowExecutionsResource, type WorkflowNode, type WorkflowOverview, type WorkflowStatus, type WorkflowSummary, WorkflowsResource };