@azure-tools/typespec-ts 0.56.1-dev.1 → 0.57.0-dev.10

package/src/modular/emit-samples.ts

@@ -17,7 +17,14 @@ import { AzureIdentityDependencies } from "../modular/external-dependencies.js";
 import { getSubscriptionId } from "../transform/transform-client-options.js";
 import { hasKeyCredential, hasTokenCredential } from "../utils/credential-utils.js";
 import type { SdkContext } from "../utils/interfaces.js";
-import { NameType, normalizeName } from "../utils/name-utils.js";
+import {
+  formatPropertyName,
+  NameType,
+  normalizeName,
+  normalizeSdkName,
+  normalizeSdkPropertyName,
+  type SdkName,
+} from "../utils/name-utils.js";
 import {
   getMethodHierarchiesMap,
   isTenantLevelOperation,
@@ -61,10 +68,7 @@ export function emitSamples(dpgContext: SdkContext): SourceFile[] {
     emitClientSamples(dpgContext, client, {
       topLevelClient: client,
       generatedFiles,
-      subFolder:
-        clients.length > 1
-          ? normalizeName(getClassicalClientName(client), NameType.File)
-          : undefined,
+      subFolder: clients.length > 1 ? normalizeSdkName(client, NameType.File) : undefined,
     });
   }
   return generatedFiles;
@@ -193,9 +197,9 @@ function emitMethodSamples(
     }
     const prefix = options.classicalMethodPrefix ? `${options.classicalMethodPrefix}.` : "";
     const isPaging = method.kind === "paging";
-    const methodCall = `client.${prefix}${normalizeName(method.oriName ?? method.name, NameType.Property)}(${methodParams.join(
-      ", ",
-    )})`;
+    const methodCall = `client.${prefix}${normalizeSdkName(method, NameType.Property, {
+      nameOverride: method.oriName ?? method.name,
+    })}(${methodParams.join(", ")})`;
     if (isPaging) {
       exampleFunctionBody.push(`const resArray = new Array();`);
       exampleFunctionBody.push(`for await (const item of ${methodCall}) { resArray.push(item); }`);
@@ -244,13 +248,14 @@ function buildParameterValueMap(example: SdkHttpOperationExample) {
 
 function prepareExampleValue(
   context: SdkContext,
-  name: string,
+  name: string | SdkName,
   value: SdkExampleValue | string,
   isOptional?: boolean,
   onClient?: boolean,
 ): ExampleValue {
+  const sdkName = typeof name === "string" ? { name } : name;
   return {
-    name: normalizeName(name, NameType.Parameter, true),
+    name: normalizeSdkName(sdkName, NameType.Parameter, { shouldGuard: true }),
     value: typeof value === "string" ? value : getParameterValue(context, value),
     isOptional: Boolean(isOptional),
     onClient: Boolean(onClient),
@@ -356,13 +361,7 @@ function prepareExampleParameters(
         subscriptionIdValue = getParameterValue(dpgContext, exampleValue.value);
       }
       result.push(
-        prepareExampleValue(
-          dpgContext,
-          param.name,
-          subscriptionIdValue,
-          param.optional,
-          param.onClient,
-        ),
+        prepareExampleValue(dpgContext, param, subscriptionIdValue, param.optional, param.onClient),
       );
       continue;
     }
@@ -413,7 +412,8 @@ function prepareExampleParameters(
       bodyExample.value.kind === "model"
     ) {
       for (const prop of bodyParam.type.properties) {
-        const propExample = bodyExample.value.value[prop.name];
+        const wireName = prop.serializationOptions.json?.name ?? prop.name;
+        const propExample = bodyExample.value.value[wireName] ?? bodyExample.value.value[prop.name];
         if (!propExample) {
           continue;
         }
@@ -422,7 +422,7 @@ function prepareExampleParameters(
           continue;
         }
         result.push(
-          prepareExampleValue(dpgContext, prop.name, propExample, prop.optional, prop.onClient),
+          prepareExampleValue(dpgContext, prop, propExample, prop.optional, prop.onClient),
         );
       }
     } else {
@@ -433,18 +433,17 @@ function prepareExampleParameters(
       if (isNestedBody) {
         const path = segments[0]!;
         // The first segment is the method-level wrapper param (e.g., "body")
-        const methodParamName = path[0]!.name;
         const methodParamOptional = path[0]!.optional;
         // Wrap the example value with the intermediate property names
         let wrappedValue = getParameterValue(dpgContext, bodyExample.value);
         for (let i = path.length - 1; i >= 1; i--) {
-          const propName = normalizeName(path[i]!.name, NameType.Property, true);
+          const propName = formatPropertyName(normalizeSdkPropertyName(path[i]!));
           wrappedValue = `{ ${propName}: ${wrappedValue} }`;
         }
         result.push(
           prepareExampleValue(
             dpgContext,
-            methodParamName,
+            path[0]!,
             wrappedValue,
             methodParamOptional,
             bodyParam.onClient,
@@ -454,7 +453,7 @@ function prepareExampleParameters(
         result.push(
           prepareExampleValue(
             dpgContext,
-            bodyParam.name,
+            bodyParam,
             bodyExample.value,
             bodyParam.optional,
             bodyParam.onClient,
@@ -467,7 +466,7 @@ function prepareExampleParameters(
   // a scalar value; a parameter with nested leaves carries an object literal.
   for (const arg of methodArguments.values()) {
     result.push({
-      name: normalizeName(arg.name, NameType.Parameter, true),
+      name: normalizeSdkName(arg, NameType.Parameter, { shouldGuard: true }),
       value: serializeNestedValue(arg.value),
       isOptional: arg.isOptional,
       onClient: false,
@@ -491,15 +490,20 @@ interface ValueTreeNode {
 function placeMethodArgument(
   methodArguments: Map<
     string,
-    { name: string; isOptional: boolean; value: ValueTreeNode | string }
+    { name: string; isExactName?: boolean; isOptional: boolean; value: ValueTreeNode | string }
   >,
-  path: readonly { name: string; optional?: boolean }[],
+  path: readonly { name: string; isExactName?: boolean; optional?: boolean }[],
   leaf: string,
 ): void {
   const root = path[0]!;
   let arg = methodArguments.get(root.name);
   if (!arg) {
-    arg = { name: root.name, isOptional: Boolean(root.optional), value: {} };
+    arg = {
+      name: root.name,
+      isExactName: root.isExactName,
+      isOptional: Boolean(root.optional),
+      value: {},
+    };
     methodArguments.set(root.name, arg);
   }
   if (path.length === 1) {
@@ -515,12 +519,12 @@ function placeMethodArgument(
 /** Places `leaf` at `path` (segments after the root), creating intermediate objects as needed. */
 function setNestedValue(
   root: ValueTreeNode,
-  path: readonly { name: string }[],
+  path: readonly { name: string; isExactName?: boolean }[],
   leaf: string,
 ): void {
   let node = root;
   for (let i = 0; i < path.length; i++) {
-    const key = normalizeName(path[i]!.name, NameType.Property, true);
+    const key = normalizeSdkPropertyName(path[i]!);
     if (i === path.length - 1) {
       node[key] = leaf;
     } else {
@@ -539,7 +543,7 @@ function serializeNestedValue(node: ValueTreeNode | string): string {
     return node;
   }
   const entries = Object.entries(node).map(
-    ([key, value]) => `${key}: ${serializeNestedValue(value)}`,
+    ([key, value]) => `${formatPropertyName(key)}: ${serializeNestedValue(value)}`,
   );
   return `{ ${entries.join(", ")} }`;
 }
@@ -635,7 +639,10 @@ function getParameterValue(
       }) {
         let property;
         if (value.type.kind === "model") {
-          property = value.type.properties.find((p) => p.name === propName);
+          property =
+            value.type.properties.find(
+              (p) => (p.serializationOptions.json?.name ?? p.name) === propName,
+            ) ?? value.type.properties.find((p) => p.name === propName);
         }
         const propValue = value.value[propName];
         if (propValue === undefined || propValue === null) {
@@ -668,7 +675,7 @@ function getParameterValue(
           // so that independent inner flattens at deeper levels still work.
           const childOptions = options?.overrides?.enableFlatten === false ? undefined : options;
           propRetValue =
-            `"${mapper.get(propName) ?? propName}": ` +
+            `${JSON.stringify(mapper.get(propName) ?? propName)}: ` +
             getParameterValue(context, propValue, childOptions);
         }
         if (propRetValue) values.push(propRetValue);
@@ -682,14 +689,15 @@ function getParameterValue(
           continue;
         }
         const propRetValue =
-          `"${mapper.get(propName) ?? propName}": ` + getParameterValue(context, propValue);
+          `${JSON.stringify(mapper.get(propName) ?? propName)}: ` +
+          getParameterValue(context, propValue);
         additionalBags.push(propRetValue);
       }
       if (additionalBags.length > 0) {
         const name = mapper.get("additionalProperties")
           ? "additionalPropertiesBag"
           : "additionalProperties";
-        values.push(`"${name}": {
+        values.push(`${JSON.stringify(name)}: {
           ${additionalBags.join(", ")}
           }`);
       }

package/src/modular/emit-tests.ts

@@ -2,7 +2,7 @@ import { type CompilerHost, joinPaths } from "@typespec/compiler";
 import { SourceFile } from "ts-morph";
 import { resolveReference } from "../framework/reference.js";
 import type { SdkContext } from "../utils/interfaces.js";
-import { NameType, normalizeName } from "../utils/name-utils.js";
+import { NameType, normalizeName, normalizeSdkName } from "../utils/name-utils.js";
 import type { ServiceOperation } from "../utils/operation-util.js";
 import { AzureTestDependencies } from "./external-dependencies.js";
 import {
@@ -41,7 +41,7 @@ async function cleanupTestFolder(dpgContext: SdkContext, host: CompilerHost) {
   // If there are multiple clients, clean up subfolders
   if (clients.length > 1) {
     for (const client of clients) {
-      const subFolder = normalizeName(getClassicalClientName(client), NameType.File);
+      const subFolder = normalizeSdkName(client, NameType.File);
       const clientTestFolder = joinPaths(baseTestFolder, subFolder);
       if (await dirExists(clientTestFolder)) {
         await host.rm(clientTestFolder, { recursive: true });

package/src/modular/helpers/classical-operation-helpers.ts

@@ -15,7 +15,7 @@ import { resolveReference } from "../../framework/reference.js";
 import { refkey } from "../../framework/refkey.js";
 import { getClientModuleInfo } from "../../utils/client-utils.js";
 import type { SdkContext } from "../../utils/interfaces.js";
-import { NameType, normalizeName } from "../../utils/name-utils.js";
+import { NameType, normalizeName, normalizeSdkName } from "../../utils/name-utils.js";
 import type { ServiceOperation } from "../../utils/operation-util.js";
 import { AzurePollingDependencies } from "../external-dependencies.js";
 import { PagingHelpers, SimplePollerHelpers } from "../static-helpers-metadata.js";
@@ -25,8 +25,7 @@ import { getOperationFunction } from "./operation-helpers.js";
 interface OperationDeclarationInfo {
   // the operation function
   declaration: OptionalKind<FunctionDeclarationStructure>;
-  // the original operation name
-  oriName: string | undefined;
+  operation: ServiceOperation;
   // the refkey of the operation declaration
   declarationRefKey: string | undefined;
   // the default is false
@@ -58,6 +57,7 @@ export function getClassicalOperation(
 ) {
   const prefixes = operationGroup[0];
   const operations = operationGroup[1];
+  const client = clientMap[1];
   const { clientName } = getClientModuleInfo(clientMap);
   const hasClientContextImport = classicFile.getImportDeclarations().filter((i) => {
     return (
@@ -84,7 +84,7 @@ export function getClassicalOperation(
       const declaration = getOperationFunction(dpgContext, [prefixes, operation], clientName);
       operationDeclarationMap.set(declaration, {
         declaration,
-        oriName: operation.oriName,
+        operation,
         declarationRefKey: resolveReference(refkey(operation, "api")),
         isLro: declaration.isLro,
         lroFinalReturnType: declaration.lroFinalReturnType,
@@ -119,7 +119,9 @@ export function getClassicalOperation(
       properties.push({
         kind: StructureKind.PropertySignature,
         name,
-        type: resolveReference(refkey(nextLayerInterfaceName, layer + 1, "classicOperations")),
+        type: resolveReference(
+          refkey(client, nextLayerInterfaceName, layer + 1, "classicOperations"),
+        ),
       });
     }
   } else {
@@ -197,7 +199,7 @@ export function getClassicalOperation(
     addDeclaration(
       classicFile,
       interfaceDeclaration,
-      refkey(interfaceName, layer, "classicOperations"),
+      refkey(client, interfaceName, layer, "classicOperations"),
     );
   }
 
@@ -286,7 +288,7 @@ export function getClassicalOperation(
     addDeclaration(
       classicFile,
       functionDeclaration,
-      refkey(functionName, layer, "getClassicOperation"),
+      refkey(client, functionName, layer, "getClassicOperation"),
     );
   }
 
@@ -319,11 +321,11 @@ export function getClassicalOperation(
           ${normalizeName(
             prefixes[layer + 1] ?? "FIXME",
             NameType.Property,
-          )}: ${resolveReference(refkey(nextLayerOperationFunctionName, layer + 1, "getClassicOperations"))}(context)}`;
+          )}: ${resolveReference(refkey(client, nextLayerOperationFunctionName, layer + 1, "getClassicOperations"))}(context)}`;
         }
       } else {
         statement = `,
-      ...${resolveReference(refkey(nextLayerOperationFunctionName, layer + 1, "getClassicOperations"))}(context)}`;
+      ...${resolveReference(refkey(client, nextLayerOperationFunctionName, layer + 1, "getClassicOperations"))}(context)}`;
       }
 
       if (statement) {
@@ -342,23 +344,23 @@ export function getClassicalOperation(
           type: clientName,
         },
       ],
-      returnType: resolveReference(refkey(interfaceName, layer, "classicOperations")),
+      returnType: resolveReference(refkey(client, interfaceName, layer, "classicOperations")),
       statements:
         layer !== prefixes.length - 1
           ? `return {
             ${normalizeName(
               prefixes[layer + 1] ?? "FIXME",
               NameType.Property,
-            )}: ${resolveReference(refkey(nextLayerOperationFunctionName, layer + 1, "getClassicOperations"))}(context)   
+            )}: ${resolveReference(refkey(client, nextLayerOperationFunctionName, layer + 1, "getClassicOperations"))}(context)
       }`
           : `return {
-        ...${resolveReference(refkey(functionName, layer, "getClassicOperation"))}(context)
+        ...${resolveReference(refkey(client, functionName, layer, "getClassicOperation"))}(context)
       }`,
     };
     addDeclaration(
       classicFile,
       functions,
-      refkey(operationFunctionName, layer, "getClassicOperations"),
+      refkey(client, operationFunctionName, layer, "getClassicOperations"),
     );
   }
 
@@ -367,12 +369,11 @@ export function getClassicalOperation(
       propertyName?: string;
     },
   ) {
-    return normalizeName(
-      operationDeclarationMap.get(declaration)?.oriName ??
-        declaration.propertyName ??
-        declaration.name ??
-        "FIXME",
-      NameType.Method,
-    );
+    const operationInfo = operationDeclarationMap.get(declaration);
+    const name =
+      operationInfo?.operation.oriName ?? declaration.propertyName ?? declaration.name ?? "FIXME";
+    return normalizeSdkName(operationInfo?.operation ?? { name }, NameType.Method, {
+      nameOverride: name,
+    });
   }
 }

package/src/modular/helpers/client-helpers.ts

@@ -16,7 +16,7 @@ import type { ModularEmitterOptions } from "../interfaces.js";
 
 import { resolveReference } from "../../framework/reference.js";
 import type { SdkContext } from "../../utils/interfaces.js";
-import { NameType, normalizeName } from "../../utils/name-utils.js";
+import { NameType, normalizeSdkName } from "../../utils/name-utils.js";
 import { CloudSettingHelpers } from "../static-helpers-metadata.js";
 import { getTypeExpression } from "../type-expressions/get-type-expression.js";
 import { getClassicalClientName } from "./naming-helpers.js";
@@ -154,15 +154,16 @@ function getClientParameterTypeExpression(context: SdkContext, parameter: SdkPar
 export function getClientParameterName(parameter: SdkParameter) {
   // We have been calling this endpointParam, so special handling this here to make sure there are no unexpected side effects
   if (
-    (parameter.type.kind === "union" &&
+    !parameter.isExactName &&
+    ((parameter.type.kind === "union" &&
       parameter.type.variantTypes.some((v) => v.kind === "endpoint")) ||
-    ((parameter.kind === "endpoint" || parameter.kind === "path") &&
-      parameter.name.toLowerCase() === "endpoint")
+      ((parameter.kind === "endpoint" || parameter.kind === "path") &&
+        parameter.name.toLowerCase() === "endpoint"))
   ) {
     return "endpointParam";
   }
 
-  return normalizeName(parameter.name, NameType.Parameter, true);
+  return normalizeSdkName(parameter, NameType.Parameter, { shouldGuard: true });
 }
 
 export function buildGetClientEndpointParam(

package/src/modular/helpers/example-value-helpers.ts

@@ -15,7 +15,16 @@ import { resolveReference } from "../../framework/reference.js";
 import { getSubscriptionId } from "../../transform/transform-client-options.js";
 import { hasKeyCredential, hasTokenCredential } from "../../utils/credential-utils.js";
 import type { SdkContext } from "../../utils/interfaces.js";
-import { NameType, normalizeName } from "../../utils/name-utils.js";
+import {
+  formatOptionalPropertyAccess,
+  formatPropertyAccess,
+  formatPropertyName,
+  NameType,
+  normalizeName,
+  normalizeSdkName,
+  normalizeSdkPropertyName,
+  type SdkName,
+} from "../../utils/name-utils.js";
 import { getMethodHierarchiesMap, type ServiceOperation } from "../../utils/operation-util.js";
 import { AzureIdentityDependencies, AzureTestDependencies } from "../external-dependencies.js";
 import { getClientParametersDeclaration } from "./client-helpers.js";
@@ -56,13 +65,14 @@ export function buildParameterValueMap(
  * Prepare a common value for tests
  */
 export function prepareCommonValue(
-  name: string,
+  name: string | SdkName,
   value: SdkExampleValue | string,
   isOptional?: boolean,
   onClient?: boolean,
 ): CommonValue {
+  const sdkName = typeof name === "string" ? { name } : name;
   return {
-    name: normalizeName(name, NameType.Parameter),
+    name: normalizeSdkName(sdkName, NameType.Parameter),
     value: typeof value === "string" ? value : serializeExampleValue(value),
     isOptional: Boolean(isOptional),
     onClient: Boolean(onClient),
@@ -187,7 +197,10 @@ export function serializeExampleValue(value: SdkExampleValue): string {
       }) {
         let property;
         if (value.type.kind === "model") {
-          property = value.type.properties.find((p) => p.name === propName);
+          property =
+            value.type.properties.find(
+              (p) => (p.serializationOptions.json?.name ?? p.name) === propName,
+            ) ?? value.type.properties.find((p) => p.name === propName);
         }
         const propValue = value.value[propName];
         if (propValue === undefined || propValue === null) {
@@ -205,19 +218,23 @@ export function serializeExampleValue(value: SdkExampleValue): string {
             if (innerPropValue === undefined || innerPropValue === null) {
               continue;
             }
-            const innerProperty = property.type.properties.find((p) => p.name === innerPropName);
+            const innerProperty =
+              property.type.properties.find(
+                (p) => (p.serializationOptions.json?.name ?? p.name) === innerPropName,
+              ) ?? property.type.properties.find((p) => p.name === innerPropName);
             if (innerProperty && isReadOnly(innerProperty as SdkModelPropertyType)) {
               continue;
             }
             values.push(
-              `"${innerMapper.get(innerPropName) ?? innerPropName}": ` +
+              `${JSON.stringify(innerMapper.get(innerPropName) ?? innerPropName)}: ` +
                 serializeExampleValue(innerPropValue),
             );
           }
           continue;
         }
         const propRetValue =
-          `"${mapper.get(propName) ?? propName}": ` + serializeExampleValue(propValue);
+          `${JSON.stringify(mapper.get(propName) ?? propName)}: ` +
+          serializeExampleValue(propValue);
         values.push(propRetValue);
       }
       const additionalBags = [];
@@ -229,14 +246,15 @@ export function serializeExampleValue(value: SdkExampleValue): string {
           continue;
         }
         const propRetValue =
-          `"${mapper.get(propName) ?? propName}": ` + serializeExampleValue(propValue);
+          `${JSON.stringify(mapper.get(propName) ?? propName)}: ` +
+          serializeExampleValue(propValue);
         additionalBags.push(propRetValue);
       }
       if (additionalBags.length > 0) {
         const name = mapper.get("additionalProperties")
           ? "additionalPropertiesBag"
           : "additionalProperties";
-        values.push(`"${name}": {
+        values.push(`${JSON.stringify(name)}: {
           ${additionalBags.join(", ")}
           }`);
       }
@@ -268,10 +286,7 @@ function buildTestPropertyNameMapper(type: SdkExampleValue["type"]) {
     if (prop.kind !== "property") {
       continue;
     }
-    mapper.set(
-      prop.serializationOptions.json?.name || prop.name,
-      normalizeName(prop.name, NameType.Property),
-    );
+    mapper.set(prop.serializationOptions.json?.name || prop.name, normalizeSdkPropertyName(prop));
   }
   return mapper;
 }
@@ -368,16 +383,14 @@ export function prepareCommonParameters(
     if (!exampleValue || !exampleValue.value) {
       if (!param.optional) {
         // Generate default values for required parameters without examples in tests
-        result.push(
-          prepareCommonValue(param.name, `"{Your ${param.name}}"`, false, param.onClient),
-        );
+        result.push(prepareCommonValue(param, `"{Your ${param.name}}"`, false, param.onClient));
       }
       continue;
     }
 
     result.push(
       prepareCommonValue(
-        exampleValue.parameter.name,
+        exampleValue.parameter,
         exampleValue.value,
         param.optional,
         param.onClient,
@@ -401,7 +414,8 @@ export function prepareCommonParameters(
       bodyExample.value.kind === "model"
     ) {
       for (const prop of bodyParam.type.properties) {
-        const propExample = bodyExample.value.value[prop.name];
+        const wireName = prop.serializationOptions.json?.name ?? prop.name;
+        const propExample = bodyExample.value.value[wireName] ?? bodyExample.value.value[prop.name];
         if (!propExample) {
           continue;
         }
@@ -409,7 +423,7 @@ export function prepareCommonParameters(
         if (isReadOnly(prop as SdkModelPropertyType)) {
           continue;
         }
-        result.push(prepareCommonValue(prop.name, propExample, prop.optional, prop.onClient));
+        result.push(prepareCommonValue(prop, propExample, prop.optional, prop.onClient));
       }
     } else {
       // Check if the body parameter is nested inside a wrapper (e.g., @bodyRoot)
@@ -419,30 +433,19 @@ export function prepareCommonParameters(
       if (isNestedBody) {
         const path = segments[0]!;
         // The first segment is the method-level wrapper param (e.g., "body")
-        const methodParamName = path[0]!.name;
         const methodParamOptional = path[0]!.optional;
         // Wrap the example value with the intermediate property names
         let wrappedValue = serializeExampleValue(bodyExample.value);
         for (let i = path.length - 1; i >= 1; i--) {
-          const propName = normalizeName(path[i]!.name, NameType.Property);
+          const propName = formatPropertyName(normalizeSdkPropertyName(path[i]!));
           wrappedValue = `{ ${propName}: ${wrappedValue} }`;
         }
         result.push(
-          prepareCommonValue(
-            methodParamName,
-            wrappedValue,
-            methodParamOptional,
-            bodyParam.onClient,
-          ),
+          prepareCommonValue(path[0]!, wrappedValue, methodParamOptional, bodyParam.onClient),
         );
       } else {
         result.push(
-          prepareCommonValue(
-            bodyParam.name,
-            bodyExample.value,
-            bodyParam.optional,
-            bodyParam.onClient,
-          ),
+          prepareCommonValue(bodyParam, bodyExample.value, bodyParam.optional, bodyParam.onClient),
         );
       }
     }
@@ -457,7 +460,7 @@ export function prepareCommonParameters(
     .forEach((param) => {
       const exampleValue = parameterMap[param.serializedName];
       if (exampleValue && exampleValue.value) {
-        result.push(prepareCommonValue(param.name, exampleValue.value, true, param.onClient));
+        result.push(prepareCommonValue(param, exampleValue.value, true, param.onClient));
       }
     });
 
@@ -492,10 +495,7 @@ export function iterateClientsAndMethods(
           client,
           generatedFiles,
           classicalMethodPrefix: prefix,
-          subFolder:
-            clients.length > 1
-              ? normalizeName(getClassicalClientName(client), NameType.File)
-              : undefined,
+          subFolder: clients.length > 1 ? normalizeSdkName(client, NameType.File) : undefined,
           hierarchies: hierarchies,
         });
       }
@@ -564,7 +564,9 @@ export function generateMethodCall(
   }
 
   const prefix = options.classicalMethodPrefix ? `${options.classicalMethodPrefix}.` : "";
-  const methodCall = `client.${prefix}${normalizeName(method.oriName ?? method.name, NameType.Property)}(${methodParams.join(", ")})`;
+  const methodCall = `client.${prefix}${normalizeSdkName(method, NameType.Property, {
+    nameOverride: method.oriName ?? method.name,
+  })}(${methodParams.join(", ")})`;
 
   return { methodCall, clientParams, clientParamDefs };
 }
@@ -681,7 +683,11 @@ export function generateAssertionsForValue(
             // Check if this property is flattened in the model type
             let property;
             if (value.kind === "model" && value.type.kind === "model") {
-              property = value.type.properties.find((p) => p.kind === "property" && p.name === key);
+              property =
+                value.type.properties.find(
+                  (p) =>
+                    p.kind === "property" && (p.serializationOptions.json?.name ?? p.name) === key,
+                ) ?? value.type.properties.find((p) => p.kind === "property" && p.name === key);
             }
             if (property?.flatten && (val as SdkExampleValue).kind === "model") {
               // For flattened properties, recurse using the parent path so
@@ -694,7 +700,12 @@ export function generateAssertionsForValue(
               );
               assertions.push(...innerAssertions);
             } else {
-              const propPath = `${path}.${key}`;
+              const propertyName = property ? normalizeSdkPropertyName(property) : key;
+              const optionalBase = path.endsWith("?");
+              const basePath = optionalBase ? path.slice(0, -1) : path;
+              const propPath = optionalBase
+                ? formatOptionalPropertyAccess(basePath, propertyName)
+                : formatPropertyAccess(basePath, propertyName);
               const nestedVal = val as SdkExampleValue;
               // For nested model/dict values, append "?" to the path so child
               // property accesses use optional chaining (e.g. result.systemData?.createdBy)

package/src/modular/helpers/naming-helpers.ts

@@ -5,7 +5,12 @@ import {
 } from "@azure-tools/typespec-client-generator-core";
 import pluralize from "pluralize";
 import type { SdkContext } from "../../utils/interfaces.js";
-import { NameType, normalizeName, ReservedModelNames } from "../../utils/name-utils.js";
+import {
+  NameType,
+  normalizeName,
+  normalizeSdkName,
+  ReservedModelNames,
+} from "../../utils/name-utils.js";
 import type { ServiceOperation } from "../../utils/operation-util.js";
 
 export function getClientName(client: SdkClientType<SdkServiceOperation>): string {
@@ -29,8 +34,8 @@ export function getOperationName(
   dpgContext?: SdkContext,
   prefixes: string[] = [],
 ): GuardedName {
-  const name = normalizeName(operation.name, NameType.Method, true);
-  const propertyName = normalizeName(operation.name, NameType.Property);
+  const name = normalizeSdkName(operation, NameType.Method, { shouldGuard: true });
+  const propertyName = normalizeSdkName(operation, NameType.Property);
   const isDataplane = dpgContext !== undefined && !dpgContext.emitterOptions?.azureArm;
   // An explicit `@clientName` override is an intentional naming choice by the user, so we
   // honor it verbatim and skip the reserved-word disambiguation (and its `@fixme`). The