@xrmforge/typegen 0.1.0 → 0.3.0

package/dist/index.js

@@ -1155,6 +1155,73 @@ var MetadataClient = class {
     log4.info(`Fetching type info for ${logicalNames.length} entities`);
     return Promise.all(logicalNames.map((name) => this.getEntityTypeInfo(name)));
   }
+  // ─── Custom API Metadata ───────────────────────────────────────────────
+  /**
+   * Fetch all Custom APIs with their request parameters and response properties.
+   *
+   * Queries the customapi, customapirequestparameter, and customapiresponseproperty
+   * tables and joins them into CustomApiTypeInfo objects.
+   *
+   * @param solutionFilter - Optional: filter by solution unique name
+   * @returns Array of complete Custom API definitions
+   */
+  async getCustomApis(solutionFilter) {
+    log4.info("Fetching Custom APIs...");
+    let apiUrl = "/customapis?$select=uniquename,bindingtype,isfunction,boundentitylogicalname,displayname,description";
+    if (solutionFilter) {
+      const safeSolution = DataverseHttpClient.sanitizeIdentifier(solutionFilter);
+      apiUrl += `&$filter=solutionid/uniquename eq '${safeSolution}'`;
+    }
+    const apis = await this.http.get(apiUrl);
+    log4.info(`Found ${apis.value.length} Custom APIs`);
+    if (apis.value.length === 0) return [];
+    const params = await this.http.get(
+      "/customapirequestparameters?$select=uniquename,type,isoptional,logicalentityname,description,_customapiid_value"
+    );
+    const props = await this.http.get(
+      "/customapiresponseproperties?$select=uniquename,type,logicalentityname,description,_customapiid_value"
+    );
+    const paramsByApi = /* @__PURE__ */ new Map();
+    for (const p of params.value) {
+      const apiId = p._customapiid_value;
+      if (!paramsByApi.has(apiId)) paramsByApi.set(apiId, []);
+      paramsByApi.get(apiId).push({
+        uniquename: p.uniquename,
+        type: p.type,
+        isoptional: p.isoptional,
+        logicalentityname: p.logicalentityname,
+        description: p.description
+      });
+    }
+    const propsByApi = /* @__PURE__ */ new Map();
+    for (const p of props.value) {
+      const apiId = p._customapiid_value;
+      if (!propsByApi.has(apiId)) propsByApi.set(apiId, []);
+      propsByApi.get(apiId).push({
+        uniquename: p.uniquename,
+        type: p.type,
+        logicalentityname: p.logicalentityname,
+        description: p.description
+      });
+    }
+    const result = [];
+    for (const api of apis.value) {
+      result.push({
+        api: {
+          uniquename: api.uniquename,
+          bindingtype: api.bindingtype,
+          isfunction: api.isfunction,
+          boundentitylogicalname: api.boundentitylogicalname,
+          displayname: api.displayname,
+          description: api.description
+        },
+        requestParameters: paramsByApi.get(api.customapiid) ?? [],
+        responseProperties: propsByApi.get(api.customapiid) ?? []
+      });
+    }
+    log4.info(`Loaded ${result.length} Custom APIs with parameters and response properties`);
+    return result;
+  }
   // ─── Internal Helpers ──────────────────────────────────────────────────
   async getRelationships(logicalName) {
     const [oneToMany, manyToMany] = await Promise.all([
@@ -1487,6 +1554,37 @@ var FORM_CONTROL_TYPE_MAP = {
   Owner: "Xrm.Controls.LookupControl",
   PartyList: "Xrm.Controls.LookupControl"
 };
+function getFormMockValueType(attributeType) {
+  const mapping = FORM_MOCK_VALUE_TYPE_MAP[attributeType];
+  if (mapping) return mapping;
+  return "unknown";
+}
+var FORM_MOCK_VALUE_TYPE_MAP = {
+  // String types
+  String: "string | null",
+  Memo: "string | null",
+  EntityName: "string | null",
+  // Numeric types
+  Integer: "number | null",
+  BigInt: "number | null",
+  Decimal: "number | null",
+  Double: "number | null",
+  Money: "number | null",
+  // Boolean
+  Boolean: "boolean | null",
+  // OptionSet types (numeric values at runtime)
+  Picklist: "number | null",
+  State: "number | null",
+  Status: "number | null",
+  MultiSelectPicklist: "number[] | null",
+  // Date/Time
+  DateTime: "Date | null",
+  // Lookup types
+  Lookup: "Xrm.LookupValue[] | null",
+  Customer: "Xrm.LookupValue[] | null",
+  Owner: "Xrm.LookupValue[] | null",
+  PartyList: "Xrm.LookupValue[] | null"
+};
 function toSafeIdentifier(logicalName) {
   if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(logicalName)) {
     return logicalName;
@@ -1531,6 +1629,42 @@ function shouldIncludeInEntityInterface(attr) {
   return true;
 }
 
+// src/generators/activity-party.ts
+function generateActivityPartyInterface(namespace = "XrmForge.Entities") {
+  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("  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("}");
+  lines.push("");
+  return lines.join("\n");
+}
+
 // src/generators/label-utils.ts
 function getSecondaryLabel(label, config) {
   if (!config.secondaryLanguage) return void 0;
@@ -1901,6 +2035,15 @@ function generateFormInterface(form, entityLogicalName, attributeMap, options =
     lines.push("    } & Xrm.Ui;");
   }
   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} = {`);
+  for (const field of fields) {
+    const mockType = getFormMockValueType(field.attributeType);
+    lines.push(`    ${field.logicalName}?: ${mockType};`);
+  }
+  lines.push("  };");
   lines.push("}");
   lines.push("");
   return lines.join("\n");
@@ -1939,6 +2082,587 @@ function generateEntityForms(forms, entityLogicalName, attributes, options = {})
   return results;
 }
 
+// src/generators/entity-fields-generator.ts
+function labelToPascalMember2(label) {
+  if (!label) return "";
+  const transliterated = transliterateUmlauts(label);
+  const cleaned = transliterated.replace(/[^a-zA-Z0-9\s_]/g, "");
+  const parts = cleaned.split(/[\s_]+/).filter((p) => p.length > 0);
+  if (parts.length === 0) return "";
+  const pascal = parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join("");
+  if (/^\d/.test(pascal)) return `_${pascal}`;
+  return pascal;
+}
+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} {`);
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const attr of includedAttrs) {
+    const isLookup = isLookupType(attr.AttributeType);
+    const propertyName = isLookup ? toLookupValueProperty(attr.LogicalName) : attr.LogicalName;
+    const primaryLabel = getPrimaryLabel(attr.DisplayName, labelConfig);
+    let memberName = labelToPascalMember2(primaryLabel);
+    if (!memberName) {
+      memberName = toPascalCase(attr.LogicalName);
+    }
+    const originalName = memberName;
+    let counter = 2;
+    while (usedNames.has(memberName)) {
+      memberName = `${originalName}${counter}`;
+      counter++;
+    }
+    usedNames.add(memberName);
+    const dualLabel = getJSDocLabel(attr.DisplayName, labelConfig);
+    if (dualLabel) {
+      lines.push(`    /** ${dualLabel} */`);
+    }
+    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} {`);
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const attr of lookupAttrs) {
+    const primaryLabel = getPrimaryLabel(attr.DisplayName, labelConfig);
+    let memberName = labelToPascalMember2(primaryLabel);
+    if (!memberName) {
+      memberName = toPascalCase(attr.LogicalName);
+    }
+    const originalName = memberName;
+    let counter = 2;
+    while (usedNames.has(memberName)) {
+      memberName = `${originalName}${counter}`;
+      counter++;
+    }
+    usedNames.add(memberName);
+    const dualLabel = getJSDocLabel(attr.DisplayName, labelConfig);
+    if (dualLabel) {
+      lines.push(`    /** ${dualLabel} */`);
+    }
+    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";
+  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 {");
+  for (const name of sorted) {
+    const pascal = toPascalCase(name);
+    lines.push(`    ${pascal} = '${name}',`);
+  }
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/generators/webapi-helpers.ts
+function select(...fields) {
+  if (fields.length === 0) return "";
+  return `?$select=${fields.join(",")}`;
+}
+function parseLookup(response, navigationProperty) {
+  const key = `_${navigationProperty}_value`;
+  const id = response[key];
+  if (!id) return null;
+  return {
+    id,
+    name: response[`${key}@OData.Community.Display.V1.FormattedValue`] ?? "",
+    entityType: response[`${key}@Microsoft.Dynamics.CRM.lookuplogicalname`] ?? ""
+  };
+}
+function parseLookups(response, navigationProperties) {
+  const result = {};
+  for (const prop of navigationProperties) {
+    result[prop] = parseLookup(response, prop);
+  }
+  return result;
+}
+function parseFormattedValue(response, fieldName) {
+  return response[`${fieldName}@OData.Community.Display.V1.FormattedValue`] ?? null;
+}
+function selectExpand(fields, expand) {
+  const parts = [];
+  if (fields.length > 0) parts.push(`$select=${fields.join(",")}`);
+  if (expand) parts.push(`$expand=${expand}`);
+  return parts.length > 0 ? `?${parts.join("&")}` : "";
+}
+
+// src/generators/xrm-constants.ts
+var DisplayState = /* @__PURE__ */ ((DisplayState2) => {
+  DisplayState2["Expanded"] = "expanded";
+  DisplayState2["Collapsed"] = "collapsed";
+  return DisplayState2;
+})(DisplayState || {});
+var FormNotificationLevel = /* @__PURE__ */ ((FormNotificationLevel2) => {
+  FormNotificationLevel2["Error"] = "ERROR";
+  FormNotificationLevel2["Warning"] = "WARNING";
+  FormNotificationLevel2["Info"] = "INFO";
+  return FormNotificationLevel2;
+})(FormNotificationLevel || {});
+var RequiredLevel = /* @__PURE__ */ ((RequiredLevel2) => {
+  RequiredLevel2["None"] = "none";
+  RequiredLevel2["Required"] = "required";
+  RequiredLevel2["Recommended"] = "recommended";
+  return RequiredLevel2;
+})(RequiredLevel || {});
+var SubmitMode = /* @__PURE__ */ ((SubmitMode2) => {
+  SubmitMode2["Always"] = "always";
+  SubmitMode2["Never"] = "never";
+  SubmitMode2["Dirty"] = "dirty";
+  return SubmitMode2;
+})(SubmitMode || {});
+var SaveMode = /* @__PURE__ */ ((SaveMode2) => {
+  SaveMode2[SaveMode2["Save"] = 1] = "Save";
+  SaveMode2[SaveMode2["SaveAndClose"] = 2] = "SaveAndClose";
+  SaveMode2[SaveMode2["Deactivate"] = 5] = "Deactivate";
+  SaveMode2[SaveMode2["Reactivate"] = 6] = "Reactivate";
+  SaveMode2[SaveMode2["Send"] = 7] = "Send";
+  SaveMode2[SaveMode2["Disqualify"] = 15] = "Disqualify";
+  SaveMode2[SaveMode2["Qualify"] = 16] = "Qualify";
+  SaveMode2[SaveMode2["Assign"] = 47] = "Assign";
+  SaveMode2[SaveMode2["SaveAsCompleted"] = 58] = "SaveAsCompleted";
+  SaveMode2[SaveMode2["SaveAndNew"] = 59] = "SaveAndNew";
+  SaveMode2[SaveMode2["AutoSave"] = 70] = "AutoSave";
+  return SaveMode2;
+})(SaveMode || {});
+var ClientType = /* @__PURE__ */ ((ClientType2) => {
+  ClientType2["Web"] = "Web";
+  ClientType2["Outlook"] = "Outlook";
+  ClientType2["Mobile"] = "Mobile";
+  return ClientType2;
+})(ClientType || {});
+var ClientState = /* @__PURE__ */ ((ClientState2) => {
+  ClientState2["Online"] = "Online";
+  ClientState2["Offline"] = "Offline";
+  return ClientState2;
+})(ClientState || {});
+var OperationType = /* @__PURE__ */ ((OperationType2) => {
+  OperationType2[OperationType2["Action"] = 0] = "Action";
+  OperationType2[OperationType2["Function"] = 1] = "Function";
+  OperationType2[OperationType2["CRUD"] = 2] = "CRUD";
+  return OperationType2;
+})(OperationType || {});
+var StructuralProperty = /* @__PURE__ */ ((StructuralProperty2) => {
+  StructuralProperty2[StructuralProperty2["Unknown"] = 0] = "Unknown";
+  StructuralProperty2[StructuralProperty2["PrimitiveType"] = 1] = "PrimitiveType";
+  StructuralProperty2[StructuralProperty2["ComplexType"] = 2] = "ComplexType";
+  StructuralProperty2[StructuralProperty2["EnumerationType"] = 3] = "EnumerationType";
+  StructuralProperty2[StructuralProperty2["Collection"] = 4] = "Collection";
+  StructuralProperty2[StructuralProperty2["EntityType"] = 5] = "EntityType";
+  return StructuralProperty2;
+})(StructuralProperty || {});
+var BindingType = /* @__PURE__ */ ((BindingType2) => {
+  BindingType2[BindingType2["Global"] = 0] = "Global";
+  BindingType2[BindingType2["Entity"] = 1] = "Entity";
+  BindingType2[BindingType2["EntityCollection"] = 2] = "EntityCollection";
+  return BindingType2;
+})(BindingType || {});
+
+// src/generators/action-runtime.ts
+function executeRequest(request) {
+  return Xrm.WebApi.online.execute(request);
+}
+function executeMultiple(requests) {
+  return Xrm.WebApi.online.executeMultiple(requests);
+}
+function cleanRecordId(id) {
+  return id.replace(/[{}]/g, "");
+}
+function buildBoundRequest(operationName, entityLogicalName, operationType, recordId, paramMeta, params) {
+  const parameterTypes = {
+    entity: {
+      typeName: `mscrm.${entityLogicalName}`,
+      structuralProperty: 5 /* EntityType */
+    }
+  };
+  if (paramMeta) {
+    for (const [key, meta] of Object.entries(paramMeta)) {
+      parameterTypes[key] = meta;
+    }
+  }
+  const request = {
+    getMetadata: () => ({
+      boundParameter: "entity",
+      parameterTypes,
+      operationName,
+      operationType
+    }),
+    entity: {
+      id: cleanRecordId(recordId),
+      entityType: entityLogicalName
+    }
+  };
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      request[key] = value;
+    }
+  }
+  return request;
+}
+function buildUnboundRequest(operationName, operationType, paramMeta, params) {
+  const parameterTypes = {};
+  if (paramMeta) {
+    for (const [key, meta] of Object.entries(paramMeta)) {
+      parameterTypes[key] = meta;
+    }
+  }
+  const request = {
+    getMetadata: () => ({
+      boundParameter: null,
+      parameterTypes,
+      operationName,
+      operationType
+    })
+  };
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      request[key] = value;
+    }
+  }
+  return request;
+}
+function createBoundAction(operationName, entityLogicalName, paramMeta) {
+  return {
+    execute(recordId, params) {
+      const req = buildBoundRequest(
+        operationName,
+        entityLogicalName,
+        0 /* Action */,
+        recordId,
+        paramMeta,
+        params
+      );
+      return executeRequest(req);
+    },
+    request(recordId, params) {
+      return buildBoundRequest(
+        operationName,
+        entityLogicalName,
+        0 /* Action */,
+        recordId,
+        paramMeta,
+        params
+      );
+    }
+  };
+}
+function createUnboundAction(operationName, paramMeta) {
+  return {
+    async execute(params) {
+      const req = buildUnboundRequest(
+        operationName,
+        0 /* Action */,
+        paramMeta,
+        params
+      );
+      const response = await executeRequest(req);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(errorText);
+      }
+      if (response.status !== 204) {
+        return response.json();
+      }
+      return response;
+    },
+    request(params) {
+      return buildUnboundRequest(
+        operationName,
+        0 /* Action */,
+        paramMeta,
+        params
+      );
+    }
+  };
+}
+function createUnboundFunction(operationName) {
+  return {
+    async execute() {
+      const req = buildUnboundRequest(operationName, 1 /* Function */);
+      const response = await executeRequest(req);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(errorText);
+      }
+      return response.json();
+    },
+    request() {
+      return buildUnboundRequest(operationName, 1 /* Function */);
+    }
+  };
+}
+function createBoundFunction(operationName, entityLogicalName) {
+  return {
+    async execute(recordId) {
+      const req = buildBoundRequest(
+        operationName,
+        entityLogicalName,
+        1 /* Function */,
+        recordId
+      );
+      const response = await executeRequest(req);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(errorText);
+      }
+      return response.json();
+    },
+    request(recordId) {
+      return buildBoundRequest(
+        operationName,
+        entityLogicalName,
+        1 /* Function */,
+        recordId
+      );
+    }
+  };
+}
+async function withProgress(message, operation) {
+  Xrm.Utility.showProgressIndicator(message);
+  try {
+    return await operation();
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    Xrm.Navigation.openErrorDialog({ message: msg });
+    throw error;
+  } finally {
+    Xrm.Utility.closeProgressIndicator();
+  }
+}
+
+// src/metadata/custom-api-types.ts
+function mapCustomApiParameterType(type, entityName) {
+  switch (type) {
+    case 0 /* Boolean */:
+      return { tsType: "boolean", typeName: "Edm.Boolean", structuralProperty: 1 };
+    case 1 /* DateTime */:
+      return { tsType: "string", typeName: "Edm.DateTimeOffset", structuralProperty: 1 };
+    case 2 /* Decimal */:
+      return { tsType: "number", typeName: "Edm.Decimal", structuralProperty: 1 };
+    case 3 /* Entity */:
+      return {
+        tsType: "Record<string, unknown>",
+        typeName: `mscrm.${entityName || "crmbaseentity"}`,
+        structuralProperty: 5
+      };
+    case 4 /* EntityCollection */:
+      return {
+        tsType: "Array<Record<string, unknown>>",
+        typeName: "Collection(mscrm.crmbaseentity)",
+        structuralProperty: 4
+      };
+    case 5 /* EntityReference */:
+      return {
+        tsType: "{ id: string; entityType: string; name?: string }",
+        typeName: `mscrm.${entityName || "crmbaseentity"}`,
+        structuralProperty: 5
+      };
+    case 6 /* Float */:
+      return { tsType: "number", typeName: "Edm.Double", structuralProperty: 1 };
+    case 7 /* Integer */:
+      return { tsType: "number", typeName: "Edm.Int32", structuralProperty: 1 };
+    case 8 /* Money */:
+      return { tsType: "number", typeName: "Edm.Decimal", structuralProperty: 1 };
+    case 9 /* Picklist */:
+      return { tsType: "number", typeName: "Edm.Int32", structuralProperty: 1 };
+    case 10 /* String */:
+      return { tsType: "string", typeName: "Edm.String", structuralProperty: 1 };
+    case 11 /* StringArray */:
+      return { tsType: "string[]", typeName: "Collection(Edm.String)", structuralProperty: 4 };
+    case 12 /* Guid */:
+      return { tsType: "string", typeName: "Edm.Guid", structuralProperty: 1 };
+    default:
+      return { tsType: "unknown", typeName: "Edm.String", structuralProperty: 0 };
+  }
+}
+
+// src/generators/action-generator.ts
+function deriveActionName(uniquename) {
+  const withoutPrefix = uniquename.includes("_") ? uniquename.substring(uniquename.indexOf("_") + 1) : uniquename;
+  return toPascalCase(withoutPrefix);
+}
+function generateParamsInterface(name, params) {
+  if (params.length === 0) return "";
+  const lines = [];
+  lines.push(`  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.uniquename}${optional}: ${mapped.tsType};`);
+  }
+  lines.push("  }");
+  return lines.join("\n");
+}
+function generateResultInterface(name, props) {
+  if (props.length === 0) return "";
+  const lines = [];
+  lines.push(`  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.uniquename}: ${mapped.tsType};`);
+  }
+  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;
+  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}) */`);
+    if (hasParams) {
+      lines.push(generateParamsInterface(name, apiInfo.requestParameters));
+      lines.push("");
+    }
+    if (hasResult) {
+      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 lines = [];
+  lines.push("// Auto-generated by @xrmforge/typegen - DO NOT EDIT");
+  lines.push("");
+  const imports = /* @__PURE__ */ new Set();
+  for (const apiInfo of apis) {
+    if (apiInfo.api.bindingtype === 0 /* Global */) {
+      if (isFunction) {
+        imports.add("createUnboundFunction");
+      } else {
+        imports.add("createUnboundAction");
+      }
+    } else {
+      if (isFunction) {
+        imports.add("createBoundFunction");
+      } else {
+        imports.add("createBoundAction");
+      }
+    }
+  }
+  lines.push(`import { ${[...imports].sort().join(", ")} } from '${importPath}';`);
+  lines.push("");
+  for (const apiInfo of apis) {
+    const name = deriveActionName(apiInfo.api.uniquename);
+    const hasParams = apiInfo.requestParameters.length > 0;
+    const description = apiInfo.api.description || apiInfo.api.displayname || apiInfo.api.uniquename;
+    lines.push(`/** ${description} */`);
+    if (apiInfo.api.bindingtype === 0 /* Global */) {
+      if (isFunction) {
+        lines.push(`export const ${name} = createUnboundFunction('${apiInfo.api.uniquename}');`);
+      } else if (hasParams) {
+        const paramMeta = generateParameterMetaMap(apiInfo.requestParameters);
+        lines.push(`export const ${name} = createUnboundAction('${apiInfo.api.uniquename}', ${paramMeta});`);
+      } else {
+        lines.push(`export const ${name} = createUnboundAction('${apiInfo.api.uniquename}');`);
+      }
+    } else {
+      const entity = apiInfo.api.boundentitylogicalname;
+      if (isFunction) {
+        lines.push(`export const ${name} = createBoundFunction('${apiInfo.api.uniquename}', '${entity}');`);
+      } else if (hasParams) {
+        const paramMeta = generateParameterMetaMap(apiInfo.requestParameters);
+        lines.push(`export const ${name} = createBoundAction('${apiInfo.api.uniquename}', '${entity}', ${paramMeta});`);
+      } else {
+        lines.push(`export const ${name} = createBoundAction('${apiInfo.api.uniquename}', '${entity}');`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function generateParameterMetaMap(params) {
+  const entries = [];
+  for (const param of params) {
+    const mapped = mapCustomApiParameterType(param.type, param.logicalentityname);
+    entries.push(
+      `  ${param.uniquename}: { typeName: '${mapped.typeName}', structuralProperty: ${mapped.structuralProperty} }`
+    );
+  }
+  return `{
+${entries.join(",\n")},
+}`;
+}
+function groupCustomApis(apis) {
+  const actions = /* @__PURE__ */ new Map();
+  const functions = /* @__PURE__ */ new Map();
+  for (const api of apis) {
+    const target = api.api.isfunction ? functions : actions;
+    const key = api.api.bindingtype === 0 /* Global */ ? "global" : api.api.boundentitylogicalname || "global";
+    if (!target.has(key)) {
+      target.set(key, []);
+    }
+    target.get(key).push(api);
+  }
+  return { actions, functions };
+}
+
 // src/orchestrator/file-writer.ts
 import { mkdir, writeFile, readFile } from "fs/promises";
 import { join as join2, dirname } from "path";
@@ -2032,6 +2756,8 @@ var TypeGenerationOrchestrator = class {
       generateEntities: config.generateEntities ?? true,
       generateForms: config.generateForms ?? true,
       generateOptionSets: config.generateOptionSets ?? true,
+      generateActions: config.generateActions ?? false,
+      actionsFilter: config.actionsFilter ?? "",
       useCache: config.useCache ?? false,
       cacheDir: config.cacheDir ?? ".xrmforge/cache",
       namespacePrefix: config.namespacePrefix ?? "XrmForge"
@@ -2106,6 +2832,63 @@ var TypeGenerationOrchestrator = class {
         });
       }
     }
+    if (this.config.generateActions && !signal?.aborted) {
+      this.logger.info("Fetching Custom APIs...");
+      let customApis = await metadataClient.getCustomApis();
+      if (this.config.actionsFilter) {
+        const prefix = this.config.actionsFilter.toLowerCase();
+        const before = customApis.length;
+        customApis = customApis.filter((api) => api.api.uniquename.toLowerCase().startsWith(prefix));
+        this.logger.info(`Filtered Custom APIs by prefix "${this.config.actionsFilter}": ${before} -> ${customApis.length}`);
+      }
+      if (customApis.length > 0) {
+        const importPath = "@xrmforge/typegen";
+        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 });
+          allFiles.push({
+            relativePath: `actions/${key}.d.ts`,
+            content: addGeneratedHeader(declarations),
+            type: "action"
+          });
+          allFiles.push({
+            relativePath: `actions/${key}.ts`,
+            content: addGeneratedHeader(module),
+            type: "action"
+          });
+        }
+        for (const [key, apis] of grouped.functions) {
+          const entityName = key === "global" ? void 0 : key;
+          const declarations = generateActionDeclarations(apis, true, entityName, { importPath });
+          const module = generateActionModule(apis, true, { importPath });
+          allFiles.push({
+            relativePath: `functions/${key}.d.ts`,
+            content: addGeneratedHeader(declarations),
+            type: "action"
+          });
+          allFiles.push({
+            relativePath: `functions/${key}.ts`,
+            content: addGeneratedHeader(module),
+            type: "action"
+          });
+        }
+        this.logger.info(`Generated ${grouped.actions.size} action groups, ${grouped.functions.size} function groups`);
+      } else {
+        this.logger.info("No Custom APIs found");
+      }
+    }
+    if (this.config.entities.length > 0) {
+      const entityNamesContent = generateEntityNamesEnum(this.config.entities, {
+        namespace: this.config.namespacePrefix
+      });
+      allFiles.push({
+        relativePath: "entity-names.d.ts",
+        content: addGeneratedHeader(entityNamesContent),
+        type: "entity"
+      });
+    }
     if (allFiles.length > 0) {
       const indexContent = generateBarrelIndex(allFiles);
       const indexFile = {
@@ -2232,12 +3015,17 @@ var TypeGenerationOrchestrator = class {
 export {
   ApiRequestError,
   AuthenticationError,
+  BindingType,
+  ClientState,
+  ClientType,
   ConfigError,
   ConsoleLogSink,
   DEFAULT_LABEL_CONFIG,
   DataverseHttpClient,
+  DisplayState,
   ErrorCode,
   FastXmlParser,
+  FormNotificationLevel,
   GenerationError,
   JsonLogSink,
   LogLevel,
@@ -2245,18 +3033,35 @@ export {
   MetadataCache,
   MetadataClient,
   MetadataError,
+  OperationType,
+  RequiredLevel,
+  SaveMode,
   SilentLogSink,
+  StructuralProperty,
+  SubmitMode,
   TypeGenerationOrchestrator,
   XrmForgeError,
   configureLogging,
+  createBoundAction,
+  createBoundFunction,
   createCredential,
   createLogger,
+  createUnboundAction,
+  createUnboundFunction,
   defaultXmlParser,
   disambiguateEnumMembers,
+  executeMultiple,
+  executeRequest,
   extractControlFields,
   getJSDocLabel as formatDualLabel,
+  generateActionDeclarations,
+  generateActionModule,
+  generateActivityPartyInterface,
+  generateEntityFieldsEnum,
   generateEntityForms,
   generateEntityInterface,
+  generateEntityNamesEnum,
+  generateEntityNavigationProperties,
   generateEntityOptionSets,
   generateEnumMembers,
   generateFormInterface,
@@ -2264,18 +3069,27 @@ export {
   getEntityPropertyType,
   getFormAttributeType,
   getFormControlType,
+  getFormMockValueType,
   getJSDocLabel,
   getLabelLanguagesParam,
   getPrimaryLabel,
   getSecondaryLabel,
+  groupCustomApis,
   isLookupType,
+  isPartyListType,
   isRateLimitError,
   isXrmForgeError,
   labelToIdentifier,
   parseForm,
+  parseFormattedValue,
+  parseLookup,
+  parseLookups,
+  select,
+  selectExpand,
   shouldIncludeInEntityInterface,
   toLookupValueProperty,
   toPascalCase,
-  toSafeIdentifier
+  toSafeIdentifier,
+  withProgress
 };
 //# sourceMappingURL=index.js.map