@taico/client 0.0.2 → 0.2.0

package/dist/src/v2/secrets-resource.js

@@ -0,0 +1,30 @@
+import { BaseClient } from './base-client.js';
+export class SecretsResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Create a new secret */
+    async SecretsController_createSecret(params) {
+        return this.request('POST', '/api/v1/secrets', { body: params.body, signal: params?.signal });
+    }
+    /** List all secrets - values not included */
+    async SecretsController_listSecrets(params) {
+        return this.request('GET', '/api/v1/secrets', { signal: params?.signal });
+    }
+    /** Get secret metadata by ID - value not included */
+    async SecretsController_getSecret(params) {
+        return this.request('GET', `/api/v1/secrets/${params.id}`, { signal: params?.signal });
+    }
+    /** Update a secret */
+    async SecretsController_updateSecret(params) {
+        return this.request('PATCH', `/api/v1/secrets/${params.id}`, { body: params.body, signal: params?.signal });
+    }
+    /** Delete a secret */
+    async SecretsController_deleteSecret(params) {
+        return this.request('DELETE', `/api/v1/secrets/${params.id}`, { signal: params?.signal });
+    }
+    /** Get decrypted secret value */
+    async SecretsController_getSecretValue(params) {
+        return this.request('GET', `/api/v1/secrets/${params.id}/value`, { signal: params?.signal });
+    }
+}

package/dist/src/v2/task-blueprints-resource.d.ts

