@happyvertical/smrt-core 0.30.0

package/dist/mcp-advisor/index.d.ts

@@ -0,0 +1,499 @@
+#!/usr/bin/env node
+/**
+ * SMRT Framework Advisor MCP Server
+ *
+ * Development-time MCP server that acts as a SMRT framework expert.
+ * Provides AI-callable tools for code generation, validation, preview, and discovery.
+ *
+ * This server integrates with Claude Code to help developers write correct SMRT code.
+ */
+/**
+ * MCP tool definitions with JSON schemas
+ *
+ * Exported so tests can assert the advertised tool surface without spawning the
+ * stdio server.
+ */
+export declare const TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            className: {
+                type: string;
+                description: string;
+            };
+            properties: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                            description: string;
+                        };
+                        type: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                        required: {
+                            type: string;
+                            description: string;
+                        };
+                        description: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            baseClass: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+            includeApiConfig: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            includeMcpConfig: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            includeCliConfig: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            methods?: undefined;
+            filePath?: undefined;
+            fields?: undefined;
+            collectionName?: undefined;
+            itemClassName?: undefined;
+            itemClassPath?: undefined;
+            includeCustomMethods?: undefined;
+            api?: undefined;
+            mcp?: undefined;
+            cli?: undefined;
+            hooks?: undefined;
+            strictMode?: undefined;
+            basePath?: undefined;
+            filter?: undefined;
+            format?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            className: {
+                type: string;
+                description: string;
+            };
+            methods: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    enum: string[];
+                };
+            };
+            filePath: {
+                type: string;
+                description: string;
+            };
+            properties?: undefined;
+            baseClass?: undefined;
+            includeApiConfig?: undefined;
+            includeMcpConfig?: undefined;
+            includeCliConfig?: undefined;
+            fields?: undefined;
+            collectionName?: undefined;
+            itemClassName?: undefined;
+            itemClassPath?: undefined;
+            includeCustomMethods?: undefined;
+            api?: undefined;
+            mcp?: undefined;
+            cli?: undefined;
+            hooks?: undefined;
+            strictMode?: undefined;
+            basePath?: undefined;
+            filter?: undefined;
+            format?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            fields: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                            description: string;
+                        };
+                        type: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                        options: {
+                            type: string;
+                            description: string;
+                            additionalProperties: boolean;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            className?: undefined;
+            properties?: undefined;
+            baseClass?: undefined;
+            includeApiConfig?: undefined;
+            includeMcpConfig?: undefined;
+            includeCliConfig?: undefined;
+            methods?: undefined;
+            filePath?: undefined;
+            collectionName?: undefined;
+            itemClassName?: undefined;
+            itemClassPath?: undefined;
+            includeCustomMethods?: undefined;
+            api?: undefined;
+            mcp?: undefined;
+            cli?: undefined;
+            hooks?: undefined;
+            strictMode?: undefined;
+            basePath?: undefined;
+            filter?: undefined;
+            format?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            collectionName: {
+                type: string;
+                description: string;
+            };
+            itemClassName: {
+                type: string;
+                description: string;
+            };
+            itemClassPath: {
+                type: string;
+                description: string;
+            };
+            includeCustomMethods: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            className?: undefined;
+            properties?: undefined;
+            baseClass?: undefined;
+            includeApiConfig?: undefined;
+            includeMcpConfig?: undefined;
+            includeCliConfig?: undefined;
+            methods?: undefined;
+            filePath?: undefined;
+            fields?: undefined;
+            api?: undefined;
+            mcp?: undefined;
+            cli?: undefined;
+            hooks?: undefined;
+            strictMode?: undefined;
+            basePath?: undefined;
+            filter?: undefined;
+            format?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            className: {
+                type: string;
+                description: string;
+            };
+            api: {
+                type: string;
+                description: string;
+                properties: {
+                    include: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        description: string;
+                    };
+                    exclude: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        description: string;
+                    };
+                };
+            };
+            mcp: {
+                type: string;
+                description: string;
+                properties: {
+                    include: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        description: string;
+                    };
+                    exclude: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        description: string;
+                    };
+                };
+            };
+            cli: {
+                type: string;
+                description: string;
+            };
+            hooks: {
+                type: string;
+                description: string;
+                additionalProperties: {
+                    type: string;
+                };
+            };
+            properties?: undefined;
+            baseClass?: undefined;
+            includeApiConfig?: undefined;
+            includeMcpConfig?: undefined;
+            includeCliConfig?: undefined;
+            methods?: undefined;
+            filePath?: undefined;
+            fields?: undefined;
+            collectionName?: undefined;
+            itemClassName?: undefined;
+            itemClassPath?: undefined;
+            includeCustomMethods?: undefined;
+            strictMode?: undefined;
+            basePath?: undefined;
+            filter?: undefined;
+            format?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            filePath: {
+                type: string;
+                description: string;
+            };
+            strictMode: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            className?: undefined;
+            properties?: undefined;
+            baseClass?: undefined;
+            includeApiConfig?: undefined;
+            includeMcpConfig?: undefined;
+            includeCliConfig?: undefined;
+            methods?: undefined;
+            fields?: undefined;
+            collectionName?: undefined;
+            itemClassName?: undefined;
+            itemClassPath?: undefined;
+            includeCustomMethods?: undefined;
+            api?: undefined;
+            mcp?: undefined;
+            cli?: undefined;
+            hooks?: undefined;
+            basePath?: undefined;
+            filter?: undefined;
+            format?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            className: {
+                type: string;
+                description: string;
+            };
+            basePath: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            properties?: undefined;
+            baseClass?: undefined;
+            includeApiConfig?: undefined;
+            includeMcpConfig?: undefined;
+            includeCliConfig?: undefined;
+            methods?: undefined;
+            filePath?: undefined;
+            fields?: undefined;
+            collectionName?: undefined;
+            itemClassName?: undefined;
+            itemClassPath?: undefined;
+            includeCustomMethods?: undefined;
+            api?: undefined;
+            mcp?: undefined;
+            cli?: undefined;
+            hooks?: undefined;
+            strictMode?: undefined;
+            filter?: undefined;
+            format?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            className: {
+                type: string;
+                description: string;
+            };
+            properties?: undefined;
+            baseClass?: undefined;
+            includeApiConfig?: undefined;
+            includeMcpConfig?: undefined;
+            includeCliConfig?: undefined;
+            methods?: undefined;
+            filePath?: undefined;
+            fields?: undefined;
+            collectionName?: undefined;
+            itemClassName?: undefined;
+            itemClassPath?: undefined;
+            includeCustomMethods?: undefined;
+            api?: undefined;
+            mcp?: undefined;
+            cli?: undefined;
+            hooks?: undefined;
+            strictMode?: undefined;
+            basePath?: undefined;
+            filter?: undefined;
+            format?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            filter: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+            className?: undefined;
+            properties?: undefined;
+            baseClass?: undefined;
+            includeApiConfig?: undefined;
+            includeMcpConfig?: undefined;
+            includeCliConfig?: undefined;
+            methods?: undefined;
+            filePath?: undefined;
+            fields?: undefined;
+            collectionName?: undefined;
+            itemClassName?: undefined;
+            itemClassPath?: undefined;
+            includeCustomMethods?: undefined;
+            api?: undefined;
+            mcp?: undefined;
+            cli?: undefined;
+            hooks?: undefined;
+            strictMode?: undefined;
+            basePath?: undefined;
+            format?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            className: {
+                type: string;
+                description: string;
+            };
+            format: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+            properties?: undefined;
+            baseClass?: undefined;
+            includeApiConfig?: undefined;
+            includeMcpConfig?: undefined;
+            includeCliConfig?: undefined;
+            methods?: undefined;
+            filePath?: undefined;
+            fields?: undefined;
+            collectionName?: undefined;
+            itemClassName?: undefined;
+            itemClassPath?: undefined;
+            includeCustomMethods?: undefined;
+            api?: undefined;
+            mcp?: undefined;
+            cli?: undefined;
+            hooks?: undefined;
+            strictMode?: undefined;
+            basePath?: undefined;
+            filter?: undefined;
+        };
+        required: string[];
+    };
+})[];
+/**
+ * Route tool calls to appropriate handler functions
+ *
+ * Exported so the routing switch can be unit-tested in-process (the stdio
+ * entrypoint guard below keeps importing this module side-effect free).
+ */
+export declare function handleToolCall(name: string, args: any): Promise<any>;
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp-advisor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp-advisor/index.ts"],"names":[],"mappings":";AACA;;;;;;;GAOG;AA8BH;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqUjB,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CA2B1E"}

