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

package/src/modular/build-client-context.ts

@@ -0,0 +1,325 @@
+import { NameType, isAzurePackage, normalizeName } from "../rlc-common/index.js";
+import {
+  buildGetClientCredentialParam,
+  buildGetClientEndpointParam,
+  buildGetClientOptionsParam,
+  getClientParameterName,
+  getClientParameters,
+  getClientParametersDeclaration,
+} from "./helpers/client-helpers.js";
+import { ModularEmitterOptions } from "./interfaces.js";
+
+import {
+  SdkClientType,
+  SdkCredentialParameter,
+  SdkEndpointParameter,
+  SdkHttpParameter,
+  SdkMethodParameter,
+  SdkServiceOperation,
+} from "@azure-tools/typespec-client-generator-core";
+import { NoTarget } from "@typespec/compiler";
+import { SourceFile } from "ts-morph";
+import { useContext } from "../context-manager.js";
+import { useDependencies } from "../framework/hooks/use-dependencies.js";
+import { resolveReference } from "../framework/reference.js";
+import { refkey } from "../framework/refkey.js";
+import { reportDiagnostic } from "../lib.js";
+import { getModularClientOptions } from "../utils/client-utils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { buildEnumTypes, getApiVersionEnum } from "./emit-models.js";
+import { getDocsFromDescription } from "./helpers/docs-helpers.js";
+import { getClassicalClientName, getClientName } from "./helpers/naming-helpers.js";
+import { CloudSettingHelpers } from "./static-helpers-metadata.js";
+import { getTypeExpression } from "./type-expressions/get-type-expression.js";
+
+/**
+ * This function gets the path of the file containing the modular client context
+ */
+export function getClientContextPath(
+  clientMap: [string[], SdkClientType<SdkServiceOperation>],
+  emitterOptions: ModularEmitterOptions,
+): string {
+  const [_, client] = clientMap;
+  const { subfolder } = getModularClientOptions(clientMap);
+  const name = getClientName(client);
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
+  const contentPath = `${srcPath}/${
+    subfolder && subfolder !== "" ? subfolder + "/" : ""
+  }api/${normalizeName(name, NameType.File)}Context.ts`;
+  return contentPath;
+}
+
+/**
+ * This function creates the file containing the modular client context
+ */
+export function buildClientContext(
+  dpgContext: SdkContext,
+  clientMap: [string[], SdkClientType<SdkServiceOperation>],
+  emitterOptions: ModularEmitterOptions,
+): SourceFile {
+  const project = useContext("outputProject");
+  const dependencies = useDependencies();
+  const [hierarchy, client] = clientMap;
+  const name = getClientName(client);
+  const { rlcClientName } = getModularClientOptions(clientMap);
+  const requiredParams = getClientParametersDeclaration(client, dpgContext, {
+    onClientOnly: false,
+    requiredOnly: true,
+    apiVersionAsRequired: true,
+  });
+  const clientContextFile = project.createSourceFile(
+    getClientContextPath(clientMap, emitterOptions),
+  );
+
+  // Get all client parameters (both required and optional) for the interface
+  const requiredInterfaceProperties = getClientParameters(client, dpgContext, {
+    onClientOnly: false,
+    requiredOnly: true,
+  })
+    .filter((p) => {
+      const clientParamName = getClientParameterName(p);
+      return clientParamName !== "endpointParam" && clientParamName !== "credential";
+    })
+    .map((p) => {
+      return {
+        name: getClientParameterName(p),
+        type: getTypeExpression(dpgContext, p.type),
+        hasQuestionToken: false,
+        docs: getDocsWithKnownVersion(dpgContext, p),
+      };
+    });
+
+  // Collect names of required properties to avoid duplicates
+  const requiredPropertyNames = new Set(requiredInterfaceProperties.map((p) => p.name));
+
+  const optionalInterfaceProperties = getClientParameters(client, dpgContext, {
+    onClientOnly: false,
+    optionalOnly: true,
+  })
+    .filter((p) => {
+      const clientParamName = getClientParameterName(p);
+      return (
+        clientParamName !== "endpointParam" &&
+        clientParamName !== "credential" &&
+        clientParamName !== "endpoint" &&
+        !requiredPropertyNames.has(clientParamName) // Avoid duplicating required properties
+      );
+    })
+    .map((p) => {
+      return {
+        name: getClientParameterName(p),
+        type: getTypeExpression(dpgContext, p.type),
+        hasQuestionToken: true,
+        docs: getDocsWithKnownVersion(dpgContext, p),
+      };
+    });
+
+  clientContextFile.addInterface({
+    isExported: true,
+    name: `${rlcClientName}`,
+    extends: [resolveReference(dependencies.Client)],
+    docs: getDocsFromDescription(client.doc),
+    properties: [...requiredInterfaceProperties, ...optionalInterfaceProperties],
+  });
+
+  const propertiesInOptions = getClientParameters(client, dpgContext, {
+    optionalOnly: true,
+  })
+    .filter((p) => getClientParameterName(p) !== "endpoint")
+    .map((p) => {
+      return {
+        name: getClientParameterName(p),
+        type:
+          p.name.toLowerCase() === "apiversion" ? "string" : getTypeExpression(dpgContext, p.type),
+        hasQuestionToken: true,
+        docs: getDocsWithKnownVersion(dpgContext, p),
+      };
+    });
+  if (dpgContext.arm) {
+    propertiesInOptions.push({
+      name: "cloudSetting",
+      type: `${resolveReference(CloudSettingHelpers.AzureSupportedClouds)}`,
+      hasQuestionToken: true,
+      docs: [`Specifies the Azure cloud environment for the client.`],
+    });
+  }
+  // check if we have duplication options
+  const existingOptionNames = new Set<string>();
+  for (const property of propertiesInOptions) {
+    if (existingOptionNames.has(property.name)) {
+      reportDiagnostic(dpgContext.program, {
+        code: "parameter-name-conflict",
+        format: { parameterName: property.name },
+        target: NoTarget,
+      });
+    }
+    existingOptionNames.add(property.name);
+  }
+  clientContextFile.addInterface({
+    name: `${getClassicalClientName(client)}OptionalParams`,
+    isExported: true,
+    extends: [resolveReference(dependencies.ClientOptions)],
+    properties: propertiesInOptions,
+    docs: ["Optional parameters for the client."],
+  });
+
+  // TODO use binder here
+  // (for now) now logger for unbranded pkgs
+  if (isAzurePackage(emitterOptions)) {
+    clientContextFile.addImportDeclaration({
+      moduleSpecifier: "../".repeat(hierarchy.length + 1) + "logger.js",
+      namedImports: ["logger"],
+    });
+  }
+
+  const factoryFunction = clientContextFile.addFunction({
+    docs: getDocsFromDescription(client.doc),
+    name: `create${name}`,
+    returnType: `${rlcClientName}`,
+    parameters: getClientParametersDeclaration(client, dpgContext, {
+      onClientOnly: false,
+      requiredOnly: true,
+    }),
+    isExported: true,
+  });
+
+  const { endpointParamName: endpointParam, assignedOptionalParams } = buildGetClientEndpointParam(
+    factoryFunction,
+    dpgContext,
+    client,
+  );
+  const credentialParam = buildGetClientCredentialParam(client, emitterOptions);
+
+  // Get api version param early so we can use its name when building options
+  const apiVersionParam = getClientParameters(client, dpgContext).find((x) => x.isApiVersionParam);
+  const apiVersionParamName = apiVersionParam ? getClientParameterName(apiVersionParam) : undefined;
+
+  const optionsParam = buildGetClientOptionsParam(
+    factoryFunction,
+    emitterOptions,
+    endpointParam,
+    apiVersionParamName,
+  );
+
+  factoryFunction.addStatements(
+    `const clientContext = ${resolveReference(
+      dependencies.getClient,
+    )}(${endpointParam}, ${credentialParam}, ${optionsParam});`,
+  );
+
+  const { customHttpAuthHeaderName, customHttpAuthSharedKeyPrefix } = emitterOptions.options;
+
+  if (customHttpAuthHeaderName && customHttpAuthSharedKeyPrefix) {
+    factoryFunction.addStatements(`
+      if(${resolveReference(dependencies.isKeyCredential)}(credential)) {
+        clientContext.pipeline.addPolicy({ 
+          name: "customKeyCredentialPolicy",
+          sendRequest(request, next) {
+            request.headers.set("${customHttpAuthHeaderName}", "${customHttpAuthSharedKeyPrefix} " + credential.key);
+            return next(request);
+          }
+        });
+      }
+      `);
+  }
+
+  let apiVersionStatement = ``;
+  const endpointParameter = getClientParameters(client, dpgContext, {
+    onClientOnly: false,
+    requiredOnly: true,
+    skipEndpointTemplate: true,
+  }).find((x) => x.kind === "endpoint");
+  if (apiVersionParam) {
+    const templateArguments =
+      endpointParameter && endpointParameter.type.kind === "endpoint"
+        ? endpointParameter.type.templateArguments
+        : endpointParameter && endpointParameter.type.kind === "union"
+          ? endpointParameter.type.variantTypes[0]?.templateArguments
+          : [];
+    const apiVersionInEndpoint =
+      templateArguments && templateArguments.find((p) => p.isApiVersionParam);
+    if (!apiVersionInEndpoint && apiVersionParam.clientDefaultValue) {
+      apiVersionStatement += `const ${apiVersionParamName} = options.${apiVersionParamName};`;
+    }
+  } else if (isAzurePackage(emitterOptions)) {
+    apiVersionStatement += `
+        if (options.apiVersion) {
+          logger.warning("This client does not support client api-version, please change it at the operation level");
+        }`;
+  } else {
+    apiVersionStatement += `
+        if (options.apiVersion) {
+          console.warn("This client does not support client api-version, please change it at the operation level");
+        }`;
+  }
+  factoryFunction.addStatements(apiVersionStatement);
+
+  const contextRequiredParam = requiredParams.filter(
+    (p) => p.name !== "endpointParam" && p.name !== "credential" && p.name !== "options",
+  );
+
+  // Collect names of required parameters to avoid duplicates
+  const requiredParamNames = new Set(contextRequiredParam.map((p) => p.name));
+
+  // Also include optional parameters from clientInitialization that should be passed through
+  const contextOptionalParams = getClientParameters(client, dpgContext, {
+    optionalOnly: true,
+    onClientOnly: false,
+  }).filter((p) => {
+    const clientParamName = getClientParameterName(p);
+    return (
+      clientParamName !== "endpointParam" &&
+      clientParamName !== "credential" &&
+      clientParamName !== "endpoint" &&
+      !requiredParamNames.has(clientParamName) // Avoid duplicating required parameters
+    );
+  });
+
+  // Build context params, checking if param was already assigned as a required param
+  const allContextParams = [
+    ...contextRequiredParam.map((p) => p.name),
+    ...contextOptionalParams.map((p) => {
+      const clientParamName = getClientParameterName(p);
+      // If this param was already assigned (e.g., as a required param or in endpoint building), use the value directly
+      // Otherwise, get it from options
+      if (
+        requiredParamNames.has(clientParamName) ||
+        (assignedOptionalParams && assignedOptionalParams.has(clientParamName))
+      ) {
+        return clientParamName;
+      }
+      return `${clientParamName}: options.${clientParamName}`;
+    }),
+  ];
+
+  if (allContextParams.length) {
+    factoryFunction.addStatements(
+      `return { ...clientContext, ${allContextParams.join(", ")}} as ${rlcClientName};`,
+    );
+  } else {
+    factoryFunction.addStatements(`return clientContext;`);
+  }
+
+  clientContextFile.fixMissingImports({}, { importModuleSpecifierEnding: "js" });
+
+  clientContextFile.fixUnusedIdentifiers();
+  return clientContextFile;
+}
+
+function getDocsWithKnownVersion(
+  dpgContext: SdkContext,
+  param: SdkMethodParameter | SdkEndpointParameter | SdkCredentialParameter | SdkHttpParameter,
+) {
+  const docs = getDocsFromDescription(param.doc);
+  if (param.name.toLowerCase() !== "apiversion") {
+    return docs;
+  }
+  const apiVersionEnum = getApiVersionEnum(dpgContext);
+  if (apiVersionEnum) {
+    const [_, knownValuesEnum] = buildEnumTypes(dpgContext, apiVersionEnum, true);
+    docs.push(
+      `Known values of {@link ${resolveReference(refkey(knownValuesEnum.name, "knownValues"))}} that the service accepts.`,
+    );
+  }
+  return docs;
+}

