@azure-tools/typespec-ts 0.54.0-dev.6 → 0.54.0-dev.7

package/src/modular/helpers/operationHelpers.ts

@@ -1,107 +1,97 @@
+import {
+  getClientOptions,
+  isHttpMetadata,
+  isReadOnly,
+  SdkBodyParameter,
+  SdkClientType,
+  SdkConstantType,
+  SdkEnumType,
+  SdkHttpOperation,
+  SdkHttpParameter,
+  SdkLroPagingServiceMethod,
+  SdkLroServiceMethod,
+  SdkMethod,
+  SdkMethodParameter,
+  SdkModelPropertyType,
+  SdkModelType,
+  SdkPagingServiceMethod,
+  SdkServiceResponseHeader,
+  SdkType,
+} from "@azure-tools/typespec-client-generator-core";
+import { NoTarget, Program } from "@typespec/compiler";
+import { isHeader, isMetadata } from "@typespec/http";
 import {
   FunctionDeclarationStructure,
   OptionalKind,
   ParameterDeclarationStructure,
   StructureKind,
-  TypeAliasDeclarationStructure
+  TypeAliasDeclarationStructure,
 } from "ts-morph";
-import { NoTarget, Program } from "@typespec/compiler";
-import {
-  PagingHelpers,
-  PollingHelpers,
-  PlatformTypeHelpers,
-  SerializationHelpers,
-  StorageCompatHelpers,
-  UrlTemplateHelpers,
-  XmlHelpers
-} from "../static-helpers-metadata.js";
-import {
-  getNullableValidType,
-  isSpreadBodyParameter,
-  isTypeNullable
-} from "./typeHelpers.js";
-import {
-  getClassicalLayerPrefix,
-  getOperationName,
-  generateLocallyUniqueName
-} from "./namingHelpers.js";
+import { useContext } from "../../contextManager.js";
+import { useSdkTypes } from "../../framework/hooks/sdkTypes.js";
+import { useDependencies } from "../../framework/hooks/useDependencies.js";
+import { resolveReference } from "../../framework/reference.js";
+import { refkey } from "../../framework/refkey.js";
+import { reportDiagnostic } from "../../lib.js";
+import { NameType, normalizeName } from "../../rlc-common/index.js";
+import { SdkContext } from "../../utils/interfaces.js";
+import { isAzureCoreErrorType } from "../../utils/modelUtils.js";
 import {
+  getCollectionFormatFromArrayEncoding,
   getCollectionFormatHelper,
+  getCollectionFormatParseHelper,
   hasCollectionFormatInfo,
+  hasDualFormatSupport,
   isBinaryPayload,
-  isXmlPayload,
   isMultipartPayload,
-  hasDualFormatSupport,
+  isXmlPayload,
+  KnownCollectionFormat,
   ServiceOperation,
-  getCollectionFormatParseHelper,
-  getCollectionFormatFromArrayEncoding,
-  KnownCollectionFormat
 } from "../../utils/operationUtil.js";
-import {
-  getPropertyWithOverrides,
-  isNormalUnion,
-  isSpecialHandledUnion,
-  ModelOverrideOptions
-} from "../serialization/serializeUtils.js";
-import {
-  getDocsFromDescription,
-  getFixmeForMultilineDocs
-} from "./docsHelpers.js";
 import { AzurePollingDependencies } from "../external-dependencies.js";
-import { NameType, normalizeName } from "../../rlc-common/index.js";
 import {
   buildModelDeserializer,
-  buildPropertyDeserializer
+  buildPropertyDeserializer,
 } from "../serialization/buildDeserializerFunction.js";
 import {
   buildModelSerializer,
-  buildPropertySerializer
+  buildPropertySerializer,
 } from "../serialization/buildSerializerFunction.js";
 import {
-  buildXmlModelSerializer,
   buildXmlModelDeserializer,
-  hasXmlSerialization
+  buildXmlModelSerializer,
+  hasXmlSerialization,
 } from "../serialization/buildXmlSerializerFunction.js";
-import { refkey } from "../../framework/refkey.js";
-import { reportDiagnostic } from "../../lib.js";
-import { resolveReference } from "../../framework/reference.js";
-import { useDependencies } from "../../framework/hooks/useDependencies.js";
-import { useSdkTypes } from "../../framework/hooks/sdkTypes.js";
-import { isAzureCoreErrorType } from "../../utils/modelUtils.js";
 import {
-  getTypeExpression,
-  normalizeModelPropertyName
-} from "../type-expressions/get-type-expression.js";
-import { SdkContext } from "../../utils/interfaces.js";
-import {
-  getClientOptions,
-  isHttpMetadata,
-  isReadOnly,
-  SdkBodyParameter,
-  SdkClientType,
-  SdkConstantType,
-  SdkEnumType,
-  SdkHttpOperation,
-  SdkHttpParameter,
-  SdkLroPagingServiceMethod,
-  SdkMethodParameter,
-  SdkLroServiceMethod,
-  SdkMethod,
-  SdkModelPropertyType,
-  SdkModelType,
-  SdkPagingServiceMethod,
-  SdkServiceResponseHeader,
-  SdkType
-} from "@azure-tools/typespec-client-generator-core";
-import { isHeader, isMetadata } from "@typespec/http";
-import { useContext } from "../../contextManager.js";
+  getPropertyWithOverrides,
+  isNormalUnion,
+  isSpecialHandledUnion,
+  ModelOverrideOptions,
+} from "../serialization/serializeUtils.js";
 import {
-  getHeaderClientOptions,
-  getRestErrorCodeHeader
-} from "./clientOptionHelpers.js";
-import { getClientParameterName } from "./clientHelpers.js";
+  PagingHelpers,
+  PlatformTypeHelpers,
+  PollingHelpers,
+  SerializationHelpers,
+  StorageCompatHelpers,
+  UrlTemplateHelpers,
+  XmlHelpers,
+} from "../static-helpers-metadata.js";
 import { isExtensibleEnum } from "../type-expressions/get-enum-expression.js";
 import { emitInlineModel } from "../type-expressions/get-model-expression.js";
+import {
+  getTypeExpression,
+  normalizeModelPropertyName,
+} from "../type-expressions/get-type-expression.js";
+import { getClientParameterName } from "./clientHelpers.js";
+import { getHeaderClientOptions, getRestErrorCodeHeader } from "./clientOptionHelpers.js";
+import { getDocsFromDescription, getFixmeForMultilineDocs } from "./docsHelpers.js";
+import {
+  generateLocallyUniqueName,
+  getClassicalLayerPrefix,
+  getOperationName,
+} from "./namingHelpers.js";
+import { getNullableValidType, isSpreadBodyParameter, isTypeNullable } from "./typeHelpers.js";
 
 /**
  * Checks whether a header should be skipped during serialization/deserialization.
@@ -109,7 +99,7 @@ import { emitInlineModel } from "../type-expressions/get-model-expression.js";
  * which indicates it uses a prefix-based dictionary pattern not handled by standard ser/deser.
  */
 function shouldSkipHeaderSerialization(
-  header: SdkHttpParameter | SdkServiceResponseHeader
+  header: SdkHttpParameter | SdkServiceResponseHeader,
 ): boolean {
   return getClientOptions(header, "headerCollectionPrefix") !== undefined;
 }