package/dist/mcp-advisor/tools/add-ai-methods.d.ts

@@ -0,0 +1,6 @@
+import { AddAiMethodsInput, ToolResponse } from '../types.js';
+/**
+ * Generate AI method implementations
+ */
+export declare function addAiMethods(input: AddAiMethodsInput): Promise<ToolResponse>;
+//# sourceMappingURL=add-ai-methods.d.ts.map

package/dist/mcp-advisor/tools/add-ai-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-ai-methods.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/add-ai-methods.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEnE;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,YAAY,CAAC,CA0CvB"}

package/dist/mcp-advisor/tools/configure-decorators.d.ts

@@ -0,0 +1,6 @@
+import { ConfigureDecoratorsInput, ToolResponse } from '../types.js';
+/**
+ * Generate decorator configuration
+ */
+export declare function configureDecorators(input: ConfigureDecoratorsInput): Promise<ToolResponse>;
+//# sourceMappingURL=configure-decorators.d.ts.map

package/dist/mcp-advisor/tools/configure-decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure-decorators.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/configure-decorators.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE1E;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,YAAY,CAAC,CAuFvB"}

package/dist/mcp-advisor/tools/generate-collection.d.ts

@@ -0,0 +1,6 @@
+import { GenerateCollectionInput, ToolResponse } from '../types.js';
+/**
+ * Generate a SmrtCollection subclass
+ */
+export declare function generateCollection(input: GenerateCollectionInput): Promise<ToolResponse>;
+//# sourceMappingURL=generate-collection.d.ts.map