@@ -0,0 +1,37 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { CreateTaskBlueprintDto, TaskBlueprintListResponseDto, TaskBlueprintResponseDto, TaskResponseDto, UpdateTaskBlueprintDto } from './types.js';
+export declare class TaskBlueprintsResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Create a new task blueprint */
+    TaskBlueprintsController_createTaskBlueprint(params: {
+        body: CreateTaskBlueprintDto;
+        signal?: AbortSignal;
+    }): Promise<TaskBlueprintResponseDto>;
+    /** List all task blueprints */
+    TaskBlueprintsController_listTaskBlueprints(params?: {
+        page?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<TaskBlueprintListResponseDto>;
+    /** Get a task blueprint by ID */
+    TaskBlueprintsController_getTaskBlueprint(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<TaskBlueprintResponseDto>;
+    /** Update a task blueprint */
+    TaskBlueprintsController_updateTaskBlueprint(params: {
+        id: string;
+        body: UpdateTaskBlueprintDto;
+        signal?: AbortSignal;
+    }): Promise<TaskBlueprintResponseDto>;
+    /** Delete a task blueprint */
+    TaskBlueprintsController_deleteTaskBlueprint(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Create a task from a blueprint */
+    TaskBlueprintsController_createTaskFromBlueprint(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<TaskResponseDto>;
+}

package/dist/src/v2/task-blueprints-resource.js

@@ -0,0 +1,30 @@
+import { BaseClient } from './base-client.js';
+export class TaskBlueprintsResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Create a new task blueprint */
+    async TaskBlueprintsController_createTaskBlueprint(params) {
+        return this.request('POST', '/api/v1/task-blueprints', { body: params.body, signal: params?.signal });
+    }
+    /** List all task blueprints */
+    async TaskBlueprintsController_listTaskBlueprints(params) {
+        return this.request('GET', '/api/v1/task-blueprints', { params: { page: params?.page, limit: params?.limit }, signal: params?.signal });
+    }
+    /** Get a task blueprint by ID */
+    async TaskBlueprintsController_getTaskBlueprint(params) {
+        return this.request('GET', `/api/v1/task-blueprints/${params.id}`, { signal: params?.signal });
+    }
+    /** Update a task blueprint */
+    async TaskBlueprintsController_updateTaskBlueprint(params) {
+        return this.request('PATCH', `/api/v1/task-blueprints/${params.id}`, { body: params.body, signal: params?.signal });
+    }
+    /** Delete a task blueprint */
+    async TaskBlueprintsController_deleteTaskBlueprint(params) {
+        return this.request('DELETE', `/api/v1/task-blueprints/${params.id}`, { signal: params?.signal });
+    }
+    /** Create a task from a blueprint */
+    async TaskBlueprintsController_createTaskFromBlueprint(params) {
+        return this.request('POST', `/api/v1/task-blueprints/${params.id}/create-task`, { signal: params?.signal });
+    }
+}

package/dist/src/v2/task-resource.d.ts

@@ -0,0 +1,117 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { AnswerInputRequestDto, ArtefactResponseDto, AssignTaskDto, ChangeTaskStatusDto, CommentResponseDto, CreateArtefactDto, CreateCommentDto, CreateInputRequestDto, CreateTagDto, CreateTaskDto, InputRequestResponseDto, TaskListResponseDto, TaskResponseDto, TaskSearchResultDto, UpdateTaskDto } from './types.js';
+export declare class TaskResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Create a new task */
+    TasksController_createTask(params: {
+        body: CreateTaskDto;
+        signal?: AbortSignal;
+    }): Promise<TaskResponseDto>;
+    /** List tasks with optional filtering and pagination */
+    TasksController_listTasks(params?: {
+        assignee?: string;
+        sessionId?: string;
+        tag?: string;
+        page?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<TaskListResponseDto>;
+    /** Update task description */
+    TasksController_updateTask(params: {
+        id: string;
+        body: UpdateTaskDto;
+        signal?: AbortSignal;
+    }): Promise<TaskResponseDto>;
+    /** Delete a task */
+    TasksController_deleteTask(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Get a task by ID */
+    TasksController_getTask(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<TaskResponseDto>;
+    /** Assign a task to someone */
+    TasksController_assignTask(params: {
+        id: string;
+        body: AssignTaskDto;
+        signal?: AbortSignal;
+    }): Promise<TaskResponseDto>;
+    /** Assign a task to the current user */
+    TasksController_assignTaskToMe(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<TaskResponseDto>;
+    /** Search tasks by query string */
+    TasksController_searchTasks(params: {
+        query: string;
+        limit?: number;
+        threshold?: number;
+        signal?: AbortSignal;
+    }): Promise<TaskSearchResultDto[]>;
+    /** Add a comment to a task */
+    TasksController_addComment(params: {
+        id: string;
+        body: CreateCommentDto;
+        signal?: AbortSignal;
+    }): Promise<CommentResponseDto>;
+    /** Add an artefact to a task */
+    TasksController_addArtefact(params: {
+        id: string;
+        body: CreateArtefactDto;
+        signal?: AbortSignal;
+    }): Promise<ArtefactResponseDto>;
+    /** Change task status */
+    TasksController_changeStatus(params: {
+        id: string;
+        body: ChangeTaskStatusDto;
+        signal?: AbortSignal;
+    }): Promise<TaskResponseDto>;
+    /** Add a tag to a task */
+    TasksController_addTagToTask(params: {
+        id: string;
+        body: CreateTagDto;
+        signal?: AbortSignal;
+    }): Promise<TaskResponseDto>;
+    /** Remove a tag from a task */
+    TasksController_removeTagFromTask(params: {
+        id: string;
+        tagId: string;
+        signal?: AbortSignal;
+    }): Promise<TaskResponseDto>;
+    /** Create an input request for a task */
+    TasksController_createInputRequest(params: {
+        id: string;
+        body: CreateInputRequestDto;
+        signal?: AbortSignal;
+    }): Promise<InputRequestResponseDto>;
+    /** Answer an input request */
+    TasksController_answerInputRequest(params: {
+        id: string;
+        inputRequestId: string;
+        body: AnswerInputRequestDto;
+        signal?: AbortSignal;
+    }): Promise<InputRequestResponseDto>;
+    TasksController_handleMcp_get(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    TasksController_handleMcp_post(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    TasksController_handleMcp_put(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    TasksController_handleMcp_delete(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    TasksController_handleMcp_patch(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    TasksController_handleMcp_options(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    TasksController_handleMcp_head(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

package/dist/src/v2/task-resource.js

@@ -0,0 +1,87 @@
+import { BaseClient } from './base-client.js';
+export class TaskResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Create a new task */
+    async TasksController_createTask(params) {
+        return this.request('POST', '/api/v1/tasks/tasks', { body: params.body, signal: params?.signal });
+    }
+    /** List tasks with optional filtering and pagination */
+    async TasksController_listTasks(params) {
+        return this.request('GET', '/api/v1/tasks/tasks', { params: { assignee: params?.assignee, sessionId: params?.sessionId, tag: params?.tag, page: params?.page, limit: params?.limit }, signal: params?.signal });
+    }
+    /** Update task description */
+    async TasksController_updateTask(params) {
+        return this.request('PATCH', `/api/v1/tasks/tasks/${params.id}`, { body: params.body, signal: params?.signal });
+    }
+    /** Delete a task */
+    async TasksController_deleteTask(params) {
+        return this.request('DELETE', `/api/v1/tasks/tasks/${params.id}`, { signal: params?.signal });
+    }
+    /** Get a task by ID */
+    async TasksController_getTask(params) {
+        return this.request('GET', `/api/v1/tasks/tasks/${params.id}`, { signal: params?.signal });
+    }
+    /** Assign a task to someone */
+    async TasksController_assignTask(params) {
+        return this.request('PATCH', `/api/v1/tasks/tasks/${params.id}/assign`, { body: params.body, signal: params?.signal });
+    }
+    /** Assign a task to the current user */
+    async TasksController_assignTaskToMe(params) {
+        return this.request('PATCH', `/api/v1/tasks/tasks/${params.id}/assign-to-me`, { signal: params?.signal });
+    }
+    /** Search tasks by query string */
+    async TasksController_searchTasks(params) {
+        return this.request('GET', '/api/v1/tasks/tasks/search/query', { params: { query: params.query, limit: params.limit, threshold: params.threshold }, signal: params?.signal });
+    }
+    /** Add a comment to a task */
+    async TasksController_addComment(params) {
+        return this.request('POST', `/api/v1/tasks/tasks/${params.id}/comments`, { body: params.body, signal: params?.signal });
+    }
+    /** Add an artefact to a task */
+    async TasksController_addArtefact(params) {
+        return this.request('POST', `/api/v1/tasks/tasks/${params.id}/artefacts`, { body: params.body, signal: params?.signal });
+    }
+    /** Change task status */
+    async TasksController_changeStatus(params) {
+        return this.request('PATCH', `/api/v1/tasks/tasks/${params.id}/status`, { body: params.body, signal: params?.signal });
+    }
+    /** Add a tag to a task */
+    async TasksController_addTagToTask(params) {
+        return this.request('POST', `/api/v1/tasks/tasks/${params.id}/tags`, { body: params.body, signal: params?.signal });
+    }
+    /** Remove a tag from a task */
+    async TasksController_removeTagFromTask(params) {
+        return this.request('DELETE', `/api/v1/tasks/tasks/${params.id}/tags/${params.tagId}`, { signal: params?.signal });
+    }
+    /** Create an input request for a task */
+    async TasksController_createInputRequest(params) {
+        return this.request('POST', `/api/v1/tasks/tasks/${params.id}/input-requests`, { body: params.body, signal: params?.signal });
+    }
+    /** Answer an input request */
+    async TasksController_answerInputRequest(params) {
+        return this.request('POST', `/api/v1/tasks/tasks/${params.id}/input-requests/${params.inputRequestId}/answer`, { body: params.body, signal: params?.signal });
+    }
+    async TasksController_handleMcp_get(params) {
+        return this.request('GET', '/api/v1/tasks/tasks/mcp', { signal: params?.signal });
+    }
+    async TasksController_handleMcp_post(params) {
+        return this.request('POST', '/api/v1/tasks/tasks/mcp', { signal: params?.signal });
+    }
+    async TasksController_handleMcp_put(params) {
+        return this.request('PUT', '/api/v1/tasks/tasks/mcp', { signal: params?.signal });
+    }
+    async TasksController_handleMcp_delete(params) {
+        return this.request('DELETE', '/api/v1/tasks/tasks/mcp', { signal: params?.signal });
+    }
+    async TasksController_handleMcp_patch(params) {
+        return this.request('PATCH', '/api/v1/tasks/tasks/mcp', { signal: params?.signal });
+    }
+    async TasksController_handleMcp_options(params) {
+        return this.request('OPTIONS', '/api/v1/tasks/tasks/mcp', { signal: params?.signal });
+    }
+    async TasksController_handleMcp_head(params) {
+        return this.request('HEAD', '/api/v1/tasks/tasks/mcp', { signal: params?.signal });
+    }
+}

package/dist/src/v2/threads-resource.d.ts

@@ -0,0 +1,102 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { AddParticipantDto, AppendThreadStateDto, AttachTaskDto, CreateTagDto, CreateThreadDto, CreateThreadMessageDto, ListThreadMessagesResponseDto, ReferenceContextBlockDto, ThreadListResponseDto, ThreadMessageResponseDto, ThreadResponseDto, ThreadStateResponseDto, UpdateThreadDto, UpdateThreadStateDto } from './types.js';
+export declare class ThreadsResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Create a new thread */
+    ThreadsController_createThread(params: {
+        body: CreateThreadDto;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto>;
+    /** List all threads with lightweight retrieval */
+    ThreadsController_listThreads(params?: {
+        page?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<ThreadListResponseDto>;
+    /** Update thread title */
+    ThreadsController_updateThread(params: {
+        id: string;
+        body: UpdateThreadDto;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto>;
+    /** Get a thread by ID with full details */
+    ThreadsController_getThread(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto>;
+    /** Delete a thread */
+    ThreadsController_deleteThread(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Get a thread by task ID */
+    ThreadsController_getThreadByTaskId(params: {
+        taskId: string;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto>;
+    /** Get threads by state context block ID */
+    ThreadsController_getThreadsByStateBlockId(params: {
+        stateBlockId: string;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto[]>;
+    /** Attach a task to the thread */
+    ThreadsController_attachTask(params: {
+        id: string;
+        body: AttachTaskDto;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto>;
+    /** Reference a context block in the thread */
+    ThreadsController_referenceContextBlock(params: {
+        id: string;
+        body: ReferenceContextBlockDto;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto>;
+    /** Add a tag to a thread */
+    ThreadsController_addTagToThread(params: {
+        id: string;
+        body: CreateTagDto;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto>;
+    /** Remove a tag from a thread */
+    ThreadsController_removeTagFromThread(params: {
+        id: string;
+        tagId: string;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto>;
+    /** Add a participant to the thread */
+    ThreadsController_addParticipant(params: {
+        id: string;
+        body: AddParticipantDto;
+        signal?: AbortSignal;
+    }): Promise<ThreadResponseDto>;
+    /** Get the state of a thread */
+    ThreadsController_getThreadState(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<ThreadStateResponseDto>;
+    /** Update the state of a thread */
+    ThreadsController_updateThreadState(params: {
+        id: string;
+        body: UpdateThreadStateDto;
+        signal?: AbortSignal;
+    }): Promise<ThreadStateResponseDto>;
+    /** Append content to the state of a thread */
+    ThreadsController_appendThreadState(params: {
+        id: string;
+        body: AppendThreadStateDto;
+        signal?: AbortSignal;
+    }): Promise<ThreadStateResponseDto>;
+    /** Create a message in the thread */
+    ThreadsController_createMessage(params: {
+        id: string;
+        body: CreateThreadMessageDto;
+        signal?: AbortSignal;
+    }): Promise<ThreadMessageResponseDto>;
+    /** List messages in a thread */
+    ThreadsController_listMessages(params: {
+        id: string;
+        page?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<ListThreadMessagesResponseDto>;
+}

package/dist/src/v2/threads-resource.js

@@ -0,0 +1,74 @@
+import { BaseClient } from './base-client.js';
+export class ThreadsResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Create a new thread */
+    async ThreadsController_createThread(params) {
+        return this.request('POST', '/api/v1/threads', { body: params.body, signal: params?.signal });
+    }
+    /** List all threads with lightweight retrieval */
+    async ThreadsController_listThreads(params) {
+        return this.request('GET', '/api/v1/threads', { params: { page: params?.page, limit: params?.limit }, signal: params?.signal });
+    }
+    /** Update thread title */
+    async ThreadsController_updateThread(params) {
+        return this.request('PATCH', `/api/v1/threads/${params.id}`, { body: params.body, signal: params?.signal });
+    }
+    /** Get a thread by ID with full details */
+    async ThreadsController_getThread(params) {
+        return this.request('GET', `/api/v1/threads/${params.id}`, { signal: params?.signal });
+    }
+    /** Delete a thread */
+    async ThreadsController_deleteThread(params) {
+        return this.request('DELETE', `/api/v1/threads/${params.id}`, { signal: params?.signal });
+    }
+    /** Get a thread by task ID */
+    async ThreadsController_getThreadByTaskId(params) {
+        return this.request('GET', `/api/v1/threads/by-task/${params.taskId}`, { signal: params?.signal });
+    }
+    /** Get threads by state context block ID */
+    async ThreadsController_getThreadsByStateBlockId(params) {
+        return this.request('GET', `/api/v1/threads/by-state-block/${params.stateBlockId}`, { signal: params?.signal });
+    }
+    /** Attach a task to the thread */
+    async ThreadsController_attachTask(params) {
+        return this.request('POST', `/api/v1/threads/${params.id}/tasks`, { body: params.body, signal: params?.signal });
+    }
+    /** Reference a context block in the thread */
+    async ThreadsController_referenceContextBlock(params) {
+        return this.request('POST', `/api/v1/threads/${params.id}/context-blocks`, { body: params.body, signal: params?.signal });
+    }
+    /** Add a tag to a thread */
+    async ThreadsController_addTagToThread(params) {
+        return this.request('POST', `/api/v1/threads/${params.id}/tags`, { body: params.body, signal: params?.signal });
+    }
+    /** Remove a tag from a thread */
+    async ThreadsController_removeTagFromThread(params) {
+        return this.request('DELETE', `/api/v1/threads/${params.id}/tags/${params.tagId}`, { signal: params?.signal });
+    }
+    /** Add a participant to the thread */
+    async ThreadsController_addParticipant(params) {
+        return this.request('POST', `/api/v1/threads/${params.id}/participants`, { body: params.body, signal: params?.signal });
+    }
+    /** Get the state of a thread */
+    async ThreadsController_getThreadState(params) {
+        return this.request('GET', `/api/v1/threads/${params.id}/state`, { signal: params?.signal });
+    }
+    /** Update the state of a thread */
+    async ThreadsController_updateThreadState(params) {
+        return this.request('PATCH', `/api/v1/threads/${params.id}/state`, { body: params.body, signal: params?.signal });
+    }
+    /** Append content to the state of a thread */
+    async ThreadsController_appendThreadState(params) {
+        return this.request('POST', `/api/v1/threads/${params.id}/state/append`, { body: params.body, signal: params?.signal });
+    }
+    /** Create a message in the thread */
+    async ThreadsController_createMessage(params) {
+        return this.request('POST', `/api/v1/threads/${params.id}/messages`, { body: params.body, signal: params?.signal });
+    }
+    /** List messages in a thread */
+    async ThreadsController_listMessages(params) {
+        return this.request('GET', `/api/v1/threads/${params.id}/messages`, { params: { page: params.page, limit: params.limit }, signal: params?.signal });
+    }
+}

package/dist/src/v2/tools-resource.d.ts

@@ -0,0 +1,99 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { ConnectionResponseDto, CreateConnectionDto, CreateMappingDto, CreateScopeDto, CreateServerDto, DeleteConnectionResponseDto, DeleteMappingResponseDto, DeleteScopeResponseDto, DeleteServerResponseDto, MappingResponseDto, ScopeResponseDto, ServerListResponseDto, ServerResponseDto, UpdateConnectionDto, UpdateServerDto } from './types.js';
+export declare class ToolsResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Register a new MCP server */
+    McpRegistryController_createServer(params: {
+        body: CreateServerDto;
+        signal?: AbortSignal;
+    }): Promise<ServerResponseDto>;
+    /** List all MCP servers with pagination */
+    McpRegistryController_listServers(params?: {
+        page?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<ServerListResponseDto>;
+    /** Get MCP server by UUID or provided ID */
+    McpRegistryController_getServer(params: {
+        serverId: string;
+        signal?: AbortSignal;
+    }): Promise<ServerResponseDto>;
+    /** Update MCP server details */
+    McpRegistryController_updateServer(params: {
+        serverId: string;
+        body: UpdateServerDto;
+        signal?: AbortSignal;
+    }): Promise<ServerResponseDto>;
+    /** Delete MCP server (must have no dependencies) */
+    McpRegistryController_deleteServer(params: {
+        serverId: string;
+        signal?: AbortSignal;
+    }): Promise<DeleteServerResponseDto>;
+    /** Create MCP scope(s) for a server */
+    McpRegistryController_createScopes(params: {
+        serverId: string;
+        body: CreateScopeDto[];
+        signal?: AbortSignal;
+    }): Promise<ScopeResponseDto[]>;
+    /** List all scopes for an MCP server */
+    McpRegistryController_listScopes(params: {
+        serverId: string;
+        signal?: AbortSignal;
+    }): Promise<ScopeResponseDto[]>;
+    /** Get a specific MCP scope */
+    McpRegistryController_getScope(params: {
+        serverId: string;
+        scopeId: string;
+        signal?: AbortSignal;
+    }): Promise<ScopeResponseDto>;
+    /** Delete MCP scope (must have no mappings) */
+    McpRegistryController_deleteScope(params: {
+        serverId: string;
+        scopeId: string;
+        signal?: AbortSignal;
+    }): Promise<DeleteScopeResponseDto>;
+    /** Create OAuth connection for an MCP server */
+    McpRegistryController_createConnection(params: {
+        serverId: string;
+        body: CreateConnectionDto;
+        signal?: AbortSignal;
+    }): Promise<ConnectionResponseDto>;
+    /** List all connections for an MCP server */
+    McpRegistryController_listConnections(params: {
+        serverId: string;
+        signal?: AbortSignal;
+    }): Promise<ConnectionResponseDto[]>;
+    /** Get a specific connection */
+    McpRegistryController_getConnection(params: {
+        connectionId: string;
+        signal?: AbortSignal;
+    }): Promise<ConnectionResponseDto>;
+    /** Update connection details */
+    McpRegistryController_updateConnection(params: {
+        connectionId: string;
+        body: UpdateConnectionDto;
+        signal?: AbortSignal;
+    }): Promise<ConnectionResponseDto>;
+    /** Delete connection (must have no mappings) */
+    McpRegistryController_deleteConnection(params: {
+        connectionId: string;
+        signal?: AbortSignal;
+    }): Promise<DeleteConnectionResponseDto>;
+    /** Create scope mapping */
+    McpRegistryController_createMapping(params: {
+        serverId: string;
+        body: CreateMappingDto;
+        signal?: AbortSignal;
+    }): Promise<MappingResponseDto>;
+    /** List downstream scopes for an MCP scope */
+    McpRegistryController_listMappings(params: {
+        serverId: string;
+        scopeId: string;
+        signal?: AbortSignal;
+    }): Promise<MappingResponseDto[]>;
+    /** Delete scope mapping */
+    McpRegistryController_deleteMapping(params: {
+        mappingId: string;
+        signal?: AbortSignal;
+    }): Promise<DeleteMappingResponseDto>;
+}

package/dist/src/v2/tools-resource.js

@@ -0,0 +1,74 @@
+import { BaseClient } from './base-client.js';
+export class ToolsResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Register a new MCP server */
+    async McpRegistryController_createServer(params) {
+        return this.request('POST', '/api/v1/mcp/servers', { body: params.body, signal: params?.signal });
+    }
+    /** List all MCP servers with pagination */
+    async McpRegistryController_listServers(params) {
+        return this.request('GET', '/api/v1/mcp/servers', { params: { page: params?.page, limit: params?.limit }, signal: params?.signal });
+    }
+    /** Get MCP server by UUID or provided ID */
+    async McpRegistryController_getServer(params) {
+        return this.request('GET', `/api/v1/mcp/servers/${params.serverId}`, { signal: params?.signal });
+    }
+    /** Update MCP server details */
+    async McpRegistryController_updateServer(params) {
+        return this.request('PATCH', `/api/v1/mcp/servers/${params.serverId}`, { body: params.body, signal: params?.signal });
+    }
+    /** Delete MCP server (must have no dependencies) */
+    async McpRegistryController_deleteServer(params) {
+        return this.request('DELETE', `/api/v1/mcp/servers/${params.serverId}`, { signal: params?.signal });
+    }
+    /** Create MCP scope(s) for a server */
+    async McpRegistryController_createScopes(params) {
+        return this.request('POST', `/api/v1/mcp/servers/${params.serverId}/scopes`, { body: params.body, signal: params?.signal });
+    }
+    /** List all scopes for an MCP server */
+    async McpRegistryController_listScopes(params) {
+        return this.request('GET', `/api/v1/mcp/servers/${params.serverId}/scopes`, { signal: params?.signal });
+    }
+    /** Get a specific MCP scope */
+    async McpRegistryController_getScope(params) {
+        return this.request('GET', `/api/v1/mcp/servers/${params.serverId}/scopes/${params.scopeId}`, { signal: params?.signal });
+    }
+    /** Delete MCP scope (must have no mappings) */
+    async McpRegistryController_deleteScope(params) {
+        return this.request('DELETE', `/api/v1/mcp/servers/${params.serverId}/scopes/${params.scopeId}`, { signal: params?.signal });
+    }
+    /** Create OAuth connection for an MCP server */
+    async McpRegistryController_createConnection(params) {
+        return this.request('POST', `/api/v1/mcp/servers/${params.serverId}/connections`, { body: params.body, signal: params?.signal });
+    }
+    /** List all connections for an MCP server */
+    async McpRegistryController_listConnections(params) {
+        return this.request('GET', `/api/v1/mcp/servers/${params.serverId}/connections`, { signal: params?.signal });
+    }
+    /** Get a specific connection */
+    async McpRegistryController_getConnection(params) {
+        return this.request('GET', `/api/v1/mcp/connections/${params.connectionId}`, { signal: params?.signal });
+    }
+    /** Update connection details */
+    async McpRegistryController_updateConnection(params) {
+        return this.request('PATCH', `/api/v1/mcp/connections/${params.connectionId}`, { body: params.body, signal: params?.signal });
+    }
+    /** Delete connection (must have no mappings) */
+    async McpRegistryController_deleteConnection(params) {
+        return this.request('DELETE', `/api/v1/mcp/connections/${params.connectionId}`, { signal: params?.signal });
+    }
+    /** Create scope mapping */
+    async McpRegistryController_createMapping(params) {
+        return this.request('POST', `/api/v1/mcp/servers/${params.serverId}/mappings`, { body: params.body, signal: params?.signal });
+    }
+    /** List downstream scopes for an MCP scope */
+    async McpRegistryController_listMappings(params) {
+        return this.request('GET', `/api/v1/mcp/servers/${params.serverId}/scopes/${params.scopeId}/mappings`, { signal: params?.signal });
+    }
+    /** Delete scope mapping */
+    async McpRegistryController_deleteMapping(params) {
+        return this.request('DELETE', `/api/v1/mcp/mappings/${params.mappingId}`, { signal: params?.signal });
+    }
+}