@azure-tools/typespec-ts 0.55.0-dev.1 → 0.55.0-dev.11

package/src/transform/transform.ts

@@ -2,9 +2,8 @@
 // Licensed under the MIT License.
 
 import { SdkClient } from "@azure-tools/typespec-client-generator-core";
-import { getDoc } from "@typespec/compiler";
+import { getDoc, joinPaths } from "@typespec/compiler";
 import { getServers } from "@typespec/http";
-import * as path from "path";
 import {
   buildRuntimeImports,
   Imports,
@@ -19,7 +18,6 @@ import {
   RLCOptions,
   Schema,
   SchemaContext,
-  transformSampleGroups,
   UrlInfo,
 } from "../rlc-common/index.js";
 import { SdkContext } from "../utils/interfaces.js";
@@ -30,15 +28,15 @@ import {
   getSchemaForType,
   getTypeName,
   predictDefaultValue,
-} from "../utils/modelUtils.js";
-import { getClientLroOverload } from "../utils/operationUtil.js";
-import { transformApiVersionInfo } from "./transformApiVersionInfo.js";
-import { transformHelperFunctionDetails } from "./transformHelperFunctionDetails.js";
-import { transformToParameterTypes } from "./transformParameters.js";
-import { transformPaths } from "./transformPaths.js";
-import { transformToResponseTypes } from "./transformResponses.js";
-import { transformSchemas } from "./transformSchemas.js";
-import { transformTelemetryInfo } from "./transformTelemetryInfo.js";
+} from "../utils/model-utils.js";
+import { getClientLroOverload } from "../utils/operation-util.js";
+import { transformApiVersionInfo } from "./transform-api-version-info.js";
+import { transformHelperFunctionDetails } from "./transform-helper-function-details.js";
+import { transformToParameterTypes } from "./transform-parameters.js";
+import { transformPaths } from "./transform-paths.js";
+import { transformToResponseTypes } from "./transform-responses.js";
+import { transformSchemas } from "./transform-schemas.js";
+import { transformTelemetryInfo } from "./transform-telemetry-info.js";
 
 export async function transformRLCModel(
   client: SdkClient,
@@ -47,19 +45,14 @@ export async function transformRLCModel(
   const program = dpgContext.program;
   const options: RLCOptions = dpgContext.rlcOptions!;
   const rlcSourceDir = dpgContext.generationPathDetail?.rlcSourcesDir;
-  const srcPath = path.join(
+  const srcPath = joinPaths(
     dpgContext.generationPathDetail?.rlcSourcesDir ?? "",
     options.batch && options.batch.length > 1
       ? normalizeName(client.name.replace("Client", ""), NameType.File)
       : "",
   );
   const libraryName = normalizeName(
-    options.batch && (options.isModularLibrary || options.batch.length > 1)
-      ? client.name
-      : (options?.title ??
-          client.name ??
-          getDefaultService(program, options.isModularLibrary)?.title ??
-          ""),
+    options.batch ? client.name : (client.name ?? getDefaultService(program)?.title ?? ""),
     NameType.Class,
   );
   const importSet = initInternalImports();
@@ -73,7 +66,7 @@ export async function transformRLCModel(
     importSet,
     urlInfo?.apiVersionInfo,
   );
-  const helperDetails = transformHelperFunctionDetails(client, dpgContext, options.flavor);
+  const helperDetails = transformHelperFunctionDetails(client, dpgContext);
   // Enrich client-level annotation detail
   helperDetails.clientLroOverload = getClientLroOverload(paths);
 
@@ -92,17 +85,13 @@ export async function transformRLCModel(
     telemetryOptions,
     importInfo: {
       internalImports: importSet,
-      runtimeImports: buildRuntimeImports(options.flavor),
+      runtimeImports: buildRuntimeImports(),
     },
     rlcSourceDir,
   };
-  model.sampleGroups = transformSampleGroups(
-    model,
-    options?.generateSample === true /* Enable mock sample content if generateSample === true */,
-  );
-  options.generateSample =
-    (options.generateSample === true || options.generateSample === undefined) &&
-    (model.sampleGroups ?? []).length > 0;
+  // RLC sample generation has been removed; modular samples are emitted separately,
+  // so the RLC model never carries sample groups.
+  options.generateSample = false;
   return model;
 }
 
@@ -170,7 +159,7 @@ export function transformUrlInfo(
     }
   }
   // Set the default value if missing endpoint parameter
-  if (endpoint == undefined && urlParameters.length === 0) {
+  if (endpoint === undefined && urlParameters.length === 0) {
     endpoint = "{endpointParam}";
     urlParameters.push({
       name: "endpointParam",

package/src/transform/transfrom-rlc-options.ts

@@ -0,0 +1,363 @@
+import { getHttpOperationWithCache } from "@azure-tools/typespec-client-generator-core";
+import { getDoc, NoTarget, Program } from "@typespec/compiler";
+import { getAuthentication } from "@typespec/http";
+import { EmitterOptions, reportDiagnostic } from "../lib.js";
+import { getClientParameters } from "../modular/helpers/client-helpers.js";
+import {
+  NameType,
+  normalizeName,
+  PackageDetails,
+  pascalCase,
+  RLCOptions,
+  ServiceInfo,
+} from "../rlc-common/index.js";
+import { getRLCClients, listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { getSupportedHttpAuth } from "../utils/credential-utils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { getDefaultService } from "../utils/model-utils.js";
+import { detectModelConflicts } from "../utils/namespace-utils.js";
+import { getOperationName } from "../utils/operation-util.js";
+
+export function transformRLCOptions(
+  emitterOptions: EmitterOptions,
+  dpgContext: SdkContext,
+): RLCOptions {
+  // Extract the options from emitter option
+  const options = extractRLCOptions(
+    dpgContext,
+    emitterOptions,
+    dpgContext.generationPathDetail?.rootDir ?? "",
+  );
+  const batch = getRLCClients(dpgContext);
+  options.batch = batch;
+  return options;
+}
+function extractRLCOptions(
+  dpgContext: SdkContext,
+  emitterOptions: EmitterOptions,
+  generationRootDir: string,
+): RLCOptions {
+  const program = dpgContext.program;
+  const packageDetails = getPackageDetails(program, emitterOptions);
+  const serviceInfo = getServiceInfo(program);
+  const includeHeadersInResponse = emitterOptions["include-headers-in-response"] === true;
+  const generateMetadata = getGenerateMetadata(emitterOptions);
+  const generateTest = getGenerateTest(emitterOptions);
+  const generateSample = getGenerateSample(dpgContext, emitterOptions);
+  const credentialInfo = getCredentialInfo(program, emitterOptions);
+  const azureOutputDirectory = getAzureOutputDirectory(generationRootDir);
+  const enableOperationGroup = getEnableOperationGroup(dpgContext, emitterOptions);
+  const enableModelNamespace = getEnableModelNamespace(dpgContext, emitterOptions);
+  const hierarchyClient = getHierarchyClient(emitterOptions);
+  const clearOutputFolder = getClearOutputFolder(emitterOptions);
+  const isTypeSpecTest = emitterOptions["is-typespec-test"];
+  const compatibilityMode = emitterOptions["compatibility-mode"];
+  const compatibilityLro = emitterOptions["compatibility-lro"];
+  const experimentalExtensibleEnums = emitterOptions["experimental-extensible-enums"];
+  const ignorePropertyNameNormalize = emitterOptions["ignore-property-name-normalize"];
+  const ignoreEnumMemberNameNormalize = emitterOptions["ignore-enum-member-name-normalize"];
+  const compatibilityQueryMultiFormat = emitterOptions["compatibility-query-multi-format"];
+  const enableStorageCompat = emitterOptions["enable-storage-compat"] === true;
+  const treatUnknownAsRecord = emitterOptions["treat-unknown-as-record"] === true;
+  const typespecTitleMap = emitterOptions["typespec-title-map"];
+  const generateReactNativeTarget = emitterOptions["generate-react-native-target"] === true;
+  const hasSubscriptionId = getSubscriptionId(dpgContext);
+  const ignoreNullableOnOptional = getIgnoreNullableOnOptional(emitterOptions);
+  const wrapNonModelReturn = getWrapNonModelReturn(emitterOptions);
+  const isMultiService = (dpgContext.allServiceNamespaces?.length ?? 0) > 1;
+
+  return {
+    ...credentialInfo,
+    includeHeadersInResponse,
+    packageDetails,
+    generateMetadata,
+    generateTest,
+    generateSample,
+    serviceInfo,
+    azureOutputDirectory,
+    enableOperationGroup,
+    enableModelNamespace,
+    hierarchyClient,
+    azureArm: dpgContext.arm,
+    clearOutputFolder,
+    isTypeSpecTest,
+    compatibilityMode,
+    compatibilityLro,
+    experimentalExtensibleEnums,
+    ignorePropertyNameNormalize,
+    compatibilityQueryMultiFormat,
+    typespecTitleMap,
+    ignoreEnumMemberNameNormalize,
+    hasSubscriptionId,
+    ignoreNullableOnOptional,
+    wrapNonModelReturn,
+    isMultiService,
+    enableStorageCompat,
+    treatUnknownAsRecord,
+    generateReactNativeTarget,
+  };
+}
+
+function processAuth(program: Program) {
+  const serviceNs = getDefaultService(program)?.type;
+  if (!serviceNs) {
+    return undefined;
+  }
+  const authorization = getAuthentication(program, serviceNs);
+  if (!authorization || !authorization.options) {
+    return undefined;
+  }
+  const securityInfo: RLCOptions = {};
+  for (const auth of getSupportedHttpAuth(program, authorization)) {
+    switch (auth.type) {
+      case "http":
+        securityInfo.addCredentials = true;
+        securityInfo.customHttpAuthHeaderName = "Authorization";
+        // If it is basic or bearer auth we should generate it as Basic or Bearer
+        securityInfo.customHttpAuthSharedKeyPrefix = ["basic", "bearer"].includes(
+          auth.scheme.toLowerCase(),
+        )
+          ? pascalCase(auth.scheme)
+          : auth.scheme;
+        break;
+      case "apiKey":
+        if (auth.in === "cookie") {
+          return undefined;
+        }
+        securityInfo.addCredentials = true;
+        securityInfo.credentialKeyHeaderName = auth.name;
+        break;
+      case "oauth2": {
+        const flow = auth.flows[0];
+        if (flow === undefined || !flow.scopes) {
+          return undefined;
+        }
+        securityInfo.addCredentials = true;
+        if (!securityInfo.credentialScopes) {
+          securityInfo.credentialScopes = [];
+        }
+        if (flow.scopes.length === 0) {
+          reportDiagnostic(program, {
+            code: "no-credential-scopes",
+            target: NoTarget,
+          });
+        }
+        // ignore the user_impersonation scope
+        if (
+          flow.scopes.length === 1 &&
+          flow.scopes[0] &&
+          flow.scopes[0].value.toLowerCase() === "user_impersonation"
+        ) {
+          return securityInfo;
+        }
+        securityInfo.credentialScopes.push(
+          ...flow.scopes.map((item) => {
+            return item.value;
+          }),
+        );
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return securityInfo;
+}
+
+function getEnableOperationGroup(dpgContext: SdkContext, emitterOptions: EmitterOptions) {
+  if (
+    emitterOptions["enable-operation-group"] === true ||
+    emitterOptions["enable-operation-group"] === false
+  ) {
+    return emitterOptions["enable-operation-group"];
+  }
+  // Only detect if existing name conflicts if customers don't set hierarchyClient to true
+  return detectIfNameConflicts(dpgContext);
+}
+
+function getEnableModelNamespace(dpgContext: SdkContext, emitterOptions: EmitterOptions) {
+  if (
+    emitterOptions["enable-model-namespace"] === true ||
+    emitterOptions["enable-model-namespace"] === false
+  ) {
+    return emitterOptions["enable-model-namespace"];
+  }
+  // Detect if existing name conflicts if customers didn't set the option explicitly
+  return detectModelConflicts(dpgContext);
+}
+
+function getHierarchyClient(emitterOptions: EmitterOptions) {
+  if (emitterOptions["hierarchy-client"] === true || emitterOptions["hierarchy-client"] === false) {
+    return emitterOptions["hierarchy-client"];
+  }
+  // enable hierarchy client by default if customers didn't set the option explicitly
+  return true;
+}
+
+function getClearOutputFolder(emitterOptions: EmitterOptions) {
+  return emitterOptions["clear-output-folder"] ? true : false;
+}
+
+function detectIfNameConflicts(dpgContext: SdkContext) {
+  const clients = getRLCClients(dpgContext);
+  for (const client of clients) {
+    // only consider it's conflict when there are conflicts in the same client
+    const nameSet = new Set<string>();
+    for (const op of listOperationsUnderRLCClient(client)) {
+      const route = getHttpOperationWithCache(dpgContext, op);
+      const name = getOperationName(dpgContext, route.operation);
+      if (nameSet.has(name)) {
+        return true;
+      } else {
+        nameSet.add(name);
+      }
+    }
+  }
+
+  // No conflicts if we didn't detect any
+  return false;
+}
+
+function getIgnoreNullableOnOptional(emitterOptions: EmitterOptions): boolean {
+  // If explicitly set in options, use that value
+  if (emitterOptions["ignore-nullable-on-optional"] !== undefined) {
+    return Boolean(emitterOptions["ignore-nullable-on-optional"]);
+  }
+  // Default to true (same as HLC behavior)
+  return true;
+}
+
+function getWrapNonModelReturn(emitterOptions: EmitterOptions): boolean {
+  // If explicitly set in options, use that value
+  if (emitterOptions["wrap-non-model-return"] !== undefined) {
+    return Boolean(emitterOptions["wrap-non-model-return"]);
+  }
+  // Default to true to maintain HLC backward compatibility
+  return true;
+}
+
+function buildPackageDetails(program: Program, emitterOptions: EmitterOptions): PackageDetails {
+  const defaultDetail = {
+    name: "@msinternal/unamedpackage",
+    nameWithoutScope: "unamedpackage",
+    version: "1.0.0-beta.1",
+  };
+  const isVersionUserProvided = Boolean(emitterOptions["package-details"]?.version);
+  const packageDetails: PackageDetails = {
+    ...emitterOptions["package-details"],
+    name:
+      emitterOptions["package-details"]?.name ??
+      normalizeName(getDefaultService(program)?.title ?? "", NameType.Class),
+    version: emitterOptions["package-details"]?.version ?? "1.0.0-beta.1",
+    isVersionUserProvided,
+  };
+  if (emitterOptions["package-details"]?.name) {
+    const nameParts = emitterOptions["package-details"]?.name.split("/");
+    if (nameParts.length === 2) {
+      packageDetails.nameWithoutScope = nameParts[1];
+      packageDetails.scopeName = nameParts[0]?.replace("@", "");
+    }
+  }
+  return packageDetails ?? defaultDetail;
+}
+
+function getPackageDetails(program: Program, emitterOptions: EmitterOptions): PackageDetails {
+  return buildPackageDetails(program, emitterOptions);
+}
+
+function getServiceInfo(program: Program): ServiceInfo {
+  const defaultService = getDefaultService(program);
+  return {
+    title: defaultService?.title,
+    description: defaultService && getDoc(program, defaultService.type),
+  };
+}
+
+function getGenerateMetadata(emitterOptions: EmitterOptions) {
+  if (
+    emitterOptions["generate-metadata"] === undefined ||
+    emitterOptions["generate-metadata"] === null
+  ) {
+    return undefined;
+  }
+  return Boolean(emitterOptions["generate-metadata"]);
+}
+
+/**
+ * In azure scope, by default we generate test.
+ * @param emitterOptions
+ * @returns
+ */
+function getGenerateTest(emitterOptions: EmitterOptions) {
+  return emitterOptions["generate-test"];
+}
+
+/**
+ * In azure scope, by default we generate test.
+ * @param emitterOptions
+ * @returns
+ */
+function getGenerateSample(dpgContext: SdkContext, emitterOptions: EmitterOptions) {
+  if (dpgContext.arm && emitterOptions["generate-sample"] === undefined) {
+    return true;
+  }
+  if (
+    emitterOptions["generate-sample"] === undefined ||
+    emitterOptions["generate-sample"] === null
+  ) {
+    return undefined;
+  }
+  return Boolean(emitterOptions["generate-sample"]);
+}
+
+export function getCredentialInfo(program: Program, emitterOptions: EmitterOptions) {
+  const securityInfo = processAuth(program);
+  const addCredentials =
+    emitterOptions["add-credentials"] === false
+      ? false
+      : securityInfo
+        ? securityInfo.addCredentials
+        : emitterOptions["add-credentials"];
+  const credentialScopes =
+    securityInfo && securityInfo.credentialScopes
+      ? securityInfo.credentialScopes
+      : emitterOptions["credential-scopes"];
+  const credentialKeyHeaderName =
+    securityInfo && securityInfo.credentialKeyHeaderName
+      ? securityInfo.credentialKeyHeaderName
+      : emitterOptions["credential-key-header-name"];
+  const customHttpAuthHeaderName =
+    securityInfo && securityInfo.customHttpAuthHeaderName
+      ? securityInfo.customHttpAuthHeaderName
+      : emitterOptions["custom-http-auth-header-name"];
+  const customHttpAuthSharedKeyPrefix =
+    securityInfo && securityInfo.customHttpAuthSharedKeyPrefix
+      ? securityInfo.customHttpAuthSharedKeyPrefix
+      : emitterOptions["custom-http-auth-shared-key-prefix"];
+  return {
+    addCredentials,
+    credentialScopes,
+    credentialKeyHeaderName,
+    customHttpAuthHeaderName,
+    customHttpAuthSharedKeyPrefix,
+  };
+}
+
+function getAzureOutputDirectory(emitterOutputDir: string): string | undefined {
+  const sdkFolder = emitterOutputDir;
+  const sdkReletivePath = sdkFolder?.replace(/\/$/, "").split("/").slice(-3).join("/");
+  return sdkReletivePath?.substring(0, 3) === "sdk" ? sdkReletivePath : undefined;
+}
+
+export function getSubscriptionId(dpgContext: SdkContext) {
+  for (const client of dpgContext.sdkPackage.clients) {
+    if (
+      getClientParameters(client, dpgContext)
+        .map((item) => item.name)
+        .includes("subscriptionId")
+    ) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/utils/client-utils.ts

@@ -0,0 +1,161 @@
+import {
+  InitializedByFlags,
+  listAllServiceNamespaces,
+  listClients,
+  SdkClient,
+  SdkClientType,
+  SdkServiceOperation,
+} from "@azure-tools/typespec-client-generator-core";
+import {
+  getNamespaceFullName,
+  Interface,
+  isTemplateDeclaration,
+  isTemplateDeclarationOrInstance,
+  Namespace,
+  Operation,
+} from "@typespec/compiler";
+import { ModularClientOptions } from "../modular/interfaces.js";
+import { NameType, normalizeName } from "../rlc-common/index.js";
+import { SdkContext } from "./interfaces.js";
+
+export function getRLCClients(dpgContext: SdkContext): SdkClient[] {
+  const clients = listClients(dpgContext);
+  const rawServiceNamespaces =
+    dpgContext.allServiceNamespaces ?? listAllServiceNamespaces(dpgContext);
+
+  // For one client: Return the client from listClients with multi-service support
+  if (clients.length === 1) {
+    return clients.map((client) => {
+      const services = client.services;
+      return {
+        ...client,
+        services: services,
+        crossLanguageDefinitionId: `${getNamespaceFullName(services[0]!)}.${client.name}`,
+      };
+    });
+  } else {
+    // For multiple clients:
+    // Flatten all services and return one client per service
+    const services = new Set<Namespace>();
+    clients.forEach((c) => {
+      const clientService = c.services;
+      clientService.forEach((ns) => services.add(ns));
+    });
+
+    if (services.size > 0) {
+      return [...services.values()].map((service) => {
+        const clientName = service.name + "Client";
+        return {
+          kind: "SdkClient",
+          name: clientName,
+          service: service,
+          type: service,
+          services: [service],
+          subClients: [],
+          clientPath: clientName,
+          arm: Boolean(dpgContext.arm),
+          crossLanguageDefinitionId: `${getNamespaceFullName(service)}.${clientName}`,
+          subOperationGroups: [],
+        };
+      });
+    }
+  }
+
+  // Fallback to raw service namespaces if no clients found
+  return rawServiceNamespaces.map((service) => {
+    const clientName = service.name + "Client";
+    return {
+      kind: "SdkClient",
+      name: clientName,
+      service: service,
+      type: service,
+      services: [service],
+      subClients: [],
+      clientPath: clientName,
+      arm: Boolean(dpgContext.arm),
+      crossLanguageDefinitionId: `${getNamespaceFullName(service)}.${clientName}`,
+      subOperationGroups: [],
+    };
+  });
+}
+
+export function listOperationsUnderRLCClient(client: SdkClient): Operation[] {
+  const operations = [];
+  const serviceArray = client.services;
+  const queue: (Namespace | Interface)[] = [...serviceArray];
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    if (
+      current.decorators.some(
+        (d) =>
+          d.definition?.name === "@client" &&
+          getNamespaceFullName(d.definition?.namespace) === "Azure.ClientGenerator.Core",
+      ) &&
+      !serviceArray.includes(current as Namespace)
+    ) {
+      continue;
+    }
+    operations.push(
+      ...[...current.operations.values()].filter(
+        (op) => isTemplateDeclarationOrInstance(op) === false,
+      ),
+    );
+    if (current.kind === "Namespace") {
+      queue.push(...current.namespaces.values());
+      queue.push(
+        ...[...current.interfaces.values()].filter((i) => isTemplateDeclaration(i) === false),
+      );
+    }
+  }
+  return operations;
+}
+
+export function isRLCMultiEndpoint(dpgContext: SdkContext): boolean {
+  return getRLCClients(dpgContext).length > 1;
+}
+
+export function getModularClientOptions(clientMap: [string[], SdkClientType<SdkServiceOperation>]) {
+  const [hierarchy, client] = clientMap;
+  const clientOptions: ModularClientOptions = {
+    rlcClientName: `${client.name.replace(/Client$/, "")}Context`,
+  };
+  clientOptions.subfolder = hierarchy.join("/");
+  return clientOptions;
+}
+
+export function getClientHierarchyMap(
+  context: SdkContext,
+): [string[], SdkClientType<SdkServiceOperation>][] {
+  const clientMap: [string[], SdkClientType<SdkServiceOperation>][] = [];
+  const individualClients = context.sdkPackage.clients.filter((client) => {
+    return client.clientInitialization.initializedBy & InitializedByFlags.Individually;
+  });
+  const clients = individualClients.map((client) => {
+    return [
+      context.sdkPackage.clients.length > 1
+        ? [normalizeName(client.name.replace("Client", ""), NameType.File)]
+        : [],
+      client,
+    ];
+  }) as [string[], SdkClientType<SdkServiceOperation>][];
+  for (let i = 0; i < clients.length; i++) {
+    const [hierarchy, client] = clients[i]!;
+    clientMap.push([hierarchy, client]);
+    const childClientsToGenerate = client.children?.filter((child) => {
+      return (
+        child.clientInitialization.initializedBy & InitializedByFlags.Individually ||
+        child.clientInitialization.initializedBy & InitializedByFlags.Parent
+      );
+    });
+    if (childClientsToGenerate && childClientsToGenerate.length > 0) {
+      childClientsToGenerate.forEach((child) => {
+        const childHierarchy = [
+          ...hierarchy,
+          normalizeName(child.name.replace("Client", ""), NameType.File),
+        ];
+        clients.push([childHierarchy, child]);
+      });
+    }
+  }
+  return clientMap;
+}

package/src/utils/cross-language-def.ts

@@ -0,0 +1,66 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { UsageFlags } from "@azure-tools/typespec-client-generator-core";
+import { transformModularEmitterOptions } from "../modular/build-modular-options.js";
+import { NameType, normalizeName } from "../rlc-common/index.js";
+import { SdkContext } from "./interfaces.js";
+import { getMethodHierarchiesMap } from "./operation-util.js";
+
+export function generateCrossLanguageDefinitionFile(dpgContext: SdkContext): {
+  CrossLanguagePackageId: string;
+  CrossLanguageDefinitionId: Record<string, string>;
+} {
+  const modularSourcesRoot = dpgContext.generationPathDetail?.modularSourcesDir ?? "src";
+  const emitterOptions = transformModularEmitterOptions(dpgContext, modularSourcesRoot, {
+    casing: "camel",
+  });
+  const packageName = emitterOptions.options?.packageDetails?.name ?? "package-name";
+  const CrossLanguageDefinitionId: Record<string, string> = {};
+
+  for (const model of dpgContext.sdkPackage.models) {
+    CrossLanguageDefinitionId[`${packageName}!${model.name}:interface`] =
+      model.crossLanguageDefinitionId;
+  }
+  for (const enm of dpgContext.sdkPackage.enums) {
+    // Skip api version enum for multi-service scenarios since each service may have different versions
+    if (dpgContext.rlcOptions?.isMultiService && enm.usage === UsageFlags.ApiVersionEnum) {
+      continue;
+    }
+    CrossLanguageDefinitionId[`${packageName}!Known${enm.name}:enum`] =
+      enm.crossLanguageDefinitionId;
+  }
+  for (const union of dpgContext.sdkPackage.unions) {
+    CrossLanguageDefinitionId[`${packageName}!${union.name}:type`] =
+      union.crossLanguageDefinitionId;
+  }
+
+  for (const subClient of dpgContext.sdkPackage.clients) {
+    const clientName = emitterOptions.options?.typespecTitleMap?.[subClient.name] ?? subClient.name;
+    const methodMap = getMethodHierarchiesMap(dpgContext, subClient);
+    for (const [prefixKey, operations] of methodMap) {
+      const prefixes = prefixKey.split("/");
+      if (prefixKey === "") {
+        for (const operation of operations) {
+          const { name } = operation;
+          const operationName = `${packageName}!${clientName}#${name}:member(1)`;
+          CrossLanguageDefinitionId[operationName] = operation.crossLanguageDefinitionId;
+        }
+      } else {
+        // e,g., @azure/ai-client!ConnectionsOperations#getConnectionWithSecrets:member": "Azure.AI.Projects.Connections.getConnectionWithSecrets"
+        const rawGroupName = normalizeName(prefixes[0] ?? "", NameType.Interface);
+        const propertyType = `${normalizeName(rawGroupName, NameType.OperationGroup)}Operations`;
+        for (const operation of operations) {
+          const { name } = operation;
+          const operationName = `${packageName}!${propertyType}#${name}:member`;
+          CrossLanguageDefinitionId[operationName] = operation.crossLanguageDefinitionId;
+        }
+      }
+    }
+  }
+
+  return {
+    CrossLanguagePackageId: dpgContext.sdkPackage.crossLanguagePackageId,
+    CrossLanguageDefinitionId,
+  };
+}