☰

Microsoft Power Platform/Dynamics 365 CE - Generate TypeScript Definitions

Automatically creates TypeScript type definitions compatible with @types/xrm by extracting form attributes and controls from Dynamics 365/Power Platform model-driven applications.

当前为 2025-04-09 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name         Microsoft Power Platform/Dynamics 365 CE - Generate TypeScript Definitions
  3. // @namespace    https://github.com/gncnpk/xrm-generate-ts-overloads
  4. // @author       Gavin Canon-Phratsachack (https://github.com/gncnpk)
  5. // @version      1.984
  6. // @license      GPL-3.0
  7. // @description  Automatically creates TypeScript type definitions compatible with @types/xrm by extracting form attributes and controls from Dynamics 365/Power Platform model-driven applications.
  8. // @match        https://*.dynamics.com/main.aspx?appid=*&pagetype=entityrecord&etn=*&id=*
  9. // @grant        none
  10. // ==/UserScript==
  11.  
  12. (function () {
  13.   "use strict";
  14.  
  15.   const groupItemsByType = (items) => {
  16.     return Object.entries(items).reduce((acc, [itemName, itemType]) => {
  17.         if (!acc[itemType]) {
  18.             acc[itemType] = [];
  19.         }
  20.         acc[itemType].push(itemName);
  21.         return acc;
  22.     }, {});
  23. };
  24.   // Create a button element and style it to be fixed in the bottom-right corner.
  25.   const btn = document.createElement("button");
  26.   btn.textContent = "Generate TypeScript Definitions";
  27.   btn.style.position = "fixed";
  28.   btn.style.bottom = "20px";
  29.   btn.style.right = "20px";
  30.   btn.style.padding = "10px";
  31.   btn.style.backgroundColor = "#007ACC";
  32.   btn.style.color = "#fff";
  33.   btn.style.border = "none";
  34.   btn.style.borderRadius = "5px";
  35.   btn.style.cursor = "pointer";
  36.   btn.style.zIndex = 10000;
  37.   document.body.appendChild(btn);
  38.  
  39.   btn.addEventListener("click", () => {
  40.     // Mapping objects for Xrm attribute and control types.
  41.     var attributeTypeMapping = {
  42.       boolean: "Xrm.Attributes.BooleanAttribute",
  43.       datetime: "Xrm.Attributes.DateAttribute",
  44.       decimal: "Xrm.Attributes.NumberAttribute",
  45.       double: "Xrm.Attributes.NumberAttribute",
  46.       integer: "Xrm.Attributes.NumberAttribute",
  47.       lookup: "Xrm.Attributes.LookupAttribute",
  48.       memo: "Xrm.Attributes.StringAttribute",
  49.       money: "Xrm.Attributes.NumberAttribute",
  50.       multiselectoptionset: "Xrm.Attributes.MultiselectOptionSetAttribute",
  51.       optionset: "Xrm.Attributes.OptionSetAttribute",
  52.       string: "Xrm.Attributes.StringAttribute",
  53.     };
  54.  
  55.     var controlTypeMapping = {
  56.       standard: "Xrm.Controls.StandardControl",
  57.       iframe: "Xrm.Controls.IframeControl",
  58.       lookup: "Xrm.Controls.LookupControl",
  59.       optionset: "Xrm.Controls.OptionSetControl",
  60.       "customsubgrid:MscrmControls.Grid.GridControl":
  61.         "Xrm.Controls.GridControl",
  62.       subgrid: "Xrm.Controls.GridControl",
  63.       timelinewall: "Xrm.Controls.TimelineWall",
  64.       quickform: "Xrm.Controls.QuickFormControl",
  65.     };
  66.  
  67.     var specificControlTypeMapping = {
  68.       boolean: "Xrm.Controls.BooleanControl",
  69.       datetime: "Xrm.Controls.DateControl",
  70.       decimal: "Xrm.Controls.NumberControl",
  71.       double: "Xrm.Controls.NumberControl",
  72.       integer: "Xrm.Controls.NumberControl",
  73.       lookup: "Xrm.Controls.LookupControl",
  74.       memo: "Xrm.Controls.StringControl",
  75.       money: "Xrm.Controls.NumberControl",
  76.       multiselectoptionset: "Xrm.Controls.MultiselectOptionSetControl",
  77.       optionset: "Xrm.Controls.OptionSetControl",
  78.       string: "Xrm.Controls.StringControl",
  79.     };
  80.  
  81.     // Object to hold the type information.
  82.     const typeInfo = {
  83.       subGrids: {},
  84.       quickViews: {},
  85.       formAttributes: {},
  86.       formControls: {},
  87.       possibleEnums: [],
  88.       formTabs: {},
  89.       formEnums: {},
  90.       quickViewControls: {},
  91.       quickViewAttributes: {}
  92.     };
  93.     class Subgrid {
  94.       constructor() {
  95.         this.attributes = {};
  96.         this.enums = {};
  97.       }
  98.     }
  99.     class QuickForm {
  100.       constructor() {
  101.         this.attributes = {};
  102.         this.controls = {};
  103.         this.enums = {};
  104.       }
  105.     }
  106.  
  107.     class Tab {
  108.       constructor() {
  109.         this.sections = {};
  110.       }
  111.     }
  112.  
  113.     const currentFormName = Xrm.Page.ui.formSelector
  114.       .getCurrentItem()
  115.       .getLabel();
  116.  
  117.     // Loop through all controls on the form.
  118.     if (
  119.       typeof Xrm !== "undefined" &&
  120.       Xrm.Page &&
  121.       typeof Xrm.Page.getControl === "function"
  122.     ) {
  123.       Xrm.Page.getControl().forEach((ctrl) => {
  124.         const ctrlType = ctrl.getControlType();
  125.         const mappedType = controlTypeMapping[ctrlType];
  126.         if (mappedType) {
  127.           typeInfo.formControls[ctrl.getName()] = mappedType;
  128.         }
  129.       });
  130.     } else {
  131.       alert("Xrm.Page is not available on this page.");
  132.       return;
  133.     }
  134.  
  135.     // Loop through all tabs and sections on the form.
  136.     if (typeof Xrm.Page.ui.tabs.get === "function") {
  137.       Xrm.Page.ui.tabs.get().forEach((tab) => {
  138.         let formTab = (typeInfo.formTabs[tab.getName()] = new Tab());
  139.         tab.sections.forEach((section) => {
  140.           formTab.sections[section.getName()] = `${section.getName()}_section`;
  141.         });
  142.       });
  143.     }
  144.  
  145.     // Loop through all attributes on the form.
  146.     if (typeof Xrm.Page.getAttribute === "function") {
  147.       Xrm.Page.getAttribute().forEach((attr) => {
  148.         const attrType = attr.getAttributeType();
  149.         const attrName = attr.getName();
  150.         const mappedType = attributeTypeMapping[attrType];
  151.         const mappedControlType = specificControlTypeMapping[attrType];
  152.         if (mappedType) {
  153.           typeInfo.formAttributes[attrName] = mappedType;
  154.           attr.controls.forEach((ctrl) => {
  155.             typeInfo.formControls[ctrl.getName()] = mappedControlType;
  156.           });
  157.         }
  158.         if (
  159.           attr.getAttributeType() === "optionset" &&
  160.           attr.controls.get().length > 0
  161.         ) {
  162.           const enumValues = attr.getOptions();
  163.           if (enumValues) {
  164.             typeInfo.formEnums[attrName] = { attribute: "", values: [] };
  165.             typeInfo.formEnums[attrName].values = enumValues;
  166.             typeInfo.formEnums[attrName].attribute = attrName;
  167.             typeInfo.formAttributes[attrName] = `${attrName}_attribute`;
  168.           }
  169.         }
  170.       });
  171.     }
  172.  
  173.     // Loop through all subgrids on the form.
  174.     if (typeof Xrm.Page.getControl === "function") {
  175.       Xrm.Page.getControl().forEach((ctrl) => {
  176.         if (
  177.           ctrl.getControlType() === "subgrid" ||
  178.           ctrl.getControlType() ===
  179.             "customsubgrid:MscrmControls.Grid.GridControl"
  180.         ) {
  181.           const gridRow = ctrl.getGrid().getRows().get(0);
  182.           const gridName = ctrl.getName();
  183.           let subgrid = (typeInfo.subGrids[gridName] = new Subgrid());
  184.           typeInfo.formControls[gridName] = `${gridName}_gridcontrol`;
  185.           if (gridRow !== null) {
  186.             gridRow.data.entity.attributes.forEach((attr) => {
  187.               const attrType = attr.getAttributeType();
  188.               const attrName = attr.getName();
  189.               const mappedType = attributeTypeMapping[attrType];
  190.               if (mappedType) {
  191.                 subgrid.attributes[attrName] = mappedType;
  192.               }
  193.               if (
  194.                 attr.getAttributeType() === "optionset" &&
  195.                 attr.controls.get().length > 0
  196.               ) {
  197.                 const enumValues = attr.getOptions();
  198.                 if (enumValues) {
  199.                   subgrid.enums[attrName] = { attribute: "", values: [] };
  200.                   subgrid.enums[attrName].values = enumValues;
  201.                   subgrid.enums[attrName].attribute = attrName;
  202.                   subgrid.attributes[attrName] = `${attrName}_attribute`;
  203.                 }
  204.               }
  205.             });
  206.           }
  207.         }
  208.       });
  209.     }
  210.  
  211.     // Loop through all Quick View controls and attributes on the form.
  212.     if (typeof Xrm.Page.ui.quickForms.get === "function") {
  213.       Xrm.Page.ui.quickForms.get().forEach((ctrl) => {
  214.         const quickViewName = ctrl.getName();
  215.         let quickView = (typeInfo.quickViews[quickViewName] = new QuickForm());
  216.         const ctrlType = ctrl.getControlType();
  217.         typeInfo.formControls[
  218.           quickViewName
  219.         ] = `${quickViewName}_quickformcontrol`;
  220.         ctrl.getControl().forEach((subCtrl) => {
  221.           if (typeof subCtrl.getAttribute !== "function") {
  222.             return;
  223.           }
  224.           const subCtrlAttrType = subCtrl.getAttribute().getAttributeType();
  225.           const mappedControlType =
  226.             specificControlTypeMapping[subCtrlAttrType] ??
  227.             controlTypeMapping[subCtrl.getControlType()];
  228.           if (mappedControlType) {
  229.             quickView.controls[subCtrl.getName()] = mappedControlType;
  230.           }
  231.         });
  232.         ctrl.getAttribute().forEach((attr) => {
  233.           const attrType = attr.getAttributeType();
  234.           const attrName = attr.getName();
  235.           const mappedType = attributeTypeMapping[attrType];
  236.           if (mappedType) {
  237.             quickView.attributes[attrName] = mappedType;
  238.           }
  239.           if (attrType === "optionset" && attr.controls.get().length > 0) {
  240.             const enumValues = attr.getOptions();
  241.             if (enumValues) {
  242.               quickView.enums[attrName] = { attribute: "", values: [] };
  243.               quickView.enums[attrName].values = enumValues;
  244.               quickView.enums[attrName].attribute = attrName;
  245.               quickView.attributes[attrName] = `${attrName}_attribute`;
  246.             }
  247.           }
  248.         });
  249.       });
  250.     }
  251.  
  252.     // Build the TypeScript overload string.
  253.     let outputTS = `// These TypeScript definitions were generated automatically on: ${new Date().toDateString()}\n`;
  254.     for (const [originalEnumName, enumValues] of Object.entries(
  255.       typeInfo.formEnums
  256.     )) {
  257.       if (typeInfo.possibleEnums.includes(originalEnumName)) {
  258.         continue;
  259.       }
  260.       typeInfo.possibleEnums.push(originalEnumName);
  261.       let enumName = `${originalEnumName}_enum`;
  262.       let enumTemplate = [];
  263.       let textLiteralTypes = [];
  264.       let valueLiteralTypes = [];
  265.       for (const enumValue of enumValues.values) {
  266.         enumTemplate.push(
  267.           `   ${enumValue.text.replace(/\W/g, "").replace(/[0-9]/g, "")} = ${
  268.             enumValue.value
  269.           }`
  270.         );
  271.         textLiteralTypes.push(`"${enumValue.text}"`);
  272.         valueLiteralTypes.push(
  273.           `${enumName}.${enumValue.text
  274.             .replace(/\W/g, "")
  275.             .replace(/[0-9]/g, "")}`
  276.         );
  277.       }
  278.       outputTS += `
  279. const enum ${enumName} {
  280. ${enumTemplate.join(",\n")}
  281. }
  282. `;
  283.       outputTS += `
  284. interface ${enumValues.attribute}_value extends Xrm.OptionSetValue {
  285. text: ${textLiteralTypes.join(" | ")};
  286. value: ${valueLiteralTypes.join(" | ")};  
  287. }
  288. `;
  289.       outputTS += `
  290. interface ${enumValues.attribute}_attribute extends Xrm.Attributes.OptionSetAttribute<${enumName}> {
  291.    `
  292.       valueLiteralTypes.forEach((value, index) => { 
  293.         outputTS+= `getOption(value: ${value}): {text: ${textLiteralTypes[index]}, value: ${value}};\n`;
  294.       })
  295.   outputTS+=`getOption(value: ${enumValues.attribute}_value['value']): ${enumValues.attribute}_value | null;
  296.   getOptions(): ${enumValues.attribute}_value[];
  297.   getSelectedOption(): ${enumValues.attribute}_value | null;
  298.   getValue(): ${enumName} | null;
  299.   setValue(value: ${enumName} | null): void;
  300.   getText(): ${enumValues.attribute}_value['text'] | null;
  301. }
  302. `;
  303.     }
  304.     for (const [subgridName, subgrid] of Object.entries(typeInfo.subGrids)) {
  305.       for (const [enumName, enumValues] of Object.entries(subgrid.enums)) {
  306.         if (typeInfo.possibleEnums.includes(enumName)) {
  307.           continue;
  308.         }
  309.         typeInfo.possibleEnums.push(enumName);
  310.         let enumTemplate = [];
  311.         let textLiteralTypes = [];
  312.         let valueLiteralTypes = [];
  313.         for (const enumValue of enumValues.values) {
  314.           enumTemplate.push(
  315.             `   ${enumValue.text.replace(/\W/g, "").replace(/[0-9]/g, "")} = ${
  316.               enumValue.value
  317.             }`
  318.           );
  319.           textLiteralTypes.push(`"${enumValue.text}"`);
  320.           valueLiteralTypes.push(
  321.             `${enumName}_enum.${enumValue.text
  322.               .replace(/\W/g, "")
  323.               .replace(/[0-9]/g, "")}`
  324.           );
  325.         }
  326.         outputTS += `
  327. const enum ${enumName}_enum {
  328. ${enumTemplate.join(",\n")}
  329. }
  330. `;
  331.         outputTS += `
  332. interface ${enumValues.attribute}_value extends Xrm.OptionSetValue {
  333. text: ${textLiteralTypes.join(" | ")};
  334. value: ${valueLiteralTypes.join(" | ")};
  335.   }
  336. `;
  337.         outputTS += `
  338. interface ${enumValues.attribute}_attribute extends Xrm.Attributes.OptionSetAttribute<${enumName}_enum> {
  339. `
  340.       valueLiteralTypes.forEach((value, index) => { 
  341.         outputTS+= `getOption(value: ${value}): {text: ${textLiteralTypes[index]}, value: ${value}};\n`;
  342.       })
  343.   outputTS+=`
  344.   getOption(value: ${enumValues.attribute}_value['value']): ${enumValues.attribute}_value | null;
  345.   getOptions(): ${enumValues.attribute}_value[];
  346.   getSelectedOption(): ${enumValues.attribute}_value | null;
  347.   getValue(): ${enumName}_enum | null;
  348.   setValue(value: ${enumName}_enum | null): void;
  349.   getText(): ${enumValues.attribute}_value['text'] | null;
  350.   }
  351.   `;
  352.       }
  353.  
  354.       outputTS += `
  355.   interface ${subgridName}_attributes extends Xrm.Collection.ItemCollection<${new Set(
  356.         Object.values(subgrid.attributes)
  357.       )
  358.         .map((attrType) => `${attrType}`)
  359.         .join(" | ")}> {`;
  360.         for (const [attrType, attrNames] of Object.entries(
  361.           groupItemsByType(subgrid.attributes)
  362.         )) {
  363.           outputTS += `get(itemName: "${attrNames.join("\" | \"")}"): ${attrType};\n`;
  364.         }
  365.       outputTS += `}
  366.   `;
  367.  
  368.       outputTS += `
  369.  
  370.   interface ${subgridName}_entity extends Xrm.Entity {
  371.     attributes: ${subgridName}_attributes;
  372.   }
  373.   interface ${subgridName}_data extends Xrm.Data {
  374.     entity: ${subgridName}_entity;
  375.   }
  376.   
  377.   interface ${subgridName}_gridrow extends Xrm.Controls.Grid.GridRow {
  378.     data: ${subgridName}_data;
  379.   }
  380.   
  381.   interface ${subgridName}_grid extends Xrm.Controls.Grid {
  382.     getRows(): Xrm.Collection.ItemCollection<${subgridName}_gridrow>;
  383.   }
  384.   
  385.   interface ${subgridName}_gridcontrol extends Xrm.Controls.GridControl {
  386.     getGrid(): ${subgridName}_grid;
  387.   }
  388.   interface ${subgridName}_context extends Xrm.FormContext {`;
  389.   for (const [attrType, attrNames] of Object.entries(
  390.     groupItemsByType(subgrid.attributes)
  391.   )) {
  392.     outputTS += `getAttribute(attributeName: "${attrNames.join("\" | \"")}"): ${attrType};\n`;
  393.   }
  394.     outputTS += `getAttribute(attributeNameOrIndex: string | number): ${subgridName}_attributes | null;`
  395.       outputTS += `getAttribute(delegateFunction?): ${subgridName}_attributes[];`;
  396.       outputTS += `
  397.   }
  398.   `;
  399.       outputTS += `
  400.   interface ${subgridName}_eventcontext extends Xrm.Events.EventContext {
  401.     getFormContext(): ${subgridName}_context;
  402. }`;
  403.     }
  404.     for (const [quickViewName, quickView] of Object.entries(
  405.       typeInfo.quickViews
  406.     )) {
  407.       for (const [enumName, enumValues] of Object.entries(quickView.enums)) {
  408.         if (typeInfo.possibleEnums.includes(enumName)) {
  409.           continue;
  410.         }
  411.         typeInfo.possibleEnums.push(enumName);
  412.         let enumTemplate = [];
  413.         let textLiteralTypes = [];
  414.         let valueLiteralTypes = [];
  415.         for (const enumValue of enumValues.values) {
  416.           enumTemplate.push(
  417.             `   ${enumValue.text.replace(/\W/g, "").replace(/[0-9]/g, "")} = ${
  418.               enumValue.value
  419.             }`
  420.           );
  421.           textLiteralTypes.push(`"${enumValue.text}"`);
  422.           valueLiteralTypes.push(
  423.             `${enumName}_enum.${enumValue.text
  424.               .replace(/\W/g, "")
  425.               .replace(/[0-9]/g, "")}`
  426.           );
  427.         }
  428.         outputTS += `
  429. const enum ${enumName}_enum {
  430. ${enumTemplate.join(",\n")}
  431.       }
  432. `;
  433.         outputTS += `
  434. interface ${enumValues.attribute}_value extends Xrm.OptionSetValue {
  435. text: ${textLiteralTypes.join(" | ")};
  436. value: ${valueLiteralTypes.join(" | ")};
  437.       }
  438. `;
  439.         outputTS += `
  440. interface ${enumValues.attribute}_attribute extends Xrm.Attributes.OptionSetAttribute<${enumName}_enum> {
  441. `
  442.       valueLiteralTypes.forEach((value, index) => { 
  443.         outputTS+= `getOption(value: ${value}): {text: ${textLiteralTypes[index]}, value: ${value}};\n`;
  444.       })
  445.   outputTS+=`
  446.   getOption(value: ${enumValues.attribute}_value['value']): ${enumValues.attribute}_value | null;
  447.   getOptions(): ${enumValues.attribute}_value[];
  448.   getSelectedOption(): ${enumValues.attribute}_value | null;
  449.   getValue(): ${enumName}_enum | null;
  450.   setValue(value: ${enumName}_enum | null): void;
  451.   getText(): ${enumValues.attribute}_value['text'] | null;
  452.       }
  453.   `;
  454.       }
  455.       outputTS += `type ${quickViewName}_controls_types = ${new Set(
  456.         Object.values(quickView.controls)
  457.       )
  458.         .map((controlType) => `${controlType}`)
  459.         .join(" | ")}\n`;
  460.       outputTS += `
  461.   type ${quickViewName}_attributes_types = ${new Set(
  462.         Object.values(quickView.attributes)
  463.       )
  464.         .map((attrType) => `${attrType}`)
  465.         .join(" | ")}\n`;
  466.         outputTS += `type ${quickViewName}_controls_literals = ${new Set(
  467.           Object.keys(quickView.controls)
  468.         )
  469.           .map((controlName) => `"${controlName}"`)
  470.           .join(" | ")}\n`;
  471.         outputTS += `
  472.     type ${quickViewName}_attributes_literals = ${new Set(
  473.           Object.keys(quickView.attributes)
  474.         )
  475.           .map((attrName) => `"${attrName}"`)
  476.           .join(" | ")}\n`;
  477.   
  478.       outputTS += `
  479.   interface ${quickViewName}_quickformcontrol extends Xrm.Controls.QuickFormControl {
  480.     `;
  481.       for (const [controlType, controlNames] of Object.entries(
  482.         groupItemsByType(quickView.controls)
  483.       )) {
  484.         outputTS += `getControl(controlName: "${controlNames.join("\" | \"")}"): ${controlType};\n`;
  485.       }
  486.       outputTS += `
  487.     getControl(): ${quickViewName}_controls_types[]
  488.     getControl(controlNameOrIndex: string | number): ${quickViewName}_controls_types | null;
  489.     `;
  490.     for (const [attrType, attrNames] of Object.entries(
  491.       groupItemsByType(quickView.attributes)
  492.     )) {
  493.       outputTS += `getAttribute(attributeName: "${attrNames.join("\" | \"")}"): ${attrType};\n`;
  494.     }
  495.       outputTS += `
  496.       getAttribute(attributeNameOrIndex: string | number): ${quickViewName}_attributes_types | null;
  497.     getAttribute(): ${quickViewName}_attributes_types[];
  498.   
  499.   }`;
  500.     }
  501.     for (const [tabName, tab] of Object.entries(typeInfo.formTabs)) {
  502.       outputTS += `
  503. interface ${tabName}_sections extends Xrm.Collection.ItemCollection<Xrm.Controls.Section> {`;
  504.         outputTS += `get(itemName:"${Object.keys(tab.sections).join("\" | \"")}"): Xrm.Controls.Section;\n`;
  505.       
  506.       outputTS += `}`;
  507.  
  508.       outputTS += `
  509. interface ${tabName}_tab extends Xrm.Controls.Tab {
  510.   sections: ${tabName}_sections;
  511.     }`;
  512.     }
  513.     outputTS += `
  514. interface ${currentFormName}_tabs extends Xrm.Collection.ItemCollection<${new Set(
  515.       Object.keys(typeInfo.formTabs)
  516.     )
  517.       .map((tabName) => `${tabName}_tab`)
  518.       .join(" | ")}> {`;
  519.     for (const [itemName, itemType] of Object.entries(typeInfo.formTabs)) {
  520.       outputTS += `get(itemName:"${itemName}"): ${itemName}_tab;\n`;
  521.     }
  522.     outputTS += `}`;
  523.     outputTS += `
  524. interface ${currentFormName}_quickforms extends Xrm.Collection.ItemCollection<${new Set(
  525.       Object.keys(typeInfo.quickViews)
  526.     )
  527.       .map((quickViewName) => `${quickViewName}_quickformcontrol`)
  528.       .join(" | ")}> {`;
  529.     for (const [itemName, itemType] of Object.entries(typeInfo.quickViews)) {
  530.       outputTS += `get(itemName:"${itemName}"): ${itemName}_quickformcontrol;\n`;
  531.     }
  532.     outputTS += `}`;
  533.     outputTS += `
  534.     type ${currentFormName}_attributes_types = ${new Set(
  535.       Object.values(typeInfo.formAttributes)
  536.     )
  537.       .map((attrType) => `${attrType}`)
  538.       .join(" | ")}\n`;
  539.     outputTS += `
  540.     type ${currentFormName}_attributes_literals = ${new Set(
  541.       Object.keys(typeInfo.formAttributes)
  542.     )
  543.       .map((attrName) => `"${attrName}"`)
  544.       .join(" | ")}\n`;
  545.       
  546.     outputTS += `
  547.     type ${currentFormName}_controls_types = ${new Set(
  548.       Object.values(typeInfo.formControls)
  549.     )
  550.       .map((ctrlType) => `${ctrlType}`)
  551.       .join(" | ")}\n`
  552.     outputTS += `
  553.     type ${currentFormName}_controls_literals = ${new Set(
  554.       Object.keys(typeInfo.formControls)
  555.     )
  556.       .map((ctrlName) => `"${ctrlName}"`)
  557.       .join(" | ")}\n`;
  558.     outputTS += `
  559.     interface ${currentFormName}_ui extends Xrm.Ui {
  560.       quickForms: ${currentFormName}_quickforms | null;
  561.       tabs: ${currentFormName}_tabs;
  562.  
  563.     }
  564.     `;
  565.     outputTS += `
  566.     interface ${currentFormName}_context extends Xrm.FormContext {
  567.     ui: ${currentFormName}_ui;
  568.   `;
  569.   for (const [controlType, controlNames] of Object.entries(
  570.     groupItemsByType(typeInfo.formControls)
  571.   )) {
  572.     outputTS += `getControl(controlName: "${controlNames.join("\" | \"")}"): ${controlType};\n`;
  573.   }
  574.     outputTS += `
  575.     getControl(controlNameOrIndex: string | number): ${currentFormName}_controls_types | null;
  576.     getControl(delegateFunction?): ${currentFormName}_controls_types[];
  577.     `
  578.     for (const [attrType, attrNames] of Object.entries(
  579.       groupItemsByType(typeInfo.formAttributes)
  580.     )) {
  581.       outputTS += `getAttribute(attributeName: "${attrNames.join("\" | \"")}"): ${attrType};\n`;
  582.     }
  583.     outputTS += `
  584.     getAttribute(attributeNameOrIndex: string | number): ${currentFormName}_attributes_types | null;
  585.     getAttribute(delegateFunction?): ${currentFormName}_attributes_types[];
  586.   }`;
  587.     outputTS += `
  588.   interface ${currentFormName}_eventcontext extends Xrm.Events.EventContext {
  589.     getFormContext(): ${currentFormName}_context;
  590. }`;
  591.  
  592.     // Create a new window with a textarea showing the output.
  593.     // The textarea is set to readonly to prevent editing.
  594.     const w = window.open(
  595.       "",
  596.       "_blank",
  597.       "width=600,height=400,menubar=no,toolbar=no,location=no,resizable=yes"
  598.     );
  599.     if (w) {
  600.       w.document.write(
  601.         "<html><head><title>TypeScript Definitions</title></head><body>"
  602.       );
  603.       w.document.write(
  604.         '<textarea readonly style="width:100%; height:90%;">' +
  605.           outputTS +
  606.           "</textarea>"
  607.       );
  608.       w.document.write("</body></html>");
  609.       w.document.close();
  610.     } else {
  611.       // Fallback to prompt if popups are blocked.
  612.       prompt("Copy the TypeScript definition:", outputTS);
  613.     }
  614.   });
  615. })();