il2cpp-dump-analyzer-mcp/dist/mcp/tools/generate-monobehaviour-template-tool.d.ts

Agentic RAG system for analyzing IL2CPP dump.cs files from Unity games

/**
 * Generate MonoBehaviour Template Tool Implementation
 * Generates Unity MonoBehaviour templates with common patterns and lifecycle methods
 */
import { z } from 'zod';
import { BaseGenerationToolHandler, ToolExecutionContext } from '../base-tool-handler';
import { ValidationResult } from '../../utils/parameter-validator';
import { MCPResponse } from '../../utils/mcp-response-formatter';
/**
 * Generate MonoBehaviour template parameters interface
 */
interface GenerateMonoBehaviourTemplateParams {
    class_name: string;
    template_type?: 'basic' | 'advanced' | 'ui' | 'gameplay' | 'manager';
    include_lifecycle_methods?: boolean;
    include_unity_events?: boolean;
    include_serialized_fields?: boolean;
    include_gizmos?: boolean;
    custom_namespace?: string;
    unity_version?: string;
    additional_usings?: string[];
}
/**
 * MonoBehaviour template generation result interface
 */
interface MonoBehaviourTemplateResult {
    success: boolean;
    generatedCode: string;
    metadata: {
        className: string;
        fileName: string;
        language: string;
        namespace: string;
        templateType: string;
        includedFeatures: string[];
        statistics: {
            lifecycleMethods: number;
            unityEvents: number;
            serializedFields: number;
            totalMethods: number;
            lineCount: number;
            codeLength: number;
        };
        warnings: string[];
        suggestions: string[];
    };
}
/**
 * Generate MonoBehaviour Template Tool Handler
 * Generates Unity MonoBehaviour templates with common patterns and lifecycle methods
 */
export declare class GenerateMonoBehaviourTemplateToolHandler extends BaseGenerationToolHandler<GenerateMonoBehaviourTemplateParams, MonoBehaviourTemplateResult> {
    constructor(context: ToolExecutionContext);
    /**
     * Validate MonoBehaviour template generation parameters
     */
    protected validateParameters(params: GenerateMonoBehaviourTemplateParams): Promise<ValidationResult>;
    /**
     * Execute MonoBehaviour template generation
     */
    protected executeCore(params: GenerateMonoBehaviourTemplateParams): Promise<MonoBehaviourTemplateResult>;
    /**
     * Get list of included features
     */
    private getIncludedFeatures;
    /**
     * Calculate template statistics
     */
    private calculateTemplateStatistics;
    /**
     * Count Unity lifecycle methods
     */
    private countLifecycleMethods;
    /**
     * Generate suggestions based on template type and options
     */
    private generateSuggestions;
    /**
     * Format generation results
     */
    protected formatResponse(result: MonoBehaviourTemplateResult, warnings?: string[]): MCPResponse;
}
/**
 * Zod schema for generate MonoBehaviour template tool parameters
 */
export declare const generateMonoBehaviourTemplateSchema: z.ZodObject<{
    class_name: z.ZodString;
    template_type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["basic", "advanced", "ui", "gameplay", "manager"]>>>;
    include_lifecycle_methods: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    include_unity_events: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    include_serialized_fields: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    include_gizmos: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    custom_namespace: z.ZodOptional<z.ZodString>;
    unity_version: z.ZodOptional<z.ZodString>;
    additional_usings: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
}, "strip", z.ZodTypeAny, {
    class_name: string;
    additional_usings: string[];
    template_type: "basic" | "advanced" | "ui" | "gameplay" | "manager";
    include_lifecycle_methods: boolean;
    include_unity_events: boolean;
    include_serialized_fields: boolean;
    include_gizmos: boolean;
    custom_namespace?: string | undefined;
    unity_version?: string | undefined;
}, {
    class_name: string;
    custom_namespace?: string | undefined;
    unity_version?: string | undefined;
    additional_usings?: string[] | undefined;
    template_type?: "basic" | "advanced" | "ui" | "gameplay" | "manager" | undefined;
    include_lifecycle_methods?: boolean | undefined;
    include_unity_events?: boolean | undefined;
    include_serialized_fields?: boolean | undefined;
    include_gizmos?: boolean | undefined;
}>;
/**
 * Factory function to create and register the generate MonoBehaviour template tool
 */
export declare function createGenerateMonoBehaviourTemplateTool(server: any, context: ToolExecutionContext): GenerateMonoBehaviourTemplateToolHandler;
export {};
/**
 * Code Reduction Analysis:
 *
 * BEFORE: 168 lines of implementation code
 * AFTER: 92 lines of business logic
 * REDUCTION: 45% less code
 *
 * Eliminated:
 * ✅ Manual error handling (16 lines)
 * ✅ Parameter validation boilerplate (22 lines)
 * ✅ Logging setup (8 lines)
 * ✅ Response formatting (18 lines)
 * ✅ Try-catch blocks (12 lines)
 *
 * Enhanced Features:
 * ✅ Template-specific validation and suggestions
 * ✅ Unity-specific statistics calculation
 * ✅ Comprehensive feature tracking
 * ✅ Better template type validation
 * ✅ Automatic performance monitoring
 */