@xrmforge/typegen 0.7.1 → 0.8.1

package/dist/index.js

@@ -1295,7 +1295,7 @@ var MetadataCache = class {
       log5.info(`Loaded metadata cache: ${data.manifest.entities.length} entities, last refreshed ${data.manifest.lastRefreshed}`);
       return data;
     } catch (error) {
-      if (error.code === "ENOENT") {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
         log5.info("No metadata cache found, will do full refresh");
       } else {
         log5.warn("Failed to read metadata cache, will do full refresh", {
@@ -1367,7 +1367,7 @@ var MetadataCache = class {
       await fs.unlink(this.cacheFilePath);
       log5.info("Metadata cache cleared");
     } catch (error) {
-      if (error.code !== "ENOENT") {
+      if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
         throw error;
       }
     }
@@ -1748,36 +1748,33 @@ function shouldIncludeInEntityInterface(attr) {
 }
 
 // src/generators/activity-party.ts
-function generateActivityPartyInterface(namespace = "XrmForge.Entities") {
+function generateActivityPartyInterface() {
   const lines = [];
-  lines.push(`declare namespace ${namespace} {`);
-  lines.push("");
+  lines.push("/**");
+  lines.push(" * Activity Party - Teilnehmer einer Aktivit\xE4t (E-Mail, Termin, etc.)");
+  lines.push(" * Wird von PartyList-Feldern (to, from, cc, bcc, requiredattendees) referenziert.");
+  lines.push(" * @see https://learn.microsoft.com/en-us/power-apps/developer/data-platform/reference/entities/activityparty");
+  lines.push(" */");
+  lines.push("export interface ActivityParty {");
+  lines.push("  /** Primary key */");
+  lines.push("  activitypartyid?: string;");
+  lines.push("  /** Referenz auf die zugeh\xF6rige Aktivit\xE4t */");
+  lines.push("  _activityid_value?: string;");
+  lines.push("  /** Referenz auf den Teilnehmer (account | contact | systemuser | queue | knowledgearticle) */");
+  lines.push("  _partyid_value?: string;");
   lines.push("  /**");
-  lines.push("   * Activity Party - Teilnehmer einer Aktivit\xE4t (E-Mail, Termin, etc.)");
-  lines.push("   * Wird von PartyList-Feldern (to, from, cc, bcc, requiredattendees) referenziert.");
-  lines.push("   * @see https://learn.microsoft.com/en-us/power-apps/developer/data-platform/reference/entities/activityparty");
+  lines.push("   * Rolle des Teilnehmers:");
+  lines.push("   * 1=Sender, 2=To, 3=CC, 4=BCC, 5=Required Attendee,");
+  lines.push("   * 6=Optional Attendee, 7=Organizer, 8=Regarding, 9=Owner,");
+  lines.push("   * 10=Resource, 11=Customer, 12=Chat Participant, 13=Related");
   lines.push("   */");
-  lines.push("  interface ActivityParty {");
-  lines.push("    /** Primary key */");
-  lines.push("    activitypartyid?: string;");
-  lines.push("    /** Referenz auf die zugeh\xF6rige Aktivit\xE4t */");
-  lines.push("    _activityid_value?: string;");
-  lines.push("    /** Referenz auf den Teilnehmer (account | contact | systemuser | queue | knowledgearticle) */");
-  lines.push("    _partyid_value?: string;");
-  lines.push("    /**");
-  lines.push("     * Rolle des Teilnehmers:");
-  lines.push("     * 1=Sender, 2=To, 3=CC, 4=BCC, 5=Required Attendee,");
-  lines.push("     * 6=Optional Attendee, 7=Organizer, 8=Regarding, 9=Owner,");
-  lines.push("     * 10=Resource, 11=Customer, 12=Chat Participant, 13=Related");
-  lines.push("     */");
-  lines.push("    participationtypemask?: number;");
-  lines.push("    /** E-Mail-Adresse f\xFCr die Zustellung */");
-  lines.push("    addressused?: string;");
-  lines.push("    /** Aufwand des Teilnehmers (bei Serviceterminen) */");
-  lines.push("    effort?: number;");
-  lines.push("    /** Name des Teilnehmers (wenn nicht aufgel\xF6st) */");
-  lines.push("    unresolvedpartyname?: string;");
-  lines.push("  }");
+  lines.push("  participationtypemask?: number;");
+  lines.push("  /** E-Mail-Adresse f\xFCr die Zustellung */");
+  lines.push("  addressused?: string;");
+  lines.push("  /** Aufwand des Teilnehmers (bei Serviceterminen) */");
+  lines.push("  effort?: number;");
+  lines.push("  /** Name des Teilnehmers (wenn nicht aufgel\xF6st) */");
+  lines.push("  unresolvedpartyname?: string;");
   lines.push("}");
   lines.push("");
   return lines.join("\n");
@@ -1824,16 +1821,18 @@ function disambiguateEnumMembers(members) {
 // src/generators/entity-generator.ts
 function generateEntityInterface(info, options = {}) {
   const labelConfig = options.labelConfig || DEFAULT_LABEL_CONFIG;
-  const namespace = options.namespace || "XrmForge.Entities";
   const entityName = toPascalCase(info.entity.LogicalName);
   const entityLabel = getJSDocLabel(info.entity.DisplayName, labelConfig);
   const lines = [];
-  lines.push(`declare namespace ${namespace} {`);
-  lines.push("");
+  const partyListAttrs = info.attributes.filter((a) => isPartyListType(a.AttributeType));
+  if (partyListAttrs.length > 0) {
+    lines.push("import type { ActivityParty } from './_activity-party.js';");
+    lines.push("");
+  }
   if (entityLabel) {
-    lines.push(`  /** ${entityLabel} */`);
+    lines.push(`/** ${entityLabel} */`);
   }
-  lines.push(`  interface ${entityName} {`);
+  lines.push(`export interface ${entityName} {`);
   const includedAttrs = info.attributes.filter(shouldIncludeInEntityInterface).sort((a, b) => a.LogicalName.localeCompare(b.LogicalName));
   const lookupTargets = /* @__PURE__ */ new Map();
   for (const la of info.lookupAttributes) {
@@ -1858,21 +1857,19 @@ function generateEntityInterface(info, options = {}) {
       jsdocParts.push("read-only");
     }
     if (jsdocParts.length > 0) {
-      lines.push(`    /** ${jsdocParts.join(" - ")} */`);
+      lines.push(`  /** ${jsdocParts.join(" - ")} */`);
     }
-    lines.push(`    ${propertyName}: ${tsType} | null;`);
+    lines.push(`  ${propertyName}: ${tsType} | null;`);
   }
-  const partyListAttrs = info.attributes.filter((a) => isPartyListType(a.AttributeType));
   if (partyListAttrs.length > 0) {
     const relationship = info.oneToManyRelationships.find(
       (r) => r.ReferencingEntity === "activityparty"
     );
     const navPropName = relationship ? relationship.SchemaName.charAt(0).toLowerCase() + relationship.SchemaName.slice(1) : `${info.entity.LogicalName}_activity_parties`;
     lines.push("");
-    lines.push(`    /** ActivityParty collection (${partyListAttrs.length} PartyList-Felder: ${partyListAttrs.map((a) => a.LogicalName).join(", ")}) */`);
-    lines.push(`    ${navPropName}: ActivityParty[] | null;`);
+    lines.push(`  /** ActivityParty collection (${partyListAttrs.length} PartyList-Felder: ${partyListAttrs.map((a) => a.LogicalName).join(", ")}) */`);
+    lines.push(`  ${navPropName}: ActivityParty[] | null;`);
   }
-  lines.push("  }");
   lines.push("}");
   lines.push("");
   return lines.join("\n");
@@ -1881,7 +1878,6 @@ function generateEntityInterface(info, options = {}) {
 // src/generators/optionset-generator.ts
 function generateOptionSetEnum(optionSet, _entityLogicalName, attributeSchemaName, options = {}) {
   const labelConfig = options.labelConfig || DEFAULT_LABEL_CONFIG;
-  const namespace = options.namespace || "XrmForge.OptionSets";
   const enumName = optionSet.IsGlobal ? toPascalCase(optionSet.Name) : toPascalCase(attributeSchemaName);
   const rawMembers = optionSet.Options.map((opt) => {
     const label = getPrimaryLabel(opt.Label, labelConfig);
@@ -1897,24 +1893,21 @@ function generateOptionSetEnum(optionSet, _entityLogicalName, attributeSchemaNam
     rawMembers.map((m) => ({ name: m.name, value: m.value }))
   );
   const lines = [];
-  lines.push(`declare namespace ${namespace} {`);
-  lines.push("");
   const enumLabel = getJSDocLabel(optionSet.DisplayName, labelConfig);
   if (enumLabel) {
-    lines.push(`  /** ${enumLabel} (${optionSet.Name}) */`);
+    lines.push(`/** ${enumLabel} (${optionSet.Name}) */`);
   }
-  lines.push(`  const enum ${enumName} {`);
+  lines.push(`export const enum ${enumName} {`);
   for (let i = 0; i < disambiguated.length; i++) {
     const member = disambiguated[i];
     const rawMember = rawMembers[i];
     if (!rawMember) continue;
     const memberLabel = getJSDocLabel(rawMember.option.Label, labelConfig);
     if (memberLabel) {
-      lines.push(`    /** ${memberLabel} */`);
+      lines.push(`  /** ${memberLabel} */`);
     }
-    lines.push(`    ${member.name} = ${member.value},`);
+    lines.push(`  ${member.name} = ${member.value},`);
   }
-  lines.push("  }");
   lines.push("}");
   lines.push("");
   return lines.join("\n");
@@ -1979,9 +1972,7 @@ function labelToPascalMember(label) {
 }
 function generateFormInterface(form, entityLogicalName, attributeMap, options = {}, baseNameOverride) {
   const labelConfig = options.labelConfig || DEFAULT_LABEL_CONFIG;
-  const namespacePrefix = options.namespacePrefix || "XrmForge.Forms";
   const entityPascal = toPascalCase(entityLogicalName);
-  const namespace = `${namespacePrefix}.${entityPascal}`;
   const baseName = baseNameOverride || buildFormBaseName(entityPascal, toSafeFormName(form.name));
   const interfaceName = `${baseName}Form`;
   const fieldsTypeName = `${baseName}FormFields`;
@@ -2021,38 +2012,48 @@ function generateFormInterface(form, entityLogicalName, attributeMap, options =
     });
   }
   const lines = [];
-  lines.push(`declare namespace ${namespace} {`);
-  lines.push("");
-  lines.push(`  /** Valid field names for the "${form.name}" form */`);
-  lines.push(`  type ${fieldsTypeName} =`);
-  for (let i = 0; i < fields.length; i++) {
-    const separator = i === fields.length - 1 ? ";" : "";
-    lines.push(`    | "${fields[i].logicalName}"${separator}`);
+  lines.push(`/** Valid field names for the "${form.name}" form */`);
+  if (fields.length === 0) {
+    lines.push(`export type ${fieldsTypeName} = never;`);
+  } else {
+    lines.push(`export type ${fieldsTypeName} =`);
+    for (let i = 0; i < fields.length; i++) {
+      const separator = i === fields.length - 1 ? ";" : "";
+      lines.push(`  | "${fields[i].logicalName}"${separator}`);
+    }
   }
   lines.push("");
-  lines.push(`  /** Attribute type map for "${form.name}" */`);
-  lines.push(`  type ${attrMapName} = {`);
-  for (const field of fields) {
-    lines.push(`    ${field.logicalName}: ${field.formAttributeType};`);
+  lines.push(`/** Attribute type map for "${form.name}" */`);
+  if (fields.length === 0) {
+    lines.push(`export type ${attrMapName} = Record<string, never>;`);
+  } else {
+    lines.push(`export type ${attrMapName} = {`);
+    for (const field of fields) {
+      lines.push(`  ${field.logicalName}: ${field.formAttributeType};`);
+    }
+    lines.push("};");
   }
-  lines.push("  };");
   lines.push("");
-  lines.push(`  /** Control type map for "${form.name}" */`);
-  lines.push(`  type ${ctrlMapName} = {`);
-  for (const field of fields) {
-    lines.push(`    ${field.logicalName}: ${field.formControlType};`);
+  lines.push(`/** Control type map for "${form.name}" */`);
+  if (fields.length === 0) {
+    lines.push(`export type ${ctrlMapName} = Record<string, never>;`);
+  } else {
+    lines.push(`export type ${ctrlMapName} = {`);
+    for (const field of fields) {
+      lines.push(`  ${field.logicalName}: ${field.formControlType};`);
+    }
+    lines.push("};");
   }
-  lines.push("  };");
   lines.push("");
-  lines.push(`  /** Field constants for "${form.name}" (compile-time only, zero runtime) */`);
-  lines.push(`  const enum ${fieldsTypeName}Enum {`);
+  lines.push(`/** Field constants for "${form.name}" (compile-time only, zero runtime) */`);
+  lines.push(`export const enum ${fieldsTypeName}Enum {`);
   for (const field of fields) {
     if (field.label) {
-      lines.push(`    /** ${field.label} */`);
+      lines.push(`  /** ${field.label} */`);
     }
-    lines.push(`    ${field.enumMemberName} = '${field.logicalName}',`);
+    lines.push(`  ${field.enumMemberName} = '${field.logicalName}',`);
   }
-  lines.push("  }");
+  lines.push("}");
   lines.push("");
   const namedTabs = form.tabs.filter((t) => t.name);
   if (namedTabs.length > 0) {
@@ -2070,16 +2071,16 @@ function generateFormInterface(form, entityLogicalName, attributeMap, options =
       usedTabMembers.add(memberName);
       tabMemberNames.push(memberName);
     }
-    lines.push(`  /** Tab constants for "${form.name}" (compile-time only, zero runtime) */`);
-    lines.push(`  const enum ${tabsEnumName} {`);
+    lines.push(`/** Tab constants for "${form.name}" (compile-time only, zero runtime) */`);
+    lines.push(`export const enum ${tabsEnumName} {`);
     for (let i = 0; i < namedTabs.length; i++) {
       const tab = namedTabs[i];
       if (tab.label) {
-        lines.push(`    /** ${tab.label} */`);
+        lines.push(`  /** ${tab.label} */`);
       }
-      lines.push(`    ${tabMemberNames[i]} = '${tab.name}',`);
+      lines.push(`  ${tabMemberNames[i]} = '${tab.name}',`);
     }
-    lines.push("  }");
+    lines.push("}");
     lines.push("");
     for (let i = 0; i < namedTabs.length; i++) {
       const tab = namedTabs[i];
@@ -2087,12 +2088,12 @@ function generateFormInterface(form, entityLogicalName, attributeMap, options =
       if (namedSections.length === 0) continue;
       const tabMemberName = tabMemberNames[i];
       const sectionsEnumName = `${baseName}Form${tabMemberName}Sections`;
-      lines.push(`  /** Section constants for tab "${tab.name}" (compile-time only, zero runtime) */`);
-      lines.push(`  const enum ${sectionsEnumName} {`);
+      lines.push(`/** Section constants for tab "${tab.name}" (compile-time only, zero runtime) */`);
+      lines.push(`export const enum ${sectionsEnumName} {`);
       const usedSectionMembers = /* @__PURE__ */ new Set();
       for (const section of namedSections) {
         if (section.label) {
-          lines.push(`    /** ${section.label} */`);
+          lines.push(`  /** ${section.label} */`);
         }
         let sectionMember = toSafeFormName(section.name) || toPascalCase(section.name);
         const originalSectionMember = sectionMember;
@@ -2102,9 +2103,9 @@ function generateFormInterface(form, entityLogicalName, attributeMap, options =
           sCounter++;
         }
         usedSectionMembers.add(sectionMember);
-        lines.push(`    ${sectionMember} = '${section.name}',`);
+        lines.push(`  ${sectionMember} = '${section.name}',`);
       }
-      lines.push("  }");
+      lines.push("}");
       lines.push("");
     }
   }
@@ -2113,8 +2114,8 @@ function generateFormInterface(form, entityLogicalName, attributeMap, options =
   const quickViews = specialControls.filter((sc) => sc.controlType === "quickview");
   if (subgrids.length > 0) {
     const subgridsEnumName = `${baseName}FormSubgrids`;
-    lines.push(`  /** Subgrid constants for "${form.name}" (compile-time only, zero runtime) */`);
-    lines.push(`  const enum ${subgridsEnumName} {`);
+    lines.push(`/** Subgrid constants for "${form.name}" (compile-time only, zero runtime) */`);
+    lines.push(`export const enum ${subgridsEnumName} {`);
     const usedMembers = /* @__PURE__ */ new Set();
     for (const sg of subgrids) {
       let member = toSafeFormName(sg.id) || toPascalCase(sg.id);
@@ -2126,16 +2127,16 @@ function generateFormInterface(form, entityLogicalName, attributeMap, options =
       }
       usedMembers.add(member);
       const label = sg.targetEntityType ? `Subgrid: ${sg.targetEntityType}` : `Subgrid`;
-      lines.push(`    /** ${label} */`);
-      lines.push(`    ${member} = '${sg.id}',`);
+      lines.push(`  /** ${label} */`);
+      lines.push(`  ${member} = '${sg.id}',`);
     }
-    lines.push("  }");
+    lines.push("}");
     lines.push("");
   }
   if (quickViews.length > 0) {
     const qvEnumName = `${baseName}FormQuickViews`;
-    lines.push(`  /** Quick View constants for "${form.name}" (compile-time only, zero runtime) */`);
-    lines.push(`  const enum ${qvEnumName} {`);
+    lines.push(`/** Quick View constants for "${form.name}" (compile-time only, zero runtime) */`);
+    lines.push(`export const enum ${qvEnumName} {`);
     const usedMembers = /* @__PURE__ */ new Set();
     for (const qv of quickViews) {
       let member = toSafeFormName(qv.id) || toPascalCase(qv.id);
@@ -2146,66 +2147,65 @@ function generateFormInterface(form, entityLogicalName, attributeMap, options =
         counter++;
       }
       usedMembers.add(member);
-      lines.push(`    /** Quick View */`);
-      lines.push(`    ${member} = '${qv.id}',`);
+      lines.push(`  /** Quick View */`);
+      lines.push(`  ${member} = '${qv.id}',`);
     }
-    lines.push("  }");
+    lines.push("}");
     lines.push("");
   }
-  lines.push(`  /** ${form.name} */`);
-  lines.push(`  interface ${interfaceName} extends Omit<Xrm.FormContext, 'getAttribute' | 'getControl'> {`);
-  lines.push(`    /** Typisierter Feldzugriff: nur Felder die auf diesem Formular existieren */`);
-  lines.push(`    getAttribute<K extends ${fieldsTypeName}>(name: K): ${attrMapName}[K];`);
-  lines.push("    getAttribute(index: number): Xrm.Attributes.Attribute;");
-  lines.push("    getAttribute(): Xrm.Attributes.Attribute[];");
+  lines.push(`/** ${form.name} */`);
+  lines.push(`export interface ${interfaceName} extends Omit<Xrm.FormContext, 'getAttribute' | 'getControl'> {`);
+  lines.push(`  /** Typisierter Feldzugriff: nur Felder die auf diesem Formular existieren */`);
+  lines.push(`  getAttribute<K extends ${fieldsTypeName}>(name: K): ${attrMapName}[K];`);
+  lines.push("  getAttribute(index: number): Xrm.Attributes.Attribute;");
+  lines.push("  getAttribute(): Xrm.Attributes.Attribute[];");
   lines.push("");
-  lines.push(`    /** Typisierter Control-Zugriff: nur Controls die auf diesem Formular existieren */`);
-  lines.push(`    getControl<K extends ${fieldsTypeName}>(name: K): ${ctrlMapName}[K];`);
+  lines.push(`  /** Typisierter Control-Zugriff: nur Controls die auf diesem Formular existieren */`);
+  lines.push(`  getControl<K extends ${fieldsTypeName}>(name: K): ${ctrlMapName}[K];`);
   for (const sc of specialControls) {
     const xrmType = specialControlToXrmType(sc.controlType);
     if (xrmType) {
-      lines.push(`    getControl(name: "${sc.id}"): ${xrmType};`);
+      lines.push(`  getControl(name: "${sc.id}"): ${xrmType};`);
     }
   }
-  lines.push("    getControl(index: number): Xrm.Controls.Control;");
-  lines.push("    getControl(): Xrm.Controls.Control[];");
+  lines.push("  getControl(index: number): Xrm.Controls.Control;");
+  lines.push("  getControl(): Xrm.Controls.Control[];");
   if (form.tabs.length > 0) {
     lines.push("");
-    lines.push("    /** Typisierter Tab-Zugriff */");
-    lines.push("    ui: {");
-    lines.push("      tabs: {");
+    lines.push("  /** Typisierter Tab-Zugriff */");
+    lines.push("  ui: {");
+    lines.push("    tabs: {");
     for (const tab of form.tabs) {
       if (tab.name) {
         const sectionNames = tab.sections.filter((s) => s.name).map((s) => s.name);
         if (sectionNames.length > 0) {
-          lines.push(`        get(name: "${tab.name}"): Xrm.Controls.Tab & {`);
-          lines.push("          sections: {");
+          lines.push(`      get(name: "${tab.name}"): Xrm.Controls.Tab & {`);
+          lines.push("        sections: {");
           for (const sectionName of sectionNames) {
-            lines.push(`            get(name: "${sectionName}"): Xrm.Controls.Section;`);
+            lines.push(`          get(name: "${sectionName}"): Xrm.Controls.Section;`);
           }
-          lines.push("            get(name: string): Xrm.Controls.Section;");
-          lines.push("          };");
+          lines.push("          get(name: string): Xrm.Controls.Section;");
           lines.push("        };");
+          lines.push("      };");
         } else {
-          lines.push(`        get(name: "${tab.name}"): Xrm.Controls.Tab;`);
+          lines.push(`      get(name: "${tab.name}"): Xrm.Controls.Tab;`);
         }
       }
     }
-    lines.push("        get(name: string): Xrm.Controls.Tab;");
-    lines.push("      };");
-    lines.push("    } & Xrm.Ui;");
+    lines.push("      get(name: string): Xrm.Controls.Tab;");
+    lines.push("    };");
+    lines.push("  } & Xrm.Ui;");
   }
-  lines.push("  }");
+  lines.push("}");
   const mockValuesName = `${interfaceName}MockValues`;
   lines.push("");
-  lines.push(`  /** Mock value types for "${form.name}" form (used with @xrmforge/testing) */`);
-  lines.push(`  type ${mockValuesName} = {`);
+  lines.push(`/** Mock value types for "${form.name}" form (used with @xrmforge/testing) */`);
+  lines.push(`export type ${mockValuesName} = {`);
   for (const field of fields) {
     const mockType = getFormMockValueType(field.attributeType);
-    lines.push(`    ${field.logicalName}?: ${mockType};`);
+    lines.push(`  ${field.logicalName}?: ${mockType};`);
   }
-  lines.push("  };");
-  lines.push("}");
+  lines.push("};");
   lines.push("");
   return lines.join("\n");
 }
@@ -2256,15 +2256,12 @@ function labelToPascalMember2(label) {
 }
 function generateEntityFieldsEnum(info, options = {}) {
   const labelConfig = options.labelConfig || DEFAULT_LABEL_CONFIG;
-  const namespace = options.namespace || "XrmForge.Entities";
   const entityName = toPascalCase(info.entity.LogicalName);
   const enumName = `${entityName}Fields`;
   const includedAttrs = info.attributes.filter(shouldIncludeInEntityInterface).sort((a, b) => a.LogicalName.localeCompare(b.LogicalName));
   const lines = [];
-  lines.push(`declare namespace ${namespace} {`);
-  lines.push("");
-  lines.push(`  /** All fields of ${entityName} (for Web API $select queries) */`);
-  lines.push(`  const enum ${enumName} {`);
+  lines.push(`/** All fields of ${entityName} (for Web API $select queries) */`);
+  lines.push(`export const enum ${enumName} {`);
   const usedNames = /* @__PURE__ */ new Set();
   for (const attr of includedAttrs) {
     const isLookup = isLookupType(attr.AttributeType);
@@ -2283,27 +2280,23 @@ function generateEntityFieldsEnum(info, options = {}) {
     usedNames.add(memberName);
     const dualLabel = getJSDocLabel(attr.DisplayName, labelConfig);
     if (dualLabel) {
-      lines.push(`    /** ${dualLabel} */`);
+      lines.push(`  /** ${dualLabel} */`);
     }
-    lines.push(`    ${memberName} = '${propertyName}',`);
+    lines.push(`  ${memberName} = '${propertyName}',`);
   }
-  lines.push("  }");
   lines.push("}");
   lines.push("");
   return lines.join("\n");
 }
 function generateEntityNavigationProperties(info, options = {}) {
   const labelConfig = options.labelConfig || DEFAULT_LABEL_CONFIG;
-  const namespace = options.namespace || "XrmForge.Entities";
   const entityName = toPascalCase(info.entity.LogicalName);
   const enumName = `${entityName}NavigationProperties`;
   const lookupAttrs = info.attributes.filter(shouldIncludeInEntityInterface).filter((a) => isLookupType(a.AttributeType)).sort((a, b) => a.LogicalName.localeCompare(b.LogicalName));
   if (lookupAttrs.length === 0) return "";
   const lines = [];
-  lines.push(`declare namespace ${namespace} {`);
-  lines.push("");
-  lines.push(`  /** Navigation properties of ${entityName} (for parseLookup and $expand) */`);
-  lines.push(`  const enum ${enumName} {`);
+  lines.push(`/** Navigation properties of ${entityName} (for parseLookup and $expand) */`);
+  lines.push(`export const enum ${enumName} {`);
   const usedNames = /* @__PURE__ */ new Set();
   for (const attr of lookupAttrs) {
     const primaryLabel = getPrimaryLabel(attr.DisplayName, labelConfig);
@@ -2320,29 +2313,25 @@ function generateEntityNavigationProperties(info, options = {}) {
     usedNames.add(memberName);
     const dualLabel = getJSDocLabel(attr.DisplayName, labelConfig);
     if (dualLabel) {
-      lines.push(`    /** ${dualLabel} */`);
+      lines.push(`  /** ${dualLabel} */`);
     }
-    lines.push(`    ${memberName} = '${attr.LogicalName}',`);
+    lines.push(`  ${memberName} = '${attr.LogicalName}',`);
   }
-  lines.push("  }");
   lines.push("}");
   lines.push("");
   return lines.join("\n");
 }
 
 // src/generators/entity-names-generator.ts
-function generateEntityNamesEnum(entityNames, options = {}) {
-  const namespace = options.namespace ?? "XrmForge";
+function generateEntityNamesEnum(entityNames, _options = {}) {
   const sorted = [...entityNames].sort();
   const lines = [];
-  lines.push(`declare namespace ${namespace} {`);
-  lines.push("  /** Entity logical names for Xrm.WebApi calls (compile-time only, zero runtime) */");
-  lines.push("  const enum EntityNames {");
+  lines.push("/** Entity logical names for Xrm.WebApi calls (compile-time only, zero runtime) */");
+  lines.push("export const enum EntityNames {");
   for (const name of sorted) {
     const pascal = toPascalCase(name);
-    lines.push(`    ${pascal} = '${name}',`);
+    lines.push(`  ${pascal} = '${name}',`);
   }
-  lines.push("  }");
   lines.push("}");
   lines.push("");
   return lines.join("\n");
@@ -2541,7 +2530,6 @@ function createBoundAction(operationName, entityLogicalName, paramMeta) {
 }
 function createUnboundAction(operationName, paramMeta) {
   return {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- return type varies (Response or parsed JSON)
     async execute(params) {
       const req = buildUnboundRequest(
         operationName,
@@ -2678,46 +2666,42 @@ function deriveActionName(uniquename) {
 function generateParamsInterface(name, params) {
   if (params.length === 0) return "";
   const lines = [];
-  lines.push(`  interface ${name}Params {`);
+  lines.push(`export interface ${name}Params {`);
   for (const param of params) {
     const mapped = mapCustomApiParameterType(param.type, param.logicalentityname);
     const optional = param.isoptional ? "?" : "";
     if (param.description) {
-      lines.push(`    /** ${param.description} */`);
+      lines.push(`  /** ${param.description} */`);
     }
-    lines.push(`    ${param.uniquename}${optional}: ${mapped.tsType};`);
+    lines.push(`  ${param.uniquename}${optional}: ${mapped.tsType};`);
   }
-  lines.push("  }");
+  lines.push("}");
   return lines.join("\n");
 }
 function generateResultInterface(name, props) {
   if (props.length === 0) return "";
   const lines = [];
-  lines.push(`  interface ${name}Result {`);
+  lines.push(`export interface ${name}Result {`);
   for (const prop of props) {
     const mapped = mapCustomApiParameterType(prop.type, prop.logicalentityname);
     if (prop.description) {
-      lines.push(`    /** ${prop.description} */`);
+      lines.push(`  /** ${prop.description} */`);
     }
-    lines.push(`    ${prop.uniquename}: ${mapped.tsType};`);
+    lines.push(`  ${prop.uniquename}: ${mapped.tsType};`);
   }
-  lines.push("  }");
+  lines.push("}");
   return lines.join("\n");
 }
-function generateActionDeclarations(apis, isFunction, entityName, options = {}) {
-  const baseNamespace = isFunction ? options.functionsNamespace || "XrmForge.Functions" : options.actionsNamespace || "XrmForge.Actions";
-  const namespace = entityName ? `${baseNamespace}.${toPascalCase(entityName)}` : baseNamespace;
+function generateActionDeclarations(apis, _isFunction, _entityName, _options = {}) {
   const lines = [];
   lines.push("// Auto-generated by @xrmforge/typegen - DO NOT EDIT");
   lines.push("");
-  lines.push(`declare namespace ${namespace} {`);
   for (const apiInfo of apis) {
     const name = deriveActionName(apiInfo.api.uniquename);
     const hasParams = apiInfo.requestParameters.length > 0;
     const hasResult = apiInfo.responseProperties.length > 0;
-    lines.push("");
     const description = apiInfo.api.description || apiInfo.api.displayname || apiInfo.api.uniquename;
-    lines.push(`  /** ${description} (${apiInfo.api.uniquename}) */`);
+    lines.push(`/** ${description} (${apiInfo.api.uniquename}) */`);
     if (hasParams) {
       lines.push(generateParamsInterface(name, apiInfo.requestParameters));
       lines.push("");
@@ -2726,29 +2710,11 @@ function generateActionDeclarations(apis, isFunction, entityName, options = {})
       lines.push(generateResultInterface(name, apiInfo.responseProperties));
       lines.push("");
     }
-    const importFrom = options.importPath || "@xrmforge/typegen";
-    if (apiInfo.api.bindingtype === 0 /* Global */) {
-      if (hasParams && hasResult) {
-        lines.push(`  const ${name}: import('${importFrom}').UnboundActionWithParamsExecutor<${name}Params, ${name}Result>;`);
-      } else if (hasParams) {
-        lines.push(`  const ${name}: import('${importFrom}').UnboundActionWithParamsExecutor<${name}Params, void>;`);
-      } else {
-        lines.push(`  const ${name}: import('${importFrom}').UnboundActionExecutor;`);
-      }
-    } else {
-      if (hasParams) {
-        lines.push(`  const ${name}: import('${importFrom}').BoundActionWithParamsExecutor<${name}Params>;`);
-      } else {
-        lines.push(`  const ${name}: import('${importFrom}').BoundActionExecutor;`);
-      }
-    }
   }
-  lines.push("}");
-  lines.push("");
   return lines.join("\n");
 }
 function generateActionModule(apis, isFunction, options = {}) {
-  const importPath = options.importPath || "@xrmforge/typegen";
+  const importPath = options.importPath || "@xrmforge/helpers";
   const lines = [];
   lines.push("// Auto-generated by @xrmforge/typegen - DO NOT EDIT");
   lines.push("");
@@ -2773,8 +2739,17 @@ function generateActionModule(apis, isFunction, options = {}) {
   for (const apiInfo of apis) {
     const name = deriveActionName(apiInfo.api.uniquename);
     const hasParams = apiInfo.requestParameters.length > 0;
+    const hasResult = apiInfo.responseProperties.length > 0;
     const description = apiInfo.api.description || apiInfo.api.displayname || apiInfo.api.uniquename;
-    lines.push(`/** ${description} */`);
+    lines.push(`/** ${description} (${apiInfo.api.uniquename}) */`);
+    if (hasParams) {
+      lines.push(generateParamsInterface(name, apiInfo.requestParameters));
+      lines.push("");
+    }
+    if (hasResult) {
+      lines.push(generateResultInterface(name, apiInfo.responseProperties));
+      lines.push("");
+    }
     if (apiInfo.api.bindingtype === 0 /* Global */) {
       if (isFunction) {
         lines.push(`export const ${name} = createUnboundFunction('${apiInfo.api.uniquename}');`);
@@ -2860,10 +2835,10 @@ async function writeAllFiles(outputDir, files) {
 }
 async function deleteOrphanedFiles(outputDir, deletedEntityNames) {
   let deleted = 0;
-  const subdirs = ["entities", "optionsets", "forms"];
+  const subdirs = ["entities", "optionsets", "forms", "fields"];
   for (const entityName of deletedEntityNames) {
     for (const subdir of subdirs) {
-      const filePath = join2(outputDir, subdir, `${entityName}.d.ts`);
+      const filePath = join2(outputDir, subdir, `${entityName}.ts`);
       try {
         await unlink(filePath);
         deleted++;
@@ -2885,29 +2860,49 @@ var GENERATED_HEADER = `// \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
 function addGeneratedHeader(content) {
   return GENERATED_HEADER + content;
 }
+function toImportSpecifier(relativePath) {
+  const withoutExt = relativePath.replace(/\.ts$/, "");
+  return `./${withoutExt}.js`;
+}
 function generateBarrelIndex(files) {
   const lines = [GENERATED_HEADER];
   const entities = files.filter((f) => f.type === "entity");
   const optionsets = files.filter((f) => f.type === "optionset");
   const forms = files.filter((f) => f.type === "form");
+  const fields = files.filter((f) => f.type === "fields");
+  const actions = files.filter((f) => f.type === "action");
   if (entities.length > 0) {
     lines.push("// Entity Interfaces");
     for (const f of entities) {
-      lines.push(`/// <reference path="${f.relativePath}" />`);
+      lines.push(`export * from '${toImportSpecifier(f.relativePath)}';`);
     }
     lines.push("");
   }
   if (optionsets.length > 0) {
-    lines.push("// OptionSet Enums");
+    lines.push("// OptionSet Enums - import directly from individual files to avoid name conflicts:");
     for (const f of optionsets) {
-      lines.push(`/// <reference path="${f.relativePath}" />`);
+      lines.push(`//   import { ... } from '${toImportSpecifier(f.relativePath)}';`);
     }
     lines.push("");
   }
   if (forms.length > 0) {
     lines.push("// Form Interfaces");
     for (const f of forms) {
-      lines.push(`/// <reference path="${f.relativePath}" />`);
+      lines.push(`export * from '${toImportSpecifier(f.relativePath)}';`);
+    }
+    lines.push("");
+  }
+  if (fields.length > 0) {
+    lines.push("// Entity Fields & Navigation Properties - import directly from individual files to avoid name conflicts:");
+    for (const f of fields) {
+      lines.push(`//   import { ... } from '${toImportSpecifier(f.relativePath)}';`);
+    }
+    lines.push("");
+  }
+  if (actions.length > 0) {
+    lines.push("// Custom API Actions & Functions");
+    for (const f of actions) {
+      lines.push(`export * from '${toImportSpecifier(f.relativePath)}';`);
     }
     lines.push("");
   }
@@ -3024,6 +3019,19 @@ var TypeGenerationOrchestrator = class {
         }
       }
     }
+    if (this.config.generateEntities) {
+      const hasPartyList = Object.values(cachedEntityInfos).some(
+        (info) => info.attributes.some((a) => isPartyListType(a.AttributeType))
+      );
+      if (hasPartyList) {
+        const activityPartyContent = generateActivityPartyInterface();
+        allFiles.push({
+          relativePath: "entities/_activity-party.ts",
+          content: addGeneratedHeader(activityPartyContent),
+          type: "entity"
+        });
+      }
+    }
     this.logger.info(`Generating types for ${this.config.entities.length - failedEntities.size} entities`);
     for (const entityName of this.config.entities) {
       if (signal?.aborted) break;
@@ -3047,11 +3055,9 @@ var TypeGenerationOrchestrator = class {
       allFiles.push(...actionFiles);
     }
     if (this.config.entities.length > 0) {
-      const entityNamesContent = generateEntityNamesEnum(this.config.entities, {
-        namespace: this.config.namespacePrefix
-      });
+      const entityNamesContent = generateEntityNamesEnum(this.config.entities);
       allFiles.push({
-        relativePath: "entity-names.d.ts",
+        relativePath: "entity-names.ts",
         content: addGeneratedHeader(entityNamesContent),
         type: "entity"
       });
@@ -3059,7 +3065,7 @@ var TypeGenerationOrchestrator = class {
     if (allFiles.length > 0) {
       const indexContent = generateBarrelIndex(allFiles);
       const indexFile = {
-        relativePath: "index.d.ts",
+        relativePath: "index.ts",
         content: indexContent,
         type: "entity"
       };
@@ -3212,11 +3218,10 @@ var TypeGenerationOrchestrator = class {
     const files = [];
     if (this.config.generateEntities) {
       const entityContent = generateEntityInterface(entityInfo, {
-        labelConfig: this.config.labelConfig,
-        namespace: `${this.config.namespacePrefix}.Entities`
+        labelConfig: this.config.labelConfig
       });
       files.push({
-        relativePath: `entities/${entityName}.d.ts`,
+        relativePath: `entities/${entityName}.ts`,
         content: addGeneratedHeader(entityContent),
         type: "entity"
       });
@@ -3225,13 +3230,12 @@ var TypeGenerationOrchestrator = class {
       const picklistAttrs = this.getPicklistAttributes(entityInfo);
       if (picklistAttrs.length > 0) {
         const optionSets = generateEntityOptionSets(picklistAttrs, entityName, {
-          labelConfig: this.config.labelConfig,
-          namespace: `${this.config.namespacePrefix}.OptionSets`
+          labelConfig: this.config.labelConfig
         });
         if (optionSets.length > 0) {
           const combinedContent = optionSets.map((os) => os.content).join("\n");
           files.push({
-            relativePath: `optionsets/${entityName}.d.ts`,
+            relativePath: `optionsets/${entityName}.ts`,
             content: addGeneratedHeader(combinedContent),
             type: "optionset"
           });
@@ -3247,14 +3251,13 @@ var TypeGenerationOrchestrator = class {
           entityName,
           entityInfo.attributes,
           {
-            labelConfig: this.config.labelConfig,
-            namespacePrefix: `${this.config.namespacePrefix}.Forms`
+            labelConfig: this.config.labelConfig
           }
         );
         if (formResults.length > 0) {
           const combinedContent = formResults.map((f) => f.content).join("\n");
           files.push({
-            relativePath: `forms/${entityName}.d.ts`,
+            relativePath: `forms/${entityName}.ts`,
             content: addGeneratedHeader(combinedContent),
             type: "form"
           });
@@ -3263,6 +3266,21 @@ var TypeGenerationOrchestrator = class {
         warnings.push(`No forms found for ${entityName}`);
       }
     }
+    if (this.config.generateEntities) {
+      const fieldsEnumContent = generateEntityFieldsEnum(entityInfo, {
+        labelConfig: this.config.labelConfig
+      });
+      const navPropsContent = generateEntityNavigationProperties(entityInfo, {
+        labelConfig: this.config.labelConfig
+      });
+      const combinedFieldsContent = navPropsContent ? `${fieldsEnumContent}
+${navPropsContent}` : fieldsEnumContent;
+      files.push({
+        relativePath: `fields/${entityName}.ts`,
+        content: addGeneratedHeader(combinedFieldsContent),
+        type: "fields"
+      });
+    }
     return { entityLogicalName: entityName, files, warnings };
   }
   /**
@@ -3279,20 +3297,16 @@ var TypeGenerationOrchestrator = class {
       this.logger.info(`Filtered Custom APIs by prefix "${this.config.actionsFilter}": ${before} -> ${customApis.length}`);
     }
     if (customApis.length > 0) {
-      const importPath = "@xrmforge/typegen";
+      const importPath = "@xrmforge/helpers";
       const grouped = groupCustomApis(customApis);
       for (const [key, apis] of grouped.actions) {
         const entityName = key === "global" ? void 0 : key;
         const declarations = generateActionDeclarations(apis, false, entityName, { importPath });
         const module = generateActionModule(apis, false, { importPath });
-        files.push({
-          relativePath: `actions/${key}.d.ts`,
-          content: addGeneratedHeader(declarations),
-          type: "action"
-        });
         files.push({
           relativePath: `actions/${key}.ts`,
-          content: addGeneratedHeader(module),
+          content: addGeneratedHeader(`${declarations}
+${module}`),
           type: "action"
         });
       }
@@ -3300,14 +3314,10 @@ var TypeGenerationOrchestrator = class {
         const entityName = key === "global" ? void 0 : key;
         const declarations = generateActionDeclarations(apis, true, entityName, { importPath });
         const module = generateActionModule(apis, true, { importPath });
-        files.push({
-          relativePath: `functions/${key}.d.ts`,
-          content: addGeneratedHeader(declarations),
-          type: "action"
-        });
         files.push({
           relativePath: `functions/${key}.ts`,
-          content: addGeneratedHeader(module),
+          content: addGeneratedHeader(`${declarations}
+${module}`),
           type: "action"
         });
       }