package/dist/mcp-advisor/tools/generate-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-collection.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/generate-collection.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEzE;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,uBAAuB,GAC7B,OAAO,CAAC,YAAY,CAAC,CA6EvB"}

package/dist/mcp-advisor/tools/generate-field-definitions.d.ts

@@ -0,0 +1,6 @@
+import { GenerateFieldDefinitionsInput, ToolResponse } from '../types.js';
+/**
+ * Generate field definitions code using decorators
+ */
+export declare function generateFieldDefinitions(input: GenerateFieldDefinitionsInput): Promise<ToolResponse>;
+//# sourceMappingURL=generate-field-definitions.d.ts.map

package/dist/mcp-advisor/tools/generate-field-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-field-definitions.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/generate-field-definitions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,6BAA6B,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE/E;;GAEG;AACH,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,YAAY,CAAC,CA2CvB"}

package/dist/mcp-advisor/tools/generate-smrt-class.d.ts

@@ -0,0 +1,6 @@
+import { GenerateSmrtClassInput, ToolResponse } from '../types.js';
+/**
+ * Generate a complete SMRT class definition
+ */
+export declare function generateSmrtClass(input: GenerateSmrtClassInput): Promise<ToolResponse>;
+//# sourceMappingURL=generate-smrt-class.d.ts.map

package/dist/mcp-advisor/tools/generate-smrt-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-smrt-class.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/generate-smrt-class.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAExE;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,sBAAsB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAkHvB"}

package/dist/mcp-advisor/tools/get-object-config.d.ts

