@azure-tools/typespec-ts 0.56.0-dev.0 → 0.56.0-dev.2

package/src/transform/transform-helper-function-details.ts

@@ -1,6 +1,6 @@
 import { getHttpOperationWithCache, SdkClient } from "@azure-tools/typespec-client-generator-core";
-import { HelperFunctionDetails } from "../rlc-common/index.js";
-import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { HelperFunctionDetails } from "../interfaces.js";
+import { listOperationsUnderClient } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
 import { getCollectionFormat } from "../utils/model-utils.js";
 import {
@@ -34,7 +34,7 @@ function extractClientPageDetails(client: SdkClient, dpgContext: SdkContext) {
   }
   const nextLinks = new Set<string>(["nextLink"]);
   const itemNames = new Set<string>(["value"]);
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const route = getHttpOperationWithCache(dpgContext, op);
     // ignore overload base operation
     if (route.overloads && route.overloads?.length > 0) {
@@ -61,11 +61,11 @@ function extractClientPageDetails(client: SdkClient, dpgContext: SdkContext) {
 function extractSpecialSerializeInfo(client: SdkClient, dpgContext: SdkContext) {
   let hasMultiCollection = false;
   let hasCsvCollection = false;
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const route = getHttpOperationWithCache(dpgContext, op);
     route.parameters.parameters.forEach((parameter) => {
       const format = getCollectionFormat(dpgContext, parameter as any);
-      const serializeInfo = getSpecialSerializeInfo(dpgContext, parameter.type, format!);
+      const serializeInfo = getSpecialSerializeInfo(parameter.type, format!);
       hasMultiCollection = hasMultiCollection
         ? hasMultiCollection
         : serializeInfo.hasMultiCollection;

package/src/transform/transform-parameters.ts

@@ -8,7 +8,6 @@ import {
 } from "@azure-tools/typespec-client-generator-core";
 import { NoTarget, Type, isVoidType } from "@typespec/compiler";
 import { HttpOperation, HttpOperationParameter, HttpOperationParameters } from "@typespec/http";
-import { reportDiagnostic } from "../lib.js";
 import {
   ApiVersionInfo,
   Imports,
@@ -18,8 +17,9 @@ import {
   ParameterMetadata,
   Schema,
   SchemaContext,
-} from "../rlc-common/index.js";
-import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+} from "../interfaces.js";
+import { reportDiagnostic } from "../lib.js";
+import { listOperationsUnderClient } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
 import {
   KnownMediaType,
@@ -57,9 +57,9 @@ export function transformToParameterTypes(
   importDetails: Imports,
   apiVersionInfo?: ApiVersionInfo,
 ): OperationParameter[] {
-  const rlcParameters: OperationParameter[] = [];
+  const clientParameters: OperationParameter[] = [];
   const outputImportedSet = new Set<string>();
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const route = getHttpOperationWithCache(dpgContext, op);
     // ignore overload base operation
     if (route.overloads && route.overloads?.length > 0) {
@@ -73,15 +73,15 @@ export function transformToParameterTypes(
   }
   function transformToParameterTypesForRoute(route: HttpOperation) {
     const parameters = route.parameters;
-    const rlcParameter: OperationParameter = {
+    const clientParameter: OperationParameter = {
       operationGroup: getOperationGroupName(dpgContext, route),
       operationName: getOperationName(dpgContext, route.operation),
       parameters: [],
     };
     const options = {
       apiVersionInfo,
-      operationGroupName: rlcParameter.operationGroup,
-      operationName: rlcParameter.operationName,
+      operationGroupName: clientParameter.operationGroup,
+      operationName: clientParameter.operationName,
       importModels: outputImportedSet,
     };
     // transform query param
@@ -104,13 +104,13 @@ export function transformToParameterTypes(
         bodyType,
       );
     }
-    rlcParameter.parameters.push({
+    clientParameter.parameters.push({
       parameters: [...queryParams, ...pathParams, ...headerParams],
       body: bodyParameter,
     });
-    rlcParameters.push(rlcParameter);
+    clientParameters.push(clientParameter);
   }
-  return rlcParameters;
+  return clientParameters;
 }
 
 function getParameterMetadata(
@@ -131,7 +131,7 @@ function getParameterMetadata(
   let description = getFormattedPropertyDoc(program, parameter.param, schema) ?? "";
   const format = getCollectionFormat(dpgContext, parameter as any);
   if (isArrayType(schema) && format) {
-    const serializeInfo = getSpecialSerializeInfo(dpgContext, parameter.type, format);
+    const serializeInfo = getSpecialSerializeInfo(parameter.type, format);
     if (serializeInfo.hasMultiCollection || serializeInfo.hasCsvCollection) {
       description += `${description ? "\n" : ""}This parameter could be formatted as ${serializeInfo.collectionInfo.join(
         ", ",

package/src/transform/transform-paths.ts

@@ -7,15 +7,6 @@ import {
   isApiVersion,
 } from "@azure-tools/typespec-client-generator-core";
 import { HttpOperation, HttpOperationParameters } from "@typespec/http";
-import {
-  Imports,
-  OperationMethod,
-  PathMetadata,
-  Paths,
-  SchemaContext,
-  getParameterTypeName,
-  getResponseTypeName,
-} from "../rlc-common/index.js";
 import { getImportedModelName, getSchemaForType, isBodyRequired } from "../utils/model-utils.js";
 import {
   extractOperationLroDetail,
@@ -29,8 +20,10 @@ import {
 } from "../utils/operation-util.js";
 
 import { getDoc } from "@typespec/compiler";
-import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { Imports, OperationMethod, PathMetadata, Paths, SchemaContext } from "../interfaces.js";
+import { listOperationsUnderClient } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
+import { getParameterTypeName, getResponseTypeName } from "../utils/name-constructors.js";
 import { getParameterSerializationInfo } from "../utils/parameter-utils.js";
 
 export function transformPaths(
@@ -40,7 +33,7 @@ export function transformPaths(
 ): Paths {
   const pathParamsImportedSet = new Set<string>();
   const paths: Paths = {};
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const route = getHttpOperationWithCache(dpgContext, op);
     // ignore overload base operation
     if (route.overloads && route.overloads?.length > 0) {
@@ -50,7 +43,7 @@ export function transformPaths(
   }
 
   if (pathParamsImportedSet.size > 0) {
-    importDetails.rlcClientDefinition.importsSet = pathParamsImportedSet;
+    importDetails.clientDefinition.importsSet = pathParamsImportedSet;
   }
 
   return paths;

package/src/transform/transform-responses.ts

@@ -5,15 +5,14 @@ import { getHttpOperationWithCache, SdkClient } from "@azure-tools/typespec-clie
 import { getDoc, isVoidType } from "@typespec/compiler";
 import { HttpOperation, HttpOperationResponse } from "@typespec/http";
 import {
-  getLroLogicalResponseName,
   Imports,
   OperationResponse,
   ResponseHeaderSchema,
   ResponseMetadata,
   Schema,
   SchemaContext,
-} from "../rlc-common/index.js";
-import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+} from "../interfaces.js";
+import { listOperationsUnderClient } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
 import {
   getBinaryType,
@@ -21,6 +20,7 @@ import {
   getSchemaForType,
   getTypeName,
 } from "../utils/model-utils.js";
+import { getLroLogicalResponseName } from "../utils/name-constructors.js";
 import {
   getOperationGroupName,
   getOperationLroOverload,
@@ -35,9 +35,9 @@ export function transformToResponseTypes(
   dpgContext: SdkContext,
   importDetails: Imports,
 ): OperationResponse[] {
-  const rlcResponses: OperationResponse[] = [];
+  const clientResponses: OperationResponse[] = [];
   const inputImportedSet = new Set<string>();
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const route = getHttpOperationWithCache(dpgContext, op);
     // ignore overload base operation
     if (route.overloads && route.overloads?.length > 0) {
@@ -49,7 +49,7 @@ export function transformToResponseTypes(
     importDetails.response.importsSet = inputImportedSet;
   }
   function transformToResponseTypesForRoute(route: HttpOperation) {
-    const rlcOperationUnit: OperationResponse = {
+    const operationUnit: OperationResponse = {
       operationGroup: getOperationGroupName(dpgContext, route),
       operationName: getOperationName(dpgContext, route.operation),
       path: route.path,
@@ -59,7 +59,7 @@ export function transformToResponseTypes(
       nonDefaultSchemas: Schema[] = [];
     for (const resp of sortedOperationResponses(route.responses)) {
       const statusCode = getOperationStatuscode(resp);
-      const rlcResponseUnit: ResponseMetadata = {
+      const responseUnit: ResponseMetadata = {
         statusCode,
         description: resp.description,
       };
@@ -67,8 +67,8 @@ export function transformToResponseTypes(
       const headers = transformHeaders(dpgContext, resp, inputImportedSet);
       // transform body
       const [body, schemas] = transformBody(dpgContext, resp, inputImportedSet) ?? [undefined, []];
-      rlcOperationUnit.responses.push({
-        ...rlcResponseUnit,
+      operationUnit.responses.push({
+        ...responseUnit,
         headers,
         body,
       });
@@ -82,20 +82,20 @@ export function transformToResponseTypes(
       dpgContext,
       route,
       getOperationGroupName(dpgContext, route),
-      rlcOperationUnit.responses,
+      operationUnit.responses,
     );
     if (lroLogicalResponse) {
-      rlcOperationUnit.responses.push(lroLogicalResponse);
+      operationUnit.responses.push(lroLogicalResponse);
     }
-    rlcResponses.push(rlcOperationUnit);
+    clientResponses.push(operationUnit);
   }
-  return rlcResponses;
+  return clientResponses;
 }
 
 /**
  * Return undefined if no valid header param
  * @param response response detail
- * @returns rlc header schema
+ * @returns the response header schema
  */
 function transformHeaders(
   dpgContext: SdkContext,
@@ -106,8 +106,8 @@ function transformHeaders(
     return;
   }
 
-  const rlcHeaders: Map<string, ResponseHeaderSchema> = new Map();
-  // Current RLC client can't represent different headers per content type.
+  const responseHeaders: Map<string, ResponseHeaderSchema> = new Map();
+  // The client can't represent different headers per content type.
   // So we merge headers here, and report any duplicates.
   // It may be possible in principle to not error for identically declared
   // headers.
@@ -139,11 +139,11 @@ function transformHeaders(
         required: !value?.optional,
         description: getDoc(dpgContext.program, value!),
       };
-      rlcHeaders.set(header.name, header);
+      responseHeaders.set(header.name, header);
     }
   }
 
-  return rlcHeaders.size ? Array.from(rlcHeaders.values()) : undefined;
+  return responseHeaders.size ? Array.from(responseHeaders.values()) : undefined;
 }
 
 function transformBody(
@@ -154,7 +154,7 @@ function transformBody(
   if (!response.responses.length) {
     return;
   }
-  // Currently RLC response only have one header and body defined
+  // Currently a response only has one header and body defined
   // So we'll union all body shapes together with "|"
   const typeSet = new Set<string>();
   const descriptions = new Set<string>();

package/src/transform/transform-schemas.ts

@@ -15,19 +15,19 @@ import {
 } from "../utils/model-utils.js";
 
 import { useContext } from "../context-manager.js";
-import { SchemaContext } from "../rlc-common/index.js";
-import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { SchemaContext } from "../interfaces.js";
+import { listOperationsUnderClient } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
 
 export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
   const program = dpgContext.program;
-  const metatree = useContext("rlcMetaTree");
+  const metatree = useContext("clientTypeMetaTree");
   const schemas: Map<string, SchemaContext[]> = new Map<string, SchemaContext[]>();
   const schemaMap: Map<any, any> = new Map<any, any>();
   const usageMap = new Map<Type, SchemaContext[]>();
   const requestBodySet = new Set<Type>();
   const contentTypeMap = new Map<Type, KnownMediaType[]>();
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const route = getHttpOperationWithCache(dpgContext, op);
     // ignore overload base operation
     if (route.overloads && route.overloads?.length > 0) {
@@ -103,7 +103,7 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
     if (model) {
       model.usage = context;
     }
-    metatree.set(tspModel, { rlcType: model });
+    metatree.set(tspModel, { clientType: model });
     if (model.name === "") {
       return;
     }

package/src/transform/transform-telemetry-info.ts

@@ -3,8 +3,8 @@ import {
   SdkClient,
   SdkContext,
 } from "@azure-tools/typespec-client-generator-core";
-import { TelemetryInfo } from "../rlc-common/index.js";
-import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { TelemetryInfo } from "../interfaces.js";
+import { listOperationsUnderClient } from "../utils/client-utils.js";
 import { getCustomRequestHeaderNameForOperation } from "../utils/operation-util.js";
 
 export function transformTelemetryInfo(
@@ -21,7 +21,7 @@ export function transformTelemetryInfo(
 }
 
 function getCustomRequestHeaderNameForClient(dpgContext: SdkContext, client: SdkClient) {
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const headerName = getCustomRequestHeaderNameForOperation(
       getHttpOperationWithCache(dpgContext, op),
     );

package/src/transform/transform.ts

@@ -5,21 +5,18 @@ import { SdkClient } from "@azure-tools/typespec-client-generator-core";
 import { getDoc, joinPaths } from "@typespec/compiler";
 import { getServers } from "@typespec/http";
 import {
-  buildRuntimeImports,
+  ClientModel,
+  ClientOptions,
   Imports,
-  initInternalImports,
-  NameType,
-  normalizeName,
   OperationParameter,
   OperationResponse,
   PathParameter,
   Paths,
-  RLCModel,
-  RLCOptions,
   Schema,
   SchemaContext,
   UrlInfo,
-} from "../rlc-common/index.js";
+} from "../interfaces.js";
+import { buildRuntimeImports, initInternalImports } from "../utils/imports-util.js";
 import { SdkContext } from "../utils/interfaces.js";
 import {
   getDefaultService,
@@ -29,6 +26,7 @@ import {
   getTypeName,
   predictDefaultValue,
 } from "../utils/model-utils.js";
+import { NameType, normalizeName } from "../utils/name-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";
@@ -38,15 +36,15 @@ import { transformToResponseTypes } from "./transform-responses.js";
 import { transformSchemas } from "./transform-schemas.js";
 import { transformTelemetryInfo } from "./transform-telemetry-info.js";
 
-export async function transformRLCModel(
+export async function transformClientModel(
   client: SdkClient,
   dpgContext: SdkContext,
-): Promise<RLCModel> {
+): Promise<ClientModel> {
   const program = dpgContext.program;
-  const options: RLCOptions = dpgContext.rlcOptions!;
-  const rlcSourceDir = dpgContext.generationPathDetail?.rlcSourcesDir;
+  const options: ClientOptions = dpgContext.emitterOptions!;
+  const sourceDir = dpgContext.generationPathDetail?.sourcesDir;
   const srcPath = joinPaths(
-    dpgContext.generationPathDetail?.rlcSourcesDir ?? "",
+    dpgContext.generationPathDetail?.sourcesDir ?? "",
     options.batch && options.batch.length > 1
       ? normalizeName(client.name.replace("Client", ""), NameType.File)
       : "",
@@ -71,7 +69,7 @@ export async function transformRLCModel(
   helperDetails.clientLroOverload = getClientLroOverload(paths);
 
   const telemetryOptions = transformTelemetryInfo(client, dpgContext);
-  const model: RLCModel = {
+  const model: ClientModel = {
     srcPath,
     libraryName,
     paths,
@@ -87,11 +85,8 @@ export async function transformRLCModel(
       internalImports: importSet,
       runtimeImports: buildRuntimeImports(),
     },
-    rlcSourceDir,
+    sourceDir,
   };
-  // RLC sample generation has been removed; modular samples are emitted separately,
-  // so the RLC model never carries sample groups.
-  options.generateSample = false;
   return model;
 }
 
@@ -145,7 +140,7 @@ export function transformUrlInfo(
     }
   }
   if (importedModels.size > 0) {
-    importDetails.rlcClientFactory.importsSet = importedModels;
+    importDetails.clientFactory.importsSet = importedModels;
   }
   if (endpoint && urlParameters.length > 0) {
     for (const param of urlParameters) {

package/src/utils/client-utils.ts

@@ -14,11 +14,11 @@ import {
   Namespace,
   Operation,
 } from "@typespec/compiler";
-import { ModularClientOptions } from "../modular/interfaces.js";
-import { NameType, normalizeName } from "../rlc-common/index.js";
+import { ClientModuleInfo } from "../modular/interfaces.js";
 import { SdkContext } from "./interfaces.js";
+import { NameType, normalizeName } from "./name-utils.js";
 
-export function getRLCClients(dpgContext: SdkContext): SdkClient[] {
+export function getClients(dpgContext: SdkContext): SdkClient[] {
   const clients = listClients(dpgContext);
   const rawServiceNamespaces =
     dpgContext.allServiceNamespaces ?? listAllServiceNamespaces(dpgContext);
@@ -79,7 +79,7 @@ export function getRLCClients(dpgContext: SdkContext): SdkClient[] {
   });
 }
 
-export function listOperationsUnderRLCClient(client: SdkClient): Operation[] {
+export function listOperationsUnderClient(client: SdkClient): Operation[] {
   const operations = [];
   const serviceArray = client.services;
   const queue: (Namespace | Interface)[] = [...serviceArray];
@@ -110,17 +110,17 @@ export function listOperationsUnderRLCClient(client: SdkClient): Operation[] {
   return operations;
 }
 
-export function isRLCMultiEndpoint(dpgContext: SdkContext): boolean {
-  return getRLCClients(dpgContext).length > 1;
+export function isMultiEndpointClient(dpgContext: SdkContext): boolean {
+  return getClients(dpgContext).length > 1;
 }
 
-export function getModularClientOptions(clientMap: [string[], SdkClientType<SdkServiceOperation>]) {
+export function getClientModuleInfo(clientMap: [string[], SdkClientType<SdkServiceOperation>]) {
   const [hierarchy, client] = clientMap;
-  const clientOptions: ModularClientOptions = {
-    rlcClientName: `${client.name.replace(/Client$/, "")}Context`,
+  const clientModuleInfo: ClientModuleInfo = {
+    clientName: `${client.name.replace(/Client$/, "")}Context`,
   };
-  clientOptions.subfolder = hierarchy.join("/");
-  return clientOptions;
+  clientModuleInfo.subfolder = hierarchy.join("/");
+  return clientModuleInfo;
 }
 
 export function getClientHierarchyMap(

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

@@ -3,15 +3,15 @@
 
 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 { NameType, normalizeName } from "./name-utils.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 modularSourcesRoot = dpgContext.generationPathDetail?.sourcesDir ?? "src";
   const emitterOptions = transformModularEmitterOptions(dpgContext, modularSourcesRoot, {
     casing: "camel",
   });
@@ -24,7 +24,7 @@ export function generateCrossLanguageDefinitionFile(dpgContext: SdkContext): {
   }
   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) {
+    if (dpgContext.emitterOptions?.isMultiService && enm.usage === UsageFlags.ApiVersionEnum) {
       continue;
     }
     CrossLanguageDefinitionId[`${packageName}!Known${enm.name}:enum`] =

package/src/utils/emit-util.ts

@@ -3,20 +3,20 @@ import { format } from "prettier";
 import prettierPluginBabel from "prettier/plugins/babel";
 import prettierPluginEstree from "prettier/plugins/estree";
 import prettierPluginTypescript from "prettier/plugins/typescript";
+import { ClientModel, ContentBuilder, File } from "../interfaces.js";
 import { prettierJSONOptions, prettierTypeScriptOptions, reportDiagnostic } from "../lib.js";
-import { ContentBuilder, File, RLCModel } from "../rlc-common/index.js";
 
 export async function emitContentByBuilder(
   program: Program,
   builderFnOrList: ContentBuilder | ContentBuilder[],
-  rlcModels: RLCModel,
+  clientModels: ClientModel,
   emitterOutputDir?: string,
 ) {
   if (!Array.isArray(builderFnOrList)) {
     builderFnOrList = [builderFnOrList];
   }
   for (const builderFn of builderFnOrList) {
-    let contentFiles: File[] | File | undefined = builderFn(rlcModels);
+    let contentFiles: File[] | File | undefined = builderFn(clientModels);
     if (!contentFiles) {
       continue;
     }

package/src/{rlc-common/helpers → utils}/imports-util.ts

@@ -63,20 +63,20 @@ export function initInternalImports(): Imports {
       type: "response",
       importsSet: new Set<string>(),
     },
-    rlcIndex: {
-      type: "rlcIndex",
+    index: {
+      type: "index",
       importsSet: new Set<string>(),
     },
     modularModel: {
       type: "modularModel",
       importsSet: new Set<string>(),
     },
-    rlcClientFactory: {
-      type: "rlcClientFactory",
+    clientFactory: {
+      type: "clientFactory",
       importsSet: new Set<string>(),
     },
-    rlcClientDefinition: {
-      type: "rlcClientDefinition",
+    clientDefinition: {
+      type: "clientDefinition",
       importsSet: new Set<string>(),
     },
     serializerHelpers: {

package/src/utils/interfaces.ts

@@ -1,10 +1,10 @@
 import { SdkContext as TCGCSdkContext } from "@azure-tools/typespec-client-generator-core";
 import { ModelProperty, Namespace } from "@typespec/compiler";
-import { RLCOptions, SchemaContext } from "../rlc-common/index.js";
+import { ClientOptions, SchemaContext } from "../interfaces.js";
 import { KnownMediaType } from "./media-types.js";
 
 export interface SdkContext extends TCGCSdkContext {
-  rlcOptions?: RLCOptions;
+  emitterOptions?: ClientOptions;
   generationPathDetail?: GenerationDirDetail;
   hasApiVersionInClient?: boolean;
   allServiceNamespaces?: Namespace[];
@@ -12,8 +12,7 @@ export interface SdkContext extends TCGCSdkContext {
 
 export interface GenerationDirDetail {
   rootDir: string;
-  rlcSourcesDir: string;
-  modularSourcesDir?: string;
+  sourcesDir: string;
   metadataDir: string;
 }
 

package/src/utils/model-utils.ts

@@ -64,21 +64,20 @@ import {
   isBody,
   isStatusCode,
 } from "@typespec/http";
+import { GetSchemaOptions, SdkContext } from "./interfaces.js";
+import { KnownMediaType, hasMediaType, isMediaTypeMultipartFormData } from "./media-types.js";
+
 import {
   ArraySchema,
   DictionarySchema,
-  NameType,
   ObjectSchema,
   Schema,
   SchemaContext,
-  isArraySchema,
-  normalizeName,
-} from "../rlc-common/index.js";
-import { GetSchemaOptions, SdkContext } from "./interfaces.js";
-import { KnownMediaType, hasMediaType, isMediaTypeMultipartFormData } from "./media-types.js";
-
+} from "../interfaces.js";
 import { reportDiagnostic } from "../lib.js";
+import { NameType, normalizeName } from "./name-utils.js";
 import { getModelNamespaceName } from "./namespace-utils.js";
+import { isArraySchema } from "./schema-helpers.js";
 
 export const BINARY_TYPE_UNION =
   "string | Uint8Array | ReadableStream<Uint8Array> | NodeReadableStream";
@@ -859,7 +858,7 @@ function getModelName(dpgContext: SdkContext, model: Model) {
     fullNamespacePrefix = "";
   }
   // 5. check if this model should be namespaced
-  return dpgContext.rlcOptions?.enableModelNamespace ? `${fullNamespacePrefix}${name}` : name;
+  return dpgContext.emitterOptions?.enableModelNamespace ? `${fullNamespacePrefix}${name}` : name;
 }
 
 // Map an typespec type to an OA schema. Returns undefined when the resulting

package/src/{rlc-common/helpers → utils}/name-constructors.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { RLCModel } from "../interfaces.js";
+import { ClientModel } from "../interfaces.js";
 import { NameType, normalizeName } from "./name-utils.js";
 
 /**
@@ -76,7 +76,7 @@ export function getParameterTypeName(baseNameOrOperationGroup: string, operation
   return normalizeName(`${baseNameOrOperationGroup}_Parameters`, NameType.Interface);
 }
 
-export function getClientName(model: RLCModel) {
+export function getClientName(model: ClientModel) {
   return model.libraryName;
 }
 

package/src/utils/namespace-utils.ts

@@ -22,15 +22,15 @@ export function getOperationNamespaceInterfaceName(
 ): string[] {
   const result: string[] = [];
   if (
-    dpgContext.rlcOptions?.hierarchyClient === false &&
-    dpgContext.rlcOptions?.enableOperationGroup !== true
+    dpgContext.emitterOptions?.hierarchyClient === false &&
+    dpgContext.emitterOptions?.enableOperationGroup !== true
   ) {
     return result;
   }
   if (operation.interface) {
     if (
-      dpgContext.rlcOptions?.enableOperationGroup === true &&
-      dpgContext.rlcOptions?.hierarchyClient === false
+      dpgContext.emitterOptions?.enableOperationGroup === true &&
+      dpgContext.emitterOptions?.hierarchyClient === false
     ) {
       result.push(operation.interface.name);
       return result;