snow-flow 8.42.12 → 9.0.1

package/dist/mcp/servicenow-mcp-unified/tools/integration/snow_rest_message_manage.js

@@ -1,1280 +0,0 @@
-"use strict";
-/**
- * snow_rest_message_manage - Universal REST Message Management Tool
- *
- * Complete CRUD operations for REST Messages, HTTP Methods, Headers, and Parameters.
- *
- * Tables used:
- * - sys_rest_message: REST Message definitions
- * - sys_rest_message_headers: Headers for REST Message (apply to ALL methods)
- * - sys_rest_message_fn: HTTP Methods (functions) for REST Messages
- * - sys_rest_message_fn_headers: Headers for specific HTTP Methods
- * - sys_rest_message_fn_parameters: Query parameters for HTTP Methods
- *
- * Header Levels:
- * - Message headers (sys_rest_message_headers): Apply to ALL methods in the REST message
- * - Method headers (sys_rest_message_fn_headers): Apply only to specific method
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.changelog = 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_rest_message_manage',
-    description: `Universal REST Message management tool. CRUD operations for:
-• REST Messages (list, get, create, update, delete)
-• HTTP Methods (list_methods, get_method, create_method, update_method, delete_method)
-• Message-level Headers - apply to ALL methods (list_message_headers, create_message_header, delete_message_header)
-• Method-level Headers - apply to specific method (list_method_headers, create_method_header, delete_method_header)
-• Query Parameters (list_parameters, create_parameter, delete_parameter)
-• Testing (test) - generates ES5-compatible test script for snow_schedule_script_job`,
-    // Metadata for tool discovery (not sent to LLM)
-    category: 'integration',
-    subcategory: 'rest',
-    use_cases: ['integration', 'rest', 'api', 'crud', 'headers', 'parameters', 'testing'],
-    complexity: 'intermediate',
-    frequency: 'high',
-    // Permission enforcement
-    permission: 'write',
-    allowedRoles: ['developer', 'admin'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: [
-                    // REST Message operations
-                    'list', // List all REST messages
-                    'get', // Get a specific REST message with its methods
-                    'create', // Create a new REST message
-                    'update', // Update an existing REST message
-                    'delete', // Delete a REST message
-                    // Method operations
-                    'list_methods', // List methods for a REST message
-                    'get_method', // Get a specific method
-                    'create_method', // Create a method for a REST message
-                    'update_method', // Update a method
-                    'delete_method', // Delete a method
-                    // Message-level headers (apply to ALL methods)
-                    'list_message_headers', // List headers at REST message level
-                    'create_message_header', // Create header at REST message level
-                    'delete_message_header', // Delete header at REST message level
-                    // Method-level headers (apply to specific method only)
-                    'list_method_headers', // List headers for a specific method
-                    'create_method_header', // Create header for a specific method
-                    'delete_method_header', // Delete header from a method
-                    // Query parameters (for methods)
-                    'list_parameters', // List query parameters for a method
-                    'create_parameter', // Create query parameter for a method
-                    'delete_parameter', // Delete query parameter from a method
-                    // Testing
-                    'test' // Test a REST message/method
-                ],
-                description: 'Action to perform'
-            },
-            // For list action
-            filter: {
-                type: 'string',
-                description: 'Filter for list action (e.g., "nameLIKEopenai" or "active=true")'
-            },
-            limit: {
-                type: 'number',
-                description: 'Maximum results to return',
-                default: 50
-            },
-            // For get/update/delete actions
-            sys_id: {
-                type: 'string',
-                description: 'sys_id of REST message or method'
-            },
-            name: {
-                type: 'string',
-                description: 'Name of REST message (alternative to sys_id for lookup)'
-            },
-            // For create/update REST message
-            endpoint: {
-                type: 'string',
-                description: 'Base URL endpoint for REST message'
-            },
-            description: {
-                type: 'string',
-                description: 'Description of the REST message'
-            },
-            authentication_type: {
-                type: 'string',
-                enum: ['no_authentication', 'basic', 'oauth2', 'api_key', 'mutual_auth'],
-                description: 'Authentication type',
-                default: 'no_authentication'
-            },
-            basic_auth_profile: {
-                type: 'string',
-                description: 'Basic auth profile sys_id (if authentication_type is basic)'
-            },
-            oauth_profile: {
-                type: 'string',
-                description: 'OAuth profile sys_id (if authentication_type is oauth2)'
-            },
-            use_mid_server: {
-                type: 'boolean',
-                description: 'Route through MID Server',
-                default: false
-            },
-            mid_server: {
-                type: 'string',
-                description: 'MID Server name or sys_id'
-            },
-            // For method operations
-            rest_message_sys_id: {
-                type: 'string',
-                description: 'Parent REST message sys_id (for method operations)'
-            },
-            method_sys_id: {
-                type: 'string',
-                description: 'Method sys_id (for method update/delete)'
-            },
-            http_method: {
-                type: 'string',
-                enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'],
-                description: 'HTTP method type',
-                default: 'GET'
-            },
-            relative_path: {
-                type: 'string',
-                description: 'Relative endpoint path for method (e.g., "/v1/completions")'
-            },
-            request_body: {
-                type: 'string',
-                description: 'Request body template (for POST/PUT/PATCH)'
-            },
-            // For headers
-            header_name: {
-                type: 'string',
-                description: 'Header name'
-            },
-            header_value: {
-                type: 'string',
-                description: 'Header value'
-            },
-            header_sys_id: {
-                type: 'string',
-                description: 'Header sys_id (for delete operations)'
-            },
-            headers: {
-                type: 'object',
-                description: 'Multiple headers as key-value pairs'
-            },
-            // For query parameters
-            parameter_name: {
-                type: 'string',
-                description: 'Query parameter name'
-            },
-            parameter_value: {
-                type: 'string',
-                description: 'Query parameter value'
-            },
-            parameter_sys_id: {
-                type: 'string',
-                description: 'Parameter sys_id (for delete operations)'
-            },
-            parameters: {
-                type: 'object',
-                description: 'Multiple query parameters as key-value pairs'
-            },
-            // For test action
-            test_params: {
-                type: 'object',
-                description: 'Parameters for testing the REST message'
-            }
-        },
-        required: ['action']
-    }
-};
-async function execute(args, context) {
-    const { action } = args;
-    try {
-        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
-        switch (action) {
-            // REST Message operations
-            case 'list':
-                return await listRestMessages(client, args);
-            case 'get':
-                return await getRestMessage(client, args);
-            case 'create':
-                return await createRestMessage(client, args);
-            case 'update':
-                return await updateRestMessage(client, args);
-            case 'delete':
-                return await deleteRestMessage(client, args);
-            // Method operations
-            case 'list_methods':
-                return await listMethods(client, args);
-            case 'get_method':
-                return await getMethod(client, args);
-            case 'create_method':
-                return await createMethod(client, args);
-            case 'update_method':
-                return await updateMethod(client, args);
-            case 'delete_method':
-                return await deleteMethod(client, args);
-            // Message-level headers (apply to ALL methods)
-            case 'list_message_headers':
-                return await listMessageHeaders(client, args);
-            case 'create_message_header':
-                return await createMessageHeader(client, args);
-            case 'delete_message_header':
-                return await deleteMessageHeader(client, args);
-            // Method-level headers (apply to specific method only)
-            case 'list_method_headers':
-                return await listMethodHeaders(client, args);
-            case 'create_method_header':
-                return await createMethodHeader(client, args);
-            case 'delete_method_header':
-                return await deleteMethodHeader(client, args);
-            // Query parameters
-            case 'list_parameters':
-                return await listParameters(client, args);
-            case 'create_parameter':
-                return await createParameter(client, args);
-            case 'delete_parameter':
-                return await deleteParameter(client, args);
-            // Testing
-            case 'test':
-                return await testRestMessage(client, args);
-            default:
-                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, `Unknown action: ${action}. See tool description for valid actions.`);
-        }
-    }
-    catch (error) {
-        if (error.response?.status === 403) {
-            return (0, error_handler_js_1.createErrorResult)(`Permission denied (403): Your ServiceNow user lacks permissions for REST message operations. ` +
-                `Required roles: 'rest_service' or 'admin'. ` +
-                `Please contact your ServiceNow administrator to grant the necessary permissions.`);
-        }
-        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError
-            ? error
-            : new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.UNKNOWN_ERROR, error.message, { originalError: error }));
-    }
-}
-// ============================================================================
-// REST MESSAGE OPERATIONS
-// ============================================================================
-async function listRestMessages(client, args) {
-    const { filter, limit = 50 } = args;
-    const params = {
-        sysparm_fields: 'sys_id,name,rest_endpoint,description,authentication_type,use_mid_server,active,sys_updated_on',
-        sysparm_limit: limit
-    };
-    if (filter) {
-        params.sysparm_query = filter;
-    }
-    const response = await client.get('/api/now/table/sys_rest_message', { params });
-    const messages = response.data?.result || [];
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'list',
-        count: messages.length,
-        rest_messages: messages.map((m) => ({
-            sys_id: m.sys_id,
-            name: m.name,
-            endpoint: m.rest_endpoint,
-            description: m.description,
-            authentication_type: m.authentication_type,
-            use_mid_server: m.use_mid_server === 'true',
-            active: m.active === 'true',
-            updated: m.sys_updated_on
-        }))
-    }, { operation: 'list_rest_messages' });
-}
-async function getRestMessage(client, args) {
-    const { sys_id, name } = args;
-    if (!sys_id && !name) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'Either sys_id or name is required for get action');
-    }
-    let messageSysId = sys_id;
-    // Lookup by name if sys_id not provided
-    if (!messageSysId && name) {
-        const lookupResponse = await client.get('/api/now/table/sys_rest_message', {
-            params: {
-                sysparm_query: `name=${name}`,
-                sysparm_fields: 'sys_id',
-                sysparm_limit: 1
-            }
-        });
-        if (!lookupResponse.data?.result?.[0]) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `REST message not found: ${name}`);
-        }
-        messageSysId = lookupResponse.data.result[0].sys_id;
-    }
-    // Get the REST message
-    const messageResponse = await client.get(`/api/now/table/sys_rest_message/${messageSysId}`);
-    const message = messageResponse.data?.result;
-    if (!message) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `REST message not found: ${messageSysId}`);
-    }
-    // Get associated methods
-    const methodsResponse = await client.get('/api/now/table/sys_rest_message_fn', {
-        params: {
-            sysparm_query: `rest_message=${messageSysId}`,
-            sysparm_fields: 'sys_id,name,http_method,rest_endpoint,content,active'
-        }
-    });
-    const methods = methodsResponse.data?.result || [];
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'get',
-        rest_message: {
-            sys_id: message.sys_id,
-            name: message.name,
-            endpoint: message.rest_endpoint,
-            description: message.description,
-            authentication_type: message.authentication_type,
-            basic_auth_profile: message.basic_auth_profile,
-            oauth_profile: message.oauth2_profile,
-            use_mid_server: message.use_mid_server === 'true',
-            mid_server: message.mid_server,
-            active: message.active === 'true',
-            created: message.sys_created_on,
-            updated: message.sys_updated_on
-        },
-        methods: methods.map((m) => ({
-            sys_id: m.sys_id,
-            name: m.name,
-            http_method: m.http_method,
-            endpoint: m.rest_endpoint,
-            has_body: !!m.content,
-            active: m.active === 'true'
-        })),
-        method_count: methods.length
-    }, { operation: 'get_rest_message' });
-}
-async function createRestMessage(client, args) {
-    const { name, endpoint, description = '', authentication_type = 'no_authentication', basic_auth_profile, oauth_profile, use_mid_server = false, mid_server } = args;
-    if (!name || !endpoint) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'name and endpoint are required for create action');
-    }
-    const messageData = {
-        name,
-        rest_endpoint: endpoint,
-        description,
-        authentication_type,
-        use_mid_server,
-        active: true
-    };
-    if (authentication_type === 'basic' && basic_auth_profile) {
-        messageData.basic_auth_profile = basic_auth_profile;
-    }
-    if (authentication_type === 'oauth2' && oauth_profile) {
-        messageData.oauth2_profile = oauth_profile;
-    }
-    if (use_mid_server && mid_server) {
-        messageData.mid_server = mid_server;
-    }
-    const response = await client.post('/api/now/table/sys_rest_message', messageData);
-    const created = response.data?.result;
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'create',
-        created: true,
-        rest_message: {
-            sys_id: created.sys_id,
-            name: created.name,
-            endpoint: created.rest_endpoint,
-            authentication_type: created.authentication_type
-        },
-        message: `REST message "${name}" created successfully`,
-        next_steps: [
-            `Create methods using: action="create_method", rest_message_sys_id="${created.sys_id}"`,
-            `Add headers using: action="create_header", method_sys_id="<method_sys_id>"`
-        ]
-    }, { operation: 'create_rest_message' });
-}
-async function updateRestMessage(client, args) {
-    const { sys_id, name, endpoint, description, authentication_type, basic_auth_profile, oauth_profile, use_mid_server, mid_server } = args;
-    let messageSysId = sys_id;
-    // Lookup by name if needed
-    if (!messageSysId && name) {
-        const lookupResponse = await client.get('/api/now/table/sys_rest_message', {
-            params: {
-                sysparm_query: `name=${name}`,
-                sysparm_fields: 'sys_id',
-                sysparm_limit: 1
-            }
-        });
-        if (!lookupResponse.data?.result?.[0]) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `REST message not found: ${name}`);
-        }
-        messageSysId = lookupResponse.data.result[0].sys_id;
-    }
-    if (!messageSysId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'sys_id or name is required for update action');
-    }
-    const updateData = {};
-    if (endpoint !== undefined)
-        updateData.rest_endpoint = endpoint;
-    if (description !== undefined)
-        updateData.description = description;
-    if (authentication_type !== undefined)
-        updateData.authentication_type = authentication_type;
-    if (basic_auth_profile !== undefined)
-        updateData.basic_auth_profile = basic_auth_profile;
-    if (oauth_profile !== undefined)
-        updateData.oauth2_profile = oauth_profile;
-    if (use_mid_server !== undefined)
-        updateData.use_mid_server = use_mid_server;
-    if (mid_server !== undefined)
-        updateData.mid_server = mid_server;
-    if (Object.keys(updateData).length === 0) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'No fields to update. Provide at least one field to change.');
-    }
-    const response = await client.patch(`/api/now/table/sys_rest_message/${messageSysId}`, updateData);
-    const updated = response.data?.result;
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'update',
-        updated: true,
-        rest_message: {
-            sys_id: updated.sys_id,
-            name: updated.name,
-            endpoint: updated.rest_endpoint
-        },
-        fields_updated: Object.keys(updateData)
-    }, { operation: 'update_rest_message' });
-}
-async function deleteRestMessage(client, args) {
-    const { sys_id, name } = args;
-    let messageSysId = sys_id;
-    // Lookup by name if needed
-    if (!messageSysId && name) {
-        const lookupResponse = await client.get('/api/now/table/sys_rest_message', {
-            params: {
-                sysparm_query: `name=${name}`,
-                sysparm_fields: 'sys_id,name',
-                sysparm_limit: 1
-            }
-        });
-        if (!lookupResponse.data?.result?.[0]) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `REST message not found: ${name}`);
-        }
-        messageSysId = lookupResponse.data.result[0].sys_id;
-    }
-    if (!messageSysId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'sys_id or name is required for delete action');
-    }
-    // Delete associated methods first
-    const methodsResponse = await client.get('/api/now/table/sys_rest_message_fn', {
-        params: {
-            sysparm_query: `rest_message=${messageSysId}`,
-            sysparm_fields: 'sys_id'
-        }
-    });
-    const methods = methodsResponse.data?.result || [];
-    for (const method of methods) {
-        await client.delete(`/api/now/table/sys_rest_message_fn/${method.sys_id}`);
-    }
-    // Delete the REST message
-    await client.delete(`/api/now/table/sys_rest_message/${messageSysId}`);
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'delete',
-        deleted: true,
-        sys_id: messageSysId,
-        methods_deleted: methods.length,
-        message: `REST message and ${methods.length} associated methods deleted`
-    }, { operation: 'delete_rest_message' });
-}
-// ============================================================================
-// METHOD OPERATIONS
-// ============================================================================
-async function listMethods(client, args) {
-    const { rest_message_sys_id, name, limit = 50 } = args;
-    let messageSysId = rest_message_sys_id;
-    // Lookup by name if needed
-    if (!messageSysId && name) {
-        const lookupResponse = await client.get('/api/now/table/sys_rest_message', {
-            params: {
-                sysparm_query: `name=${name}`,
-                sysparm_fields: 'sys_id',
-                sysparm_limit: 1
-            }
-        });
-        if (!lookupResponse.data?.result?.[0]) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `REST message not found: ${name}`);
-        }
-        messageSysId = lookupResponse.data.result[0].sys_id;
-    }
-    if (!messageSysId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'rest_message_sys_id or name is required for list_methods action');
-    }
-    const response = await client.get('/api/now/table/sys_rest_message_fn', {
-        params: {
-            sysparm_query: `rest_message=${messageSysId}`,
-            sysparm_fields: 'sys_id,name,http_method,rest_endpoint,content,active',
-            sysparm_limit: limit
-        }
-    });
-    const methods = response.data?.result || [];
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'list_methods',
-        rest_message_sys_id: messageSysId,
-        count: methods.length,
-        methods: methods.map((m) => ({
-            sys_id: m.sys_id,
-            name: m.name,
-            http_method: m.http_method,
-            endpoint: m.rest_endpoint,
-            has_body: !!m.content,
-            active: m.active === 'true'
-        }))
-    }, { operation: 'list_methods' });
-}
-async function getMethod(client, args) {
-    const { method_sys_id, sys_id } = args;
-    const methodId = method_sys_id || sys_id;
-    if (!methodId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'method_sys_id is required for get_method action');
-    }
-    // Get the method
-    const methodResponse = await client.get(`/api/now/table/sys_rest_message_fn/${methodId}`);
-    const method = methodResponse.data?.result;
-    if (!method) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `Method not found: ${methodId}`);
-    }
-    // Get associated headers
-    const headersResponse = await client.get('/api/now/table/sys_rest_message_fn_headers', {
-        params: {
-            sysparm_query: `rest_message_function=${methodId}`,
-            sysparm_fields: 'sys_id,name,value'
-        }
-    });
-    const headers = headersResponse.data?.result || [];
-    // Get associated parameters
-    const paramsResponse = await client.get('/api/now/table/sys_rest_message_fn_parameters', {
-        params: {
-            sysparm_query: `rest_message_function=${methodId}`,
-            sysparm_fields: 'sys_id,name,value'
-        }
-    });
-    const parameters = paramsResponse.data?.result || [];
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'get_method',
-        method: {
-            sys_id: method.sys_id,
-            name: method.name,
-            http_method: method.http_method,
-            endpoint: method.rest_endpoint,
-            request_body: method.content,
-            active: method.active === 'true',
-            rest_message: method.rest_message
-        },
-        headers: headers.map((h) => ({
-            sys_id: h.sys_id,
-            name: h.name,
-            value: h.value
-        })),
-        parameters: parameters.map((p) => ({
-            sys_id: p.sys_id,
-            name: p.name,
-            value: p.value
-        }))
-    }, { operation: 'get_method' });
-}
-async function createMethod(client, args) {
-    const { rest_message_sys_id, name, http_method = 'GET', relative_path = '', request_body, headers } = args;
-    if (!rest_message_sys_id) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'rest_message_sys_id is required for create_method action');
-    }
-    if (!name) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'name is required for create_method action');
-    }
-    // Get the parent REST message to build full endpoint
-    const messageResponse = await client.get(`/api/now/table/sys_rest_message/${rest_message_sys_id}`, {
-        params: { sysparm_fields: 'rest_endpoint' }
-    });
-    const baseEndpoint = messageResponse.data?.result?.rest_endpoint || '';
-    const methodData = {
-        rest_message: rest_message_sys_id,
-        name,
-        http_method,
-        rest_endpoint: baseEndpoint + relative_path,
-        active: true
-    };
-    if (request_body) {
-        methodData.content = request_body;
-    }
-    const response = await client.post('/api/now/table/sys_rest_message_fn', methodData);
-    const created = response.data?.result;
-    // Create headers if provided
-    const createdHeaders = [];
-    if (headers && typeof headers === 'object') {
-        for (const [headerName, headerValue] of Object.entries(headers)) {
-            const headerResponse = await client.post('/api/now/table/sys_rest_message_fn_headers', {
-                rest_message_function: created.sys_id,
-                name: headerName,
-                value: headerValue
-            });
-            createdHeaders.push({
-                sys_id: headerResponse.data?.result?.sys_id,
-                name: headerName,
-                value: headerValue
-            });
-        }
-    }
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'create_method',
-        created: true,
-        method: {
-            sys_id: created.sys_id,
-            name: created.name,
-            http_method: created.http_method,
-            endpoint: created.rest_endpoint
-        },
-        headers_created: createdHeaders.length,
-        headers: createdHeaders
-    }, { operation: 'create_method' });
-}
-async function updateMethod(client, args) {
-    const { method_sys_id, sys_id, name, http_method, relative_path, request_body } = args;
-    const methodId = method_sys_id || sys_id;
-    if (!methodId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'method_sys_id is required for update_method action');
-    }
-    const updateData = {};
-    if (name !== undefined)
-        updateData.name = name;
-    if (http_method !== undefined)
-        updateData.http_method = http_method;
-    if (relative_path !== undefined) {
-        // Get parent REST message to build full endpoint
-        const methodResponse = await client.get(`/api/now/table/sys_rest_message_fn/${methodId}`, {
-            params: { sysparm_fields: 'rest_message' }
-        });
-        const restMessageId = methodResponse.data?.result?.rest_message?.value;
-        if (restMessageId) {
-            const messageResponse = await client.get(`/api/now/table/sys_rest_message/${restMessageId}`, {
-                params: { sysparm_fields: 'rest_endpoint' }
-            });
-            const baseEndpoint = messageResponse.data?.result?.rest_endpoint || '';
-            updateData.rest_endpoint = baseEndpoint + relative_path;
-        }
-    }
-    if (request_body !== undefined)
-        updateData.content = request_body;
-    if (Object.keys(updateData).length === 0) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'No fields to update');
-    }
-    const response = await client.patch(`/api/now/table/sys_rest_message_fn/${methodId}`, updateData);
-    const updated = response.data?.result;
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'update_method',
-        updated: true,
-        method: {
-            sys_id: updated.sys_id,
-            name: updated.name,
-            http_method: updated.http_method,
-            endpoint: updated.rest_endpoint
-        },
-        fields_updated: Object.keys(updateData)
-    }, { operation: 'update_method' });
-}
-async function deleteMethod(client, args) {
-    const { method_sys_id, sys_id } = args;
-    const methodId = method_sys_id || sys_id;
-    if (!methodId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'method_sys_id is required for delete_method action');
-    }
-    // Delete associated headers first
-    const headersResponse = await client.get('/api/now/table/sys_rest_message_fn_headers', {
-        params: {
-            sysparm_query: `rest_message_function=${methodId}`,
-            sysparm_fields: 'sys_id'
-        }
-    });
-    const headers = headersResponse.data?.result || [];
-    for (const header of headers) {
-        await client.delete(`/api/now/table/sys_rest_message_fn_headers/${header.sys_id}`);
-    }
-    // Delete the method
-    await client.delete(`/api/now/table/sys_rest_message_fn/${methodId}`);
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'delete_method',
-        deleted: true,
-        method_sys_id: methodId,
-        headers_deleted: headers.length
-    }, { operation: 'delete_method' });
-}
-// ============================================================================
-// MESSAGE-LEVEL HEADER OPERATIONS (sys_rest_message_headers)
-// These headers apply to ALL methods in the REST message
-// ============================================================================
-async function listMessageHeaders(client, args) {
-    const { rest_message_sys_id, sys_id, name } = args;
-    let messageSysId = rest_message_sys_id || sys_id;
-    // Lookup by name if needed
-    if (!messageSysId && name) {
-        const lookupResponse = await client.get('/api/now/table/sys_rest_message', {
-            params: {
-                sysparm_query: `name=${name}`,
-                sysparm_fields: 'sys_id',
-                sysparm_limit: 1
-            }
-        });
-        if (!lookupResponse.data?.result?.[0]) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `REST message not found: ${name}`);
-        }
-        messageSysId = lookupResponse.data.result[0].sys_id;
-    }
-    if (!messageSysId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'rest_message_sys_id, sys_id, or name is required for list_message_headers action');
-    }
-    const response = await client.get('/api/now/table/sys_rest_message_headers', {
-        params: {
-            sysparm_query: `rest_message=${messageSysId}`,
-            sysparm_fields: 'sys_id,name,value'
-        }
-    });
-    const headers = response.data?.result || [];
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'list_message_headers',
-        rest_message_sys_id: messageSysId,
-        count: headers.length,
-        headers: headers.map((h) => ({
-            sys_id: h.sys_id,
-            name: h.name,
-            value: h.value
-        })),
-        note: 'These headers apply to ALL methods in this REST message'
-    }, { operation: 'list_message_headers' });
-}
-async function createMessageHeader(client, args) {
-    const { rest_message_sys_id, sys_id, name, header_name, header_value, headers } = args;
-    let messageSysId = rest_message_sys_id || sys_id;
-    // Lookup by name if needed
-    if (!messageSysId && name) {
-        const lookupResponse = await client.get('/api/now/table/sys_rest_message', {
-            params: {
-                sysparm_query: `name=${name}`,
-                sysparm_fields: 'sys_id',
-                sysparm_limit: 1
-            }
-        });
-        if (!lookupResponse.data?.result?.[0]) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `REST message not found: ${name}`);
-        }
-        messageSysId = lookupResponse.data.result[0].sys_id;
-    }
-    if (!messageSysId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'rest_message_sys_id, sys_id, or name is required for create_message_header action');
-    }
-    const createdHeaders = [];
-    // Create multiple headers if provided as object
-    if (headers && typeof headers === 'object') {
-        for (const [hName, hValue] of Object.entries(headers)) {
-            const response = await client.post('/api/now/table/sys_rest_message_headers', {
-                rest_message: messageSysId,
-                name: hName,
-                value: hValue
-            });
-            createdHeaders.push({
-                sys_id: response.data?.result?.sys_id,
-                name: hName,
-                value: hValue
-            });
-        }
-    }
-    else if (header_name && header_value !== undefined) {
-        // Create single header
-        const response = await client.post('/api/now/table/sys_rest_message_headers', {
-            rest_message: messageSysId,
-            name: header_name,
-            value: header_value
-        });
-        createdHeaders.push({
-            sys_id: response.data?.result?.sys_id,
-            name: header_name,
-            value: header_value
-        });
-    }
-    else {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'Either headers object or header_name+header_value is required');
-    }
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'create_message_header',
-        created: true,
-        rest_message_sys_id: messageSysId,
-        headers: createdHeaders,
-        count: createdHeaders.length,
-        note: 'These headers will apply to ALL methods in this REST message'
-    }, { operation: 'create_message_header' });
-}
-async function deleteMessageHeader(client, args) {
-    const { header_sys_id, sys_id, header_name, rest_message_sys_id, name } = args;
-    const headerSysIdToDelete = header_sys_id || sys_id;
-    if (headerSysIdToDelete) {
-        // Delete by sys_id
-        await client.delete(`/api/now/table/sys_rest_message_headers/${headerSysIdToDelete}`);
-        return (0, error_handler_js_1.createSuccessResult)({
-            action: 'delete_message_header',
-            deleted: true,
-            header_sys_id: headerSysIdToDelete
-        }, { operation: 'delete_message_header' });
-    }
-    else if (header_name && (rest_message_sys_id || name)) {
-        // Find REST message sys_id if needed
-        let messageSysId = rest_message_sys_id;
-        if (!messageSysId && name) {
-            const lookupResponse = await client.get('/api/now/table/sys_rest_message', {
-                params: {
-                    sysparm_query: `name=${name}`,
-                    sysparm_fields: 'sys_id',
-                    sysparm_limit: 1
-                }
-            });
-            if (!lookupResponse.data?.result?.[0]) {
-                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `REST message not found: ${name}`);
-            }
-            messageSysId = lookupResponse.data.result[0].sys_id;
-        }
-        // Find and delete by name
-        const lookupResponse = await client.get('/api/now/table/sys_rest_message_headers', {
-            params: {
-                sysparm_query: `rest_message=${messageSysId}^name=${header_name}`,
-                sysparm_fields: 'sys_id',
-                sysparm_limit: 1
-            }
-        });
-        if (!lookupResponse.data?.result?.[0]) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `Message header not found: ${header_name}`);
-        }
-        const foundHeaderSysId = lookupResponse.data.result[0].sys_id;
-        await client.delete(`/api/now/table/sys_rest_message_headers/${foundHeaderSysId}`);
-        return (0, error_handler_js_1.createSuccessResult)({
-            action: 'delete_message_header',
-            deleted: true,
-            header_name,
-            header_sys_id: foundHeaderSysId
-        }, { operation: 'delete_message_header' });
-    }
-    else {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'Either header_sys_id/sys_id OR (header_name + rest_message_sys_id/name) is required');
-    }
-}
-// ============================================================================
-// METHOD-LEVEL HEADER OPERATIONS (sys_rest_message_fn_headers)
-// These headers apply only to a specific method
-// ============================================================================
-async function listMethodHeaders(client, args) {
-    const { method_sys_id, sys_id } = args;
-    const methodId = method_sys_id || sys_id;
-    if (!methodId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'method_sys_id is required for list_method_headers action');
-    }
-    const response = await client.get('/api/now/table/sys_rest_message_fn_headers', {
-        params: {
-            sysparm_query: `rest_message_function=${methodId}`,
-            sysparm_fields: 'sys_id,name,value'
-        }
-    });
-    const headers = response.data?.result || [];
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'list_method_headers',
-        method_sys_id: methodId,
-        count: headers.length,
-        headers: headers.map((h) => ({
-            sys_id: h.sys_id,
-            name: h.name,
-            value: h.value
-        })),
-        note: 'These headers apply only to this specific method'
-    }, { operation: 'list_method_headers' });
-}
-async function createMethodHeader(client, args) {
-    const { method_sys_id, header_name, header_value, headers } = args;
-    if (!method_sys_id) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'method_sys_id is required for create_method_header action');
-    }
-    const createdHeaders = [];
-    // Create multiple headers if provided as object
-    if (headers && typeof headers === 'object') {
-        for (const [hName, hValue] of Object.entries(headers)) {
-            const response = await client.post('/api/now/table/sys_rest_message_fn_headers', {
-                rest_message_function: method_sys_id,
-                name: hName,
-                value: hValue
-            });
-            createdHeaders.push({
-                sys_id: response.data?.result?.sys_id,
-                name: hName,
-                value: hValue
-            });
-        }
-    }
-    else if (header_name && header_value !== undefined) {
-        // Create single header
-        const response = await client.post('/api/now/table/sys_rest_message_fn_headers', {
-            rest_message_function: method_sys_id,
-            name: header_name,
-            value: header_value
-        });
-        createdHeaders.push({
-            sys_id: response.data?.result?.sys_id,
-            name: header_name,
-            value: header_value
-        });
-    }
-    else {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'Either headers object or header_name+header_value is required');
-    }
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'create_method_header',
-        created: true,
-        method_sys_id,
-        headers: createdHeaders,
-        count: createdHeaders.length,
-        note: 'These headers apply only to this specific method'
-    }, { operation: 'create_method_header' });
-}
-async function deleteMethodHeader(client, args) {
-    const { header_sys_id, sys_id, header_name, method_sys_id } = args;
-    const headerSysIdToDelete = header_sys_id || sys_id;
-    if (headerSysIdToDelete) {
-        // Delete by sys_id
-        await client.delete(`/api/now/table/sys_rest_message_fn_headers/${headerSysIdToDelete}`);
-        return (0, error_handler_js_1.createSuccessResult)({
-            action: 'delete_method_header',
-            deleted: true,
-            header_sys_id: headerSysIdToDelete
-        }, { operation: 'delete_method_header' });
-    }
-    else if (header_name && method_sys_id) {
-        // Find and delete by name
-        const lookupResponse = await client.get('/api/now/table/sys_rest_message_fn_headers', {
-            params: {
-                sysparm_query: `rest_message_function=${method_sys_id}^name=${header_name}`,
-                sysparm_fields: 'sys_id',
-                sysparm_limit: 1
-            }
-        });
-        if (!lookupResponse.data?.result?.[0]) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `Method header not found: ${header_name}`);
-        }
-        const foundHeaderSysId = lookupResponse.data.result[0].sys_id;
-        await client.delete(`/api/now/table/sys_rest_message_fn_headers/${foundHeaderSysId}`);
-        return (0, error_handler_js_1.createSuccessResult)({
-            action: 'delete_method_header',
-            deleted: true,
-            header_name,
-            header_sys_id: foundHeaderSysId
-        }, { operation: 'delete_method_header' });
-    }
-    else {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'Either header_sys_id/sys_id OR (header_name + method_sys_id) is required');
-    }
-}
-// ============================================================================
-// QUERY PARAMETER OPERATIONS (sys_rest_message_fn_parameters)
-// ============================================================================
-async function listParameters(client, args) {
-    const { method_sys_id, sys_id } = args;
-    const methodId = method_sys_id || sys_id;
-    if (!methodId) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'method_sys_id is required for list_parameters action');
-    }
-    const response = await client.get('/api/now/table/sys_rest_message_fn_parameters', {
-        params: {
-            sysparm_query: `rest_message_function=${methodId}`,
-            sysparm_fields: 'sys_id,name,value'
-        }
-    });
-    const parameters = response.data?.result || [];
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'list_parameters',
-        method_sys_id: methodId,
-        count: parameters.length,
-        parameters: parameters.map((p) => ({
-            sys_id: p.sys_id,
-            name: p.name,
-            value: p.value
-        }))
-    }, { operation: 'list_parameters' });
-}
-async function createParameter(client, args) {
-    const { method_sys_id, parameter_name, parameter_value, parameters } = args;
-    if (!method_sys_id) {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'method_sys_id is required for create_parameter action');
-    }
-    const createdParams = [];
-    // Create multiple parameters if provided as object
-    if (parameters && typeof parameters === 'object') {
-        for (const [pName, pValue] of Object.entries(parameters)) {
-            const response = await client.post('/api/now/table/sys_rest_message_fn_parameters', {
-                rest_message_function: method_sys_id,
-                name: pName,
-                value: pValue
-            });
-            createdParams.push({
-                sys_id: response.data?.result?.sys_id,
-                name: pName,
-                value: pValue
-            });
-        }
-    }
-    else if (parameter_name && parameter_value !== undefined) {
-        // Create single parameter
-        const response = await client.post('/api/now/table/sys_rest_message_fn_parameters', {
-            rest_message_function: method_sys_id,
-            name: parameter_name,
-            value: parameter_value
-        });
-        createdParams.push({
-            sys_id: response.data?.result?.sys_id,
-            name: parameter_name,
-            value: parameter_value
-        });
-    }
-    else {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'Either parameters object or parameter_name+parameter_value is required');
-    }
-    return (0, error_handler_js_1.createSuccessResult)({
-        action: 'create_parameter',
-        created: true,
-        method_sys_id,
-        parameters: createdParams,
-        count: createdParams.length
-    }, { operation: 'create_parameter' });
-}
-async function deleteParameter(client, args) {
-    const { parameter_sys_id, sys_id, parameter_name, method_sys_id } = args;
-    const paramSysIdToDelete = parameter_sys_id || sys_id;
-    if (paramSysIdToDelete) {
-        // Delete by sys_id
-        await client.delete(`/api/now/table/sys_rest_message_fn_parameters/${paramSysIdToDelete}`);
-        return (0, error_handler_js_1.createSuccessResult)({
-            action: 'delete_parameter',
-            deleted: true,
-            parameter_sys_id: paramSysIdToDelete
-        }, { operation: 'delete_parameter' });
-    }
-    else if (parameter_name && method_sys_id) {
-        // Find and delete by name
-        const lookupResponse = await client.get('/api/now/table/sys_rest_message_fn_parameters', {
-            params: {
-                sysparm_query: `rest_message_function=${method_sys_id}^name=${parameter_name}`,
-                sysparm_fields: 'sys_id',
-                sysparm_limit: 1
-            }
-        });
-        if (!lookupResponse.data?.result?.[0]) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `Parameter not found: ${parameter_name}`);
-        }
-        const foundParamSysId = lookupResponse.data.result[0].sys_id;
-        await client.delete(`/api/now/table/sys_rest_message_fn_parameters/${foundParamSysId}`);
-        return (0, error_handler_js_1.createSuccessResult)({
-            action: 'delete_parameter',
-            deleted: true,
-            parameter_name,
-            parameter_sys_id: foundParamSysId
-        }, { operation: 'delete_parameter' });
-    }
-    else {
-        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'Either parameter_sys_id/sys_id OR (parameter_name + method_sys_id) is required');
-    }
-}
-// ============================================================================
-// TEST OPERATIONS
-// ============================================================================
-async function testRestMessage(client, args) {
-    const { method_sys_id, sys_id, name, rest_message_sys_id, test_params = {} } = args;
-    const methodId = method_sys_id || sys_id;
-    // If we have a method_sys_id, get method details
-    if (methodId) {
-        const methodResponse = await client.get(`/api/now/table/sys_rest_message_fn/${methodId}`, {
-            params: { sysparm_fields: 'name,http_method,rest_endpoint,rest_message,content' }
-        });
-        const method = methodResponse.data?.result;
-        if (!method) {
-            throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `Method not found: ${methodId}`);
-        }
-        // Get REST message details
-        const restMessageId = method.rest_message?.value;
-        const messageResponse = await client.get(`/api/now/table/sys_rest_message/${restMessageId}`, {
-            params: { sysparm_fields: 'name,rest_endpoint,authentication_type' }
-        });
-        const restMessage = messageResponse.data?.result;
-        const restMessageName = restMessage?.name;
-        // Get method headers
-        const headersResponse = await client.get('/api/now/table/sys_rest_message_fn_headers', {
-            params: {
-                sysparm_query: `rest_message_function=${methodId}`,
-                sysparm_fields: 'name,value'
-            }
-        });
-        const methodHeaders = headersResponse.data?.result || [];
-        // Get message-level headers
-        const msgHeadersResponse = await client.get('/api/now/table/sys_rest_message_headers', {
-            params: {
-                sysparm_query: `rest_message=${restMessageId}`,
-                sysparm_fields: 'name,value'
-            }
-        });
-        const messageHeaders = msgHeadersResponse.data?.result || [];
-        // Get parameters
-        const paramsResponse = await client.get('/api/now/table/sys_rest_message_fn_parameters', {
-            params: {
-                sysparm_query: `rest_message_function=${methodId}`,
-                sysparm_fields: 'name,value'
-            }
-        });
-        const parameters = paramsResponse.data?.result || [];
-        // Build parameter setting code
-        const paramLines = Object.entries(test_params).map(([k, v]) => `rm.setStringParameterNoEscape('${k}', '${String(v).replace(/'/g, "\\'")}');`);
-        // Generate the test script (ES5 compatible!)
-        const testScript = `
-// Test REST Message: ${restMessageName} - Method: ${method.name}
-// Generated by snow_rest_message_manage test action
-// ES5 COMPATIBLE - Safe for ServiceNow execution
-
-(function() {
-  var results = {
-    success: false,
-    status_code: null,
-    response_body: null,
-    response_headers: {},
-    error: null,
-    timing_ms: 0
-  };
-
-  try {
-    var startTime = new Date().getTime();
-
-    // Create REST message instance
-    var rm = new sn_ws.RESTMessageV2('${restMessageName}', '${method.name}');
-
-    // Set parameters from test_params
-${paramLines.length > 0 ? '    ' + paramLines.join('\n    ') : '    // No parameters specified'}
-
-    // Execute the request
-    var response = rm.execute();
-    var endTime = new Date().getTime();
-
-    // Collect results
-    results.success = true;
-    results.status_code = response.getStatusCode();
-    results.response_body = response.getBody();
-    results.timing_ms = endTime - startTime;
-
-    // Try to get response headers
-    try {
-      var headerStr = response.getAllHeaders();
-      if (headerStr) {
-        results.response_headers = headerStr;
-      }
-    } catch(headerErr) {
-      // Headers may not be available
-    }
-
-    // Log results
-    gs.info('=== REST MESSAGE TEST RESULTS ===');
-    gs.info('REST Message: ${restMessageName}');
-    gs.info('Method: ${method.name}');
-    gs.info('HTTP Method: ${method.http_method}');
-    gs.info('Status Code: ' + results.status_code);
-    gs.info('Response Time: ' + results.timing_ms + 'ms');
-    gs.info('Response Body: ' + results.response_body);
-
-  } catch(e) {
-    results.success = false;
-    results.error = e.message || String(e);
-    gs.error('REST Message Test Failed: ' + results.error);
-  }
-
-  // Store results in sys_properties for retrieval
-  var propName = 'snow_flow.rest_test.${methodId}';
-  gs.setProperty(propName, JSON.stringify(results));
-  gs.info('Results stored in property: ' + propName);
-
-  return results;
-})();
-    `.trim();
-        return (0, error_handler_js_1.createSuccessResult)({
-            action: 'test',
-            method: {
-                sys_id: methodId,
-                name: method.name,
-                http_method: method.http_method,
-                endpoint: method.rest_endpoint,
-                has_body: !!method.content
-            },
-            rest_message: {
-                sys_id: restMessageId,
-                name: restMessageName,
-                base_endpoint: restMessage?.rest_endpoint,
-                authentication_type: restMessage?.authentication_type
-            },
-            configuration: {
-                message_headers: messageHeaders.map((h) => ({ name: h.name, value: h.value })),
-                method_headers: methodHeaders.map((h) => ({ name: h.name, value: h.value })),
-                parameters: parameters.map((p) => ({ name: p.name, value: p.value }))
-            },
-            test_params_provided: test_params,
-            test_script: testScript,
-            usage: {
-                description: 'Use snow_schedule_script_job to execute this test script',
-                example: `snow_schedule_script_job({ script: <test_script>, description: 'Test REST: ${restMessageName}' })`,
-                manual_test: `In ServiceNow: System Web Services > Outbound > REST Message > ${restMessageName} > ${method.name} > Test`
-            },
-            note: 'Direct REST message testing requires ServiceNow script execution. Copy the test_script and run it via snow_schedule_script_job.'
-        }, { operation: 'test_rest_message' });
-    }
-    // If we have REST message name but no method, list available methods
-    if (name || rest_message_sys_id) {
-        let messageSysId = rest_message_sys_id;
-        let messageName = name;
-        // Lookup by name if needed
-        if (!messageSysId && name) {
-            const lookupResponse = await client.get('/api/now/table/sys_rest_message', {
-                params: {
-                    sysparm_query: `name=${name}`,
-                    sysparm_fields: 'sys_id,name',
-                    sysparm_limit: 1
-                }
-            });
-            if (!lookupResponse.data?.result?.[0]) {
-                throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.NOT_FOUND, `REST message not found: ${name}`);
-            }
-            messageSysId = lookupResponse.data.result[0].sys_id;
-            messageName = lookupResponse.data.result[0].name;
-        }
-        else if (messageSysId && !messageName) {
-            const msgResponse = await client.get(`/api/now/table/sys_rest_message/${messageSysId}`, {
-                params: { sysparm_fields: 'name' }
-            });
-            messageName = msgResponse.data?.result?.name;
-        }
-        // Get methods for this REST message
-        const methodsResponse = await client.get('/api/now/table/sys_rest_message_fn', {
-            params: {
-                sysparm_query: `rest_message=${messageSysId}`,
-                sysparm_fields: 'sys_id,name,http_method,rest_endpoint'
-            }
-        });
-        const methods = methodsResponse.data?.result || [];
-        return (0, error_handler_js_1.createSuccessResult)({
-            action: 'test',
-            rest_message: {
-                sys_id: messageSysId,
-                name: messageName
-            },
-            available_methods: methods.map((m) => ({
-                sys_id: m.sys_id,
-                name: m.name,
-                http_method: m.http_method,
-                endpoint: m.rest_endpoint
-            })),
-            note: 'Specify method_sys_id to generate a test script for a specific method'
-        }, { operation: 'test_rest_message' });
-    }
-    throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.VALIDATION_ERROR, 'method_sys_id, name, or rest_message_sys_id is required for test action');
-}
-exports.version = '2.0.0';
-exports.author = 'Snow-Flow SDK';
-exports.changelog = {
-    '2.0.0': 'Added message-level headers, method-level headers, query parameters, improved test with ES5 script generation',
-    '1.0.0': 'Initial release with REST message and method CRUD operations'
-};
-//# sourceMappingURL=snow_rest_message_manage.js.map