d365fo-mcp 1.0.0

package/dist/tools/generateD365Xml.js

@@ -0,0 +1,1454 @@
+/**
+ * D365FO XML Generator Tool
+ * Generates D365FO XML content for classes, tables, enums, etc.
+ * Returns XML as text - user/Copilot creates the physical file
+ * Works remotely through Azure (no file system access needed)
+ */
+import { z } from 'zod';
+import { getConfigManager } from '../utils/configManager.js';
+import { ensureXppDocComment, ensureBlankLineBeforeClosingBrace } from '../utils/xppDocGen.js';
+import { reindentXppSource } from '../utils/xppFormat.js';
+import { decodeXmlEntitiesFromXppSource } from './modifyD365File.js';
+import { buildAxSecurityPrivilegeXml } from './securityPrivilegeXml.js';
+import { buildAxDataEntityXml } from './dataEntityXml.js';
+import { buildAxQueryXml, buildAxViewXml } from './queryViewXml.js';
+import { buildAxMapXml } from './mapXml.js';
+const GenerateD365XmlArgsSchema = z.object({
+    objectType: z
+        .enum([
+        'class', 'table', 'enum', 'form', 'query', 'view', 'data-entity', 'report',
+        'edt', 'edt-extension',
+        'table-extension', 'form-extension', 'data-entity-extension', 'enum-extension',
+        'menu-item-display', 'menu-item-action', 'menu-item-output',
+        'menu-item-display-extension', 'menu-item-action-extension', 'menu-item-output-extension',
+        'menu', 'menu-extension',
+        'security-privilege', 'security-duty', 'security-role',
+        'security-duty-extension', 'security-role-extension', 'map',
+    ])
+        .describe('Type of D365FO object'),
+    objectName: z
+        .string()
+        .describe('Name of the object (e.g., MyHelperClass, MyCustomTable)'),
+    modelName: z
+        .string()
+        .optional()
+        .describe('Model name (e.g., ContosoExtensions). Auto-detected from mcp.json if omitted.'),
+    sourceCode: z
+        .string()
+        .optional()
+        .describe('X++ source code for the object (class declaration, methods, etc.)'),
+    properties: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe('Additional properties for the object (extends, implements, label, etc.)'),
+});
+/**
+ * XML Template Generator for D365FO Objects
+ */
+class XmlTemplateGenerator {
+    /**
+     * Split X++ class source into the Declaration block (class header + field
+     * declarations) and individual method bodies, as required by D365FO XML.
+     *
+     * D365FO XML structure:
+     *   <Declaration> = class keyword + field declarations (the outer {} block)
+     *   <Methods>     = one <Method><Name/><Source/></Method> per method body
+     *
+     * AI generators often emit the entire source (header + methods) as a single
+     * string.  This helper separates them so the generated XML is correct.
+     */
+    static splitXppClassSource(fullSource) {
+        const firstBrace = fullSource.indexOf('{');
+        if (firstBrace === -1)
+            return { declaration: fullSource, methods: [] };
+        // Walk to the matching '}' that closes the class header block
+        let depth = 0;
+        let classEndIdx = -1;
+        for (let i = firstBrace; i < fullSource.length; i++) {
+            if (fullSource[i] === '{')
+                depth++;
+            else if (fullSource[i] === '}') {
+                depth--;
+                if (depth === 0) {
+                    classEndIdx = i;
+                    break;
+                }
+            }
+        }
+        if (classEndIdx === -1)
+            return { declaration: fullSource, methods: [] };
+        let declaration = fullSource.substring(0, classEndIdx + 1);
+        const rest = fullSource.substring(classEndIdx + 1);
+        if (!rest.trim()) {
+            const innerResult = XmlTemplateGenerator.extractInnerClassMethods(declaration);
+            if (innerResult) {
+                return innerResult;
+            }
+            return { declaration, methods: [] };
+        }
+        // Rescue member-variable declarations that appear outside the class {} block
+        const nextBraceInRest = rest.indexOf('{');
+        if (nextBraceInRest !== -1) {
+            const preMethodText = rest.substring(0, nextBraceInRest);
+            const varLines = preMethodText
+                .split('\n')
+                .filter(l => { const t = l.trim(); return t.endsWith(';') && !t.includes('('); });
+            if (varLines.length > 0) {
+                const injected = varLines.map(l => '    ' + l.trim()).join('\n');
+                declaration = declaration.replace(/}(\s*)$/, `\n${injected}\n\n}`);
+            }
+        }
+        // Parse each method block from the remaining source
+        const methods = [];
+        let pos = 0;
+        while (pos < rest.length) {
+            const nextBrace = rest.indexOf('{', pos);
+            if (nextBrace === -1)
+                break;
+            const sigText = rest.substring(pos, nextBrace);
+            // Find the matching '}' for this method body (depth-counting)
+            let d = 0;
+            let bodyEnd = -1;
+            for (let i = nextBrace; i < rest.length; i++) {
+                if (rest[i] === '{')
+                    d++;
+                else if (rest[i] === '}') {
+                    d--;
+                    if (d === 0) {
+                        bodyEnd = i;
+                        break;
+                    }
+                }
+            }
+            if (bodyEnd === -1)
+                break;
+            const methodSource = rest.substring(pos, bodyEnd + 1).trim();
+            // Extract method name: last identifier before '(' in the signature
+            const parenIdx = sigText.lastIndexOf('(');
+            const nameMatch = parenIdx !== -1 ? sigText.substring(0, parenIdx).match(/(\w+)\s*$/) : null;
+            const methodName = nameMatch ? nameMatch[1] : `method${methods.length + 1}`;
+            methods.push({ name: methodName, source: methodSource });
+            pos = bodyEnd + 1;
+        }
+        // Fallback: methods declared inside the class {} body rather than after it
+        if (methods.length === 0) {
+            const innerResult = XmlTemplateGenerator.extractInnerClassMethods(declaration);
+            if (innerResult) {
+                return innerResult;
+            }
+        }
+        return { declaration, methods };
+    }
+    /**
+     * Extract methods defined INSIDE the class body (depth-1 inside {}).
+     * Mirror of the same method in createD365File.ts — kept in sync manually.
+     */
+    static extractInnerClassMethods(classDeclaration) {
+        const classOpenIdx = classDeclaration.indexOf('{');
+        const classCloseIdx = classDeclaration.lastIndexOf('}');
+        if (classOpenIdx === -1 || classCloseIdx <= classOpenIdx)
+            return null;
+        const classBody = classDeclaration.substring(classOpenIdx + 1, classCloseIdx);
+        const methods = [];
+        const memberVarLines = [];
+        let pos = 0;
+        while (pos < classBody.length) {
+            const nextBrace = classBody.indexOf('{', pos);
+            if (nextBrace === -1) {
+                for (const line of classBody.substring(pos).split('\n')) {
+                    const t = line.trim();
+                    if (t.length > 0 && t.endsWith(';') && !t.includes('(') &&
+                        !t.startsWith('//') && !t.startsWith('*')) {
+                        memberVarLines.push(t);
+                    }
+                }
+                break;
+            }
+            const sigText = classBody.substring(pos, nextBrace);
+            let depth = 0;
+            let bodyEnd = -1;
+            for (let i = nextBrace; i < classBody.length; i++) {
+                if (classBody[i] === '{')
+                    depth++;
+                else if (classBody[i] === '}') {
+                    depth--;
+                    if (depth === 0) {
+                        bodyEnd = i;
+                        break;
+                    }
+                }
+            }
+            if (bodyEnd === -1)
+                break;
+            const parenIdx = sigText.lastIndexOf('(');
+            if (parenIdx !== -1) {
+                for (const line of sigText.split('\n')) {
+                    const t = line.trim();
+                    if (t.length > 0 && t.endsWith(';') && !t.includes('(') &&
+                        !t.startsWith('//') && !t.startsWith('*') && !t.startsWith('[')) {
+                        memberVarLines.push(t);
+                    }
+                }
+                const beforeLastParen = sigText.substring(0, parenIdx);
+                const lastNewlineBeforeLastParen = beforeLastParen.lastIndexOf('\n');
+                let methodStartInSig = lastNewlineBeforeLastParen !== -1
+                    ? lastNewlineBeforeLastParen + 1
+                    : 0;
+                const sigBeforeMethod = sigText.substring(0, methodStartInSig);
+                const sigBeforeLines = sigBeforeMethod.split('\n').reverse();
+                let droppedChars = 0;
+                for (const line of sigBeforeLines) {
+                    const t = line.trim();
+                    if (t.length === 0 || t.startsWith('[') || t.startsWith('//') || t.startsWith('*') || t.startsWith('/*')) {
+                        droppedChars += line.length + 1;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                methodStartInSig = Math.max(0, methodStartInSig - droppedChars);
+                const methodSource = classBody
+                    .substring(pos + methodStartInSig, bodyEnd + 1)
+                    .trim();
+                const nameMatch = sigText.substring(0, parenIdx).match(/(\w+)\s*$/);
+                const methodName = nameMatch ? nameMatch[1] : `method${methods.length + 1}`;
+                methods.push({ name: methodName, source: methodSource });
+            }
+            else {
+                for (const line of sigText.split('\n')) {
+                    const t = line.trim();
+                    if (t.length > 0 && t.endsWith(';') && !t.includes('(') &&
+                        !t.startsWith('//') && !t.startsWith('*')) {
+                        memberVarLines.push(t);
+                    }
+                }
+            }
+            pos = bodyEnd + 1;
+        }
+        if (methods.length === 0)
+            return null;
+        const classHeader = classDeclaration.substring(0, classOpenIdx + 1);
+        const memberVarsXpp = memberVarLines.length > 0
+            ? '\n' + memberVarLines.map(v => '    ' + v).join('\n') + '\n\n'
+            : '\n';
+        return {
+            declaration: classHeader + memberVarsXpp + '}',
+            methods,
+        };
+    }
+    /**
+     * Generate AxClass XML structure
+     */
+    static generateAxClassXml(className, sourceCode, properties) {
+        // Decode XML entities that AI models may introduce when copying from SSRS report
+        // entity-encoded <Text> blocks (e.g. &lt;summary&gt; → <summary>).
+        const rawSource = decodeXmlEntitiesFromXppSource(sourceCode || `public class ${className}\n{\n}`);
+        // Split full X++ source into Declaration (class header + fields) and Methods.
+        // D365FO XML requires member variable declarations in <Declaration> and
+        // each method body as a separate <Method> element under <Methods>.
+        const { declaration, methods } = XmlTemplateGenerator.splitXppClassSource(rawSource);
+        const extendsAttr = properties?.extends
+            ? `\t<Extends>${properties.extends}</Extends>\n`
+            : '';
+        const implementsAttr = properties?.implements
+            ? `\t<Implements>${properties.implements}</Implements>\n`
+            : '';
+        const methodsXml = methods.length === 0
+            ? '\t\t<Methods />\n'
+            : `\t\t<Methods>\n${methods
+                .map(m => `\t\t\t<Method>\n\t\t\t\t<Name>${m.name}</Name>\n\t\t\t\t<Source><![CDATA[\n${reindentXppSource(ensureXppDocComment(m.source))}\n\n]]></Source>\n\t\t\t</Method>`)
+                .join('\n\n')}\n\t\t</Methods>\n`;
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxClass xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${className}</Name>
+${extendsAttr}${implementsAttr}\t<SourceCode>
+\t\t<Declaration><![CDATA[
+${ensureBlankLineBeforeClosingBrace(ensureXppDocComment(declaration))}
+]]></Declaration>
+${methodsXml}\t</SourceCode>
+</AxClass>
+`;
+    }
+    /**
+     * Generate AxTable XML structure
+     */
+    static generateAxTableXml(tableName, properties) {
+        const label = properties?.label || tableName;
+        const tableGroup = properties?.tableGroup || 'Main';
+        const titleField1 = properties?.titleField1 || '';
+        const titleField2 = properties?.titleField2 || '';
+        const titleField1Xml = titleField1
+            ? `\t<TitleField1>${titleField1}</TitleField1>\n`
+            : '';
+        const titleField2Xml = titleField2
+            ? `\t<TitleField2>${titleField2}</TitleField2>\n`
+            : '';
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxTable xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${tableName}</Name>
+\t<SourceCode>
+\t\t<Declaration><![CDATA[
+public class ${tableName} extends common
+{
+}
+]]></Declaration>
+\t\t<Methods />
+\t</SourceCode>
+\t<Label>${label}</Label>
+\t<TableGroup>${tableGroup}</TableGroup>
+${titleField1Xml}${titleField2Xml}\t<DeleteActions />
+\t<FieldGroups>
+\t\t<AxTableFieldGroup>
+\t\t\t<Name>AutoReport</Name>
+\t\t\t<Fields />
+\t\t</AxTableFieldGroup>
+\t\t<AxTableFieldGroup>
+\t\t\t<Name>AutoLookup</Name>
+\t\t\t<Fields />
+\t\t</AxTableFieldGroup>
+\t\t<AxTableFieldGroup>
+\t\t\t<Name>AutoIdentification</Name>
+\t\t\t<AutoPopulate>Yes</AutoPopulate>
+\t\t\t<Fields />
+\t\t</AxTableFieldGroup>
+\t\t<AxTableFieldGroup>
+\t\t\t<Name>AutoSummary</Name>
+\t\t\t<Fields />
+\t\t</AxTableFieldGroup>
+\t\t<AxTableFieldGroup>
+\t\t\t<Name>AutoBrowse</Name>
+\t\t\t<Fields />
+\t\t</AxTableFieldGroup>
+\t</FieldGroups>
+\t<Fields />
+\t<Indexes />
+\t<Relations />
+</AxTable>
+`;
+    }
+    /**
+     * Generate AxEnum XML structure
+     */
+    static generateAxEnumXml(enumName, properties) {
+        const label = properties?.label || enumName;
+        // Extensible enums MUST have UseEnumValue=No (xppc hard requirement).
+        // Explicit <Value> elements also force UseEnumValue=Yes at compile time,
+        // so we suppress them when UseEnumValue=No.
+        const useEnumValue = (properties?.isExtensible || properties?.useEnumValue === false)
+            ? 'No'
+            : (properties?.useEnumValue ? 'Yes' : 'No');
+        const suppressExplicitValues = useEnumValue === 'No';
+        const configKeyXml = properties?.configurationKey
+            ? `\t<ConfigurationKey>${properties.configurationKey}</ConfigurationKey>\n`
+            : '';
+        // Build <EnumValues> block from properties.enumValues array
+        // Each entry: { name: string; value?: number; label?: string; helpText?: string }
+        const enumValueSpecs = Array.isArray(properties?.enumValues) ? properties.enumValues : [];
+        // D365FO hard limit: max 251 elements (0–250). Warn early — compiler rejects beyond this.
+        if (enumValueSpecs.length > 251) {
+            throw new Error(`Enum '${enumName}' has ${enumValueSpecs.length} values but D365FO supports a maximum of 251 (0–250). ` +
+                `Consider redesigning as a class hierarchy or splitting into multiple enums.`);
+        }
+        let enumValuesXml;
+        if (enumValueSpecs.length === 0) {
+            enumValuesXml = '\t<EnumValues />\n';
+        }
+        else {
+            enumValuesXml = '\t<EnumValues>\n';
+            let autoValue = 0;
+            for (const v of enumValueSpecs) {
+                const intValue = v.value ?? autoValue;
+                autoValue = intValue + 1;
+                enumValuesXml += `\t\t<AxEnumValue>\n`;
+                enumValuesXml += `\t\t\t<Name>${v.name}</Name>\n`;
+                if (v.label)
+                    enumValuesXml += `\t\t\t<Label>${v.label}</Label>\n`;
+                if (v.helpText)
+                    enumValuesXml += `\t\t\t<HelpText>${v.helpText}</HelpText>\n`;
+                // Omit <Value> when UseEnumValue=No (position-based ordering) or for implicit 0
+                if (intValue !== 0 && !suppressExplicitValues)
+                    enumValuesXml += `\t\t\t<Value>${intValue}</Value>\n`;
+                enumValuesXml += `\t\t</AxEnumValue>\n`;
+            }
+            enumValuesXml += '\t</EnumValues>\n';
+        }
+        // IsExtensible goes after EnumValues; value is lowercase true/false
+        const isExtensibleXml = properties?.isExtensible ? '\t<IsExtensible>true</IsExtensible>\n' : '';
+        // Element order matches real D365FO: Name → ConfigurationKey → Label → UseEnumValue → EnumValues → IsExtensible
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxEnum xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${enumName}</Name>
+${configKeyXml}\t<Label>${label}</Label>
+\t<UseEnumValue>${useEnumValue}</UseEnumValue>
+${enumValuesXml}${isExtensibleXml}</AxEnum>
+`;
+    }
+    /**
+     * Generate AxForm XML structure
+     */
+    static generateAxFormXml(formName, _properties) {
+        // D365FO forms require xmlns="Microsoft.Dynamics.AX.Metadata.V6" and SourceCode first
+        // NOTE: <Label> is intentionally absent — AxForm files do not carry a top-level <Label>.
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxForm xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="Microsoft.Dynamics.AX.Metadata.V6">
+\t<Name>${formName}</Name>
+\t<SourceCode>
+\t\t<Methods xmlns="">
+\t\t\t<Method>
+\t\t\t\t<Name>classDeclaration</Name>
+\t\t\t\t<Source><!\[CDATA[
+    [Form]
+    public class ${formName} extends FormRun
+    {
+    }
+
+]]></Source>
+\t\t\t</Method>
+\t\t</Methods>
+\t\t<DataSources xmlns="" />
+\t\t<DataControls xmlns="" />
+\t\t<Members xmlns="" />
+\t</SourceCode>
+\t<DataSources />
+\t<Design>
+\t\t<Controls xmlns="" />
+\t</Design>
+\t<Parts />
+</AxForm>
+`;
+    }
+    /**
+     * Generate AxQuery XML structure. Delegates to the shared builder
+     * (queryViewXml.ts) so this cannot drift from createD365File.ts's copy.
+     */
+    static generateAxQueryXml(queryName, properties) {
+        return buildAxQueryXml(queryName, properties);
+    }
+    /**
+     * Generate AxView XML structure. Delegates to the shared builder
+     * (queryViewXml.ts) so this cannot drift from createD365File.ts's copy.
+     */
+    static generateAxViewXml(viewName, properties) {
+        return buildAxViewXml(viewName, properties);
+    }
+    /**
+     * Generate AxMap XML structure. Delegates to the shared builder (mapXml.ts)
+     * so this cannot drift from createD365File.ts's copy.
+     */
+    static generateAxMapXml(mapName, properties) {
+        return buildAxMapXml(mapName, properties);
+    }
+    /**
+     * Generate AxDataEntityView XML structure. Delegates to the shared builder
+     * (dataEntityXml.ts) so this cannot drift from createD365File.ts's copy.
+     */
+    static generateAxDataEntityXml(entityName, properties) {
+        return buildAxDataEntityXml(entityName, properties);
+    }
+    /**
+     * Generate AxReport XML skeleton.
+     *
+     * properties:
+     *   dpClassName   - Data Provider class name          (default: <ReportName>DP)
+     *   tmpTableName  - TempDB table name                 (default: <ReportName>Tmp)
+     *   datasetName   - AxReportDataSet name              (default: tmpTableName)
+     *   designName    - AxReportDesign name               (default: 'Report')
+     *   caption       - Design caption label ref           (e.g. '@MyModel:MyLabel')
+     *   style         - Design style template             (e.g. 'TableStyleTemplate')
+     *   aotQuery      - AOT query name for DynamicParameter (e.g. 'SalesTable')
+     *   fields        - Array of { name, alias?, dataType?, caption?, disableAutoCreate? } → AxReportDataSetField
+     *   datasets      - Array of { name, dpClassName, tmpTableName, fields?, aotQuery?, contractParams? } for multi-dataset reports
+     *   contractParams - Array of { name, dataType?, label?, defaultValue? } → contract class parameters (DataMember)
+     *   rdlContent    - Full RDL XML string to embed (auto-generated from fields when omitted)
+     *
+     * AOT structure generated (mirrors real D365FO reports like ContosoReports_CashOrder_CZ):
+     *   <AxReport xmlns="Microsoft.Dynamics.AX.Metadata.V2">
+     *     <DataMethods />
+     *     <DataSets>
+     *       <AxReportDataSet xmlns="">           ← one per dataset
+     *         <Fields>…</Fields>
+     *         <Parameters>   ← 6 AX system params + {DPCLASS}_DynamicParameter
+     *       </AxReportDataSet>
+     *     </DataSets>
+     *     <DefaultParameterGroup>               ← 6 AX params + DynamicParameter (with AOTQuery+DataType)
+     *     <Designs>
+     *       <AxReportDesign xmlns="" i:type="AxReportPrecisionDesign">
+     *         <Text><![CDATA[…RDL…]]></Text>   ← 2016 schema with DataSources/DataSets/ReportParameters
+     *         <DisableIndividualTransformation><Name>…</Name></DisableIndividualTransformation>
+     *     </Designs>
+     *   </AxReport>
+     */
+    static generateAxReportXml(reportName, properties) {
+        // Resolve datasets: multi-dataset array or single-dataset shorthand
+        let datasets;
+        if (properties?.datasets && Array.isArray(properties.datasets)) {
+            datasets = properties.datasets;
+        }
+        else {
+            const tmpTableName = properties?.tmpTableName || `${reportName}Tmp`;
+            const dpClassName = properties?.dpClassName || `${reportName}DP`;
+            const datasetName = properties?.datasetName || tmpTableName;
+            datasets = [{
+                    name: datasetName,
+                    dpClassName,
+                    tmpTableName,
+                    fields: properties?.fields,
+                    aotQuery: properties?.aotQuery,
+                    contractParams: properties?.contractParams,
+                }];
+        }
+        const designName = properties?.designName || 'Report';
+        const rdlType = (dt) => {
+            switch (dt) {
+                case 'System.Double': return 'System.Double';
+                case 'System.Int32': return 'System.Int32';
+                case 'System.Int64': return 'System.Int64';
+                case 'System.DateTime': return 'System.DateTime';
+                case 'System.Byte[]': return 'System.Byte[]';
+                default: return 'System.String';
+            }
+        };
+        // Node.js crypto gives a guaranteed RFC-4122 v4 UUID
+        const uuid = () => crypto.randomUUID();
+        const buildDatasetXml = (ds) => {
+            const dpParamName = `${ds.dpClassName.toUpperCase()}_DynamicParameter`;
+            const contractDatasetParamsXml = (ds.contractParams || []).map(cp => {
+                const pn = `${ds.name}_ds_${cp.name}`;
+                const dt = cp.dataType || 'System.String';
+                return `\t\t\t\t<AxReportDataSetParameter>\n\t\t\t\t\t<Name>${pn}</Name>\n\t\t\t\t\t<Alias>${pn}</Alias>\n\t\t\t\t\t<DataType>${dt}</DataType>\n\t\t\t\t\t<Parameter>${pn}</Parameter>\n\t\t\t\t</AxReportDataSetParameter>`;
+            }).join('\n');
+            let fieldsXml;
+            if (ds.fields && ds.fields.length > 0) {
+                const entries = ds.fields.map(f => {
+                    const alias = f.alias || `${ds.tmpTableName}.1.${f.name}`;
+                    const capLine = f.caption ? `\n\t\t\t\t<Caption>${f.caption}</Caption>` : '';
+                    const dtLine = f.dataType ? `\n\t\t\t\t<DataType>${f.dataType}</DataType>` : '';
+                    const disableLine = f.disableAutoCreate ? `\n\t\t\t\t<DisableAutoCreateInDataRegion>true</DisableAutoCreateInDataRegion>` : '';
+                    return [
+                        `\t\t\t<AxReportDataSetField>`,
+                        `\t\t\t\t<Name>${f.name}</Name>`,
+                        `\t\t\t\t<Alias>${alias}</Alias>${capLine}${dtLine}${disableLine}`,
+                        `\t\t\t\t<DisplayWidth>Auto</DisplayWidth>`,
+                        `\t\t\t\t<UserDefined>false</UserDefined>`,
+                        `\t\t\t</AxReportDataSetField>`,
+                    ].join('\n');
+                });
+                fieldsXml = `\t\t\t<Fields>\n${entries.join('\n')}\n\t\t\t</Fields>`;
+            }
+            else {
+                fieldsXml = `\t\t\t<Fields />`;
+            }
+            return `\t\t<AxReportDataSet xmlns="">
+\t\t\t<Name>${ds.name}</Name>
+\t\t\t<DataSourceType>ReportDataProvider</DataSourceType>
+\t\t\t<Query>SELECT * FROM ${ds.dpClassName}.${ds.tmpTableName}</Query>
+\t\t\t<FieldGroups />
+${fieldsXml}
+\t\t\t<Parameters>
+\t\t\t\t<AxReportDataSetParameter>
+\t\t\t\t\t<Name>AX_PartitionKey</Name>
+\t\t\t\t\t<Alias>AX_PartitionKey</Alias>
+\t\t\t\t\t<DataType>System.String</DataType>
+\t\t\t\t\t<Parameter>AX_PartitionKey</Parameter>
+\t\t\t\t</AxReportDataSetParameter>
+\t\t\t\t<AxReportDataSetParameter>
+\t\t\t\t\t<Name>AX_CompanyName</Name>
+\t\t\t\t\t<Alias>AX_CompanyName</Alias>
+\t\t\t\t\t<DataType>System.String</DataType>
+\t\t\t\t\t<Parameter>AX_CompanyName</Parameter>
+\t\t\t\t</AxReportDataSetParameter>
+\t\t\t\t<AxReportDataSetParameter>
+\t\t\t\t\t<Name>AX_UserContext</Name>
+\t\t\t\t\t<Alias>AX_UserContext</Alias>
+\t\t\t\t\t<DataType>System.String</DataType>
+\t\t\t\t\t<Parameter>AX_UserContext</Parameter>
+\t\t\t\t</AxReportDataSetParameter>
+\t\t\t\t<AxReportDataSetParameter>
+\t\t\t\t\t<Name>AX_RenderingCulture</Name>
+\t\t\t\t\t<Alias>AX_RenderingCulture</Alias>
+\t\t\t\t\t<DataType>System.String</DataType>
+\t\t\t\t\t<Parameter>AX_RenderingCulture</Parameter>
+\t\t\t\t</AxReportDataSetParameter>
+\t\t\t\t<AxReportDataSetParameter>
+\t\t\t\t\t<Name>AX_ReportContext</Name>
+\t\t\t\t\t<Alias>AX_ReportContext</Alias>
+\t\t\t\t\t<DataType>System.String</DataType>
+\t\t\t\t\t<Parameter>AX_ReportContext</Parameter>
+\t\t\t\t</AxReportDataSetParameter>
+\t\t\t\t<AxReportDataSetParameter>
+\t\t\t\t\t<Name>AX_RdpPreProcessedId</Name>
+\t\t\t\t\t<Alias>AX_RdpPreProcessedId</Alias>
+\t\t\t\t\t<DataType>System.String</DataType>
+\t\t\t\t\t<Parameter>AX_RdpPreProcessedId</Parameter>
+\t\t\t\t</AxReportDataSetParameter>
+${contractDatasetParamsXml ? contractDatasetParamsXml + '\n' : ''}\t\t\t\t<AxReportDataSetParameter>
+\t\t\t\t\t<Name>${dpParamName}</Name>
+\t\t\t\t\t<Alias>${dpParamName}</Alias>
+\t\t\t\t\t<DataType>Microsoft.Dynamics.AX.Framework.Services.Client.QueryMetadata</DataType>
+\t\t\t\t\t<Parameter>${dpParamName}</Parameter>
+\t\t\t\t</AxReportDataSetParameter>
+\t\t\t</Parameters>
+\t\t</AxReportDataSet>`;
+        };
+        const datasetsXml = datasets.map(buildDatasetXml).join('\n');
+        // DefaultParameterGroup uses the first dataset's DP for DynamicParameter
+        const firstDs = datasets[0];
+        const dpParamName = `${firstDs.dpClassName.toUpperCase()}_DynamicParameter`;
+        const aotQueryLine = firstDs.aotQuery ? `\n\t\t\t\t<AOTQuery>${firstDs.aotQuery}</AOTQuery>` : '';
+        // Contract parameters (from DataContract class with [DataMember] attributes)
+        const contractParamsXml = (firstDs.contractParams || []).map(cp => {
+            const dataTypeLine = cp.dataType ? `\n\t\t\t\t<DataType>${cp.dataType}</DataType>` : '';
+            const promptLine = cp.label ? `\n\t\t\t\t<PromptString>${cp.label}</PromptString>` : '';
+            return `\t\t\t<AxReportParameterBase xmlns=""
+\t\t\t\t\ti:type="AxReportParameter">
+\t\t\t\t<Name>${firstDs.name}_ds_${cp.name}</Name>${dataTypeLine}${promptLine}
+\t\t\t\t<DefaultValue />
+\t\t\t\t<Values />
+\t\t\t</AxReportParameterBase>`;
+        }).join('\n');
+        const defaultParamGroupXml = `\t<DefaultParameterGroup>
+\t\t<Name xmlns="">Parameters</Name>
+\t\t<ReportParameterBases xmlns="">
+\t\t\t<AxReportParameterBase xmlns=""
+\t\t\t\t\ti:type="AxReportParameter">
+\t\t\t\t<Name>AX_PartitionKey</Name>
+\t\t\t\t<AllowBlank>true</AllowBlank>
+\t\t\t\t<Nullable>true</Nullable>
+\t\t\t\t<UserVisibility>Hidden</UserVisibility>
+\t\t\t\t<DefaultValue />
+\t\t\t\t<Values />
+\t\t\t</AxReportParameterBase>
+\t\t\t<AxReportParameterBase xmlns=""
+\t\t\t\t\ti:type="AxReportParameter">
+\t\t\t\t<Name>AX_CompanyName</Name>
+\t\t\t\t<UserVisibility>Hidden</UserVisibility>
+\t\t\t\t<DefaultValue />
+\t\t\t\t<Values />
+\t\t\t</AxReportParameterBase>
+\t\t\t<AxReportParameterBase xmlns=""
+\t\t\t\t\ti:type="AxReportParameter">
+\t\t\t\t<Name>AX_UserContext</Name>
+\t\t\t\t<AllowBlank>true</AllowBlank>
+\t\t\t\t<Nullable>true</Nullable>
+\t\t\t\t<UserVisibility>Hidden</UserVisibility>
+\t\t\t\t<DefaultValue />
+\t\t\t\t<Values />
+\t\t\t</AxReportParameterBase>
+\t\t\t<AxReportParameterBase xmlns=""
+\t\t\t\t\ti:type="AxReportParameter">
+\t\t\t\t<Name>AX_RenderingCulture</Name>
+\t\t\t\t<AllowBlank>true</AllowBlank>
+\t\t\t\t<Nullable>true</Nullable>
+\t\t\t\t<UserVisibility>Hidden</UserVisibility>
+\t\t\t\t<DefaultValue />
+\t\t\t\t<Values />
+\t\t\t</AxReportParameterBase>
+\t\t\t<AxReportParameterBase xmlns=""
+\t\t\t\t\ti:type="AxReportParameter">
+\t\t\t\t<Name>AX_ReportContext</Name>
+\t\t\t\t<AllowBlank>true</AllowBlank>
+\t\t\t\t<Nullable>true</Nullable>
+\t\t\t\t<UserVisibility>Hidden</UserVisibility>
+\t\t\t\t<DefaultValue />
+\t\t\t\t<Values />
+\t\t\t</AxReportParameterBase>
+\t\t\t<AxReportParameterBase xmlns=""
+\t\t\t\t\ti:type="AxReportParameter">
+\t\t\t\t<Name>AX_RdpPreProcessedId</Name>
+\t\t\t\t<AllowBlank>true</AllowBlank>
+\t\t\t\t<Nullable>true</Nullable>
+\t\t\t\t<UserVisibility>Hidden</UserVisibility>
+\t\t\t\t<DefaultValue />
+\t\t\t\t<Values />
+\t\t\t</AxReportParameterBase>
+${contractParamsXml}${contractParamsXml ? '\n' : ''}\t\t\t<AxReportParameterBase xmlns=""
+\t\t\t\t\ti:type="AxReportParameter">
+\t\t\t\t<Name>${dpParamName}</Name>${aotQueryLine}
+\t\t\t\t<AllowBlank>true</AllowBlank>
+\t\t\t\t<DataType>Microsoft.Dynamics.AX.Framework.Services.Client.QueryMetadata</DataType>
+\t\t\t\t<Nullable>true</Nullable>
+\t\t\t\t<UserVisibility>Hidden</UserVisibility>
+\t\t\t\t<DefaultValue />
+\t\t\t\t<Values />
+\t\t\t</AxReportParameterBase>
+\t\t</ReportParameterBases>
+\t</DefaultParameterGroup>`;
+        // Auto-generated RDL skeleton (2016 namespace, mirrors real D365FO reports)
+        const buildRdlSkeleton = () => {
+            const ns2016 = 'http://schemas.microsoft.com/sqlserver/reporting/2016/01/reportdefinition';
+            const nsRd = 'http://schemas.microsoft.com/SQLServer/reporting/reportdesigner';
+            const rdlDataSourcesXml = `  <DataSources>
+    <DataSource Name="AutoGen__ReportDataProvider">
+      <Transaction>true</Transaction>
+      <ConnectionProperties>
+        <DataProvider>AXREPORTDATAPROVIDER</DataProvider>
+        <ConnectString />
+        <IntegratedSecurity>true</IntegratedSecurity>
+      </ConnectionProperties>
+      <rd:DataSourceID>${uuid()}</rd:DataSourceID>
+    </DataSource>
+  </DataSources>`;
+            const buildRdlDataset = (ds) => {
+                const dsDpParam = `${ds.dpClassName.toUpperCase()}_DynamicParameter`;
+                const contractParamNamesRdl = (ds.contractParams || []).map(cp => `${ds.name}_ds_${cp.name}`);
+                const paramNames = [
+                    'AX_PartitionKey', 'AX_CompanyName', 'AX_UserContext',
+                    'AX_RenderingCulture', 'AX_ReportContext', 'AX_RdpPreProcessedId',
+                    ...contractParamNamesRdl,
+                    dsDpParam,
+                ];
+                const queryParams = paramNames
+                    .map(p => `          <QueryParameter Name="${p}">\n            <Value>=Parameters!${p}.Value</Value>\n          </QueryParameter>`)
+                    .join('\n');
+                let rdlFields = '';
+                if (ds.fields && ds.fields.length > 0) {
+                    const flines = ds.fields.map(f => {
+                        const alias = f.alias || `${ds.tmpTableName}.1.${f.name}`;
+                        return `        <Field Name="${f.name}">\n          <DataField>${alias}</DataField>\n          <rd:TypeName>${rdlType(f.dataType)}</rd:TypeName>\n        </Field>`;
+                    });
+                    rdlFields = `      <Fields>\n${flines.join('\n')}\n      </Fields>\n`;
+                }
+                return `    <DataSet Name="${ds.name}">
+      <rd:DataSetID>${uuid()}</rd:DataSetID>
+      <Query>
+        <DataSourceName>AutoGen__ReportDataProvider</DataSourceName>
+        <QueryParameters>
+${queryParams}
+        </QueryParameters>
+        <CommandText>SELECT * FROM ${ds.dpClassName}.${ds.tmpTableName}</CommandText>
+        <rd:UseGenericDesigner>true</rd:UseGenericDesigner>
+      </Query>
+${rdlFields}      <rd:DataSetInfo>
+        <rd:DataSetName>${ds.name}</rd:DataSetName>
+        <rd:TableName>Fields</rd:TableName>
+        <rd:TableAdapterFillMethod>Fill</rd:TableAdapterFillMethod>
+        <rd:TableAdapterGetDataMethod>GetData</rd:TableAdapterGetDataMethod>
+        <rd:TableAdapterName>FieldsTableAdapter</rd:TableAdapterName>
+      </rd:DataSetInfo>
+    </DataSet>`;
+            };
+            const rdlDatasetsXml = `  <DataSets>\n${datasets.map(buildRdlDataset).join('\n')}\n  </DataSets>`;
+            // Simple detail tablix per dataset so the design is not empty
+            const buildRdlTablix = (ds) => {
+                if (!ds.fields || ds.fields.length === 0)
+                    return '';
+                const n = ds.fields.length;
+                const colW = +Math.min(1.5, 7 / n).toFixed(2);
+                const totalW = +(colW * n).toFixed(2);
+                const grp = `Details_${ds.name}`;
+                const cols = ds.fields.map(() => `            <TablixColumn><Width>${colW}in</Width></TablixColumn>`).join('\n');
+                const hCells = ds.fields.map(f => [
+                    `            <TablixCell><CellContents>`,
+                    `              <Textbox Name="Textbox_${f.name}_H">`,
+                    `                <CanGrow>true</CanGrow><Value>${f.name}</Value>`,
+                    `                <Style><FontWeight>Bold</FontWeight>`,
+                    `                  <BackgroundColor>LightGrey</BackgroundColor>`,
+                    `                  <Border><Style>Solid</Style></Border>`,
+                    `                  <PaddingLeft>2pt</PaddingLeft><PaddingRight>2pt</PaddingRight>`,
+                    `                  <PaddingTop>2pt</PaddingTop><PaddingBottom>2pt</PaddingBottom>`,
+                    `                </Style></Textbox>`,
+                    `            </CellContents></TablixCell>`,
+                ].join('\n')).join('\n');
+                const dCells = ds.fields.map(f => [
+                    `            <TablixCell><CellContents>`,
+                    `              <Textbox Name="Textbox_${f.name}">`,
+                    `                <CanGrow>true</CanGrow><Value>=Fields!${f.name}.Value</Value>`,
+                    `                <Style><Border><Style>Solid</Style></Border>`,
+                    `                  <PaddingLeft>2pt</PaddingLeft><PaddingRight>2pt</PaddingRight>`,
+                    `                  <PaddingTop>2pt</PaddingTop><PaddingBottom>2pt</PaddingBottom>`,
+                    `                </Style></Textbox>`,
+                    `            </CellContents></TablixCell>`,
+                ].join('\n')).join('\n');
+                const cMembers = ds.fields.map(() => `          <TablixMember />`).join('\n');
+                return [
+                    `        <Tablix Name="Tablix_${ds.name}">`,
+                    `          <TablixBody>`,
+                    `            <TablixColumns>`,
+                    cols,
+                    `            </TablixColumns>`,
+                    `            <TablixRows>`,
+                    `              <TablixRow><Height>0.25in</Height><TablixCells>`,
+                    hCells,
+                    `              </TablixCells></TablixRow>`,
+                    `              <TablixRow><Height>0.25in</Height><TablixCells>`,
+                    dCells,
+                    `              </TablixCells></TablixRow>`,
+                    `            </TablixRows>`,
+                    `          </TablixBody>`,
+                    `          <TablixColumnHierarchy><TablixMembers>`,
+                    cMembers,
+                    `          </TablixMembers></TablixColumnHierarchy>`,
+                    `          <TablixRowHierarchy><TablixMembers>`,
+                    `            <TablixMember>`,
+                    `              <KeepWithGroup>After</KeepWithGroup>`,
+                    `              <RepeatOnNewPage>true</RepeatOnNewPage>`,
+                    `            </TablixMember>`,
+                    `            <TablixMember><Group Name="${grp}"><DataGroupName>${grp}</DataGroupName></Group></TablixMember>`,
+                    `          </TablixMembers></TablixRowHierarchy>`,
+                    `          <DataSetName>${ds.name}</DataSetName>`,
+                    `          <Top>0.5in</Top><Left>0.5in</Left>`,
+                    `          <Height>0.5in</Height><Width>${totalW}in</Width>`,
+                    `          <Style><Border><Style>Solid</Style></Border></Style>`,
+                    `        </Tablix>`,
+                ].join('\n');
+            };
+            const rdlBodyItemsXml = datasets.map(buildRdlTablix).filter(Boolean).join('\n');
+            const rdlBodyTag = rdlBodyItemsXml
+                ? `        <ReportItems>\n${rdlBodyItemsXml}\n        </ReportItems>`
+                : `        <ReportItems />`;
+            const contractRdlParams = (firstDs.contractParams || []).map(cp => ({
+                name: `${firstDs.name}_ds_${cp.name}`,
+                nullable: true, blank: true, usedInQuery: true,
+            }));
+            const rdlParamDefs = [
+                { name: 'AX_PartitionKey', nullable: true, blank: true, usedInQuery: false },
+                { name: 'AX_CompanyName', nullable: false, blank: false, usedInQuery: false },
+                { name: 'AX_UserContext', nullable: true, blank: true, usedInQuery: false },
+                { name: 'AX_RenderingCulture', nullable: true, blank: true, usedInQuery: false },
+                { name: 'AX_ReportContext', nullable: true, blank: true, usedInQuery: true },
+                { name: 'AX_RdpPreProcessedId', nullable: true, blank: true, usedInQuery: false },
+                { name: dpParamName, nullable: true, blank: true, usedInQuery: false },
+                ...contractRdlParams,
+            ];
+            const rdlParamsXml = `  <ReportParameters>\n` +
+                rdlParamDefs.map(p => {
+                    const nullLine = p.nullable ? `\n      <Nullable>true</Nullable>` : '';
+                    const blankLine = p.blank ? `\n      <AllowBlank>true</AllowBlank>` : '';
+                    const usedLine = p.usedInQuery ? `\n      <UsedInQuery>true</UsedInQuery>` : '';
+                    return `    <ReportParameter Name="${p.name}">\n      <DataType>String</DataType>${nullLine}${blankLine}\n      <Prompt>${p.name}</Prompt>\n      <Hidden>true</Hidden>${usedLine}\n    </ReportParameter>`;
+                }).join('\n') + `\n  </ReportParameters>`;
+            const cellDefs = rdlParamDefs
+                .map((p, i) => `        <CellDefinition>\n          <ColumnIndex>${i}</ColumnIndex>\n          <RowIndex>0</RowIndex>\n          <ParameterName>${p.name}</ParameterName>\n        </CellDefinition>`)
+                .join('\n');
+            const rdlParamLayoutXml = `  <ReportParametersLayout>
+    <GridLayoutDefinition>
+      <NumberOfColumns>${rdlParamDefs.length}</NumberOfColumns>
+      <NumberOfRows>1</NumberOfRows>
+      <CellDefinitions>
+${cellDefs}
+      </CellDefinitions>
+    </GridLayoutDefinition>
+  </ReportParametersLayout>`;
+            return `<?xml version="1.0" encoding="utf-8"?>
+<Report xmlns="${ns2016}" xmlns:rd="${nsRd}">
+  <AutoRefresh>0</AutoRefresh>
+${rdlDataSourcesXml}
+${rdlDatasetsXml}
+  <ReportSections>
+    <ReportSection>
+      <Body>
+${rdlBodyTag}
+        <Height>1in</Height>
+        <Style>
+          <Border>
+            <Style>None</Style>
+          </Border>
+        </Style>
+      </Body>
+      <Width>7.5in</Width>
+      <Page>
+        <PageHeight>11.69in</PageHeight>
+        <PageWidth>8.27in</PageWidth>
+        <InteractiveHeight>11in</InteractiveHeight>
+        <InteractiveWidth>8.5in</InteractiveWidth>
+        <LeftMargin>0.2in</LeftMargin>
+        <TopMargin>0.2in</TopMargin>
+        <Style />
+      </Page>
+    </ReportSection>
+  </ReportSections>
+${rdlParamsXml}
+${rdlParamLayoutXml}
+  <Language>en-US</Language>
+  <rd:ReportUnitType>Inch</rd:ReportUnitType>
+  <rd:ReportID>${uuid()}</rd:ReportID>
+</Report>`;
+        };
+        const captionLine = properties?.caption ? `\n\t\t\t<Caption>${properties.caption}</Caption>` : '';
+        const styleLine = properties?.style ? `\n\t\t\t<Style>${properties.style}</Style>` : '';
+        const rdlContent = properties?.rdlContent;
+        // Sanitize: fix old-schema <Header> inside <TablixMember> — renamed to <TablixHeader> in 2016 RDL.
+        // This handles AI-generated or older-tool-generated RDL that still uses the pre-2016 element name.
+        const rdl = (rdlContent || buildRdlSkeleton())
+            .replace(/<Header>/g, '<TablixHeader>')
+            .replace(/<\/Header>/g, '</TablixHeader>');
+        const textElement = `\n\t\t\t<Text><![CDATA[${rdl}]]></Text>`;
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxReport xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="Microsoft.Dynamics.AX.Metadata.V2">
+\t<Name>${reportName}</Name>
+\t<DataMethods />
+\t<DataSets>
+${datasetsXml}
+\t</DataSets>
+${defaultParamGroupXml}
+\t<Designs>
+\t\t<AxReportDesign xmlns=""
+\t\t\t\ti:type="AxReportPrecisionDesign">
+\t\t\t<Name>${designName}</Name>${captionLine}${styleLine}${textElement}
+\t\t\t<DisableIndividualTransformation>
+\t\t\t\t<Name>DisableIndividualTransformation</Name>
+\t\t\t</DisableIndividualTransformation>
+\t\t</AxReportDesign>
+\t</Designs>
+\t<EmbeddedImages />
+</AxReport>`;
+    }
+    /**
+     * Main generate method
+     */
+    static generate(objectType, objectName, sourceCode, properties) {
+        switch (objectType) {
+            case 'class':
+                return this.generateAxClassXml(objectName, sourceCode, properties);
+            case 'table':
+                return this.generateAxTableXml(objectName, properties);
+            case 'enum':
+                return this.generateAxEnumXml(objectName, properties);
+            case 'form':
+                return this.generateAxFormXml(objectName, properties);
+            case 'query':
+                return this.generateAxQueryXml(objectName, properties);
+            case 'view':
+                return this.generateAxViewXml(objectName, properties);
+            case 'map':
+                return this.generateAxMapXml(objectName, properties);
+            case 'data-entity':
+                return this.generateAxDataEntityXml(objectName, properties);
+            case 'report':
+                return this.generateAxReportXml(objectName, properties);
+            case 'edt':
+                return this.generateAxEdtXml(objectName, properties);
+            case 'table-extension':
+                return this.generateAxTableExtensionXml(objectName, properties);
+            case 'form-extension':
+                return this.generateAxFormExtensionXml(objectName);
+            case 'edt-extension':
+                return this.generateAxSimpleExtensionXml('AxEdtExtension', objectName);
+            case 'enum-extension':
+                return this.generateAxEnumExtensionXml(objectName, properties);
+            case 'data-entity-extension':
+                return this.generateAxSimpleExtensionXml('AxDataEntityViewExtension', objectName);
+            case 'menu-item-display':
+            case 'menu-item-action':
+            case 'menu-item-output':
+                return this.generateAxMenuItemXml(objectType, objectName, properties);
+            case 'menu-item-display-extension':
+                return this.generateAxSimpleExtensionXml('AxMenuItemDisplayExtension', objectName);
+            case 'menu-item-action-extension':
+                return this.generateAxSimpleExtensionXml('AxMenuItemActionExtension', objectName);
+            case 'menu-item-output-extension':
+                return this.generateAxSimpleExtensionXml('AxMenuItemOutputExtension', objectName);
+            case 'menu':
+                return this.generateAxMenuXml(objectName, properties);
+            case 'menu-extension':
+                return this.generateAxMenuExtensionXml(objectName);
+            case 'security-privilege':
+                return this.generateAxSecurityPrivilegeXml(objectName, properties);
+            case 'security-duty':
+                return this.generateAxSecurityDutyXml(objectName, properties);
+            case 'security-role':
+                return this.generateAxSecurityRoleXml(objectName, properties);
+            case 'security-duty-extension':
+                return this.generateAxSecurityDutyExtensionXml(objectName, properties);
+            case 'security-role-extension':
+                return this.generateAxSecurityRoleExtensionXml(objectName, properties);
+            default:
+                throw new Error(`Unsupported object type: ${objectType}`);
+        }
+    }
+    static generateAxEdtXml(name, properties) {
+        const edtTypeRaw = properties?.edtType || 'AxEdtString';
+        const edtTypeNormMap = {
+            string: 'AxEdtString',
+            integer: 'AxEdtInt',
+            int: 'AxEdtInt',
+            int64: 'AxEdtInt64',
+            real: 'AxEdtReal',
+            date: 'AxEdtDate',
+            datetime: 'AxEdtUtcDateTime',
+            utcdatetime: 'AxEdtUtcDateTime',
+            enum: 'AxEdtEnum',
+            guid: 'AxEdtGuid',
+            container: 'AxEdtContainer',
+        };
+        const edtType = edtTypeNormMap[edtTypeRaw.toLowerCase()] ?? edtTypeRaw;
+        const label = properties?.label || '@TODO:LabelId';
+        const extends_ = properties?.extends ? `\n\t<Extends>${properties.extends}</Extends>` : '';
+        const stringSize = edtType === 'AxEdtString'
+            ? `\n\t<StringSize>${properties?.stringSize ?? 30}</StringSize>` : '';
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxEdt xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns=""
+\ti:type="${edtType}">
+\t<Name>${name}</Name>
+\t<Label>${label}</Label>${extends_}
+\t<ArrayElements />
+\t<Relations />
+\t<TableReferences />${stringSize}
+</AxEdt>`;
+    }
+    static generateAxSimpleExtensionXml(rootElement, name) {
+        return `<?xml version="1.0" encoding="utf-8"?>
+<${rootElement} xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${name}</Name>
+\t<PropertyModifications />
+</${rootElement}>`;
+    }
+    /**
+     * Generate AxEnumExtension XML.
+     * Name convention: BaseEnumName.PrefixExtension
+     *
+     * Supported properties:
+     *   enumValues: Array<{ name, label?, value?, countryRegionCodes?, helpText? }>
+     */
+    static generateAxEnumExtensionXml(name, properties) {
+        const enumValueSpecs = Array.isArray(properties?.enumValues) ? properties.enumValues : [];
+        let enumValuesXml;
+        if (enumValueSpecs.length === 0) {
+            enumValuesXml = '\t<EnumValues />';
+        }
+        else {
+            enumValuesXml = '\t<EnumValues>';
+            for (const v of enumValueSpecs) {
+                enumValuesXml += `\n\t\t<AxEnumValue>`;
+                enumValuesXml += `\n\t\t\t<Name>${v.name}</Name>`;
+                if (v.countryRegionCodes)
+                    enumValuesXml += `\n\t\t\t<CountryRegionCodes>${v.countryRegionCodes}</CountryRegionCodes>`;
+                if (v.label)
+                    enumValuesXml += `\n\t\t\t<Label>${v.label}</Label>`;
+                if (v.helpText)
+                    enumValuesXml += `\n\t\t\t<HelpText>${v.helpText}</HelpText>`;
+                if (v.value !== undefined && v.value !== 0)
+                    enumValuesXml += `\n\t\t\t<Value>${v.value}</Value>`;
+                enumValuesXml += `\n\t\t</AxEnumValue>`;
+            }
+            enumValuesXml += '\n\t</EnumValues>';
+        }
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxEnumExtension xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${name}</Name>
+${enumValuesXml}
+\t<PropertyModifications />
+\t<ValueModifications />
+</AxEnumExtension>`;
+    }
+    static generateAxTableExtensionXml(name, properties) {
+        // Fields
+        const fieldSpecs = Array.isArray(properties?.fields) ? properties.fields : [];
+        let fieldsXml;
+        if (fieldSpecs.length === 0) {
+            fieldsXml = '\t<Fields />';
+        }
+        else {
+            fieldsXml = '\t<Fields>\n';
+            for (const f of fieldSpecs) {
+                const iType = f.fieldType ?? (f.enumType ? 'AxTableFieldEnum' : 'AxTableFieldString');
+                fieldsXml += `\t\t<AxTableField xmlns=""\n\t\t\ti:type="${iType}">\n`;
+                fieldsXml += `\t\t\t<Name>${f.name}</Name>\n`;
+                if (f.edt)
+                    fieldsXml += `\t\t\t<ExtendedDataType>${f.edt}</ExtendedDataType>\n`;
+                if (f.label)
+                    fieldsXml += `\t\t\t<Label>${f.label}</Label>\n`;
+                if (f.mandatory)
+                    fieldsXml += `\t\t\t<Mandatory>Yes</Mandatory>\n`;
+                if (f.enumType)
+                    fieldsXml += `\t\t\t<EnumType>${f.enumType}</EnumType>\n`;
+                fieldsXml += `\t\t</AxTableField>\n`;
+            }
+            fieldsXml += '\t</Fields>';
+        }
+        // FieldGroups
+        const fgSpecs = Array.isArray(properties?.fieldGroups) ? properties.fieldGroups : [];
+        let fieldGroupsXml;
+        if (fgSpecs.length === 0) {
+            fieldGroupsXml = '\t<FieldGroups />';
+        }
+        else {
+            fieldGroupsXml = '\t<FieldGroups>\n';
+            for (const fg of fgSpecs) {
+                fieldGroupsXml += `\t\t<AxTableFieldGroup>\n\t\t\t<Name>${fg.name}</Name>\n`;
+                if (fg.label)
+                    fieldGroupsXml += `\t\t\t<Label>${fg.label}</Label>\n`;
+                const fgFields = Array.isArray(fg.fields) ? fg.fields : [];
+                if (fgFields.length === 0) {
+                    fieldGroupsXml += `\t\t\t<Fields />\n`;
+                }
+                else {
+                    fieldGroupsXml += `\t\t\t<Fields>\n`;
+                    for (const df of fgFields)
+                        fieldGroupsXml += `\t\t\t\t<AxTableFieldGroupField>\n\t\t\t\t\t<DataField>${df}</DataField>\n\t\t\t\t</AxTableFieldGroupField>\n`;
+                    fieldGroupsXml += `\t\t\t</Fields>\n`;
+                }
+                fieldGroupsXml += `\t\t</AxTableFieldGroup>\n`;
+            }
+            fieldGroupsXml += '\t</FieldGroups>';
+        }
+        // FieldGroupExtensions
+        const fgeSpecs = Array.isArray(properties?.fieldGroupExtensions) ? properties.fieldGroupExtensions : [];
+        let fieldGroupExtensionsXml;
+        if (fgeSpecs.length === 0) {
+            fieldGroupExtensionsXml = '\t<FieldGroupExtensions />';
+        }
+        else {
+            fieldGroupExtensionsXml = '\t<FieldGroupExtensions>\n';
+            for (const fge of fgeSpecs) {
+                fieldGroupExtensionsXml += `\t\t<AxTableFieldGroupExtension>\n\t\t\t<Name>${fge.name}</Name>\n`;
+                const fgeFields = Array.isArray(fge.fields) ? fge.fields : [];
+                if (fgeFields.length === 0) {
+                    fieldGroupExtensionsXml += `\t\t\t<Fields />\n`;
+                }
+                else {
+                    fieldGroupExtensionsXml += `\t\t\t<Fields>\n`;
+                    for (const df of fgeFields)
+                        fieldGroupExtensionsXml += `\t\t\t\t<AxTableFieldGroupField>\n\t\t\t\t\t<DataField>${df}</DataField>\n\t\t\t\t</AxTableFieldGroupField>\n`;
+                    fieldGroupExtensionsXml += `\t\t\t</Fields>\n`;
+                }
+                fieldGroupExtensionsXml += `\t\t</AxTableFieldGroupExtension>\n`;
+            }
+            fieldGroupExtensionsXml += '\t</FieldGroupExtensions>';
+        }
+        // Indexes
+        const idxSpecs = Array.isArray(properties?.indexes) ? properties.indexes : [];
+        let indexesXml;
+        if (idxSpecs.length === 0) {
+            indexesXml = '\t<Indexes />';
+        }
+        else {
+            indexesXml = '\t<Indexes>\n';
+            for (const idx of idxSpecs) {
+                indexesXml += `\t\t<AxTableIndex>\n\t\t\t<Name>${idx.name}</Name>\n`;
+                if (idx.allowDuplicates !== undefined)
+                    indexesXml += `\t\t\t<AllowDuplicates>${idx.allowDuplicates ? 'Yes' : 'No'}</AllowDuplicates>\n`;
+                if (idx.alternateKey)
+                    indexesXml += `\t\t\t<AlternateKey>Yes</AlternateKey>\n`;
+                const idxFields = Array.isArray(idx.fields) ? idx.fields : [];
+                if (idxFields.length === 0) {
+                    indexesXml += `\t\t\t<Fields />\n`;
+                }
+                else {
+                    indexesXml += `\t\t\t<Fields>\n`;
+                    for (const f of idxFields) {
+                        indexesXml += `\t\t\t\t<AxTableIndexField>\n\t\t\t\t\t<DataField>${f.fieldName}</DataField>\n`;
+                        if (f.direction)
+                            indexesXml += `\t\t\t\t\t<Direction>${f.direction}</Direction>\n`;
+                        indexesXml += `\t\t\t\t</AxTableIndexField>\n`;
+                    }
+                    indexesXml += `\t\t\t</Fields>\n`;
+                }
+                indexesXml += `\t\t</AxTableIndex>\n`;
+            }
+            indexesXml += '\t</Indexes>';
+        }
+        // Relations
+        const relSpecs = Array.isArray(properties?.relations) ? properties.relations : [];
+        let relationsXml;
+        if (relSpecs.length === 0) {
+            relationsXml = '\t<Relations />';
+        }
+        else {
+            relationsXml = '\t<Relations>\n';
+            for (const rel of relSpecs) {
+                relationsXml += `\t\t<AxTableRelation>\n\t\t\t<Name>${rel.name}</Name>\n`;
+                relationsXml += `\t\t\t<Cardinality>${rel.cardinality || 'ZeroMore'}</Cardinality>\n`;
+                relationsXml += `\t\t\t<RelatedTable>${rel.relatedTable}</RelatedTable>\n`;
+                relationsXml += `\t\t\t<RelatedTableCardinality>${rel.relatedTableCardinality || 'ExactlyOne'}</RelatedTableCardinality>\n`;
+                relationsXml += `\t\t\t<RelationshipType>${rel.relationshipType || 'Association'}</RelationshipType>\n`;
+                const constraints = Array.isArray(rel.constraints) ? rel.constraints : [];
+                if (constraints.length === 0) {
+                    relationsXml += `\t\t\t<Constraints />\n`;
+                }
+                else {
+                    relationsXml += `\t\t\t<Constraints>\n`;
+                    for (const c of constraints) {
+                        relationsXml += `\t\t\t\t<AxTableRelationConstraint xmlns="" i:type="AxTableRelationConstraintField">\n`;
+                        relationsXml += `\t\t\t\t\t<Name>${c.fieldName}</Name>\n`;
+                        relationsXml += `\t\t\t\t\t<Field>${c.fieldName}</Field>\n`;
+                        relationsXml += `\t\t\t\t\t<RelatedField>${c.relatedFieldName}</RelatedField>\n`;
+                        relationsXml += `\t\t\t\t</AxTableRelationConstraint>\n`;
+                    }
+                    relationsXml += `\t\t\t</Constraints>\n`;
+                }
+                relationsXml += `\t\t</AxTableRelation>\n`;
+            }
+            relationsXml += '\t</Relations>';
+        }
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxTableExtension xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${name}</Name>
+${fieldGroupExtensionsXml}
+${fieldGroupsXml}
+\t<FieldModifications />
+${fieldsXml}
+\t<FullTextIndexes />
+${indexesXml}
+\t<Mappings />
+\t<PropertyModifications />
+\t<RelationExtensions />
+\t<RelationModifications />
+${relationsXml}
+</AxTableExtension>`;
+    }
+    static generateAxFormExtensionXml(name) {
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxFormExtension xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="Microsoft.Dynamics.AX.Metadata.V6">
+\t<Name>${name}</Name>
+\t<ControlModifications />
+\t<Controls />
+\t<DataSourceModifications />
+\t<DataSourceReferences />
+\t<DataSources />
+\t<Parts />
+\t<PropertyModifications />
+</AxFormExtension>`;
+    }
+    static generateAxMenuItemXml(itemType, name, properties) {
+        const elemName = itemType === 'menu-item-action' ? 'AxMenuItemAction'
+            : itemType === 'menu-item-output' ? 'AxMenuItemOutput'
+                : 'AxMenuItemDisplay';
+        const targetObject = properties?.targetObject || properties?.object || name;
+        const label = properties?.label || '@TODO:LabelId';
+        // Determine ObjectType based on item type and explicit properties.
+        // D365FO serializer rules (confirmed from real XML files):
+        //   - AxMenuItemAction:  ObjectType is always "Class"; must be present.
+        //   - AxMenuItemDisplay: ObjectType is OMITTED when targeting a Form (default);
+        //                        use "Class" only when explicitly set.
+        //   - AxMenuItemOutput:  ObjectType is "Class" (controller) or "SSRSReport";
+        //                        "Report" is NOT a valid value — real files use "SSRSReport".
+        const explicitObjType = properties?.objectType || properties?.targetType;
+        let objType;
+        if (itemType === 'menu-item-action') {
+            objType = explicitObjType || 'Class';
+        }
+        else if (itemType === 'menu-item-output') {
+            if (explicitObjType === 'Report') {
+                objType = 'SSRSReport';
+            }
+            else {
+                objType = explicitObjType || 'Class';
+            }
+        }
+        else {
+            // Display: omit ObjectType when targeting a Form (implicit default)
+            if (explicitObjType && explicitObjType !== 'Form') {
+                objType = explicitObjType;
+            }
+        }
+        const objectTypeXml = objType ? `\n\t<ObjectType>${objType}</ObjectType>` : '';
+        return `<?xml version="1.0" encoding="utf-8"?>
+<${elemName} xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="Microsoft.Dynamics.AX.Metadata.V1">
+\t<Name>${name}</Name>
+\t<Label>${label}</Label>
+\t<Object>${targetObject}</Object>${objectTypeXml}
+</${elemName}>`;
+    }
+    static generateAxMenuXml(name, properties) {
+        const label = properties?.label || '@TODO:LabelId';
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxMenu xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="Microsoft.Dynamics.AX.Metadata.V1">
+\t<Name>${name}</Name>
+\t<Label>${label}</Label>
+\t<Elements />
+</AxMenu>`;
+    }
+    static generateAxMenuExtensionXml(name) {
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxMenuExtension xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="Microsoft.Dynamics.AX.Metadata.V1">
+\t<Name>${name}</Name>
+\t<Customizations />
+\t<Elements />
+\t<MenuElementModifications />
+\t<PropertyModifications />
+</AxMenuExtension>`;
+    }
+    // Delegates to the shared builder so this mirror and the one in
+    // createD365File.ts cannot drift. @see buildAxSecurityPrivilegeXml.
+    static generateAxSecurityPrivilegeXml(name, properties) {
+        return buildAxSecurityPrivilegeXml(name, properties);
+    }
+    static generateAxSecurityDutyXml(name, properties) {
+        const label = properties?.label || '@TODO:LabelId';
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxSecurityDuty xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${name}</Name>
+\t<Label>${label}</Label>
+\t<Privileges />
+</AxSecurityDuty>`;
+    }
+    static generateAxSecurityRoleXml(name, properties) {
+        const label = properties?.label || '@TODO:LabelId';
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxSecurityRole xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${name}</Name>
+\t<Label>${label}</Label>
+\t<DirectAccessPermissions />
+\t<Duties />
+\t<Privileges />
+\t<SubRoles />
+</AxSecurityRole>`;
+    }
+    /** Normalize a name list that may arrive as an array or a comma/semicolon/newline-separated string. */
+    static normalizeNameList(value) {
+        if (!value)
+            return [];
+        const arr = Array.isArray(value) ? value : String(value).split(/[,;\n]+/);
+        return arr.map((s) => String(s).trim()).filter((s) => s.length > 0);
+    }
+    static refContainer(container, childTag, names) {
+        if (names.length === 0)
+            return `\t<${container} />`;
+        const children = names
+            .map(n => `\t\t<${childTag}>\n\t\t\t<Name>${n}</Name>\n\t\t</${childTag}>`)
+            .join('\n');
+        return `\t<${container}>\n${children}\n\t</${container}>`;
+    }
+    /**
+     * Generate AxSecurityDutyExtension XML — adds privileges to an EXISTING duty
+     * without overlaying it. Name convention: "<BaseDuty>.<PrefixOrModel>Extension".
+     */
+    static generateAxSecurityDutyExtensionXml(name, properties) {
+        const privileges = this.normalizeNameList(properties?.privileges);
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxSecurityDutyExtension xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${name}</Name>
+${this.refContainer('Privileges', 'AxSecurityPrivilegeReference', privileges)}
+\t<PropertyModifications />
+</AxSecurityDutyExtension>`;
+    }
+    /**
+     * Generate AxSecurityRoleExtension XML — adds duties/privileges to an EXISTING
+     * role without overlaying it. Name convention: "<BaseRole>.<PrefixOrModel>Extension".
+     */
+    static generateAxSecurityRoleExtensionXml(name, properties) {
+        const duties = this.normalizeNameList(properties?.duties);
+        const privileges = this.normalizeNameList(properties?.privileges);
+        return `<?xml version="1.0" encoding="utf-8"?>
+<AxSecurityRoleExtension xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+\t<Name>${name}</Name>
+\t<DirectAccessPermissions />
+${this.refContainer('Duties', 'AxSecurityDutyReference', duties)}
+${this.refContainer('Privileges', 'AxSecurityPrivilegeReference', privileges)}
+\t<PropertyModifications />
+</AxSecurityRoleExtension>`;
+    }
+}
+/**
+ * Generate D365FO XML handler function
+ */
+export async function handleGenerateD365Xml(request) {
+    try {
+        const args = GenerateD365XmlArgsSchema.parse(request.params.arguments);
+        // Resolve model name: arg → mcp.json modelName → workspacePath segment
+        const configManager = getConfigManager();
+        const modelName = args.modelName || configManager.getModelName();
+        if (!modelName) {
+            const errorMsg = '❌ ERROR: modelName could not be resolved.\n\n' +
+                'Provide it in one of these ways:\n' +
+                '  1. Pass modelName explicitly in the tool call arguments\n' +
+                '  2. Add modelName to .mcp.json context: { "context": { "modelName": "YourModel" } }\n' +
+                '  3. Add workspacePath ending with the package/model name: { "context": { "workspacePath": "K:\\\\...\\\\YourModel" } }';
+            return { content: [{ type: 'text', text: errorMsg }], isError: true };
+        }
+        console.error(`[generate_d365fo_xml] Generating XML for ${args.objectType}: ${args.objectName}, model: ${modelName}`);
+        // Determine object folder based on type
+        const objectFolderMap = {
+            class: 'AxClass',
+            table: 'AxTable',
+            enum: 'AxEnum',
+            form: 'AxForm',
+            query: 'AxQuery',
+            view: 'AxView',
+            'data-entity': 'AxDataEntityView',
+            report: 'AxReport',
+            edt: 'AxEdt',
+            'edt-extension': 'AxEdtExtension',
+            'table-extension': 'AxTableExtension',
+            'form-extension': 'AxFormExtension',
+            'data-entity-extension': 'AxDataEntityViewExtension',
+            'enum-extension': 'AxEnumExtension',
+            'menu-item-display': 'AxMenuItemDisplay',
+            'menu-item-action': 'AxMenuItemAction',
+            'menu-item-output': 'AxMenuItemOutput',
+            'menu-item-display-extension': 'AxMenuItemDisplayExtension',
+            'menu-item-action-extension': 'AxMenuItemActionExtension',
+            'menu-item-output-extension': 'AxMenuItemOutputExtension',
+            menu: 'AxMenu',
+            'menu-extension': 'AxMenuExtension',
+            'security-privilege': 'AxSecurityPrivilege',
+            'security-duty': 'AxSecurityDuty',
+            'security-role': 'AxSecurityRole',
+            'security-duty-extension': 'AxSecurityDutyExtension',
+            'security-role-extension': 'AxSecurityRoleExtension',
+            map: 'AxMap',
+        };
+        const objectFolder = objectFolderMap[args.objectType];
+        if (!objectFolder) {
+            throw new Error(`Unsupported object type: ${args.objectType}`);
+        }
+        // Generate XML content
+        let xmlContent = XmlTemplateGenerator.generate(args.objectType, args.objectName, args.sourceCode, args.properties);
+        // For reports: convert any remaining CDATA <Text> to entity-encoded form.
+        // The generator now emits entity-encoded directly, but guard against xmlContent
+        // passed in pre-generated form with CDATA.
+        if (args.objectType === 'report') {
+            xmlContent = xmlContent.replace(/<Text><!\[CDATA\[([\s\S]*?)\]\]><\/Text>/g, (_m, inner) => `<Text>${inner.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')}</Text>`);
+        }
+        console.error(`[generate_d365fo_xml] Generated XML content: ${xmlContent.length} bytes`);
+        // Construct recommended file path
+        const recommendedPath = `K:\\AosService\\PackagesLocalDirectory\\${modelName}\\${modelName}\\${objectFolder}\\${args.objectName}.xml`;
+        // Return XML content with instructions
+        const instructions = `✅ Generated D365FO ${args.objectType} XML for: ${args.objectName}
+
+📋 Model: ${modelName}
+📁 Recommended path: ${recommendedPath}
+
+⚠️ CRITICAL NEXT STEPS (GitHub Copilot MUST do this):
+
+1. **Create the file** using create_file tool:
+   - Path: ${recommendedPath}
+   - Content: Use the XML content below (between xml markers)
+   - ⚠️ IMPORTANT: D365FO requires UTF-8 with BOM encoding!
+   - VS Code create_file uses UTF-8 without BOM by default, which may cause "unicode substitution character" errors
+
+2. **If you see encoding errors**, manually add UTF-8 BOM:
+   - Open file in hex editor
+   - Ensure first 3 bytes are: EF BB BF (UTF-8 BOM)
+   - Or use d365fo_file(action="create") tool instead (if MCP server runs on local Windows)
+
+3. **Add to Visual Studio project** (.rnrproj):
+   <Content Include="${recommendedPath.replace(/\\/g, '\\\\')}" />
+   
+4. **Build the project** to synchronize with AOT
+
+---
+
+📄 XML Content (copy exactly, do not modify):
+
+\`\`\`xml
+${xmlContent}
+\`\`\`
+
+---
+
+💡 **Alternative:** If MCP server runs on local Windows, use \`d365fo_file(action="create")\` tool instead - it handles UTF-8 BOM automatically and adds to VS project.`;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: instructions,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error(`[generate_d365fo_xml] Error:`, error);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `❌ Error generating D365FO XML:\n\n${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=generateD365Xml.js.map