@utaba/ucm-mcp-server 6.6.0 → 6.7.0

package/dist/tools/memory-graph/GraphOpenTool.d.ts

@@ -1,12 +1,15 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
 import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphOpenParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
 export declare class GraphOpenTool extends BaseToolController {
     constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
     get name(): string;
     get description(): string;
-    get inputSchema(): any;
-    protected handleExecute(params: any): Promise<any>;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphOpenParams): Promise<string>;
     private handleApiError;
 }
 //# sourceMappingURL=GraphOpenTool.d.ts.map

package/dist/tools/memory-graph/GraphOpenTool.js

@@ -1,13 +1,15 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphOpenSchema } from '../../../schemas/memory-graph-tool-schemas.js';
 export class GraphOpenTool extends BaseToolController {
     constructor(ucmClient, logger, publishingAuthorId) {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() { return 'ucm_graph_open'; }
     get description() {
-        return 'Open a Memory Graph and get its vocabulary, statistics, instructions, and policies. Call this FIRST before querying a graph — it returns the schema (entity types, relationship types, property definitions) needed to construct queries.';
+        return 'Open a Memory Graph and get its vocabulary, statistics, query instructions, usage instructions, and policies. Call this FIRST before querying a graph — it returns the schema (entity types, relationship types, property definitions) needed to construct queries.';
     }
+    get schema() { return GraphOpenSchema; }
     get inputSchema() {
         return {
             type: 'object',

package/dist/tools/memory-graph/GraphProposeVocabularyTool.d.ts

@@ -1,11 +1,14 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
 import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphProposeVocabularyParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
 export declare class GraphProposeVocabularyTool extends BaseToolController {
     constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
     get name(): string;
     get description(): string;
-    get inputSchema(): any;
-    protected handleExecute(params: any): Promise<any>;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphProposeVocabularyParams): Promise<string>;
 }
 //# sourceMappingURL=GraphProposeVocabularyTool.d.ts.map

package/dist/tools/memory-graph/GraphProposeVocabularyTool.js

@@ -1,13 +1,15 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphProposeVocabularySchema } from '../../../schemas/memory-graph-tool-schemas.js';
 export class GraphProposeVocabularyTool extends BaseToolController {
     constructor(ucmClient, logger, publishingAuthorId) {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() { return 'ucm_graph_propose_vocabulary'; }
     get description() {
-        return 'Propose new entity types or relationship types for a Memory Graph vocabulary. Behaviour depends on the governance mode: auto-approved in "open" mode, queued for review in "managed" mode, rejected in "locked" mode.';
+        return 'Propose new entity or relationship types, or edit existing types (add/remove/update properties) for a Memory Graph vocabulary. Behaviour depends on the governance mode: auto-approved in "open" mode, queued for review in "managed" mode, rejected in "locked" mode.';
     }
+    get schema() { return GraphProposeVocabularySchema; }
     get inputSchema() {
         return {
             type: 'object',
@@ -72,21 +74,64 @@ export class GraphProposeVocabularyTool extends BaseToolController {
                         },
                         required: ['type', 'description', 'justification', 'allowedSourceTypes', 'allowedTargetTypes']
                     }
+                },
+                editEntityTypes: {
+                    type: 'array',
+                    description: 'Edits to existing entity types — add, remove, or update properties',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', description: 'Existing entity type name to modify' },
+                            description: { type: 'string', description: 'New description (omit to keep current)' },
+                            justification: { type: 'string', description: 'Why this change is needed' },
+                            addProperties: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, type: { type: 'string', description: 'string, number, boolean, date' }, required: { type: 'boolean' }, description: { type: 'string' } }, required: ['name', 'type', 'required'] }, description: 'New properties to add' },
+                            removeProperties: { type: 'array', items: { type: 'string' }, description: 'Property names to remove' },
+                            updateProperties: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, type: { type: 'string', description: 'string, number, boolean, date' }, required: { type: 'boolean' }, description: { type: 'string' } }, required: ['name', 'type', 'required'] }, description: 'Existing properties to update (matched by name)' }
+                        },
+                        required: ['type', 'justification']
+                    }
+                },
+                editRelationshipTypes: {
+                    type: 'array',
+                    description: 'Edits to existing relationship types',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', description: 'Existing relationship type name to modify' },
+                            description: { type: 'string', description: 'New description (omit to keep current)' },
+                            justification: { type: 'string', description: 'Why this change is needed' },
+                            allowedSourceTypes: { type: 'array', items: { type: 'string' }, description: 'Replace allowed source entity types' },
+                            allowedTargetTypes: { type: 'array', items: { type: 'string' }, description: 'Replace allowed target entity types' },
+                            bidirectional: { type: 'boolean', description: 'Change bidirectional flag' },
+                            addProperties: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, type: { type: 'string' }, required: { type: 'boolean' }, description: { type: 'string' } }, required: ['name', 'type', 'required'] }, description: 'New properties to add' },
+                            removeProperties: { type: 'array', items: { type: 'string' }, description: 'Property names to remove' },
+                            updateProperties: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, type: { type: 'string' }, required: { type: 'boolean' }, description: { type: 'string' } }, required: ['name', 'type', 'required'] }, description: 'Existing properties to update (matched by name)' }
+                        },
+                        required: ['type', 'justification']
+                    }
                 }
             },
             required: ['memoryGraphId']
         };
     }
     async handleExecute(params) {
-        const { memoryGraphId, entityTypes, relationshipTypes } = params;
-        if ((!entityTypes || entityTypes.length === 0) && (!relationshipTypes || relationshipTypes.length === 0)) {
-            throw new McpError(McpErrorCode.InvalidParams, 'At least one of entityTypes or relationshipTypes must be provided');
+        const { memoryGraphId, entityTypes, relationshipTypes, editEntityTypes, editRelationshipTypes } = params;
+        const hasAny = (entityTypes && entityTypes.length > 0) ||
+            (relationshipTypes && relationshipTypes.length > 0) ||
+            (editEntityTypes && editEntityTypes.length > 0) ||
+            (editRelationshipTypes && editRelationshipTypes.length > 0);
+        if (!hasAny) {
+            throw new McpError(McpErrorCode.InvalidParams, 'At least one of entityTypes, relationshipTypes, editEntityTypes, or editRelationshipTypes must be provided');
         }
         this.logger.info('GraphProposeVocabularyTool', `Proposing vocabulary for graph: ${memoryGraphId}`);
         try {
             const result = await this.ucmClient.graphProposeVocabulary(memoryGraphId, {
-                entityTypes,
-                relationshipTypes
+                // TYPE-EXCEPTION: Zod infers `required?: boolean` but API client expects `required: boolean`;
+                // runtime values are always valid — cast to satisfy the client signature.
+                entityTypes: entityTypes,
+                relationshipTypes: relationshipTypes,
+                editEntityTypes: editEntityTypes,
+                editRelationshipTypes: editRelationshipTypes,
             });
             return JSON.stringify(result);
         }

package/dist/tools/memory-graph/GraphSearchTool.d.ts

@@ -1,11 +1,14 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
 import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphSearchParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
 export declare class GraphSearchTool extends BaseToolController {
     constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
     get name(): string;
     get description(): string;
-    get inputSchema(): any;
-    protected handleExecute(params: any): Promise<any>;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphSearchParams): Promise<string>;
 }
 //# sourceMappingURL=GraphSearchTool.d.ts.map

package/dist/tools/memory-graph/GraphSearchTool.js

@@ -1,5 +1,6 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphSearchSchema } from '../../../schemas/memory-graph-tool-schemas.js';
 export class GraphSearchTool extends BaseToolController {
     constructor(ucmClient, logger, publishingAuthorId) {
         super(ucmClient, logger, publishingAuthorId);
@@ -8,6 +9,7 @@ export class GraphSearchTool extends BaseToolController {
     get description() {
         return 'Semantic search across one or more Memory Graphs using vector similarity. Uses embeddings if available. Returns entities ranked by relevance to the query concept. Provide memoryGraphId for single-graph search, graphIds (array) for multi-graph search, or omit both to search all accessible graphs.';
     }
+    get schema() { return GraphSearchSchema; }
     get inputSchema() {
         return {
             type: 'object',

package/dist/tools/memory-graph/GraphTraverseTool.d.ts

@@ -1,11 +1,14 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
 import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphTraverseParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
 export declare class GraphTraverseTool extends BaseToolController {
     constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
     get name(): string;
     get description(): string;
-    get inputSchema(): any;
-    protected handleExecute(params: any): Promise<any>;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphTraverseParams): Promise<string>;
 }
 //# sourceMappingURL=GraphTraverseTool.d.ts.map

package/dist/tools/memory-graph/GraphTraverseTool.js

@@ -1,5 +1,6 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphTraverseSchema } from '../../../schemas/memory-graph-tool-schemas.js';
 export class GraphTraverseTool extends BaseToolController {
     constructor(ucmClient, logger, publishingAuthorId) {
         super(ucmClient, logger, publishingAuthorId);
@@ -8,6 +9,7 @@ export class GraphTraverseTool extends BaseToolController {
     get description() {
         return 'Execute a structured graph traversal using a JSON spec. Supports start point selection, ordered hop steps with relationship/entity type filters, property filters, repeat loops, and multiple return modes (terminal, all, paths). The most powerful query tool for complex graph navigation.';
     }
+    get schema() { return GraphTraverseSchema; }
     get inputSchema() {
         return {
             type: 'object',

package/dist/tools/memory-graph/GraphUpdateEntitiesTool.d.ts

@@ -1,11 +1,14 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
 import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphUpdateEntitiesParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
 export declare class GraphUpdateEntitiesTool extends BaseToolController {
     constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
     get name(): string;
     get description(): string;
-    get inputSchema(): any;
-    protected handleExecute(params: any): Promise<any>;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphUpdateEntitiesParams): Promise<string>;
 }
 //# sourceMappingURL=GraphUpdateEntitiesTool.d.ts.map

package/dist/tools/memory-graph/GraphUpdateEntitiesTool.js

@@ -1,5 +1,6 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphUpdateEntitiesSchema } from '../../../schemas/memory-graph-tool-schemas.js';
 export class GraphUpdateEntitiesTool extends BaseToolController {
     constructor(ucmClient, logger, publishingAuthorId) {
         super(ucmClient, logger, publishingAuthorId);
@@ -8,6 +9,7 @@ export class GraphUpdateEntitiesTool extends BaseToolController {
     get description() {
         return 'Update one or more entities in a Memory Graph. Each update specifies an entityId and the fields to change (label, summary, properties, data). Pass a single item in the array for single operations.';
     }
+    get schema() { return GraphUpdateEntitiesSchema; }
     get inputSchema() {
         return {
             type: 'object',

package/dist/{mcp-server/tools/memory-graph/GraphSearchTool.d.ts → tools/memory-graph/GraphUpdateTool.d.ts}

@@ -1,14 +1,14 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
 import { ILogger } from '../../interfaces/ILogger.js';
-import { type GraphSearchParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { type GraphUpdateParams } from '../../../schemas/memory-graph-tool-schemas.js';
 import { ZodSchema } from 'zod';
-export declare class GraphSearchTool extends BaseToolController {
+export declare class GraphUpdateTool extends BaseToolController {
     constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
     get name(): string;
     get description(): string;
     get schema(): ZodSchema;
     get inputSchema(): Record<string, unknown>;
-    protected handleExecute(params: GraphSearchParams): Promise<string>;
+    protected handleExecute(params: GraphUpdateParams): Promise<string>;
 }
-//# sourceMappingURL=GraphSearchTool.d.ts.map
+//# sourceMappingURL=GraphUpdateTool.d.ts.map

package/dist/tools/memory-graph/GraphUpdateTool.js

@@ -0,0 +1,59 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphUpdateSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphUpdateTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_update'; }
+    get description() {
+        return 'Update a Memory Graph\'s metadata — label, description, or usage instructions. Use this to update usage instructions with per-graph behavioural rules. Whole-document replacement for usageInstructions.';
+    }
+    get schema() { return GraphUpdateSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The ID of the Memory Graph to update'
+                },
+                label: {
+                    type: 'string',
+                    description: 'New display name for the Memory Graph'
+                },
+                description: {
+                    type: ['string', 'null'],
+                    description: 'New description of the Memory Graph purpose'
+                },
+                usageInstructions: {
+                    type: ['string', 'null'],
+                    description: 'Per-graph behavioural rules and usage instructions. Whole-document replacement.'
+                }
+            },
+            required: ['memoryGraphId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, label, description, usageInstructions } = params;
+        this.logger.info('GraphUpdateTool', `Updating memory graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.updateMemoryGraph(memoryGraphId, { label, description, usageInstructions });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 400) {
+                const detail = error.response?.data?.message || 'Invalid parameters for graph update';
+                throw new McpError(McpErrorCode.InvalidParams, detail);
+            }
+            if (error.response?.status === 403) {
+                throw new McpError(McpErrorCode.InvalidParams, 'Access denied: you do not have permission to update this Memory Graph.');
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found: ${memoryGraphId}`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to update memory graph: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphUpdateTool.js.map

package/dist/tools/memory-graph/KnowledgeSetListTool.d.ts

@@ -1,11 +1,14 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
 import { ILogger } from '../../interfaces/ILogger.js';
+import { type KnowledgeSetListParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
 export declare class KnowledgeSetListTool extends BaseToolController {
     constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
     get name(): string;
     get description(): string;
-    get inputSchema(): any;
-    protected handleExecute(_params: any): Promise<any>;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(_params: KnowledgeSetListParams): Promise<string>;
 }
 //# sourceMappingURL=KnowledgeSetListTool.d.ts.map

package/dist/tools/memory-graph/KnowledgeSetListTool.js

@@ -1,4 +1,5 @@
 import { BaseToolController } from '../base/BaseToolController.js';
+import { KnowledgeSetListSchema } from '../../../schemas/memory-graph-tool-schemas.js';
 export class KnowledgeSetListTool extends BaseToolController {
     constructor(ucmClient, logger, publishingAuthorId) {
         super(ucmClient, logger, publishingAuthorId);
@@ -7,6 +8,7 @@ export class KnowledgeSetListTool extends BaseToolController {
     get description() {
         return 'List Knowledge Sets you have access to. Use `ucm_knowledge_set_open` with a Knowledge Set ID to explore its contents.';
     }
+    get schema() { return KnowledgeSetListSchema; }
     get inputSchema() {
         return {
             type: 'object',

package/dist/tools/memory-graph/KnowledgeSetOpenTool.d.ts

@@ -1,11 +1,14 @@
 import { BaseToolController } from '../base/BaseToolController.js';
 import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
 import { ILogger } from '../../interfaces/ILogger.js';
+import { type KnowledgeSetOpenParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
 export declare class KnowledgeSetOpenTool extends BaseToolController {
     constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
     get name(): string;
     get description(): string;
-    get inputSchema(): any;
-    protected handleExecute(_params: any): Promise<any>;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(_params: KnowledgeSetOpenParams): Promise<string>;
 }
 //# sourceMappingURL=KnowledgeSetOpenTool.d.ts.map

package/dist/tools/memory-graph/KnowledgeSetOpenTool.js

@@ -1,4 +1,5 @@
 import { BaseToolController } from '../base/BaseToolController.js';
+import { KnowledgeSetOpenSchema } from '../../../schemas/memory-graph-tool-schemas.js';
 export class KnowledgeSetOpenTool extends BaseToolController {
     constructor(ucmClient, logger, publishingAuthorId) {
         super(ucmClient, logger, publishingAuthorId);
@@ -7,6 +8,7 @@ export class KnowledgeSetOpenTool extends BaseToolController {
     get description() {
         return 'Open a Knowledge Set to see its contents — Memory Graphs, artifact repositories, and artifact namespaces — with guidance on which tools to use for each.';
     }
+    get schema() { return KnowledgeSetOpenSchema; }
     get inputSchema() {
         return {
             type: 'object',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utaba/ucm-mcp-server",
-  "version": "6.6.0",
+  "version": "6.7.0",
   "description": "Universal Context Manager MCP Server - AI Productivity Platform",
   "main": "dist/index.js",
   "type": "module",

package/package.json.backup

@@ -1,6 +1,6 @@
 {
   "name": "ucm-mcp-server",
-  "version": "6.6.0",
+  "version": "6.7.0",
   "description": "Universal Context Manager MCP Server - AI Productivity Platform",
   "main": "dist/index.js",
   "type": "module",

package/dist/clients/UcmApiClient.d.ts

@@ -1,157 +0,0 @@
-import { ArtifactData, AuthorData } from '../types/UcmApiTypes.js';
-export declare class UcmLocalApiClient {
-    private baseUrl;
-    private authToken?;
-    private authorId?;
-    private organizationId?;
-    private client;
-    constructor(baseUrl: string, authToken?: string | undefined, timeout?: number, authorId?: string | undefined, organizationId?: string | undefined);
-    /**
-     * Get organizationId from constructor or throw error
-     * For local MCP server, organizationId should be provided during initialization
-     */
-    getOrganizationId(): Promise<string>;
-    private setupInterceptors;
-    private ensureClient;
-    getAuthors(): Promise<AuthorData[]>;
-    getAuthor(authorId: string): Promise<AuthorData | null>;
-    private buildApiPath;
-    getArtifact(author?: string, repository?: string, category?: string, subcategory?: string, filename?: string, version?: string): Promise<ArtifactData>;
-    getLatestArtifact(author?: string, repository?: string, category?: string, subcategory?: string, filename?: string): Promise<ArtifactData>;
-    listArtifacts(author?: string, repository?: string, category?: string, subcategory?: string, offset?: number, limit?: number): Promise<{
-        data: any[];
-        pagination: {
-            offset: number;
-            limit: number;
-            total: number;
-        };
-        _links?: any;
-    }>;
-    searchArtifacts(filters?: {
-        repository?: string;
-        category?: string;
-        technology?: string;
-        subcategory?: string;
-        offset?: number;
-        limit?: number;
-    }): Promise<ArtifactData[]>;
-    searchArtifactsByText(searchParams: {
-        searchText?: string;
-        namespace?: string;
-        author?: string;
-        repository?: string;
-        category?: string;
-        subcategory?: string;
-        filename?: string;
-        tags?: string;
-        offset?: number;
-        limit?: number;
-    }): Promise<{
-        data: any[];
-        pagination: {
-            offset: number;
-            limit: number;
-            total: number;
-            hasMore: boolean;
-        };
-        _links?: any;
-    }>;
-    publishArtifact(author: string, repository: string, category: string, subcategory: string, data: any): Promise<ArtifactData>;
-    updateArtifact(author: string, repository: string, category: string, subcategory: string, filename: string, version: string, data: any): Promise<ArtifactData>;
-    deleteArtifact(author: string, repository: string, category: string, subcategory: string, filename: string, version?: string): Promise<any>;
-    getArtifactVersions(author: string, repository: string, category: string, subcategory: string, filename: string): Promise<any>;
-    getCategories(): Promise<string[]>;
-    healthCheck(): Promise<{
-        status: string;
-        timestamp: string;
-    }>;
-    getQuickstart(): Promise<string>;
-    getAuthorIndex(author: string, repository?: string): Promise<string>;
-    getAuthorRecents(author: string): Promise<string>;
-    /**
-     * Cleanup method to properly dispose of HTTP client resources
-     * This helps prevent memory leaks from accumulated AbortSignal listeners
-     */
-    cleanup(): void;
-    /**
-     * Check if the client is still available for use
-     */
-    isAvailable(): boolean;
-    createRepository(author: string, data: {
-        repositoryName: string;
-        displayName?: string;
-        description?: string;
-    }): Promise<any>;
-    getRepository(author: string, repository: string): Promise<any>;
-    updateRepository(author: string, repository: string, data: {
-        displayName?: string;
-        description?: string;
-    }): Promise<any>;
-    deleteRepository(author: string, repository: string): Promise<any>;
-    listRepositories(author: string, offset?: number, limit?: number): Promise<{
-        data: any[];
-        pagination: {
-            offset: number;
-            limit: number;
-            total: number;
-        };
-        _links?: any;
-    }>;
-    submitFeedback(data: {
-        title: string;
-        body: string;
-        reportType: 'issue' | 'feedback';
-        tags?: string;
-    }): Promise<any>;
-    editArtifactMetadata(author: string, repository: string, category: string, subcategory: string, filename: string, data: {
-        updateDescription?: string;
-        updateNamespace?: string;
-        updateFilename?: string;
-        updateMimeType?: string;
-        updateTechnology?: string;
-        updateTags?: string;
-    }): Promise<any>;
-    /**
-     * Generate markdown for SharePoint connections (safe, non-sensitive data only)
-     */
-    sharePointGenerateConnectionsMarkdown(organizationId: string, params: {
-        limit?: number;
-        offset?: number;
-    }): Promise<any>;
-    /**
-     * List SharePoint connections for an organization (includes sensitive data - use with caution)
-     */
-    sharePointListConnections(organizationId: string, params: {
-        limit?: number;
-        offset?: number;
-    }): Promise<any>;
-    /**
-     * Search SharePoint documents using Microsoft Search API
-     */
-    sharePointSearch(organizationId: string, connectionId: string, params: {
-        query: string;
-        limit?: number;
-        offset?: number;
-        fileType?: string;
-    }): Promise<any>;
-    /**
-     * List folders and files in SharePoint with pagination
-     */
-    sharePointListFolders(organizationId: string, connectionId: string, params: {
-        folderPath?: string;
-        includeFiles?: boolean;
-        recursive?: boolean;
-        limit?: number;
-        offset?: number;
-    }): Promise<any>;
-    /**
-     * Read SharePoint file content with support for both fileUrl and legacy fileId
-     */
-    sharePointReadFile(organizationId: string, connectionId: string, params: {
-        fileUrl?: string;
-        fileId?: string;
-        fileName?: string;
-        extractMetadata?: boolean;
-    }): Promise<any>;
-}
-//# sourceMappingURL=UcmApiClient.d.ts.map