package/src/modular/build-operations.ts

@@ -0,0 +1,248 @@
+import { InterfaceDeclarationStructure, SourceFile, StructureKind } from "ts-morph";
+import { NameType, normalizeName } from "../rlc-common/index.js";
+import {
+  getDeserializeExceptionHeadersPrivateFunction,
+  getDeserializeHeadersPrivateFunction,
+  getDeserializePrivateFunction,
+  getExpectedStatuses,
+  getOperationFunction,
+  getOperationOptionsName,
+  getSendPrivateFunction,
+  isLroAndPagingOperation,
+  isLroOnlyOperation,
+} from "./helpers/operation-helpers.js";
+import { ModularEmitterOptions } from "./interfaces.js";
+
+import {
+  SdkClientType,
+  SdkMethodParameter,
+  SdkServiceOperation,
+} from "@azure-tools/typespec-client-generator-core";
+import { useContext } from "../context-manager.js";
+import { addDeclaration } from "../framework/declaration.js";
+import { useDependencies } from "../framework/hooks/use-dependencies.js";
+import { resolveReference } from "../framework/reference.js";
+import { refkey } from "../framework/refkey.js";
+import { getModularClientOptions, isRLCMultiEndpoint } from "../utils/client-utils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import {
+  getMethodHierarchiesMap,
+  hasDualFormatSupport,
+  ServiceOperation,
+} from "../utils/operation-util.js";
+import { getDocsFromDescription } from "./helpers/docs-helpers.js";
+import { getOperationName } from "./helpers/naming-helpers.js";
+import { OperationPathAndDeserDetails } from "./interfaces.js";
+import { getTypeExpression } from "./type-expressions/get-type-expression.js";
+
+/**
+ * This function creates a file under /api for each operation group.
+ * If there is no operation group in the TypeSpec program, we create a single
+ * file called operations.ts where all operations are generated.
+ */
+export function buildOperationFiles(
+  dpgContext: SdkContext,
+  clientMap: [string[], SdkClientType<SdkServiceOperation>],
+  emitterOptions: ModularEmitterOptions,
+) {
+  const project = useContext("outputProject");
+  const [_, client] = clientMap;
+  const operationFiles: Set<SourceFile> = new Set();
+  const { subfolder, rlcClientName } = getModularClientOptions(clientMap);
+  const isMultiEndpoint = isRLCMultiEndpoint(dpgContext);
+  const clientType = isMultiEndpoint ? `Client.${rlcClientName}` : "Client";
+  const methodMap = getMethodHierarchiesMap(dpgContext, client);
+  for (const [prefixKey, operations] of methodMap) {
+    const prefixes = prefixKey.split("/");
+    const operationFileName =
+      prefixes.length > 0 && prefixKey !== ""
+        ? `${prefixes
+            .map((hierarchy) => {
+              return normalizeName(hierarchy, NameType.File);
+            })
+            .join("/")}/operations`
+        : // When the program has no operation groups defined all operations are put
+          // into a nameless operation group. We'll call this operations.
+          "operations";
+
+    const srcPath = emitterOptions.modularOptions.sourceRoot;
+    const filepath = `${srcPath}/${
+      subfolder && subfolder !== "" ? subfolder + "/" : ""
+    }api/${operationFileName}.ts`;
+
+    const operationGroupFile = project.createSourceFile(filepath);
+    operations.forEach((op) => {
+      const operationDeclaration = getOperationFunction(dpgContext, [prefixes, op], clientType);
+      const sendOperationDeclaration = getSendPrivateFunction(
+        dpgContext,
+        [prefixes, op],
+        clientType,
+        client,
+      );
+      const deserializeOperationDeclaration = getDeserializePrivateFunction(dpgContext, [
+        prefixes,
+        op,
+      ]);
+      const deserializeHeadersDeclaration = getDeserializeHeadersPrivateFunction(dpgContext, op);
+      const deserializeExceptionHeadersDeclaration = getDeserializeExceptionHeadersPrivateFunction(
+        dpgContext,
+        op,
+      );
+      const functionsToAdd = [sendOperationDeclaration, deserializeOperationDeclaration];
+      if (deserializeHeadersDeclaration) {
+        functionsToAdd.push(deserializeHeadersDeclaration);
+      }
+      if (deserializeExceptionHeadersDeclaration) {
+        functionsToAdd.push(deserializeExceptionHeadersDeclaration);
+      }
+
+      operationGroupFile.addFunctions(functionsToAdd);
+      addDeclaration(operationGroupFile, operationDeclaration, refkey(op, "api"));
+    });
+
+    const indexPathPrefix = "../".repeat(prefixKey === "" ? 0 : prefixes.length) || "./";
+    operationGroupFile.addImportDeclaration({
+      namedImports: [`${rlcClientName} as Client`],
+      moduleSpecifier: `${indexPathPrefix}index.js`,
+    });
+    operationGroupFile.fixUnusedIdentifiers();
+
+    operationFiles.add(operationGroupFile);
+  }
+  return Array.from(operationFiles);
+}
+
+/**
+ * This function generates the interfaces for each operation options
+ */
+export function buildOperationOptions(
+  context: SdkContext,
+  method: [string[], ServiceOperation],
+  sourceFile: SourceFile,
+) {
+  const dependencies = useDependencies();
+  const operation = method[1];
+  const optionalParameters = operation.parameters
+    .filter(
+      (p) =>
+        p.onClient === false &&
+        !(p.isGeneratedName && (p.name === "contentType" || p.name !== "accept")),
+    )
+    .filter((p) => p.optional || p.clientDefaultValue);
+  const options: SdkMethodParameter[] = [...optionalParameters];
+
+  const name = getOperationOptionsName(method, true);
+  const lroOptions = {
+    name: "updateIntervalInMs",
+    type: "number",
+    hasQuestionToken: true,
+    docs: ["Delay to wait until next poll, in milliseconds."],
+  };
+
+  // Check if this operation supports both JSON and XML content types
+  const bodyContentTypes = operation.operation.bodyParam?.contentTypes ?? [];
+  const isDualFormat = hasDualFormatSupport(bodyContentTypes);
+
+  // Content type option for dual-format operations
+  const contentTypeOption = {
+    name: "contentType",
+    type: "string",
+    hasQuestionToken: true,
+    docs: [
+      'The content type for the request body. Defaults to "application/json". Use "application/xml" for XML serialization.',
+    ],
+  };
+
+  // handle optional body parameter
+  // if (operation.operation.bodyParam?.optional === true) {
+  //   options.push(operation.operation.bodyParam);
+  // }
+  const operationOptionsReference = resolveReference(dependencies.OperationOptions);
+
+  // Build the additional options array
+  const additionalOptions: {
+    name: string;
+    type: string;
+    hasQuestionToken: boolean;
+    docs: string[];
+  }[] = [];
+  if (isLroOnlyOperation(operation) || isLroAndPagingOperation(operation)) {
+    additionalOptions.push(lroOptions);
+  }
+  if (isDualFormat) {
+    additionalOptions.push(contentTypeOption);
+  }
+
+  const operationOptionsInterface: InterfaceDeclarationStructure = {
+    kind: StructureKind.Interface,
+    name,
+    isExported: true,
+    extends: [operationOptionsReference],
+    properties: additionalOptions.concat(
+      options.map((p) => {
+        return {
+          docs: getDocsFromDescription(p.doc),
+          hasQuestionToken: true,
+          type: getTypeExpression(context, p.type, { isOptional: true }),
+          name: normalizeName(p.name, NameType.Parameter),
+        };
+      }),
+    ),
+    docs: [`Optional parameters.`],
+  };
+  addDeclaration(sourceFile, operationOptionsInterface, refkey(method[1], "operationOptions"));
+}
+
+/**
+ * This function creates a map of operation file path to operation names.
+ */
+export function buildLroDeserDetailMap(
+  context: SdkContext,
+  client: SdkClientType<SdkServiceOperation>,
+) {
+  const map = new Map<string, OperationPathAndDeserDetails[]>();
+  const existingNames = new Set<string>();
+  const methodMap = getMethodHierarchiesMap(context, client);
+  for (const [prefixKey, operations] of methodMap) {
+    const prefixes = prefixKey.split("/");
+    const lroOperations = operations.filter((o) => isLroOnlyOperation(o));
+    // skip this operation group if it has no LRO operations
+    if (lroOperations.length === 0) {
+      continue;
+    }
+
+    const operationFileName =
+      prefixes.length > 0 && prefixKey !== ""
+        ? `${prefixes
+            .map((hierarchy) => {
+              return normalizeName(hierarchy, NameType.File);
+            })
+            .join("/")}/operations`
+        : // When the program has no operation groups defined all operations are put
+          // into a nameless operation group. We'll call this operations.
+          "operations";
+    map.set(
+      `./api/${operationFileName}.js`,
+      lroOperations.map((o) => {
+        const { name } = getOperationName(o);
+        const deserName = `_${name}Deserialize`;
+        let renamedDeserName = undefined;
+        if (existingNames.has(deserName)) {
+          const newName = `${name}Deserialize${normalizeName(
+            operationFileName.split("/").slice(0, -1).join("_"),
+            NameType.Interface,
+          )}`;
+          renamedDeserName = `_${newName}`;
+        }
+        existingNames.add(deserName);
+        return {
+          path: `${o.operation.verb.toUpperCase()} ${o.operation.path}`,
+          expectedStatusesExpression: getExpectedStatuses(o),
+          deserName,
+          renamedDeserName,
+        };
+      }),
+    );
+  }
+  return map;
+}