@@ -118,14 +108,10 @@ export function getSendPrivateFunction(
   dpgContext: SdkContext,
   method: [string[], ServiceOperation],
   clientType: string,
-  client?: SdkClientType<SdkHttpOperation>
+  client?: SdkClientType<SdkHttpOperation>,
 ): OptionalKind<FunctionDeclarationStructure> {
   const operation = method[1];
-  const parameters = getOperationSignatureParameters(
-    dpgContext,
-    method,
-    clientType
-  );
+  const parameters = getOperationSignatureParameters(dpgContext, method, clientType);
   const { name } = getOperationName(operation);
   const dependencies = useDependencies();
 
@@ -134,7 +120,7 @@ export function getSendPrivateFunction(
     isExported: true,
     name: `_${name}Send`,
     parameters,
-    returnType: resolveReference(dependencies.StreamableMethod)
+    returnType: resolveReference(dependencies.StreamableMethod),
   };
 
   const operationPath = operation.operation.path;
@@ -144,15 +130,13 @@ export function getSendPrivateFunction(
   let pathStr = `"${operationPath}"`;
   const urlTemplateParams = [
     ...getPathParameters(operation),
-    ...getQueryParameters(dpgContext, operation)
+    ...getQueryParameters(dpgContext, operation),
   ];
   if (urlTemplateParams.length > 0) {
     // Generate a unique local variable name that doesn't conflict with parameter names
     const paramNames = new Set(parameters.map((p) => p.name));
     const pathVarName = generateLocallyUniqueName("path", paramNames);
-    const includeRootSlash = client
-      ? getClientOptions(client, "includeRootSlash") !== false
-      : true;
+    const includeRootSlash = client ? getClientOptions(client, "includeRootSlash") !== false : true;
 
     const uriTemplate = includeRootSlash
       ? operation.operation.uriTemplate
@@ -170,26 +154,24 @@ export function getSendPrivateFunction(
     `return context.path(${pathStr}).${operationMethod}({...${resolveReference(dependencies.operationOptionsToRequestParameters)}(${optionalParamName}), ${getHeaderAndBodyParameters(
       dpgContext,
       operation,
-      optionalParamName
-    )}});`
+      optionalParamName,
+    )}});`,
   );
 
   return {
     ...functionStatement,
-    statements
+    statements,
   };
 }
 
 export function getDeserializePrivateFunction(
   context: SdkContext,
-  method: [string[], ServiceOperation]
+  method: [string[], ServiceOperation],
 ): OptionalKind<FunctionDeclarationStructure> {
   const operation = method[1];
   const { name } = getOperationName(operation);
   const dependencies = useDependencies();
-  const PathUncheckedResponseReference = resolveReference(
-    dependencies.PathUncheckedResponse
-  );
+  const PathUncheckedResponseReference = resolveReference(dependencies.PathUncheckedResponse);
 
   // Check if we need to wrap the non-model return type
   const { shouldWrap, isBinary } = checkWrapNonModelReturn(context, operation);
@@ -211,7 +193,7 @@ export function getDeserializePrivateFunction(
       // For LRO-only operations with non-model final result, wrap in a response type alias
       returnType = {
         name: getOperationResponseTypeName(method),
-        type: resolveReference(refkey(operation, "response"))
+        type: resolveReference(refkey(operation, "response")),
       };
     } else {
       returnType = buildLroReturnType(context, operation);
@@ -221,13 +203,13 @@ export function getDeserializePrivateFunction(
     // instead of just the array element type
     returnType = {
       name: (restResponse as any).name ?? "",
-      type: getTypeExpression(context, restResponse.type)
+      type: getTypeExpression(context, restResponse.type),
     };
   } else if (shouldWrap) {
     // Use the wrapper response type name (resolved via binder for cross-file imports)
     returnType = {
       name: getOperationResponseTypeName(method),
-      type: resolveReference(refkey(operation, "response"))
+      type: resolveReference(refkey(operation, "response")),
     };
   } else if (response.type) {
     // When response.optional is true, some HTTP responses have no body (e.g. 204), so
@@ -235,7 +217,7 @@ export function getDeserializePrivateFunction(
     const baseType = getTypeExpression(context, response.type);
     returnType = {
       name: (response as any).name ?? "",
-      type: response.optional ? `${baseType} | undefined` : baseType
+      type: response.optional ? `${baseType} | undefined` : baseType,
     };
   } else if (isHeadAsBooleanOperation(operation)) {
     returnType = { name: "", type: "boolean" };
@@ -250,27 +232,23 @@ export function getDeserializePrivateFunction(
   const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
     {
       name: resultParamName,
-      type: resultParamType
-    }
+      type: resultParamType,
+    },
   ];
   const functionStatement: OptionalKind<FunctionDeclarationStructure> = {
     isAsync: true,
     isExported: true,
     name: `_${name}Deserialize`,
     parameters,
-    returnType: `Promise<${returnType.type}>`
+    returnType: `Promise<${returnType.type}>`,
   };
   const statements: string[] = [];
-  const createRestErrorReference = resolveReference(
-    dependencies.createRestError
-  );
-  statements.push(
-    `const expectedStatuses = ${getExpectedStatuses(operation)};`
-  );
+  const createRestErrorReference = resolveReference(dependencies.createRestError);
+  statements.push(`const expectedStatuses = ${getExpectedStatuses(operation)};`);
   statements.push(
     `if(!expectedStatuses.includes(result.status)){`,
     `${getExceptionThrowStatement(context, operation)}`,
-    "}"
+    "}",
   );
   const deserializedType =
     isLroOnly || isLroAndPaging
@@ -299,7 +277,7 @@ export function getDeserializePrivateFunction(
       `if(${deserializedRoot.split(".").join("?.")} === undefined) {
         throw ${createRestErrorReference}(\`Expected a result in the response at position "${deserializedRoot}"\`, result);
       }
-      `
+      `,
     );
   }
 
@@ -308,17 +286,14 @@ export function getDeserializePrivateFunction(
     // guard all body deserialization so we return undefined instead of throwing.
     // This only applies to non-LRO, non-paging operations where the deserialized type
     // comes from response.type (not from LRO metadata or paging).
-    const needsBodyGuard =
-      response.optional && !isLroOnly && !isLroAndPaging && !isPagingOnly;
+    const needsBodyGuard = response.optional && !isLroOnly && !isLroAndPaging && !isPagingOnly;
 
     const contentTypes = operation.operation.responses[0]?.contentTypes ?? [];
     const isXml = isXmlPayload(contentTypes);
     const isDualFormat = hasDualFormatSupport(contentTypes);
     const isMultipart = isMultipartPayload(contentTypes);
     const useXmlDeserialization =
-      isXml &&
-      deserializedType.kind === "model" &&
-      hasXmlSerialization(deserializedType);
+      isXml && deserializedType.kind === "model" && hasXmlSerialization(deserializedType);
 
     // Workaround for multipart response: cast return value as any due to lack of multipart response handling in core
     const multipartCastSuffix = isMultipart ? " as any" : "";
@@ -333,51 +308,35 @@ export function getDeserializePrivateFunction(
         statements.push(
           `if (!result.body) {
             return result.body as ${returnType.type};
-          }`
+          }`,
         );
       }
-      const xmlDeserializerName = buildXmlModelDeserializer(
-        context,
-        deserializedType,
-        {
-          nameOnly: true,
-          skipDiscriminatedUnionSuffix: false
-        }
-      ) as string | undefined;
-      const jsonDeserializerName = buildModelDeserializer(
-        context,
-        deserializedType,
-        {
-          nameOnly: true,
-          skipDiscriminatedUnionSuffix: false
-        }
-      );
+      const xmlDeserializerName = buildXmlModelDeserializer(context, deserializedType, {
+        nameOnly: true,
+        skipDiscriminatedUnionSuffix: false,
+      }) as string | undefined;
+      const jsonDeserializerName = buildModelDeserializer(context, deserializedType, {
+        nameOnly: true,
+        skipDiscriminatedUnionSuffix: false,
+      });
 
       if (xmlDeserializerName && jsonDeserializerName) {
-        const isXmlContentTypeRef = resolveReference(
-          XmlHelpers.isXmlContentType
-        );
+        const isXmlContentTypeRef = resolveReference(XmlHelpers.isXmlContentType);
         statements.push(
           `const responseContentType = result.headers?.["content-type"] ?? "";
           if (${isXmlContentTypeRef}(responseContentType)) {
             return ${xmlDeserializerName}(${deserializedRoot});
           }
-          return ${jsonDeserializerName}(${deserializedRoot});`
+          return ${jsonDeserializerName}(${deserializedRoot});`,
         );
       } else {
         // Fall back to JSON deserializer
-        const deserializeFunctionName = buildModelDeserializer(
-          context,
-          deserializedType,
-          {
-            nameOnly: true,
-            skipDiscriminatedUnionSuffix: false
-          }
-        );
+        const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
+          nameOnly: true,
+          skipDiscriminatedUnionSuffix: false,
+        });
         if (deserializeFunctionName) {
-          statements.push(
-            `return ${deserializeFunctionName}(${deserializedRoot})`
-          );
+          statements.push(`return ${deserializeFunctionName}(${deserializedRoot})`);
         }
       }
     } else if (useXmlDeserialization) {
@@ -386,48 +345,34 @@ export function getDeserializePrivateFunction(
         statements.push(
           `if (!result.body) {
             return result.body as ${returnType.type};
-          }`
+          }`,
         );
       }
-      const xmlDeserializerName = buildXmlModelDeserializer(
-        context,
-        deserializedType,
-        {
-          nameOnly: true,
-          skipDiscriminatedUnionSuffix: false
-        }
-      ) as string | undefined;
+      const xmlDeserializerName = buildXmlModelDeserializer(context, deserializedType, {
+        nameOnly: true,
+        skipDiscriminatedUnionSuffix: false,
+      }) as string | undefined;
 
       if (xmlDeserializerName) {
         statements.push(`return ${xmlDeserializerName}(${deserializedRoot})`);
       } else {
         // Fall back to JSON deserializer if XML deserializer is not available
-        const deserializeFunctionName = buildModelDeserializer(
-          context,
-          deserializedType,
-          {
-            nameOnly: true,
-            skipDiscriminatedUnionSuffix: false
-          }
-        );
+        const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
+          nameOnly: true,
+          skipDiscriminatedUnionSuffix: false,
+        });
         if (deserializeFunctionName) {
-          statements.push(
-            `return ${deserializeFunctionName}(${deserializedRoot})`
-          );
+          statements.push(`return ${deserializeFunctionName}(${deserializedRoot})`);
         } else {
           statements.push(`return ${deserializedRoot}`);
         }
       }
     } else {
       // JSON response (default) - also handles multipart responses
-      const deserializeFunctionName = buildModelDeserializer(
-        context,
-        deserializedType,
-        {
-          nameOnly: true,
-          skipDiscriminatedUnionSuffix: false
-        }
-      );
+      const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
+        nameOnly: true,
+        skipDiscriminatedUnionSuffix: false,
+      });
       // Handle wrap-non-model-return for non-LRO, non-paging and LRO-only operations
       if (shouldWrap) {
         if (isBinary) {
@@ -435,7 +380,7 @@ export function getDeserializePrivateFunction(
           // status check and error.details handling ran above.
           // Return the platform-specific stream properties.
           statements.push(
-            `return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };`
+            `return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };`,
           );
         } else if (isHeadAsBooleanOperation(operation)) {
           // HEAD has no body; derive boolean from status code
@@ -449,29 +394,27 @@ export function getDeserializePrivateFunction(
             deserializedType,
             deserializedRoot,
             true,
-            getEncodeForType(deserializedType)
+            getEncodeForType(deserializedType),
           );
           statements.push(`return { body: ${bodyValue} };`);
         }
         return {
           ...functionStatement,
-          statements
+          statements,
         };
       }
       if (deserializeFunctionName) {
         if (needsBodyGuard) {
           // Use ternary form: return result.body ? deserializer(result.body) : undefined
           statements.push(
-            `return ${deserializedRoot} ? ${deserializeFunctionName}(${deserializedRoot})${multipartCastSuffix} : undefined`
+            `return ${deserializedRoot} ? ${deserializeFunctionName}(${deserializedRoot})${multipartCastSuffix} : undefined`,
           );
         } else {
           statements.push(
-            `return ${deserializeFunctionName}(${deserializedRoot})${multipartCastSuffix}`
+            `return ${deserializeFunctionName}(${deserializedRoot})${multipartCastSuffix}`,
           );
         }
-      } else if (
-        isAzureCoreErrorType(context.program, deserializedType.__raw)
-      ) {
+      } else if (isAzureCoreErrorType(context.program, deserializedType.__raw)) {
         statements.push(`return ${deserializedRoot}${multipartCastSuffix}`);
       } else if (isHeadAsBooleanOperation(operation)) {
         // HEAD has no body; derive boolean from status code
@@ -487,11 +430,11 @@ export function getDeserializePrivateFunction(
               context,
               response.type!.__raw!,
               contentTypes,
-              getEncodeForType(response.type!)
+              getEncodeForType(response.type!),
             )
               ? "binary"
-              : getEncodeForType(deserializedType)
-          )}${multipartCastSuffix}`
+              : getEncodeForType(deserializedType),
+          )}${multipartCastSuffix}`,
         );
       }
     }
@@ -507,7 +450,7 @@ export function getDeserializePrivateFunction(
 
   return {
     ...functionStatement,
-    statements
+    statements,
   };
 }
 
@@ -518,33 +461,26 @@ export function getDeserializePrivateFunction(
  */
 export function getDeserializeHeadersPrivateFunction(
   context: SdkContext,
-  operation: ServiceOperation
+  operation: ServiceOperation,
 ): OptionalKind<FunctionDeclarationStructure> | undefined {
   const responseHeaders = getResponseHeaders(operation.operation.responses);
-  const isResponseHeadersEnabled =
-    context.rlcOptions?.includeHeadersInResponse === true;
-  const isStorageCompatEnabled =
-    context.rlcOptions?.enableStorageCompat === true;
+  const isResponseHeadersEnabled = context.rlcOptions?.includeHeadersInResponse === true;
+  const isStorageCompatEnabled = context.rlcOptions?.enableStorageCompat === true;
 
   // Only generate if headers exist and a relevant feature is enabled
-  if (
-    responseHeaders.length === 0 ||
-    (!isResponseHeadersEnabled && !isStorageCompatEnabled)
-  ) {
+  if (responseHeaders.length === 0 || (!isResponseHeadersEnabled && !isStorageCompatEnabled)) {
     return undefined;
   }
 
   const { name } = getOperationName(operation);
   const dependencies = useDependencies();
-  const PathUncheckedResponseReference = resolveReference(
-    dependencies.PathUncheckedResponse
-  );
+  const PathUncheckedResponseReference = resolveReference(dependencies.PathUncheckedResponse);
 
   const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
     {
       name: "result",
-      type: PathUncheckedResponseReference
-    }
+      type: PathUncheckedResponseReference,
+    },
   ];
 
   const returnType = buildHeaderOnlyResponseType(context, responseHeaders);
@@ -554,17 +490,15 @@ export function getDeserializeHeadersPrivateFunction(
     isExported: true,
     name: `_${name}DeserializeHeaders`,
     parameters,
-    returnType
+    returnType,
   };
 
   const statements: string[] = [];
-  statements.push(
-    `return ${buildHeaderOnlyResponseValue(context, responseHeaders)};`
-  );
+  statements.push(`return ${buildHeaderOnlyResponseValue(context, responseHeaders)};`);
 
   return {
     ...functionStatement,
-    statements
+    statements,
   };
 }
 
