snow-flow 4.6.8 → 5.0.0

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_delete_record.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * snow_delete_record - Safe record deletion
+ *
+ * Delete records with safety checks, dependency validation, and
+ * optional soft delete capability.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_delete_record',
+    description: 'Safely delete a record with dependency checks and optional soft delete',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            table: {
+                type: 'string',
+                description: 'Table name'
+            },
+            sys_id: {
+                type: 'string',
+                description: 'sys_id of record to delete'
+            },
+            check_references: {
+                type: 'boolean',
+                description: 'Check for dependent records before deletion',
+                default: true
+            },
+            soft_delete: {
+                type: 'boolean',
+                description: 'Mark as deleted instead of hard delete (if table supports it)',
+                default: false
+            },
+            force: {
+                type: 'boolean',
+                description: 'Force deletion even with dependencies',
+                default: false
+            }
+        },
+        required: ['table', 'sys_id']
+    }
+};
+async function execute(args, context) {
+    const { table, sys_id, check_references = true, soft_delete = false, force = false } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Get record to verify existence
+        const recordCheck = await client.get(`/api/now/table/${table}/${sys_id}`, {
+            params: { sysparm_fields: 'sys_id' }
+        });
+        if (!recordCheck.data.result) {
+            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND_ERROR, `Record not found in table '${table}' with sys_id '${sys_id}'`, { details: { table, sys_id } });
+        }
+        // Check for dependencies
+        let dependencies = [];
+        if (check_references && !force) {
+            // Find all tables that reference this table
+            const refFieldsResponse = await client.get(`/api/now/table/sys_dictionary`, {
+                params: {
+                    sysparm_query: `reference=${table}^internal_type=reference`,
+                    sysparm_fields: 'name,element',
+                    sysparm_limit: 1000
+                }
+            });
+            for (const refField of refFieldsResponse.data.result || []) {
+                const refTable = refField.name;
+                const refColumn = refField.element;
+                // Check if any records reference this record
+                const dependentRecords = await client.get(`/api/now/table/${refTable}`, {
+                    params: {
+                        sysparm_query: `${refColumn}=${sys_id}`,
+                        sysparm_fields: 'sys_id,number',
+                        sysparm_limit: 5
+                    }
+                });
+                if (dependentRecords.data.result && dependentRecords.data.result.length > 0) {
+                    dependencies.push({
+                        table: refTable,
+                        field: refColumn,
+                        count: dependentRecords.data.result.length,
+                        sample_records: dependentRecords.data.result.map((r) => ({
+                            sys_id: r.sys_id,
+                            number: r.number || r.sys_id
+                        }))
+                    });
+                }
+            }
+            if (dependencies.length > 0 && !force) {
+                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'Cannot delete record with dependencies. Use force=true to override.', {
+                    details: {
+                        dependencies,
+                        total_dependent_tables: dependencies.length,
+                        suggestion: 'Review dependencies or use soft_delete=true'
+                    }
+                });
+            }
+        }
+        // Perform deletion
+        if (soft_delete) {
+            // Check if table has active field
+            const hasActiveField = await client.get(`/api/now/table/sys_dictionary`, {
+                params: {
+                    sysparm_query: `name=${table}^element=active`,
+                    sysparm_fields: 'element',
+                    sysparm_limit: 1
+                }
+            });
+            if (hasActiveField.data.result && hasActiveField.data.result.length > 0) {
+                // Soft delete by setting active=false
+                await client.put(`/api/now/table/${table}/${sys_id}`, {
+                    active: 'false'
+                });
+                return (0, error_handler_js_1.createSuccessResult)({
+                    deleted: true,
+                    soft_delete: true,
+                    sys_id,
+                    table,
+                    message: 'Record marked as inactive (soft delete)',
+                    dependencies_found: dependencies.length > 0,
+                    dependencies
+                });
+            }
+            else {
+                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `Table '${table}' does not support soft delete (no 'active' field)`, { details: { table } });
+            }
+        }
+        else {
+            // Hard delete
+            await client.delete(`/api/now/table/${table}/${sys_id}`);
+            return (0, error_handler_js_1.createSuccessResult)({
+                deleted: true,
+                soft_delete: false,
+                sys_id,
+                table,
+                message: 'Record permanently deleted',
+                dependencies_found: dependencies.length > 0,
+                dependencies,
+                forced: force && dependencies.length > 0
+            });
+        }
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_delete_record.js.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_discover_table_fields.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_discover_table_fields - Discover table schema
+ *
+ * Get comprehensive table schema information including fields,
+ * relationships, indexes, and ACLs.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_discover_table_fields.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_discover_table_fields.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * snow_discover_table_fields - Discover table schema
+ *
+ * Get comprehensive table schema information including fields,
+ * relationships, indexes, and ACLs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_discover_table_fields',
+    description: 'Discover table schema with fields, types, relationships, and metadata',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            table_name: {
+                type: 'string',
+                description: 'Table name to discover schema for'
+            },
+            include_relationships: {
+                type: 'boolean',
+                description: 'Include field relationships (reference fields)',
+                default: true
+            },
+            include_acls: {
+                type: 'boolean',
+                description: 'Include ACL information',
+                default: false
+            },
+            include_indexes: {
+                type: 'boolean',
+                description: 'Include index information',
+                default: false
+            }
+        },
+        required: ['table_name']
+    }
+};
+async function execute(args, context) {
+    const { table_name, include_relationships = true, include_acls = false, include_indexes = false } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Step 1: Get table metadata
+        const tableResponse = await client.get('/api/now/table/sys_db_object', {
+            params: {
+                sysparm_query: `name=${table_name}`,
+                sysparm_limit: 1
+            }
+        });
+        if (tableResponse.data.result.length === 0) {
+            return (0, error_handler_js_1.createErrorResult)(`Table not found: ${table_name}`);
+        }
+        const tableInfo = tableResponse.data.result[0];
+        // Step 2: Get all fields for the table
+        const fieldsResponse = await client.get('/api/now/table/sys_dictionary', {
+            params: {
+                sysparm_query: `name=${table_name}^element!=NULL^ORDERBYelement`,
+                sysparm_limit: 1000
+            }
+        });
+        const fields = fieldsResponse.data.result.map((field) => ({
+            name: field.element,
+            label: field.column_label,
+            type: field.internal_type?.display_value || field.internal_type,
+            max_length: field.max_length,
+            mandatory: field.mandatory === 'true',
+            read_only: field.read_only === 'true',
+            default_value: field.default_value,
+            reference: field.reference?.display_value || field.reference,
+            help_text: field.help
+        }));
+        // Step 3: Get relationships if requested
+        let relationships = [];
+        if (include_relationships) {
+            const refFields = fields.filter((f) => f.type === 'reference');
+            relationships = refFields.map((f) => ({
+                field: f.name,
+                references_table: f.reference,
+                type: 'many-to-one'
+            }));
+        }
+        // Step 4: Get ACLs if requested
+        let acls = [];
+        if (include_acls) {
+            const aclResponse = await client.get('/api/now/table/sys_security_acl', {
+                params: {
+                    sysparm_query: `name=${table_name}`,
+                    sysparm_limit: 100
+                }
+            });
+            acls = aclResponse.data.result.map((acl) => ({
+                operation: acl.operation,
+                roles: acl.roles,
+                condition: acl.condition,
+                script: acl.script ? 'Present' : 'None'
+            }));
+        }
+        // Step 5: Get indexes if requested
+        let indexes = [];
+        if (include_indexes) {
+            const indexResponse = await client.get('/api/now/table/sys_db_index', {
+                params: {
+                    sysparm_query: `table=${table_name}`,
+                    sysparm_limit: 100
+                }
+            });
+            indexes = indexResponse.data.result.map((idx) => ({
+                name: idx.name,
+                fields: idx.field_list,
+                unique: idx.unique === 'true'
+            }));
+        }
+        return (0, error_handler_js_1.createSuccessResult)({
+            table: {
+                name: table_name,
+                label: tableInfo.label,
+                extends: tableInfo.super_class?.display_value || null,
+                sys_id: tableInfo.sys_id
+            },
+            fields,
+            field_count: fields.length,
+            relationships,
+            acls: include_acls ? acls : undefined,
+            indexes: include_indexes ? indexes : undefined
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_discover_table_fields.js.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_get_by_sysid.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_get_by_sysid - Get artifact by sys_id
+ *
+ * Retrieve any ServiceNow record by its sys_id with optional
+ * field selection and display values.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_get_by_sysid.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_get_by_sysid.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * snow_get_by_sysid - Get artifact by sys_id
+ *
+ * Retrieve any ServiceNow record by its sys_id with optional
+ * field selection and display values.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_get_by_sysid',
+    description: 'Get any ServiceNow record by sys_id with optional field selection',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            table: {
+                type: 'string',
+                description: 'Table name (e.g., sp_widget, sys_ux_page, incident)'
+            },
+            sys_id: {
+                type: 'string',
+                description: 'sys_id of the record to retrieve'
+            },
+            fields: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Specific fields to return (default: all)',
+                default: []
+            },
+            display_value: {
+                type: 'boolean',
+                description: 'Return display values for reference fields',
+                default: false
+            }
+        },
+        required: ['table', 'sys_id']
+    }
+};
+async function execute(args, context) {
+    const { table, sys_id, fields = [], display_value = false } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Build query parameters
+        const params = {};
+        if (fields.length > 0) {
+            params.sysparm_fields = fields.join(',');
+        }
+        if (display_value) {
+            params.sysparm_display_value = 'true';
+        }
+        // Get record
+        const response = await client.get(`/api/now/table/${table}/${sys_id}`, { params });
+        if (!response.data || !response.data.result) {
+            return (0, error_handler_js_1.createErrorResult)(`Record not found: ${table}/${sys_id}`);
+        }
+        const record = response.data.result;
+        return (0, error_handler_js_1.createSuccessResult)({
+            found: true,
+            record,
+            table,
+            sys_id
+        });
+    }
+    catch (error) {
+        if (error.response?.status === 404) {
+            return (0, error_handler_js_1.createSuccessResult)({
+                found: false,
+                table,
+                sys_id,
+                error: 'Record not found'
+            });
+        }
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_get_by_sysid.js.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_list_group_members.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snow_list_group_members - List group members
+ *
+ * Lists all members of a ServiceNow group.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_list_group_members.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_list_group_members.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * snow_list_group_members - List group members
+ *
+ * Lists all members of a ServiceNow group.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_list_group_members',
+    description: 'Lists all members of a ServiceNow group',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            group_identifier: {
+                type: 'string',
+                description: 'Group sys_id or name'
+            },
+            include_details: {
+                type: 'boolean',
+                description: 'Include detailed user information',
+                default: true
+            }
+        },
+        required: ['group_identifier']
+    }
+};
+async function execute(args, context) {
+    const { group_identifier, include_details = true } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Resolve group
+        const groupQuery = group_identifier.length === 32
+            ? `sys_id=${group_identifier}`
+            : `name=${group_identifier}`;
+        const groupResponse = await client.get('/api/now/table/sys_user_group', {
+            params: { sysparm_query: groupQuery, sysparm_limit: 1 }
+        });
+        if (!groupResponse.data.result || groupResponse.data.result.length === 0) {
+            return (0, error_handler_js_1.createErrorResult)(`Group "${group_identifier}" not found`);
+        }
+        const group = groupResponse.data.result[0];
+        // Get group memberships
+        const membershipsResponse = await client.get('/api/now/table/sys_user_grmember', {
+            params: {
+                sysparm_query: `group=${group.sys_id}`,
+                sysparm_limit: 500
+            }
+        });
+        const memberships = membershipsResponse.data.result || [];
+        let members = [];
+        if (include_details && memberships.length > 0) {
+            // Get detailed user information for each member
+            const userSysIds = memberships.map((m) => m.user?.value || m.user);
+            const userQuery = `sys_idIN${userSysIds.join(',')}`;
+            const usersResponse = await client.get('/api/now/table/sys_user', {
+                params: {
+                    sysparm_query: userQuery,
+                    sysparm_limit: 500
+                }
+            });
+            const users = usersResponse.data.result || [];
+            // Create a map of user details
+            const userMap = new Map();
+            users.forEach((user) => {
+                userMap.set(user.sys_id, user);
+            });
+            // Combine membership with user details
+            members = memberships.map((membership) => {
+                const userId = membership.user?.value || membership.user;
+                const user = userMap.get(userId);
+                return {
+                    membership_sys_id: membership.sys_id,
+                    user_sys_id: userId,
+                    user_name: user?.user_name || 'Unknown',
+                    name: user?.name || 'Unknown',
+                    email: user?.email,
+                    title: user?.title,
+                    department: user?.department,
+                    active: user?.active
+                };
+            });
+        }
+        else {
+            // Just return basic membership info
+            members = memberships.map((membership) => ({
+                membership_sys_id: membership.sys_id,
+                user_sys_id: membership.user?.value || membership.user
+            }));
+        }
+        return (0, error_handler_js_1.createSuccessResult)({
+            group: {
+                sys_id: group.sys_id,
+                name: group.name,
+                description: group.description,
+                type: group.type
+            },
+            member_count: members.length,
+            members
+        }, { group_name: group.name, member_count: members.length });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_list_group_members.js.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_operational_metrics.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snow_operational_metrics - Get operational metrics
+ *
+ * Provides operational metrics and analytics including incident trends, resolution times, and performance indicators.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_operational_metrics.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_operational_metrics.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * snow_operational_metrics - Get operational metrics
+ *
+ * Provides operational metrics and analytics including incident trends, resolution times, and performance indicators.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_operational_metrics',
+    description: 'Provides operational metrics and analytics including incident trends, resolution times, and performance indicators',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            timeframe: {
+                type: 'string',
+                description: 'Time period for metrics',
+                enum: ['today', 'week', 'month', 'quarter'],
+                default: 'week'
+            },
+            metric_types: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Types of metrics to include (leave empty for all)',
+                examples: [['incidents', 'requests', 'problems']]
+            }
+        }
+    }
+};
+function getDateFilter(timeframe) {
+    switch (timeframe) {
+        case 'today':
+            return 'ONToday@javascript:gs.daysAgoStart(0)@javascript:gs.daysAgoEnd(0)';
+        case 'week':
+            return 'ONLast 7 days@javascript:gs.daysAgoStart(7)@javascript:gs.daysAgoEnd(0)';
+        case 'month':
+            return 'ONLast 30 days@javascript:gs.daysAgoStart(30)@javascript:gs.daysAgoEnd(0)';
+        case 'quarter':
+            return 'ONLast 90 days@javascript:gs.daysAgoStart(90)@javascript:gs.daysAgoEnd(0)';
+        default:
+            return 'ONLast 7 days@javascript:gs.daysAgoStart(7)@javascript:gs.daysAgoEnd(0)';
+    }
+}
+async function execute(args, context) {
+    const { timeframe = 'week', metric_types = [] } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const dateFilter = getDateFilter(timeframe);
+        const metrics = {
+            timeframe,
+            generated_at: new Date().toISOString()
+        };
+        const includeAll = metric_types.length === 0;
+        // Get incident metrics
+        if (includeAll || metric_types.includes('incidents')) {
+            // Total incidents
+            const totalIncidents = await client.get('/api/now/table/incident', {
+                params: {
+                    sysparm_query: `sys_created_on${dateFilter}`,
+                    sysparm_limit: 1000,
+                    sysparm_fields: 'number,state,priority,category'
+                }
+            });
+            const incidents = totalIncidents.data.result || [];
+            // Open incidents
+            const openIncidents = incidents.filter((inc) => inc.state !== '6' && inc.state !== '7');
+            // High priority incidents
+            const highPriorityIncidents = incidents.filter((inc) => inc.priority === '1');
+            // Category distribution
+            const categories = new Map();
+            incidents.forEach((inc) => {
+                const cat = inc.category || 'uncategorized';
+                categories.set(cat, (categories.get(cat) || 0) + 1);
+            });
+            metrics.incidents = {
+                total: incidents.length,
+                open: openIncidents.length,
+                high_priority: highPriorityIncidents.length,
+                common_categories: Array.from(categories.entries())
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 5)
+                    .map(([category, count]) => ({ category, count }))
+            };
+        }
+        // Get request metrics
+        if (includeAll || metric_types.includes('requests')) {
+            const requests = await client.get('/api/now/table/sc_request', {
+                params: {
+                    sysparm_query: `sys_created_on${dateFilter}`,
+                    sysparm_limit: 1000,
+                    sysparm_fields: 'number,request_state,approval'
+                }
+            });
+            const requestData = requests.data.result || [];
+            const openRequests = requestData.filter((req) => req.request_state !== 'closed');
+            const pendingApproval = requestData.filter((req) => req.approval === 'requested');
+            metrics.requests = {
+                total: requestData.length,
+                open: openRequests.length,
+                pending_approval: pendingApproval.length
+            };
+        }
+        // Get problem metrics
+        if (includeAll || metric_types.includes('problems')) {
+            const problems = await client.get('/api/now/table/problem', {
+                params: {
+                    sysparm_query: `sys_created_on${dateFilter}`,
+                    sysparm_limit: 100,
+                    sysparm_fields: 'number,state,priority'
+                }
+            });
+            const problemData = problems.data.result || [];
+            const openProblems = problemData.filter((prb) => prb.state !== '4');
+            metrics.problems = {
+                total: problemData.length,
+                open: openProblems.length
+            };
+        }
+        return (0, error_handler_js_1.createSuccessResult)({ metrics }, { timeframe, metric_types: includeAll ? 'all' : metric_types.join(',') });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_operational_metrics.js.map

package/dist/mcp/servicenow-mcp-unified/tools/operations/snow_pattern_analysis.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snow_pattern_analysis - Analyze patterns
+ *
+ * Analyzes patterns across incidents, requests, and problems to identify trends, common issues, and improvement opportunities.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_pattern_analysis.d.ts.map