@@ -0,0 +1,6 @@
+import { GetObjectConfigInput, ObjectConfig } from '../types.js';
+/**
+ * Get object decorator configuration
+ */
+export declare function getObjectConfig(input: GetObjectConfigInput): Promise<ObjectConfig>;
+//# sourceMappingURL=get-object-config.d.ts.map

package/dist/mcp-advisor/tools/get-object-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-object-config.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/get-object-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEtE;;GAEG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAqFvB"}

package/dist/mcp-advisor/tools/get-object-schema.d.ts

@@ -0,0 +1,10 @@
+import { FieldDefinition, GetObjectSchemaInput } from '../types.js';
+/**
+ * Get object schema with field definitions
+ */
+export declare function getObjectSchema(input: GetObjectSchemaInput): Promise<{
+    className: string;
+    fields: FieldDefinition[];
+    format: string;
+}>;
+//# sourceMappingURL=get-object-schema.d.ts.map

package/dist/mcp-advisor/tools/get-object-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-object-schema.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/get-object-schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEzE;;GAEG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAiD3E"}

package/dist/mcp-advisor/tools/list-registered-objects.d.ts

@@ -0,0 +1,9 @@
+import { ListRegisteredObjectsInput, RegisteredObjectInfo } from '../types.js';
+/**
+ * List registered objects with metadata
+ */
+export declare function listRegisteredObjects(input?: ListRegisteredObjectsInput): Promise<{
+    objects: RegisteredObjectInfo[];
+    total: number;
+}>;
+//# sourceMappingURL=list-registered-objects.d.ts.map

package/dist/mcp-advisor/tools/list-registered-objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-registered-objects.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/list-registered-objects.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EACV,0BAA0B,EAC1B,oBAAoB,EACrB,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,GAAE,0BAA+B,GACrC,OAAO,CAAC;IAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CA8D7D"}

package/dist/mcp-advisor/tools/preview-api-endpoints.d.ts

@@ -0,0 +1,9 @@
+import { ApiEndpoint, PreviewApiEndpointsInput } from '../types.js';
+/**
+ * Preview API endpoints that would be generated for a class
+ */
+export declare function previewApiEndpoints(input: PreviewApiEndpointsInput): Promise<{
+    endpoints: ApiEndpoint[];
+    basePath: string;
+}>;
+//# sourceMappingURL=preview-api-endpoints.d.ts.map

package/dist/mcp-advisor/tools/preview-api-endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-api-endpoints.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/preview-api-endpoints.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEzE;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC;IAAE,SAAS,EAAE,WAAW,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA2LzD"}

package/dist/mcp-advisor/tools/preview-mcp-tools.d.ts

@@ -0,0 +1,9 @@
+import { McpToolDefinition, PreviewMcpToolsInput } from '../types.js';
+/**
+ * Preview MCP tools that would be generated for a class
+ */
+export declare function previewMcpTools(input: PreviewMcpToolsInput): Promise<{
+    tools: McpToolDefinition[];
+    className: string;
+}>;
+//# sourceMappingURL=preview-mcp-tools.d.ts.map

package/dist/mcp-advisor/tools/preview-mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-mcp-tools.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/preview-mcp-tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAE3E;;GAEG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC;IAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAsC5D"}

package/dist/mcp-advisor/tools/validate-smrt-object.d.ts

@@ -0,0 +1,6 @@
+import { ValidateSmrtObjectInput, ValidationResult } from '../types.js';
+/**
+ * Validate a SMRT object file
+ */
+export declare function validateSmrtObject(input: ValidateSmrtObjectInput): Promise<ValidationResult>;
+//# sourceMappingURL=validate-smrt-object.d.ts.map

package/dist/mcp-advisor/tools/validate-smrt-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-smrt-object.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/validate-smrt-object.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE7E;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,uBAAuB,GAC7B,OAAO,CAAC,gBAAgB,CAAC,CA6I3B"}