@@ -587,7 +521,7 @@ interface OperationExceptionDetails {
 
 function getExceptionDetails(
   context: SdkContext,
-  operation: ServiceOperation
+  operation: ServiceOperation,
 ): OperationExceptionDetails {
   const customized: ExceptionThrowDetail[] = [];
   let defaultDeserializer: string | undefined;
@@ -598,18 +532,11 @@ function getExceptionDetails(
       continue;
     }
     const statusCode = exception.statusCodes;
-    const deserializeFunctionName = buildModelDeserializer(
-      context,
-      exception.type,
-      {
-        nameOnly: true,
-        skipDiscriminatedUnionSuffix: false
-      }
-    );
-    if (
-      !deserializeFunctionName ||
-      typeof deserializeFunctionName !== "string"
-    ) {
+    const deserializeFunctionName = buildModelDeserializer(context, exception.type, {
+      nameOnly: true,
+      skipDiscriminatedUnionSuffix: false,
+    });
+    if (!deserializeFunctionName || typeof deserializeFunctionName !== "string") {
       continue;
     }
 
@@ -618,14 +545,13 @@ function getExceptionDetails(
     const exceptionContentTypes = exception.contentTypes ?? [];
     const exceptionIsXml = isXmlPayload(exceptionContentTypes);
     const exceptionIsDualFormat = hasDualFormatSupport(exceptionContentTypes);
-    const typeHasXml =
-      exception.type.kind === "model" && hasXmlSerialization(exception.type);
+    const typeHasXml = exception.type.kind === "model" && hasXmlSerialization(exception.type);
 
     let xmlDeserializerName: string | undefined;
     if (exception.type.kind === "model" && (typeHasXml || exceptionIsXml)) {
       const xmlName = buildXmlModelDeserializer(context, exception.type, {
         nameOnly: true,
-        skipDiscriminatedUnionSuffix: false
+        skipDiscriminatedUnionSuffix: false,
       });
       if (typeof xmlName === "string") {
         xmlDeserializerName = xmlName;
@@ -633,10 +559,7 @@ function getExceptionDetails(
     }
 
     // XML-only when all content types are XML (no JSON support)
-    const isXmlOnly =
-      xmlDeserializerName !== undefined &&
-      exceptionIsXml &&
-      !exceptionIsDualFormat;
+    const isXmlOnly = xmlDeserializerName !== undefined && exceptionIsXml && !exceptionIsDualFormat;
 
     if (statusCode === "*") {
       defaultDeserializer = deserializeFunctionName;
@@ -647,7 +570,7 @@ function getExceptionDetails(
         start: statusCode,
         deserializer: deserializeFunctionName,
         xmlDeserializer: xmlDeserializerName,
-        isXmlOnly
+        isXmlOnly,
       });
     } else {
       customized.push({
@@ -655,7 +578,7 @@ function getExceptionDetails(
         end: statusCode.end,
         deserializer: deserializeFunctionName,
         xmlDeserializer: xmlDeserializerName,
-        isXmlOnly
+        isXmlOnly,
       });
     }
   }
@@ -663,7 +586,7 @@ function getExceptionDetails(
     customized,
     defaultDeserializer,
     defaultXmlDeserializer,
-    defaultIsXmlOnly
+    defaultIsXmlOnly,
   };
 }
 
@@ -671,7 +594,7 @@ function getExceptionDetails(
  * Collects and deduplicates all response headers from operation exceptions.
  */
 function getExceptionResponseHeaders(
-  exceptions: SdkHttpOperation["exceptions"]
+  exceptions: SdkHttpOperation["exceptions"],
 ): SdkServiceResponseHeader[] {
   const headerMap = new Map<string, SdkServiceResponseHeader>();
   for (const exception of exceptions ?? []) {
@@ -692,32 +615,27 @@ function getExceptionResponseHeaders(
  */
 export function getDeserializeExceptionHeadersPrivateFunction(
   context: SdkContext,
-  operation: ServiceOperation
+  operation: ServiceOperation,
 ): OptionalKind<FunctionDeclarationStructure> | undefined {
-  const isResponseHeadersEnabled =
-    context.rlcOptions?.includeHeadersInResponse === true;
+  const isResponseHeadersEnabled = context.rlcOptions?.includeHeadersInResponse === true;
   if (!isResponseHeadersEnabled) {
     return undefined;
   }
 
-  const exceptionHeaders = getExceptionResponseHeaders(
-    operation.operation.exceptions
-  );
+  const exceptionHeaders = getExceptionResponseHeaders(operation.operation.exceptions);
   if (exceptionHeaders.length === 0) {
     return undefined;
   }
 
   const { name } = getOperationName(operation);
   const dependencies = useDependencies();
-  const PathUncheckedResponseReference = resolveReference(
-    dependencies.PathUncheckedResponse
-  );
+  const PathUncheckedResponseReference = resolveReference(dependencies.PathUncheckedResponse);
 
   const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
     {
       name: "result",
-      type: PathUncheckedResponseReference
-    }
+      type: PathUncheckedResponseReference,
+    },
   ];
 
   const returnType = buildHeaderOnlyResponseType(context, exceptionHeaders);
@@ -727,17 +645,15 @@ export function getDeserializeExceptionHeadersPrivateFunction(
     isExported: true,
     name: `_${name}DeserializeExceptionHeaders`,
     parameters,
-    returnType
+    returnType,
   };
 
   const statements: string[] = [];
-  statements.push(
-    `return ${buildHeaderOnlyResponseValue(context, exceptionHeaders)};`
-  );
+  statements.push(`return ${buildHeaderOnlyResponseValue(context, exceptionHeaders)};`);
 
   return {
     ...functionStatement,
-    statements
+    statements,
   };
 }
 
@@ -751,50 +667,29 @@ function getExceptionDeserializeExpr(exception: ExceptionThrowDetail): string {
   return `isXml ? ${exception.xmlDeserializer}(result.body) : ${exception.deserializer}(result.body)`;
 }
 
-function getExceptionThrowStatement(
-  context: SdkContext,
-  operation: ServiceOperation
-) {
+function getExceptionThrowStatement(context: SdkContext, operation: ServiceOperation) {
   const statements = [];
-  const createRestErrorReference = resolveReference(
-    useDependencies().createRestError
-  );
-  const {
-    customized,
-    defaultDeserializer,
-    defaultXmlDeserializer,
-    defaultIsXmlOnly
-  } = getExceptionDetails(context, operation);
+  const createRestErrorReference = resolveReference(useDependencies().createRestError);
+  const { customized, defaultDeserializer, defaultXmlDeserializer, defaultIsXmlOnly } =
+    getExceptionDetails(context, operation);
 
-  const isResponseHeadersEnabled =
-    context.rlcOptions?.includeHeadersInResponse === true;
+  const isResponseHeadersEnabled = context.rlcOptions?.includeHeadersInResponse === true;
 
   // Check if exception headers function exists and build the call
-  const exceptionHeaders = getExceptionResponseHeaders(
-    operation.operation.exceptions
-  );
-  const hasExceptionHeaders =
-    isResponseHeadersEnabled && exceptionHeaders.length > 0;
+  const exceptionHeaders = getExceptionResponseHeaders(operation.operation.exceptions);
+  const hasExceptionHeaders = isResponseHeadersEnabled && exceptionHeaders.length > 0;
   const { name: opName } = getOperationName(operation);
   const exceptionHeadersCall = hasExceptionHeaders
     ? `error.details = {...(error.details as any), ..._${opName}DeserializeExceptionHeaders(result)};`
     : undefined;
 
   // Build @clientOption("header", ...) extraction code (independent of include-headers-in-response)
-  const clientOptionHeadersCall = buildClientOptionHeadersCall(
-    operation.operation.exceptions
-  );
+  const clientOptionHeadersCall = buildClientOptionHeadersCall(operation.operation.exceptions);
 
   // Build @clientOption("restErrorCodeHeader", ...) code to set error.code from a header
-  const restErrorCodeAssignment = buildRestErrorCodeAssignment(
-    operation.operation.exceptions
-  );
+  const restErrorCodeAssignment = buildRestErrorCodeAssignment(operation.operation.exceptions);
 
-  const allHeaderCalls = [
-    exceptionHeadersCall,
-    clientOptionHeadersCall,
-    restErrorCodeAssignment
-  ]
+  const allHeaderCalls = [exceptionHeadersCall, clientOptionHeadersCall, restErrorCodeAssignment]
     .filter(Boolean)
     .join("\n");
 
@@ -807,12 +702,8 @@ function getExceptionThrowStatement(
     statements.push(`const error = ${createRestErrorReference}(result);`);
     if (hasAnyDualFormatXml) {
       const isXmlContentTypeRef = resolveReference(XmlHelpers.isXmlContentType);
-      statements.push(
-        `const responseContentType = result.headers?.["content-type"] ?? "";`
-      );
-      statements.push(
-        `const isXml = ${isXmlContentTypeRef}(responseContentType);`
-      );
+      statements.push(`const responseContentType = result.headers?.["content-type"] ?? "";`);
+      statements.push(`const isXml = ${isXmlContentTypeRef}(responseContentType);`);
     }
     statements.push(`const statusCode = Number.parseInt(result.status);`);
     const stats: string[] = customized.map((exception) => {
@@ -851,9 +742,7 @@ function getExceptionThrowStatement(
           if(result.body) { error.details = ${defaultXmlDeserializer}(result.body); }
           ${allHeaderCalls}`);
         } else {
-          const isXmlContentTypeRef = resolveReference(
-            XmlHelpers.isXmlContentType
-          );
+          const isXmlContentTypeRef = resolveReference(XmlHelpers.isXmlContentType);
           statements.push(`const error = ${createRestErrorReference}(result);
           const responseContentType = result.headers?.["content-type"] ?? "";
           if(result.body) { error.details = ${isXmlContentTypeRef}(responseContentType) ? ${defaultXmlDeserializer}(result.body) : ${defaultDeserializer}(result.body); }
@@ -877,7 +766,7 @@ function getExceptionThrowStatement(
  * on exception model types. This is independent of include-headers-in-response.
  */
 function buildClientOptionHeadersCall(
-  exceptions: SdkHttpOperation["exceptions"]
+  exceptions: SdkHttpOperation["exceptions"],
 ): string | undefined {
   const seenProperties = new Set<string>();
   const assignments: string[] = [];
@@ -892,9 +781,7 @@ function buildClientOptionHeadersCall(
         continue;
       }
       seenProperties.add(opt.propertyName);
-      assignments.push(
-        `${opt.propertyName}: result.headers[${JSON.stringify(opt.headerName)}]`
-      );
+      assignments.push(`${opt.propertyName}: result.headers[${JSON.stringify(opt.headerName)}]`);
     }
   }
 
@@ -910,7 +797,7 @@ function buildClientOptionHeadersCall(
  * based on @clientOption("restErrorCodeHeader", ...) on exception model types.
  */
 function buildRestErrorCodeAssignment(
-  exceptions: SdkHttpOperation["exceptions"]
+  exceptions: SdkHttpOperation["exceptions"],
 ): string | undefined {
   for (const exception of exceptions ?? []) {
     if (!exception.type || exception.type.kind !== "model") {
@@ -925,27 +812,21 @@ if (restErrorCodeValue !== undefined) { error.code = restErrorCodeValue; }`;
   return undefined;
 }
 
-function getOptionalParamsName(
-  parameters: OptionalKind<ParameterDeclarationStructure>[]
-) {
+function getOptionalParamsName(parameters: OptionalKind<ParameterDeclarationStructure>[]) {
   return (
-    parameters.filter((p) =>
-      p.type?.toString().endsWith("operationOptions__")
-    )[0]?.name ?? "options"
+    parameters.filter((p) => p.type?.toString().endsWith("operationOptions__"))[0]?.name ??
+    "options"
   );
 }
 
 function getOperationSignatureParameters(
   context: SdkContext,
   method: [string[], ServiceOperation],
-  clientType: string
+  clientType: string,
 ): OptionalKind<ParameterDeclarationStructure>[] {
   const operation = method[1];
   const optionsType = resolveReference(refkey(method[1], "operationOptions"));
-  const parameters: Map<
-    string,
-    OptionalKind<ParameterDeclarationStructure>
-  > = new Map();
+  const parameters: Map<string, OptionalKind<ParameterDeclarationStructure>> = new Map();
 
   operation.parameters
     .filter(
@@ -960,16 +841,13 @@ function getOperationSignatureParameters(
           );
         })[0]?.kind !== "cookie" &&
         !p.optional &&
-        !(
-          p.isGeneratedName &&
-          (p.name === "contentType" || p.name === "accept")
-        ) && // skip tcgc generated contentType and accept header parameter
-        getClientOptions(p, "headerCollectionPrefix") === undefined // skip headers with collection prefix
+        !(p.isGeneratedName && (p.name === "contentType" || p.name === "accept")) && // skip tcgc generated contentType and accept header parameter
+        getClientOptions(p, "headerCollectionPrefix") === undefined, // skip headers with collection prefix
     )
     .map((p) => {
       return {
         name: p.name,
-        type: getTypeExpression(context, p.type)
+        type: getTypeExpression(context, p.type),
       };
     })
     .forEach((p) => {
@@ -983,7 +861,7 @@ function getOperationSignatureParameters(
   const optionsParam = {
     name: parameters.has("options") ? "optionalParams" : "options",
     type: optionsType,
-    initializer: "{ requestOptions: {} }"
+    initializer: "{ requestOptions: {} }",
   };
 
   const finalParameters = [contextParam, ...parameters.values(), optionsParam];
@@ -997,7 +875,7 @@ function getOperationSignatureParameters(
 export function getOperationFunction(
   context: SdkContext,
   method: [string[], ServiceOperation],
-  clientType: string
+  clientType: string,
 ): FunctionDeclarationStructure & {
   propertyName?: string;
   isLro?: boolean;
@@ -1007,23 +885,22 @@ export function getOperationFunction(
 } {
   const operation = method[1];
   // Extract required parameters
-  const parameters: OptionalKind<ParameterDeclarationStructure>[] =
-    getOperationSignatureParameters(context, method, clientType);
+  const parameters: OptionalKind<ParameterDeclarationStructure>[] = getOperationSignatureParameters(
+    context,
+    method,
+    clientType,
+  );
   const optionalParamName = getOptionalParamsName(parameters);
   if (isPagingOnlyOperation(operation)) {
     // Case 1: paging-only operation
-    return getPagingOnlyOperationFunction(
-      context,
-      [method[0], operation],
-      clientType
-    );
+    return getPagingOnlyOperationFunction(context, [method[0], operation], clientType);
   } else if (isLroOnlyOperation(operation)) {
     // Case 2: lro-only operation
     return getLroOnlyOperationFunction(
       context,
       [method[0], operation],
       clientType,
-      optionalParamName
+      optionalParamName,
     );
   } else if (isLroAndPagingOperation(operation)) {
     // Case 3: both paging + lro operation
@@ -1031,7 +908,7 @@ export function getOperationFunction(
       context,
       [method[0], operation],
       clientType,
-      optionalParamName
+      optionalParamName,
     );
   }
 
@@ -1039,10 +916,8 @@ export function getOperationFunction(
   const response = operation.response;
   const responseHeaders = getResponseHeaders(operation.operation.responses);
   const hasHeaderOnlyResponse = !response.type && responseHeaders.length > 0;
-  const isResponseHeadersEnabled =
-    context.rlcOptions?.includeHeadersInResponse === true;
-  const isStorageCompatEnabled =
-    context.rlcOptions?.enableStorageCompat === true;
+  const isResponseHeadersEnabled = context.rlcOptions?.includeHeadersInResponse === true;
+  const isStorageCompatEnabled = context.rlcOptions?.enableStorageCompat === true;
 
   // Track the raw body type separately for storage-compat (before header merging)
   const hasResponseBody = !!response.type;
@@ -1052,50 +927,42 @@ export function getOperationFunction(
   }
 
   // Check if we need to wrap the non-model return type
-  const { shouldWrap: wrapReturn, isBinary: wrapReturnIsBinary } =
-    checkWrapNonModelReturn(context, operation);
+  const { shouldWrap: wrapReturn, isBinary: wrapReturnIsBinary } = checkWrapNonModelReturn(
+    context,
+    operation,
+  );
 
   let returnType = { name: "", type: "void" };
   if (wrapReturn) {
     // Use the wrapper response type name (resolved via binder for cross-file imports)
     returnType = {
       name: getOperationResponseTypeName(method),
-      type: resolveReference(refkey(operation, "response"))
+      type: resolveReference(refkey(operation, "response")),
     };
     bodyType = returnType.type;
   } else if (response.type) {
     const type = response.type;
 
     // If feature flag enabled, we'll append the response headers to the operation response type.
-    if (
-      type.kind === "model" &&
-      responseHeaders.length > 0 &&
-      isResponseHeadersEnabled
-    ) {
+    if (type.kind === "model" && responseHeaders.length > 0 && isResponseHeadersEnabled) {
       // Build a composite type that includes both model and additional header properties
-      const baseCompositeType = buildCompositeResponseType(
-        context,
-        type,
-        responseHeaders
-      );
+      const baseCompositeType = buildCompositeResponseType(context, type, responseHeaders);
       returnType = {
         name: (type as any).name ?? "",
-        type: response.optional
-          ? `${baseCompositeType} | undefined`
-          : baseCompositeType
+        type: response.optional ? `${baseCompositeType} | undefined` : baseCompositeType,
       };
     } else {
       const baseType = getTypeExpression(context, type!);
       returnType = {
         name: (type as any).name ?? "",
-        type: response.optional ? `${baseType} | undefined` : baseType
+        type: response.optional ? `${baseType} | undefined` : baseType,
       };
     }
   } else if (hasHeaderOnlyResponse && isResponseHeadersEnabled) {
     // Here we handle returning headers when the operation return type is void
     returnType = {
       name: "",
-      type: `${buildHeaderOnlyResponseType(context, responseHeaders)}`
+      type: `${buildHeaderOnlyResponseType(context, responseHeaders)}`,
     };
   } else if (isHeadAsBooleanOperation(operation)) {
     returnType = { name: "", type: "boolean" };
@@ -1105,9 +972,7 @@ export function getOperationFunction(
   // Use the raw body type (not the header-augmented return type) for TBody
   let finalReturnType = returnType.type;
   if (isStorageCompatEnabled) {
-    const storageCompatInfoRef = resolveReference(
-      StorageCompatHelpers.StorageCompatResponseInfo
-    );
+    const storageCompatInfoRef = resolveReference(StorageCompatHelpers.StorageCompatResponseInfo);
     const headersType =
       responseHeaders.length > 0
         ? buildHeaderOnlyResponseType(context, responseHeaders)
@@ -1134,16 +999,13 @@ export function getOperationFunction(
   const { name, fixme = [] } = getOperationName(operation, context);
   const functionStatement = {
     kind: StructureKind.Function,
-    docs: [
-      ...getDocsFromDescription(operation.doc),
-      ...getFixmeForMultilineDocs(fixme)
-    ],
+    docs: [...getDocsFromDescription(operation.doc), ...getFixmeForMultilineDocs(fixme)],
     isAsync: true,
     isExported: true,
     name,
     propertyName: normalizeName(operation.name, NameType.Property),
     parameters,
-    returnType: `Promise<${finalReturnType}>`
+    returnType: `Promise<${finalReturnType}>`,
   };
 
   const statements: string[] = [];
@@ -1154,16 +1016,13 @@ export function getOperationFunction(
 
   const parameterList = parameters.map((p) => p.name).join(", ");
   // When storage-compat is enabled, set up the onResponse interceptor before sending
-  const storageCompatVarName = generateLocallyUniqueName(
-    "_storageCompat",
-    paramNames
-  );
+  const storageCompatVarName = generateLocallyUniqueName("_storageCompat", paramNames);
   if (isStorageCompatEnabled) {
     const createOnResponseRef = resolveReference(
-      StorageCompatHelpers.createStorageCompatOnResponse
+      StorageCompatHelpers.createStorageCompatOnResponse,
     );
     statements.push(
-      `const ${storageCompatVarName} = ${createOnResponseRef}(${optionalParamName}.onResponse);`
+      `const ${storageCompatVarName} = ${createOnResponseRef}(${optionalParamName}.onResponse);`,
     );
   }
 
@@ -1171,7 +1030,7 @@ export function getOperationFunction(
   const sendParameterList = isStorageCompatEnabled
     ? parameterList.replace(
         optionalParamName,
-        `{...${optionalParamName}, onResponse: ${storageCompatVarName}.onResponse}`
+        `{...${optionalParamName}, onResponse: ${storageCompatVarName}.onResponse}`,
       )
     : parameterList;
 
@@ -1180,54 +1039,37 @@ export function getOperationFunction(
   // For binary wrap, use getBinaryStreamResponse which preserves blobBody/readableStreamBody properties.
   // For non-wrapped binary, use getBinaryResponse which buffers the body into Uint8Array.
   if (response?.type?.kind === "bytes" && response.type.encode === "bytes") {
-    const streamableMethodVarName = generateLocallyUniqueName(
-      "streamableMethod",
-      paramNames
-    );
-    statements.push(
-      `const ${streamableMethodVarName} = _${name}Send(${sendParameterList});`
-    );
+    const streamableMethodVarName = generateLocallyUniqueName("streamableMethod", paramNames);
+    statements.push(`const ${streamableMethodVarName} = _${name}Send(${sendParameterList});`);
     const binaryHelper =
       wrapReturn && wrapReturnIsBinary
         ? SerializationHelpers.getBinaryStreamResponse
         : SerializationHelpers.getBinaryResponse;
     statements.push(
-      `const ${resultVarName} = await ${resolveReference(binaryHelper)}(${streamableMethodVarName});`
+      `const ${resultVarName} = await ${resolveReference(binaryHelper)}(${streamableMethodVarName});`,
     );
   } else {
-    statements.push(
-      `const ${resultVarName} = await _${name}Send(${sendParameterList});`
-    );
+    statements.push(`const ${resultVarName} = await _${name}Send(${sendParameterList});`);
   }
 
   // If the response has headers and the feature flag to include headers in response is enabled, build the headers object and include it in the return value
   if (isStorageCompatEnabled) {
     // Storage-compat mode: wrap the return value with _response metadata using captured PipelineResponse
-    const addStorageCompatRef = resolveReference(
-      StorageCompatHelpers.addStorageCompatResponse
-    );
-    const parsedBodyVarName = generateLocallyUniqueName(
-      "parsedBody",
-      paramNames
-    );
-    const parsedHeadersVarName = generateLocallyUniqueName(
-      "parsedHeaders",
-      paramNames
-    );
+    const addStorageCompatRef = resolveReference(StorageCompatHelpers.addStorageCompatResponse);
+    const parsedBodyVarName = generateLocallyUniqueName("parsedBody", paramNames);
+    const parsedHeadersVarName = generateLocallyUniqueName("parsedHeaders", paramNames);
 
     // Deserialize body
     if (!hasResponseBody) {
       statements.push(`await _${name}Deserialize(${resultVarName});`);
     } else {
-      statements.push(
-        `const ${parsedBodyVarName} = await _${name}Deserialize(${resultVarName});`
-      );
+      statements.push(`const ${parsedBodyVarName} = await _${name}Deserialize(${resultVarName});`);
     }
 
     // Deserialize headers if present
     if (responseHeaders.length > 0) {
       statements.push(
-        `const ${parsedHeadersVarName} = _${name}DeserializeHeaders(${resultVarName});`
+        `const ${parsedHeadersVarName} = _${name}DeserializeHeaders(${resultVarName});`,
       );
     }
 
@@ -1235,13 +1077,11 @@ export function getOperationFunction(
     const bodyArg = !hasResponseBody ? "undefined" : parsedBodyVarName;
     const headersArg = responseHeaders.length > 0 ? parsedHeadersVarName : "{}";
     statements.push(
-      `return ${addStorageCompatRef}(${storageCompatVarName}.getRawResponse()!, ${bodyArg}, ${headersArg});`
+      `return ${addStorageCompatRef}(${storageCompatVarName}.getRawResponse()!, ${bodyArg}, ${headersArg});`,
     );
   } else if (responseHeaders.length > 0 && isResponseHeadersEnabled) {
     const headersVarName = generateLocallyUniqueName("headers", paramNames);
-    statements.push(
-      `const ${headersVarName} = _${name}DeserializeHeaders(result);`
-    );
+    statements.push(`const ${headersVarName} = _${name}DeserializeHeaders(result);`);
 
     // If there is no body payload just return the headers
     if (hasHeaderOnlyResponse) {
@@ -1249,9 +1089,7 @@ export function getOperationFunction(
       statements.push(`return {...${headersVarName} };`);
     } else {
       const payloadVarName = generateLocallyUniqueName("payload", paramNames);
-      statements.push(
-        `const ${payloadVarName} = await _${name}Deserialize(${resultVarName});`
-      );
+      statements.push(`const ${payloadVarName} = await _${name}Deserialize(${resultVarName});`);
       statements.push(`return { ...${payloadVarName}, ...${headersVarName} };`);
     }
   } else {
@@ -1260,7 +1098,7 @@ export function getOperationFunction(
 
   return {
     ...functionStatement,
-    statements
+    statements,
   } as FunctionDeclarationStructure & { propertyName?: string };
 }
 
@@ -1268,7 +1106,7 @@ function getLroOnlyOperationFunction(
   context: SdkContext,
   method: [string[], SdkLroServiceMethod<SdkHttpOperation>],
   clientType: string,
-  optionalParamName: string = "options"
+  optionalParamName: string = "options",
 ): FunctionDeclarationStructure & {
   propertyName?: string;
   isLro?: boolean;
@@ -1276,23 +1114,19 @@ function getLroOnlyOperationFunction(
 } {
   const operation = method[1];
   // Extract required parameters
-  const parameters: OptionalKind<ParameterDeclarationStructure>[] =
-    getOperationSignatureParameters(context, method, clientType);
+  const parameters: OptionalKind<ParameterDeclarationStructure>[] = getOperationSignatureParameters(
+    context,
+    method,
+    clientType,
+  );
   const returnType = buildLroReturnType(context, operation);
   const { name, fixme = [] } = getOperationName(operation, context);
-  const pollerLikeReference = resolveReference(
-    AzurePollingDependencies.PollerLike
-  );
-  const operationStateReference = resolveReference(
-    AzurePollingDependencies.OperationState
-  );
+  const pollerLikeReference = resolveReference(AzurePollingDependencies.PollerLike);
+  const operationStateReference = resolveReference(AzurePollingDependencies.OperationState);
 
   // When wrap-non-model-return is enabled and the LRO final result is a non-model type,
   // use the wrapper response type (e.g. GetIkeSasResponse) instead of the raw type (e.g. string).
-  const { shouldWrap } = checkWrapNonModelReturn(
-    context,
-    operation as ServiceOperation
-  );
+  const { shouldWrap } = checkWrapNonModelReturn(context, operation as ServiceOperation);
   const effectiveReturnTypeStr = shouldWrap
     ? (resolveReference(refkey(operation, "response")) as string)
     : returnType.type;
@@ -1302,10 +1136,7 @@ function getLroOnlyOperationFunction(
 
   const functionStatement = {
     kind: StructureKind.Function,
-    docs: [
-      ...getDocsFromDescription(operation.doc),
-      ...getFixmeForMultilineDocs(fixme)
-    ],
+    docs: [...getDocsFromDescription(operation.doc), ...getFixmeForMultilineDocs(fixme)],
     isAsync: false,
     isExported: true,
     name,
@@ -1313,25 +1144,20 @@ function getLroOnlyOperationFunction(
     isLro: true,
     lroFinalReturnType: effectiveReturnTypeName,
     parameters,
-    returnType: `${pollerLikeReference}<${operationStateReference}<${effectiveReturnTypeStr}>, ${effectiveReturnTypeStr}>`
+    returnType: `${pollerLikeReference}<${operationStateReference}<${effectiveReturnTypeStr}>, ${effectiveReturnTypeStr}>`,
   };
 
-  const getLongRunningPollerReference = resolveReference(
-    PollingHelpers.GetLongRunningPoller
-  );
+  const getLongRunningPollerReference = resolveReference(PollingHelpers.GetLongRunningPoller);
   const lroMetadata =
-    operation.kind === "lro" || operation.kind === "lropaging"
-      ? operation.lroMetadata
-      : undefined;
+    operation.kind === "lro" || operation.kind === "lropaging" ? operation.lroMetadata : undefined;
   const allowedFinalLocation = [
     "azure-async-operation",
     "location",
     "original-uri",
-    "operation-location"
+    "operation-location",
   ];
   const resourceLocationConfig =
-    lroMetadata?.finalStateVia &&
-    allowedFinalLocation.includes(lroMetadata?.finalStateVia)
+    lroMetadata?.finalStateVia && allowedFinalLocation.includes(lroMetadata?.finalStateVia)
       ? `resourceLocationConfig: "${lroMetadata?.finalStateVia}",`
       : "";
   const apiVersion = getApiVersionExpression(context, operation);
@@ -1340,13 +1166,11 @@ function getLroOnlyOperationFunction(
   statements.push(`
 
   return ${getLongRunningPollerReference}(context, _${name}Deserialize, ${getExpectedStatuses(
-    operation
+    operation,
   )}, {
     updateIntervalInMs: ${optionalParamName}?.updateIntervalInMs,
     abortSignal: ${optionalParamName}?.abortSignal,
-    getInitialResponse: () => _${name}Send(${parameters
-      .map((p) => p.name)
-      .join(", ")}),
+    getInitialResponse: () => _${name}Send(${parameters.map((p) => p.name).join(", ")}),
     ${resourceLocationConfig}
     ${apiVersion ? `apiVersion: ${apiVersion}` : ""}
   }) as ${pollerLikeReference}<${operationStateReference}<${effectiveReturnTypeStr}>, ${effectiveReturnTypeStr}>;
@@ -1354,7 +1178,7 @@ function getLroOnlyOperationFunction(
 
   return {
     ...functionStatement,
-    statements
+    statements,
   } as FunctionDeclarationStructure & { propertyName?: string };
 }
 
@@ -1362,18 +1186,14 @@ function getLroAndPagingOperationFunction(
   context: SdkContext,
   method: [string[], SdkLroPagingServiceMethod<SdkHttpOperation>],
   clientType: string,
-  optionalParamName: string = "options"
+  optionalParamName: string = "options",
 ): FunctionDeclarationStructure & {
   isLroPaging?: boolean;
   propertyName?: string;
   lropagingFinalReturnType?: string;
 } {
   const operation = method[1];
-  const parameters = getOperationSignatureParameters(
-    context,
-    method,
-    clientType
-  );
+  const parameters = getOperationSignatureParameters(context, method, clientType);
   const { name, fixme = [] } = getOperationName(operation, context);
 
   const returnType = buildLroPagingReturnType(context, operation);
@@ -1389,7 +1209,7 @@ function getLroAndPagingOperationFunction(
       `nextLinkName: "${operation.pagingMetadata.nextLinkSegments.map((p) => p.name).join(".")}"`,
     operation.pagingMetadata.nextLinkVerb !== "GET" &&
       `nextLinkMethod: "${operation.pagingMetadata.nextLinkVerb}"`,
-    apiVersion && `apiVersion: ${apiVersion}`
+    apiVersion && `apiVersion: ${apiVersion}`,
   ].filter(Boolean);
 
   // Build LRO resource location config
@@ -1397,7 +1217,7 @@ function getLroAndPagingOperationFunction(
     "azure-async-operation",
     "location",
     "original-uri",
-    "operation-location"
+    "operation-location",
   ];
   const resourceLocationConfig =
     operation.lroMetadata?.finalStateVia &&
@@ -1412,20 +1232,16 @@ function getLroAndPagingOperationFunction(
     getLroPoller: resolveReference(PollingHelpers.GetLongRunningPoller),
     pollerLike: resolveReference(AzurePollingDependencies.PollerLike),
     operationState: resolveReference(AzurePollingDependencies.OperationState),
-    pathResponse: resolveReference(useDependencies().PathUncheckedResponse)
+    pathResponse: resolveReference(useDependencies().PathUncheckedResponse),
   };
 
   const expectedStatuses = getExpectedStatuses(operation);
   const paramList = parameters.map((p) => p.name).join(", ");
-  const pagingOptionsStr =
-    pagingOptions.length > 0 ? `,\n    {${pagingOptions.join(", ")}}` : "";
+  const pagingOptionsStr = pagingOptions.length > 0 ? `,\n    {${pagingOptions.join(", ")}}` : "";
 
   return {
     kind: StructureKind.Function,
-    docs: [
-      ...getDocsFromDescription(operation.doc),
-      ...getFixmeForMultilineDocs(fixme)
-    ],
+    docs: [...getDocsFromDescription(operation.doc), ...getFixmeForMultilineDocs(fixme)],
     isAsync: false,
     isExported: true,
     isLroPaging: true,
@@ -1452,23 +1268,21 @@ function getLroAndPagingOperationFunction(
     _${name}Deserialize,
     ${expectedStatuses}${pagingOptionsStr}
   );
-  `
-    ]
+  `,
+    ],
   };
 }
 
 function buildLroReturnType(
   context: SdkContext,
-  operation:
-    | SdkLroServiceMethod<SdkHttpOperation>
-    | SdkLroPagingServiceMethod<SdkHttpOperation>
+  operation: SdkLroServiceMethod<SdkHttpOperation> | SdkLroPagingServiceMethod<SdkHttpOperation>,
 ) {
   const metadata = operation.lroMetadata;
   if (metadata !== undefined && metadata.finalResponse !== undefined) {
     const type = metadata.finalResponse.result;
     return {
       name: type.name,
-      type: getTypeExpression(context, type)
+      type: getTypeExpression(context, type),
     };
   }
   return { name: "", type: "void" };
@@ -1476,12 +1290,12 @@ function buildLroReturnType(
 
 function buildLroPagingReturnType(
   context: SdkContext,
-  operation: SdkLroPagingServiceMethod<SdkHttpOperation>
+  operation: SdkLroPagingServiceMethod<SdkHttpOperation>,
 ) {
   if (operation.response.type?.kind === "array") {
     return {
       name: (operation.response.type.valueType as any).name ?? "",
-      type: getTypeExpression(context, operation.response.type.valueType)
+      type: getTypeExpression(context, operation.response.type.valueType),
     };
   }
   return { name: "", type: "void" };
@@ -1490,12 +1304,15 @@ function buildLroPagingReturnType(
 function getPagingOnlyOperationFunction(
   context: SdkContext,
   method: [string[], SdkPagingServiceMethod<SdkHttpOperation>],
-  clientType: string
+  clientType: string,
 ): FunctionDeclarationStructure & { propertyName?: string } {
   const operation = method[1];
   // Extract required parameters
-  const parameters: OptionalKind<ParameterDeclarationStructure>[] =
-    getOperationSignatureParameters(context, method, clientType);
+  const parameters: OptionalKind<ParameterDeclarationStructure>[] = getOperationSignatureParameters(
+    context,
+    method,
+    clientType,
+  );
 
   // TODO: Support operation overloads
   const response = operation.response;
@@ -1504,28 +1321,23 @@ function getPagingOnlyOperationFunction(
     const type = response.type;
     returnType = {
       name: (type.valueType as any).name ?? "",
-      type: getTypeExpression(context, type.valueType)
+      type: getTypeExpression(context, type.valueType),
     };
   }
   const { name, fixme = [] } = getOperationName(operation, context);
   const pagedAsyncIterableIteratorReference = resolveReference(
-    PagingHelpers.PagedAsyncIterableIterator
-  );
-  const buildPagedAsyncIteratorReference = resolveReference(
-    PagingHelpers.BuildPagedAsyncIterator
+    PagingHelpers.PagedAsyncIterableIterator,
   );
+  const buildPagedAsyncIteratorReference = resolveReference(PagingHelpers.BuildPagedAsyncIterator);
   const functionStatement = {
     kind: StructureKind.Function,
-    docs: [
-      ...getDocsFromDescription(operation.doc),
-      ...getFixmeForMultilineDocs(fixme)
-    ],
+    docs: [...getDocsFromDescription(operation.doc), ...getFixmeForMultilineDocs(fixme)],
     isAsync: false,
     isExported: true,
     name,
     propertyName: normalizeName(operation.name, NameType.Property),
     parameters,
-    returnType: `${pagedAsyncIterableIteratorReference}<${returnType.type}>`
+    returnType: `${pagedAsyncIterableIteratorReference}<${returnType.type}>`,
   };
 
   const statements: string[] = [];
@@ -1567,18 +1379,18 @@ function getPagingOnlyOperationFunction(
       () => _${name}Send(${parameters.map((p) => p.name).join(", ")}), 
       _${name}Deserialize,
       ${getExpectedStatuses(operation)}${options.length > 0 ? `,\n      {${options.join(", ")}}` : ""}
-      );`
+      );`,
   );
 
   return {
     ...functionStatement,
-    statements
+    statements,
   } as FunctionDeclarationStructure & { propertyName?: string };
 }
 
 export function getOperationOptionsName(
   method: [string[], ServiceOperation],
-  includeGroupName = false
+  includeGroupName = false,
 ) {
   const prefixes = method[0];
   const operation = method[1];
@@ -1598,24 +1410,21 @@ export function getOperationOptionsName(
 function getHeaderAndBodyParameters(
   dpgContext: SdkContext,
   operation: ServiceOperation,
-  optionalParamName: string = "options"
+  optionalParamName: string = "options",
 ): string {
   if (!operation.operation.parameters) {
     return "";
   }
-  const operationParameters = operation.operation.parameters.filter(
-    (p) => !isContentType(p)
-  );
+  const operationParameters = operation.operation.parameters.filter((p) => !isContentType(p));
 
-  const contentTypeParameter =
-    operation.operation.parameters.find(isContentType);
+  const contentTypeParameter = operation.operation.parameters.find(isContentType);
 
   const parametersImplementation: Record<
     "header" | "body",
     { paramMap: string; param: SdkHttpParameter; paramAccessor: string }[]
   > = {
     header: [],
-    body: []
+    body: [],
   };
 
   for (const param of operationParameters) {
@@ -1633,15 +1442,12 @@ function getHeaderAndBodyParameters(
         continue;
       }
       // Check if this parameter still exists in the corresponding method params (after override)
-      if (
-        param.methodParameterSegments &&
-        param.methodParameterSegments.length > 0
-      ) {
+      if (param.methodParameterSegments && param.methodParameterSegments.length > 0) {
         const paramAccessor = getParamAccessor(param, optionalParamName);
         parametersImplementation[param.kind].push({
           paramMap: getParameterMap(dpgContext, param, paramAccessor),
           param,
-          paramAccessor
+          paramAccessor,
         });
       }
     }
@@ -1655,20 +1461,10 @@ function getHeaderAndBodyParameters(
 
   if (parametersImplementation.header.length) {
     paramStr = `${paramStr}\nheaders: {${parametersImplementation.header
-      .map((i) =>
-        buildHeaderParameter(
-          dpgContext.program,
-          i.paramMap,
-          i.param,
-          i.paramAccessor
-        )
-      )
+      .map((i) => buildHeaderParameter(dpgContext.program, i.paramMap, i.param, i.paramAccessor))
       .join(",\n")}, ...${optionalParamName}.requestOptions?.headers },`;
   }
-  if (
-    operation.operation.bodyParam === undefined &&
-    parametersImplementation.body.length
-  ) {
+  if (operation.operation.bodyParam === undefined && parametersImplementation.body.length) {
     paramStr = `${paramStr}\nbody: {${parametersImplementation.body
       .map((i) => i.paramMap)
       .join(",\n")}}`;
@@ -1683,13 +1479,13 @@ function buildHeaderParameter(
   program: Program,
   paramMap: string,
   param: SdkHttpParameter,
-  paramAccessor: string
+  paramAccessor: string,
 ): string {
   const effectiveOptional = getEffectiveOptional(param);
   if (!effectiveOptional && isTypeNullable(param.type) === true) {
     reportDiagnostic(program, {
       code: "nullable-required-header",
-      target: NoTarget
+      target: NoTarget,
     });
     return paramMap;
   }
@@ -1697,8 +1493,7 @@ function buildHeaderParameter(
   // If the param has a clientDefaultValue that type-matches, the paramMap already contains
   // `?? defaultValue` from getOptional(). In this case, always send the header (do not
   // conditionally omit it when the accessor is undefined) so the default is always applied.
-  const hasEffectiveDefaultValue =
-    effectiveOptional && hasEffectiveClientDefaultValue(param);
+  const hasEffectiveDefaultValue = effectiveOptional && hasEffectiveClientDefaultValue(param);
 
   const conditions = [];
   if (effectiveOptional && !hasEffectiveDefaultValue) {
@@ -1707,15 +1502,13 @@ function buildHeaderParameter(
   if (isTypeNullable(param.type) === true) {
     conditions.push(`${paramAccessor} !== null`);
   }
-  return conditions.length > 0
-    ? `...(${conditions.join(" && ")} ? {${paramMap}} : {})`
-    : paramMap;
+  return conditions.length > 0 ? `...(${conditions.join(" && ")} ? {${paramMap}} : {})` : paramMap;
 }
 
 function buildBodyParameter(
   context: SdkContext,
   bodyParameter: SdkBodyParameter | undefined,
-  optionalParamName: string = "options"
+  optionalParamName: string = "options",
 ) {
   if (!bodyParameter || !bodyParameter.type) {
     return "";
@@ -1727,8 +1520,7 @@ function buildBodyParameter(
   const bodyType = getNullableValidType(bodyParameter.type);
 
   // Check if XML serialization is needed and available
-  const useXmlSerialization =
-    isXml && bodyType.kind === "model" && hasXmlSerialization(bodyType);
+  const useXmlSerialization = isXml && bodyType.kind === "model" && hasXmlSerialization(bodyType);
 
   let serializerFunctionName: string | undefined;
 
@@ -1736,27 +1528,24 @@ function buildBodyParameter(
     // Use XML serializer
     serializerFunctionName = buildXmlModelSerializer(context, bodyType, {
       nameOnly: true,
-      skipDiscriminatedUnionSuffix: false
+      skipDiscriminatedUnionSuffix: false,
     }) as string | undefined;
   } else {
     // Use JSON serializer (default)
     serializerFunctionName = buildModelSerializer(context, bodyType, {
       nameOnly: true,
-      skipDiscriminatedUnionSuffix: false
+      skipDiscriminatedUnionSuffix: false,
     }) as string | undefined;
   }
 
   let bodyNameExpression = getParamAccessor(bodyParameter, optionalParamName);
 
   // Check if body parameter has a client default value with matching type
-  const hasClientDefault =
-    bodyParameter.optional && hasEffectiveClientDefaultValue(bodyParameter);
+  const hasClientDefault = bodyParameter.optional && hasEffectiveClientDefaultValue(bodyParameter);
 
   // Apply client default value if present for optional body parameters
   if (hasClientDefault) {
-    const formattedDefault = formatDefaultValue(
-      bodyParameter.clientDefaultValue
-    );
+    const formattedDefault = formatDefaultValue(bodyParameter.clientDefaultValue);
     bodyNameExpression = `(${bodyNameExpression} ?? ${formattedDefault})`;
   }
 
@@ -1773,18 +1562,14 @@ function buildBodyParameter(
     : "";
 
   // For dual-format operations, check the contentType option at runtime
-  if (
-    isDualFormat &&
-    bodyType.kind === "model" &&
-    hasXmlSerialization(bodyType)
-  ) {
+  if (isDualFormat && bodyType.kind === "model" && hasXmlSerialization(bodyType)) {
     const xmlSerializerName = buildXmlModelSerializer(context, bodyType, {
       nameOnly: true,
-      skipDiscriminatedUnionSuffix: false
+      skipDiscriminatedUnionSuffix: false,
     }) as string | undefined;
     const jsonSerializerName = buildModelSerializer(context, bodyType, {
       nameOnly: true,
-      skipDiscriminatedUnionSuffix: false
+      skipDiscriminatedUnionSuffix: false,
     }) as string | undefined;
 
     if (xmlSerializerName && jsonSerializerName) {
@@ -1808,12 +1593,12 @@ function buildBodyParameter(
       context,
       bodyParameter.__raw!,
       bodyParameter.contentTypes,
-      getEncodeForType(bodyParameter.type)
+      getEncodeForType(bodyParameter.type),
     )
       ? "binary"
       : getEncodeForType(bodyParameter.type),
     undefined,
-    true
+    true,
   );
   return `\nbody: ${serializedBody.startsWith(nullOrUndefinedPrefix) ? "" : nullOrUndefinedPrefix}${serializedBody},`;
 }
@@ -1834,13 +1619,11 @@ function getEncodingFormat(type: { format?: string }) {
 export function getParameterMap(
   context: SdkContext,
   param: SdkHttpParameter,
-  paramAccessor: string
+  paramAccessor: string,
 ): string {
   // Use lowercase for header names since HTTP headers are case-insensitive
   const serializedName =
-    param.kind === "header"
-      ? getHeaderSerializedName(param)
-      : getPropertySerializedName(param);
+    param.kind === "header" ? getHeaderSerializedName(param) : getPropertySerializedName(param);
 
   if (isConstant(param.type) && !isOptional(param)) {
     return `"${serializedName}": ${getConstantValue(param.type)}`;
@@ -1856,12 +1639,7 @@ export function getParameterMap(
   }
 
   if (hasCollectionFormatInfo(param.kind, (param as any).collectionFormat)) {
-    return getCollectionFormatForParam(
-      context,
-      param,
-      paramAccessor,
-      serializedName
-    );
+    return getCollectionFormatForParam(context, param, paramAccessor, serializedName);
   }
 
   // if the parameter or property is optional, we don't need to handle the default value
@@ -1877,9 +1655,9 @@ export function getParameterMap(
     code: "unsupported-parameter-type",
     format: {
       paramName: param.name,
-      paramKind: param.kind
+      paramKind: param.kind,
     },
-    target: param.__raw || NoTarget
+    target: param.__raw || NoTarget,
   });
 
   // Return a fallback value to allow the emitter to continue
@@ -1890,7 +1668,7 @@ function getCollectionFormatForParam(
   context: SdkContext,
   param: SdkHttpParameter,
   paramAccessor: string,
-  serializedName: string
+  serializedName: string,
 ) {
   const format = (param as any).collectionFormat;
   return `"${serializedName}": ${serializeRequestValue(
@@ -1900,21 +1678,15 @@ function getCollectionFormatForParam(
     !param.optional,
     format,
     serializedName,
-    true
+    true,
   )}`;
 }
 
 function isContentType(param: SdkHttpParameter): boolean {
-  return (
-    param.kind === "header" &&
-    param.serializedName.toLowerCase() === "content-type"
-  );
+  return param.kind === "header" && param.serializedName.toLowerCase() === "content-type";
 }
 
-function getContentTypeValue(
-  param: SdkHttpParameter,
-  optionalParamName: string = "options"
-) {
+function getContentTypeValue(param: SdkHttpParameter, optionalParamName: string = "options") {
   const defaultValue = param.clientDefaultValue;
   // allow customers to customize the content type if it's guessed by tcgc.
   if (isConstant(param.type)) {
@@ -1965,13 +1737,13 @@ function getRequired(
   context: SdkContext,
   param: SdkHttpParameter,
   serializedName: string,
-  paramAccessor: string
+  paramAccessor: string,
 ) {
   if (param.type.kind === "model") {
     const propertiesStr = getRequestModelMapping(
       context,
       { ...param.type, optional: param.optional },
-      paramAccessor
+      paramAccessor,
     );
     return `"${serializedName}": { ${propertiesStr.join(",")} }`;
   }
@@ -1982,7 +1754,7 @@ function getRequired(
     true,
     getEncodeForType(param.type),
     serializedName,
-    true
+    true,
   )}`;
 }
 
@@ -2005,7 +1777,7 @@ function getOptional(
   context: SdkContext,
   param: SdkHttpParameter,
   serializedName: string,
-  paramAccessor: string
+  paramAccessor: string,
 ) {
   // Apply client default value if present and type matches
   const defaultSuffix = hasEffectiveClientDefaultValue(param)
@@ -2016,7 +1788,7 @@ function getOptional(
     const propertiesStr = getRequestModelMapping(
       context,
       { ...param.type, optional: param.optional },
-      paramAccessor + "?."
+      paramAccessor + "?.",
     );
     const serializeContent = `{${propertiesStr.join(",")}}`;
     return `"${serializedName}": ${serializeContent}`;
@@ -2028,7 +1800,7 @@ function getOptional(
     false,
     getEncodeForType(param.type),
     serializedName,
-    true
+    true,
   );
   return `"${serializedName}": ${serializedValue}${defaultSuffix}`;
 }
@@ -2036,18 +1808,14 @@ function getOptional(
 /**
  * Get the encode for SDK type
  */
-function getEncodeForType(
-  type: SdkType | SdkHttpParameter | SdkModelPropertyType
-) {
+function getEncodeForType(type: SdkType | SdkHttpParameter | SdkModelPropertyType) {
   return (type as any).encode;
 }
 
 /**
  * Get the optionality for SDK type
  */
-function getOptionalForType(
-  type: SdkType | SdkHttpParameter | SdkModelPropertyType
-) {
+function getOptionalForType(type: SdkType | SdkHttpParameter | SdkModelPropertyType) {
   return (type as any).optional;
 }
 
@@ -2061,10 +1829,7 @@ function getDefaultValue(param: SdkHttpParameter) {
 /**
  * Extracts the path parameters
  */
-function getPathParameters(
-  operation: ServiceOperation,
-  optionalParamName: string = "options"
-) {
+function getPathParameters(operation: ServiceOperation, optionalParamName: string = "options") {
   if (!operation.operation.parameters) {
     return [];
   }
@@ -2075,7 +1840,7 @@ function getPathParameters(
       const methodParam = param.methodParameterSegments[0]?.[0];
       if (methodParam) {
         pathParams.push(
-          `"${param.serializedName}": ${getPathParamExpr(param, getDefaultValue(param) as string, optionalParamName)}`
+          `"${param.serializedName}": ${getPathParamExpr(param, getDefaultValue(param) as string, optionalParamName)}`,
         );
       }
     }
@@ -2087,30 +1852,20 @@ function getPathParameters(
 /**
  * Extract the query parameters
  */
-function getQueryParameters(
-  dpgContext: SdkContext,
-  operation: ServiceOperation
-): string[] {
+function getQueryParameters(dpgContext: SdkContext, operation: ServiceOperation): string[] {
   if (!operation.parameters) {
     return [];
   }
-  const operationParameters = operation.operation.parameters.filter(
-    (p) => !isContentType(p)
-  );
-  const parametersImplementation: Record<
-    "query",
-    { paramMap: string; param: SdkHttpParameter }[]
-  > = {
-    query: []
-  };
+  const operationParameters = operation.operation.parameters.filter((p) => !isContentType(p));
+  const parametersImplementation: Record<"query", { paramMap: string; param: SdkHttpParameter }[]> =
+    {
+      query: [],
+    };
 
   for (const param of operationParameters) {
     if (param.kind === "query") {
       // Check if this parameter still exists in the corresponding method params (after override)
-      if (
-        param.methodParameterSegments &&
-        param.methodParameterSegments.length > 0
-      ) {
+      if (param.methodParameterSegments && param.methodParameterSegments.length > 0) {
         const paramAccessor = getParamAccessor(param);
         parametersImplementation[param.kind].push({
           paramMap: getParameterMap(
@@ -2119,19 +1874,17 @@ function getQueryParameters(
               ...param,
               // TODO: remember to remove this hack once compiler gives us a name
               // https://github.com/microsoft/typespec/issues/6743
-              serializedName: getUriTemplateQueryParamName(param.serializedName)
+              serializedName: getUriTemplateQueryParamName(param.serializedName),
             },
-            paramAccessor
+            paramAccessor,
           ),
-          param
+          param,
         });
       }
     }
   }
 
-  const paramStr: string[] = parametersImplementation.query.map(
-    (i) => i.paramMap
-  );
+  const paramStr: string[] = parametersImplementation.query.map((i) => i.paramMap);
 
   return paramStr;
 }
@@ -2152,19 +1905,14 @@ function escapeUriTemplateParamName(name: string) {
  *    built from those segments (e.g. `options?.ocpDate`, `body.nested`).
  * 3. Fallback: returns the parameter name directly, with optional chaining if optional.
  */
-function getParamAccessor(
-  param: SdkHttpParameter,
-  optionalParamName: string = "options"
-): string {
+function getParamAccessor(param: SdkHttpParameter, optionalParamName: string = "options"): string {
   if (param.isGeneratedName) {
     return param.name;
   }
   const methodParamExpr = getMethodParamExpr(param, optionalParamName);
   const clientPrefix = "context.";
   if (methodParamExpr) {
-    return param.onClient
-      ? `${clientPrefix}${methodParamExpr}`
-      : methodParamExpr;
+    return param.onClient ? `${clientPrefix}${methodParamExpr}` : methodParamExpr;
   }
   if (param.onClient) {
     return `${clientPrefix}${getClientParameterName(param)}`;
@@ -2182,7 +1930,7 @@ function getParamAccessor(
  */
 function getMethodParamExpr(
   param: SdkHttpParameter,
-  optionalParamName: string = "options"
+  optionalParamName: string = "options",
 ): string | undefined {
   const segments = param.methodParameterSegments;
   if (segments.length === 0) {
@@ -2222,7 +1970,7 @@ function getMethodParamExpr(
 function getPathParamExpr(
   param: SdkHttpParameter,
   defaultValue?: string,
-  optionalParamName: string = "options"
+  optionalParamName: string = "options",
 ) {
   if (isConstant(param.type)) {
     return getConstantValue(param.type);
@@ -2251,7 +1999,7 @@ function getNullableCheck(name: string, type: SdkType) {
  */
 function getEncodeForModelProperty(
   context: SdkContext,
-  property: SdkModelPropertyType
+  property: SdkModelPropertyType,
 ): string | undefined {
   if (property.encode && property.type.kind === "array") {
     // Only arrays of string type or string-based enum type can have collectionFormat encoding
@@ -2260,20 +2008,15 @@ function getEncodeForModelProperty(
         code: "un-supported-array-encoding",
         format: {
           arrayName: property.name,
-          arrayType: property.type.valueType.kind
+          arrayType: property.type.valueType.kind,
         },
-        target: NoTarget
+        target: NoTarget,
       });
       return getEncodeForType(property.type);
     }
 
-    const collectionFormat = getCollectionFormatFromArrayEncoding(
-      property.encode
-    );
-    if (
-      collectionFormat &&
-      hasCollectionFormatInfo(property.kind, collectionFormat)
-    ) {
+    const collectionFormat = getCollectionFormatFromArrayEncoding(property.encode);
+    if (collectionFormat && hasCollectionFormatInfo(property.kind, collectionFormat)) {
       return collectionFormat;
     }
   }
@@ -2290,10 +2033,7 @@ function isStringEncodableArrayValueType(valueType: SdkType): boolean {
     return true;
   }
   // String-based enum type
-  if (
-    valueType.kind === "enum" &&
-    (valueType as SdkEnumType).valueType.kind === "string"
-  ) {
+  if (valueType.kind === "enum" && (valueType as SdkEnumType).valueType.kind === "string") {
     return true;
   }
   return false;
@@ -2302,11 +2042,11 @@ function isStringEncodableArrayValueType(valueType: SdkType): boolean {
 function getSerializationExpressionForFlatten(
   context: SdkContext,
   property: SdkModelPropertyType,
-  propertyPath: string
+  propertyPath: string,
 ): string {
   const serializeFunctionName = buildPropertySerializer(context, property, {
     nameOnly: true,
-    skipDiscriminatedUnionSuffix: false
+    skipDiscriminatedUnionSuffix: false,
   });
   if (!serializeFunctionName) {
     return property.optional ? `undefined` : `{}`;
@@ -2314,12 +2054,9 @@ function getSerializationExpressionForFlatten(
   const validProps = getAllProperties(
     context,
     property.type,
-    getAllAncestors(property.type)
+    getAllAncestors(property.type),
   ).filter(
-    (p) =>
-      p.kind === "property" &&
-      !isReadOnly(p) &&
-      !isMetadata(context.program, p.__raw!)
+    (p) => p.kind === "property" && !isReadOnly(p) && !isMetadata(context.program, p.__raw!),
   );
   const optionalPrefix = property.optional
     ? `${resolveReference(SerializationHelpers.areAllPropsUndefined)}(${propertyPath}, [${validProps
@@ -2333,32 +2070,20 @@ export function getSerializationExpression(
   context: SdkContext,
   property: SdkModelPropertyType,
   propertyPath: string,
-  enableFlatten: boolean = true
+  enableFlatten: boolean = true,
 ): string {
   if (property.flatten && property.type.kind === "model" && enableFlatten) {
     return getSerializationExpressionForFlatten(context, property, "item");
   }
   const dot = propertyPath.endsWith("?") ? "." : "";
   const propertyPathWithDot = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}`;
-  const nullOrUndefinedPrefix = getPropertySerializationPrefix(
-    context,
-    property,
-    propertyPath
-  );
+  const nullOrUndefinedPrefix = getPropertySerializationPrefix(context, property, propertyPath);
 
-  const propertyFullName = getPropertyFullName(
-    context,
-    property,
-    propertyPathWithDot
-  );
-  const serializeFunctionName = buildModelSerializer(
-    context,
-    getNullableValidType(property.type),
-    {
-      nameOnly: true,
-      skipDiscriminatedUnionSuffix: false
-    }
-  );
+  const propertyFullName = getPropertyFullName(context, property, propertyPathWithDot);
+  const serializeFunctionName = buildModelSerializer(context, getNullableValidType(property.type), {
+    nameOnly: true,
+    skipDiscriminatedUnionSuffix: false,
+  });
 
   // Apply clientDefaultValue for model properties that have one
   const defaultValueSuffix = hasEffectiveClientDefaultValue(property)
@@ -2377,7 +2102,7 @@ export function getSerializationExpression(
       !property.optional,
       getEncodeForModelProperty(context, property),
       getPropertySerializedName(property),
-      propertyPath === "" ? true : false
+      propertyPath === "" ? true : false,
     );
     return `${baseExpr}${defaultValueSuffix}`;
   }
@@ -2388,7 +2113,7 @@ export function getRequestModelProperties(
   modelPropertyType: SdkModelType & { optional?: boolean },
   propertyPath: string = "body",
   overrides?: ModelOverrideOptions,
-  enableFlatten: boolean = true
+  enableFlatten: boolean = true,
 ): Array<[string, string]> {
   const props: [string, string][] = [];
   const allParents = getAllAncestors(modelPropertyType);
@@ -2407,7 +2132,7 @@ export function getRequestModelProperties(
     const property = getPropertyWithOverrides(prop, overrides);
     props.push([
       getPropertySerializedName(property)!,
-      getSerializationExpression(context, property, propertyPath, enableFlatten)
+      getSerializationExpression(context, property, propertyPath, enableFlatten),
     ]);
   }
 
@@ -2424,20 +2149,18 @@ export function getRequestModelMapping(
   modelPropertyType: SdkModelType & { optional?: boolean },
   propertyPath: string = "body",
   overrides?: ModelOverrideOptions,
-  enableFlatten: boolean = true
+  enableFlatten: boolean = true,
 ): string[] {
   return getRequestModelProperties(
     context,
     modelPropertyType,
     propertyPath,
     overrides,
-    enableFlatten
+    enableFlatten,
   ).map(([name, value]) => `"${name}": ${value}`);
 }
 
-export function getPropertySerializedName(
-  property: SdkHttpParameter | SdkModelPropertyType
-) {
+export function getPropertySerializedName(property: SdkHttpParameter | SdkModelPropertyType) {
   return (
     (property.kind === "property"
       ? property.serializationOptions.json?.name
@@ -2462,11 +2185,10 @@ export function getResponseMapping(
   type: SdkType,
   propertyPath: string = "result.body",
   overrides?: ModelOverrideOptions,
-  enableFlatten: boolean = true
+  enableFlatten: boolean = true,
 ) {
   const allParents = type.kind === "model" ? getAllAncestors(type) : [];
-  const properties =
-    type.kind === "model" ? getAllProperties(context, type, allParents) : [];
+  const properties = type.kind === "model" ? getAllProperties(context, type, allParents) : [];
   const props: string[] = [];
   for (const prop of properties) {
     if (isMetadata(context.program, prop.__raw!)) {
@@ -2475,35 +2197,28 @@ export function getResponseMapping(
     const property = getPropertyWithOverrides(prop, overrides);
     const dot = propertyPath.endsWith("?") ? "." : "";
     const serializedName = getPropertySerializedName(property);
-    const restValue = `${
-      propertyPath ? `${propertyPath}${dot}` : `${dot}`
-    }["${serializedName}"]`;
+    const restValue = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}["${serializedName}"]`;
 
     const nullOrUndefinedPrefix =
-      property.optional || isTypeNullable(property.type)
-        ? `!${restValue}? ${restValue}: `
-        : "";
-    const flattenContext =
-      useContext("sdkTypes").flattenProperties.get(property);
+      property.optional || isTypeNullable(property.type) ? `!${restValue}? ${restValue}: ` : "";
+    const flattenContext = useContext("sdkTypes").flattenProperties.get(property);
     const isSupportedFlatten = flattenContext && enableFlatten;
     const deserializeFunctionName = isSupportedFlatten
       ? buildPropertyDeserializer(context, property, {
           nameOnly: true,
-          skipDiscriminatedUnionSuffix: false
+          skipDiscriminatedUnionSuffix: false,
         })
       : buildModelDeserializer(context, getNullableValidType(property.type), {
           nameOnly: true,
-          skipDiscriminatedUnionSuffix: false
+          skipDiscriminatedUnionSuffix: false,
         });
     const propertyName = normalizeModelPropertyName(context, property);
     if (deserializeFunctionName) {
       if (isSupportedFlatten) {
-        props.push(
-          `...${nullOrUndefinedPrefix}${deserializeFunctionName}(${restValue})`
-        );
+        props.push(`...${nullOrUndefinedPrefix}${deserializeFunctionName}(${restValue})`);
       } else {
         props.push(
-          `${propertyName}: ${nullOrUndefinedPrefix}${deserializeFunctionName}(${restValue})`
+          `${propertyName}: ${nullOrUndefinedPrefix}${deserializeFunctionName}(${restValue})`,
         );
       }
     } else if (isAzureCoreErrorType(context.program, property.type.__raw)) {
@@ -2514,7 +2229,7 @@ export function getResponseMapping(
         property.type,
         `${propertyPath}${dot}["${serializedName}"]`,
         !property.optional,
-        getEncodeForModelProperty(context, property)
+        getEncodeForModelProperty(context, property),
       );
       props.push(`${propertyName}: ${deserializeValue}`);
     }
@@ -2532,7 +2247,7 @@ export function serializeRequestValue(
   required: boolean,
   format?: string,
   serializedName?: string,
-  isTopLevel: boolean = false
+  isTopLevel: boolean = false,
 ): string {
   const getSdkType = useSdkTypes();
   const dependencies = useDependencies();
@@ -2558,22 +2273,18 @@ export function serializeRequestValue(
       if (type.valueType) {
         const prefix = nullOrUndefinedPrefix + clientValue;
         const elementNullOrUndefinedPrefix =
-          isTypeNullable(type.valueType) || getOptionalForType(type.valueType)
-            ? "!p ? p : "
-            : "";
+          isTypeNullable(type.valueType) || getOptionalForType(type.valueType) ? "!p ? p : " : "";
         const serializeFunctionName = buildModelSerializer(
           context,
           getNullableValidType(type.valueType),
           {
             nameOnly: true,
-            skipDiscriminatedUnionSuffix: false
-          }
+            skipDiscriminatedUnionSuffix: false,
+          },
         );
         if (serializeFunctionName) {
           return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${serializeFunctionName}(p)})`;
-        } else if (
-          isAzureCoreErrorType(context.program, type.valueType.__raw)
-        ) {
+        } else if (isAzureCoreErrorType(context.program, type.valueType.__raw)) {
           return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}p})`;
         } else {
           const serializedValue = `${clientValue}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${serializeRequestValue(context, type.valueType, "p", true, getEncodeForType(type.valueType))}})`;
@@ -2594,13 +2305,11 @@ export function serializeRequestValue(
     case "bytes":
       // TODO https://github.com/Azure/typespec-azure/issues/1999
       if (format !== "binary" && format !== "bytes") {
-        const uint8ArrayToStringReference = resolveReference(
-          dependencies.uint8ArrayToString
-        );
+        const uint8ArrayToStringReference = resolveReference(dependencies.uint8ArrayToString);
         return required
           ? `${getNullableCheck(
               clientValue,
-              type
+              type,
             )} ${uint8ArrayToStringReference}(${clientValue}, "${
               getEncodingFormat({ format }) ?? "base64"
             }")`
@@ -2615,8 +2324,7 @@ export function serializeRequestValue(
       } else if (
         isSpecialHandledUnion({
           ...type,
-          isNonExhaustive:
-            context.rlcOptions?.experimentalExtensibleEnums ?? false
+          isNonExhaustive: context.rlcOptions?.experimentalExtensibleEnums ?? false,
         })
       ) {
         const sdkType = getSdkType(type.__raw!);
@@ -2639,7 +2347,7 @@ export function serializeRequestValue(
         type.type,
         clientValue,
         false,
-        getEncodeForType(type.type)
+        getEncodeForType(type.type),
       );
     default:
       if (clientValue === "constructorParam") {
@@ -2659,7 +2367,7 @@ export function deserializeResponseHeadersValue(
   restValue: string,
   required: boolean,
   format?: string,
-  recursionDepth: number = 0
+  recursionDepth: number = 0,
 ) {
   const nullOrUndefinedPrefix =
     isTypeNullable(type) || getOptionalForType(type) || !required
@@ -2695,7 +2403,7 @@ export function deserializeResponseHeadersValue(
         const deserializeFunctionName = type
           ? buildModelDeserializer(context, getNullableValidType(type), {
               nameOnly: true,
-              skipDiscriminatedUnionSuffix: false
+              skipDiscriminatedUnionSuffix: false,
             })
           : undefined;
         if (deserializeFunctionName) {
@@ -2707,14 +2415,7 @@ export function deserializeResponseHeadersValue(
         return `${restValue} as any`;
       }
     default: {
-      const val = deserializeResponseValue(
-        context,
-        type,
-        restValue,
-        true,
-        format,
-        recursionDepth
-      );
+      const val = deserializeResponseValue(context, type, restValue, true, format, recursionDepth);
       return `${nullOrUndefinedPrefix} ${val}`;
     }
   }
@@ -2731,12 +2432,10 @@ export function deserializeResponseValue(
   restValue: string,
   required: boolean,
   format?: string,
-  recursionDepth: number = 0
+  recursionDepth: number = 0,
 ): string {
   const dependencies = useDependencies();
-  const stringToUint8ArrayReference = resolveReference(
-    dependencies.stringToUint8Array
-  );
+  const stringToUint8ArrayReference = resolveReference(dependencies.stringToUint8Array);
   const nullOrUndefinedPrefix =
     isTypeNullable(type) || getOptionalForType(type) || !required
       ? `!${restValue}? ${restValue}: `
@@ -2758,21 +2457,14 @@ export function deserializeResponseValue(
         elementNullOrUndefinedPrefix = `!${varName} ? ${varName} :`;
       }
       const deserializeFunctionName = type.valueType
-        ? buildModelDeserializer(
-            context,
-            getNullableValidType(type.valueType),
-            {
-              nameOnly: true,
-              skipDiscriminatedUnionSuffix: false
-            }
-          )
+        ? buildModelDeserializer(context, getNullableValidType(type.valueType), {
+            nameOnly: true,
+            skipDiscriminatedUnionSuffix: false,
+          })
         : undefined;
       if (deserializeFunctionName) {
         return `${prefix}.map((${varName}: any) => { return ${elementNullOrUndefinedPrefix}${deserializeFunctionName}(${varName})})`;
-      } else if (
-        type.valueType &&
-        isAzureCoreErrorType(context.program, type.valueType.__raw)
-      ) {
+      } else if (type.valueType && isAzureCoreErrorType(context.program, type.valueType.__raw)) {
         return `${prefix}.map((${varName}: any) => { return ${elementNullOrUndefinedPrefix}${varName}})`;
       } else if (type.valueType) {
         if (format) {
@@ -2783,10 +2475,7 @@ export function deserializeResponseValue(
               isTypeNullable(type) || getOptionalForType(type) || !required
                 ? `${restValue} === null || ${restValue} === undefined ? ${restValue}: `
                 : "";
-            if (
-              type.valueType.kind === "enum" &&
-              !isExtensibleEnum(context, type.valueType)
-            ) {
+            if (type.valueType.kind === "enum" && !isExtensibleEnum(context, type.valueType)) {
               // Special handling for non-extensible enums to cast the result to the correct type
               return `${optionalPrefixForString}${parseHelper}(${restValue}) as ${getTypeExpression(context, type)}`;
             } else {
@@ -2810,21 +2499,14 @@ export function deserializeResponseValue(
         elementNullOrUndefinedPrefix = `!${valueVar} ? ${valueVar} :`;
       }
       const deserializeFunctionName = type.valueType
-        ? buildModelDeserializer(
-            context,
-            getNullableValidType(type.valueType),
-            {
-              nameOnly: true,
-              skipDiscriminatedUnionSuffix: false
-            }
-          )
+        ? buildModelDeserializer(context, getNullableValidType(type.valueType), {
+            nameOnly: true,
+            skipDiscriminatedUnionSuffix: false,
+          })
         : undefined;
       if (deserializeFunctionName) {
         return `${nullOrUndefinedPrefix}Object.fromEntries(Object.entries(${restValue}).map(([${keyVar}, ${valueVar}]: [string, any]) => [${keyVar}, ${elementNullOrUndefinedPrefix}${deserializeFunctionName}(${valueVar})]))`;
-      } else if (
-        type.valueType &&
-        isAzureCoreErrorType(context.program, type.valueType.__raw)
-      ) {
+      } else if (type.valueType && isAzureCoreErrorType(context.program, type.valueType.__raw)) {
         return `${nullOrUndefinedPrefix}Object.fromEntries(Object.entries(${restValue}).map(([${keyVar}, ${valueVar}]: [string, any]) => [${keyVar}, ${elementNullOrUndefinedPrefix}${valueVar}]))`;
       } else if (type.valueType) {
         return `${nullOrUndefinedPrefix}Object.fromEntries(Object.entries(${restValue}).map(([${keyVar}, ${valueVar}]: [string, any]) => [${keyVar}, ${elementNullOrUndefinedPrefix}${deserializeResponseValue(context, type.valueType, valueVar, true, getEncodeForType(type.valueType), recursionDepth + 1)}]))`;
@@ -2846,7 +2528,7 @@ export function deserializeResponseValue(
         const deserializeFunctionName = type
           ? buildModelDeserializer(context, getNullableValidType(type), {
               nameOnly: true,
-              skipDiscriminatedUnionSuffix: false
+              skipDiscriminatedUnionSuffix: false,
             })
           : undefined;
         if (deserializeFunctionName) {
@@ -2866,7 +2548,7 @@ export function deserializeResponseValue(
         restValue,
         false,
         getEncodeForType(type.type),
-        recursionDepth + 1
+        recursionDepth + 1,
       );
     default:
       return restValue;
@@ -2874,19 +2556,19 @@ export function deserializeResponseValue(
 }
 
 export function isLroAndPagingOperation(
-  op: SdkMethod<SdkHttpOperation>
+  op: SdkMethod<SdkHttpOperation>,
 ): op is SdkLroPagingServiceMethod<SdkHttpOperation> {
   return op.kind === "lropaging";
 }
 
 export function isLroOnlyOperation(
-  op: SdkMethod<SdkHttpOperation>
+  op: SdkMethod<SdkHttpOperation>,
 ): op is SdkLroServiceMethod<SdkHttpOperation> {
   return op.kind === "lro";
 }
 
 export function isPagingOnlyOperation(
-  op: SdkMethod<SdkHttpOperation>
+  op: SdkMethod<SdkHttpOperation>,
 ): op is SdkPagingServiceMethod<SdkHttpOperation> {
   return op.kind === "paging";
 }
@@ -2894,7 +2576,7 @@ export function isPagingOnlyOperation(
 export function getAllProperties(
   context: SdkContext,
   type: SdkType,
-  parents?: SdkType[]
+  parents?: SdkType[],
 ): SdkModelPropertyType[] {
   const propertiesMap: Map<string, SdkModelPropertyType> = new Map();
   if (!type) {
@@ -2933,7 +2615,7 @@ export function getAllAncestors(type: SdkType): SdkType[] {
  * safely into generated code.
  */
 function hasEffectiveClientDefaultValue(
-  param: SdkHttpParameter | SdkBodyParameter | SdkModelPropertyType
+  param: SdkHttpParameter | SdkBodyParameter | SdkModelPropertyType,
 ): boolean {
   return (
     param.clientDefaultValue !== undefined &&
@@ -2947,7 +2629,7 @@ function hasEffectiveClientDefaultValue(
  */
 function isDefaultValueTypeMatch(
   param: SdkHttpParameter | SdkBodyParameter | SdkModelPropertyType,
-  defaultValue: unknown
+  defaultValue: unknown,
 ): boolean {
   const defaultType = typeof defaultValue;
   const paramType = param.type;
@@ -2990,7 +2672,7 @@ function formatDefaultValue(defaultValue: unknown): string {
 export function getPropertySerializationPrefix(
   context: SdkContext,
   property: SdkHttpParameter | SdkModelPropertyType,
-  propertyPath?: string
+  propertyPath?: string,
 ) {
   const propertyFullName = getPropertyFullName(context, property, propertyPath);
 
@@ -3004,14 +2686,12 @@ export function getPropertySerializationPrefix(
 export function getPropertyFullName(
   context: SdkContext,
   property: SdkHttpParameter | SdkModelPropertyType,
-  propertyPath?: string
+  propertyPath?: string,
 ) {
   const normalizedPropertyName =
     propertyPath === ""
       ? normalizeName(property.name, NameType.Parameter, true)
-      : normalizeModelPropertyName(context, property)
-          .replace(/^"/g, "")
-          .replace(/"$/g, "");
+      : normalizeModelPropertyName(context, property).replace(/^"/g, "").replace(/"$/g, "");
 
   let fullName = normalizedPropertyName;
   if (propertyPath === "" && property.optional) {
@@ -3061,10 +2741,10 @@ export function getExpectedStatuses(operation: ServiceOperation): string {
  */
 function getApiVersionExpression(
   dpgContext: SdkContext,
-  operation: ServiceOperation
+  operation: ServiceOperation,
 ): string | undefined {
   const queryApiVersionParam = operation.operation.parameters.find(
-    (p) => p.kind === "query" && p.isApiVersionParam
+    (p) => p.kind === "query" && p.isApiVersionParam,
   );
   if (!queryApiVersionParam) {
     return undefined;
@@ -3088,7 +2768,7 @@ function getApiVersionExpression(
  * @returns Array of unique response headers
  */
 export function getResponseHeaders(
-  responses: SdkHttpOperation["responses"]
+  responses: SdkHttpOperation["responses"],
 ): SdkServiceResponseHeader[] {
   const headerMap = new Map<string, SdkServiceResponseHeader>();
   for (const response of responses ?? []) {
@@ -3114,23 +2794,24 @@ export function getResponseHeaders(
 function buildCompositeResponseType(
   context: SdkContext,
   modelType: SdkModelType,
-  headers: SdkServiceResponseHeader[]
+  headers: SdkServiceResponseHeader[],
 ): string {
   const allParents = getAllAncestors(modelType);
-  const modelProps: (SdkModelPropertyType | SdkServiceResponseHeader)[] =
-    getAllProperties(context, modelType, allParents).filter((property) => {
-      // Skip model properties that are headers with headerCollectionPrefix
-      if (
-        property.__raw &&
-        isHeader(context.program, property.__raw) &&
-        shouldSkipHeaderSerialization(
-          property as SdkModelPropertyType & SdkServiceResponseHeader
-        )
-      ) {
-        return false;
-      }
-      return true;
-    });
+  const modelProps: (SdkModelPropertyType | SdkServiceResponseHeader)[] = getAllProperties(
+    context,
+    modelType,
+    allParents,
+  ).filter((property) => {
+    // Skip model properties that are headers with headerCollectionPrefix
+    if (
+      property.__raw &&
+      isHeader(context.program, property.__raw) &&
+      shouldSkipHeaderSerialization(property as SdkModelPropertyType & SdkServiceResponseHeader)
+    ) {
+      return false;
+    }
+    return true;
+  });
 
   // Collect header property names already in the model to avoid duplicates
   const modelHeaderNames = new Set<string>();
@@ -3159,7 +2840,7 @@ function buildCompositeResponseType(
  */
 function buildHeaderOnlyResponseType(
   context: SdkContext,
-  headers: SdkServiceResponseHeader[]
+  headers: SdkServiceResponseHeader[],
 ): string {
   const properties: string[] = [];
 
@@ -3182,7 +2863,7 @@ function buildHeaderOnlyResponseType(
  */
 function buildHeaderOnlyResponseValue(
   context: SdkContext,
-  headers: SdkServiceResponseHeader[]
+  headers: SdkServiceResponseHeader[],
 ): string {
   const props = headers.map((header) => {
     const headerName = (header.serializedName ?? header.name).toLowerCase();
@@ -3193,7 +2874,7 @@ function buildHeaderOnlyResponseValue(
       `result.headers[${JSON.stringify(headerName)}]`,
       !header.optional,
       getEncodeForType(header.type),
-      0
+      0,
     );
 
     return `${key}: ${value}`;
@@ -3207,9 +2888,7 @@ function buildHeaderOnlyResponseValue(
  * The name follows the pattern: {OperationGroupName}{MethodName}Response
  * @param method - The method tuple [prefixes, operation]
  */
-export function getOperationResponseTypeName(
-  method: [string[], ServiceOperation]
-): string {
+export function getOperationResponseTypeName(method: [string[], ServiceOperation]): string {
   const prefixes = method[0];
   const operation = method[1];
   const prefix = !operation.name.includes("_")
@@ -3239,8 +2918,7 @@ export function getOperationResponseTypeName(
 function isWrappableType(context: SdkContext, type: SdkType): boolean {
   if (type.kind === "array" && type.valueType.kind === "model") return false;
   if (type.kind === "dict" || type.kind === "model") return false;
-  if (type.kind === "unknown" && context.rlcOptions?.treatUnknownAsRecord)
-    return false;
+  if (type.kind === "unknown" && context.rlcOptions?.treatUnknownAsRecord) return false;
   return true;
 }
 
@@ -3264,7 +2942,7 @@ function isHeadAsBooleanOperation(operation: ServiceOperation): boolean {
  */
 export function checkWrapNonModelReturn(
   context: SdkContext,
-  operation: ServiceOperation
+  operation: ServiceOperation,
 ): { shouldWrap: boolean; isBinary: boolean } {
   const noWrap = { shouldWrap: false, isBinary: false };
 
@@ -3286,7 +2964,7 @@ export function checkWrapNonModelReturn(
     }
     return {
       shouldWrap: isWrappableType(context, lroResultType),
-      isBinary: false
+      isBinary: false,
     };
   }
 
@@ -3303,10 +2981,7 @@ export function checkWrapNonModelReturn(
 
   // bytes with binary content type → binary wrap (isBinary=true)
   //   HLC: bytes → binary payload → separate binary handling
-  if (
-    type.__raw &&
-    isBinaryPayload(context, type.__raw, contentTypes, getEncodeForType(type))
-  ) {
+  if (type.__raw && isBinaryPayload(context, type.__raw, contentTypes, getEncodeForType(type))) {
     return { shouldWrap: true, isBinary: true };
   }
 
@@ -3321,16 +2996,14 @@ export function checkWrapNonModelReturn(
 export function buildNonModelResponseTypeDeclaration(
   context: SdkContext,
   method: [string[], ServiceOperation],
-  isBinary: boolean
+  isBinary: boolean,
 ): TypeAliasDeclarationStructure {
   const typeName = getOperationResponseTypeName(method);
   const operation = method[1];
   let typeBody: string;
 
   if (isBinary) {
-    const nodeReadableStreamRef = resolveReference(
-      PlatformTypeHelpers.NodeReadableStream
-    );
+    const nodeReadableStreamRef = resolveReference(PlatformTypeHelpers.NodeReadableStream);
     typeBody = `{
       /**
        * BROWSER ONLY
@@ -3357,6 +3030,6 @@ export function buildNonModelResponseTypeDeclaration(
     name: typeName,
     type: typeBody,
     isExported: true,
-    leadingTrivia: "\n"
+    leadingTrivia: "\n",
   };
 }