package/src/modular/build-project-files.ts

@@ -0,0 +1,111 @@
+import { NameType } from "../rlc-common/index.js";
+
+import path from "path/posix";
+import { useContext } from "../context-manager.js";
+import { getClientHierarchyMap, getModularClientOptions } from "../utils/client-utils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { getMethodHierarchiesMap } from "../utils/operation-util.js";
+import { getClassicalLayerPrefix } from "./helpers/naming-helpers.js";
+import { ModularEmitterOptions } from "./interfaces.js";
+
+/**
+ * Computes the relative path prefix (e.g. `./src` or `./src/generated`) from
+ * the project root to the modular sources directory.  This prefix is used when
+ * building export map entries so that they always point to the correct folder
+ * even when the generated code lives under `src/generated` instead of `src`.
+ */
+function getSourceRootPrefix(emitterOptions: ModularEmitterOptions, context: SdkContext): string {
+  const sourceRoot = emitterOptions.modularOptions.sourceRoot.replace(/\\/g, "/");
+  const rootDir = (context.generationPathDetail?.rootDir ?? "").replace(/\\/g, "/");
+
+  if (rootDir && sourceRoot.startsWith(rootDir)) {
+    const relativePath = path.relative(rootDir, sourceRoot).replace(/\\/g, "/");
+    return `./${relativePath}`;
+  }
+
+  return "./src";
+}
+
+function buildExportsForMultiClient(
+  context: SdkContext,
+  emitterOptions: ModularEmitterOptions,
+  packageInfo: any,
+) {
+  const srcPrefix = getSourceRootPrefix(emitterOptions, context);
+  const clientMap = getClientHierarchyMap(context);
+  let hasTopLevelClient = false;
+  for (const [hierarchy, client] of clientMap) {
+    const methodMap = getMethodHierarchiesMap(context, client);
+    if (hierarchy.length === 0) {
+      hasTopLevelClient = true;
+    }
+    const { subfolder } = getModularClientOptions([hierarchy, client]);
+    if (subfolder !== "" && methodMap.size > 0) {
+      packageInfo.exports[`./${subfolder}`] = `${srcPrefix}/${subfolder}/index.ts`;
+
+      packageInfo.exports[`./${subfolder}/api`] = `${srcPrefix}/${subfolder}/api/index.ts`;
+    }
+  }
+  if (!hasTopLevelClient) {
+    delete packageInfo.exports["./api"];
+  }
+  if (emitterOptions.options.hierarchyClient) {
+    // TODO: support api subpath exports for multi-service. Skip for now. https://github.com/Azure/autorest.typescript/issues/3717
+    if (!emitterOptions.options.isMultiService) {
+      for (const flattenedClient of clientMap) {
+        const { subfolder } = getModularClientOptions(flattenedClient);
+        const client = flattenedClient[1];
+        const methodMap = getMethodHierarchiesMap(context, client);
+        for (const [prefixKey, _] of methodMap) {
+          const prefixes = prefixKey.split("/");
+          if (prefixKey === "") {
+            continue;
+          }
+          const subApiPath = `api/${getClassicalLayerPrefix(prefixes, NameType.File, "/")}`;
+
+          packageInfo.exports[`./${subfolder ? subfolder + "/" : ""}${subApiPath}`] =
+            `${srcPrefix}/${subfolder ? subfolder + "/" : ""}${subApiPath}/index.ts`;
+        }
+      }
+    }
+    delete packageInfo.exports["./models"];
+    const modelSubpaths = getModelSubpaths(emitterOptions);
+    for (const modelSubpath of modelSubpaths) {
+      packageInfo.exports[`./${modelSubpath.replace("/index.ts", "")}`] =
+        `${srcPrefix}/${modelSubpath}`;
+    }
+  }
+
+  return packageInfo.exports;
+}
+
+export function getModuleExports(context: SdkContext, emitterOptions: ModularEmitterOptions) {
+  const srcPrefix = getSourceRootPrefix(emitterOptions, context);
+  const exports: Record<string, any> = {
+    exports: {
+      ".": `${srcPrefix}/index.ts`,
+      "./models": `${srcPrefix}/models/index.ts`,
+    },
+  };
+  exports["exports"]["./api"] = `${srcPrefix}/api/index.ts`;
+
+  return buildExportsForMultiClient(context, emitterOptions, exports);
+}
+
+function getModelSubpaths(emitterOptions: ModularEmitterOptions) {
+  const outputProject = useContext("outputProject");
+  const modelFiles = outputProject.getSourceFiles(
+    path.join(emitterOptions.modularOptions.sourceRoot.replace(/\\/g, "/"), `models/**/*.ts`),
+  );
+  const subpath = new Set<string>();
+  for (const modelFile of modelFiles) {
+    const filepath = modelFile.getFilePath().replace(/\\/g, "/");
+    if (!filepath.endsWith("index.ts")) {
+      continue;
+    }
+    subpath.add(
+      path.relative(emitterOptions.modularOptions.sourceRoot.replace(/\\/g, "/"), filepath),
+    );
+  }
+  return Array.from(subpath);
+}