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

package/dist/src/modular/helpers/operationHelpers.js

@@ -1,30 +1,30 @@
-import { StructureKind } from "ts-morph";
+import { getClientOptions, isHttpMetadata, isReadOnly, } from "@azure-tools/typespec-client-generator-core";
 import { NoTarget } 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 { getCollectionFormatHelper, hasCollectionFormatInfo, isBinaryPayload, isXmlPayload, isMultipartPayload, hasDualFormatSupport, getCollectionFormatParseHelper, getCollectionFormatFromArrayEncoding, KnownCollectionFormat } from "../../utils/operationUtil.js";
-import { getPropertyWithOverrides, isNormalUnion, isSpecialHandledUnion } 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 } from "../serialization/buildDeserializerFunction.js";
-import { buildModelSerializer, buildPropertySerializer } from "../serialization/buildSerializerFunction.js";
-import { buildXmlModelSerializer, buildXmlModelDeserializer, hasXmlSerialization } from "../serialization/buildXmlSerializerFunction.js";
+import { isHeader, isMetadata } from "@typespec/http";
+import { StructureKind, } from "ts-morph";
+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 { resolveReference } from "../../framework/reference.js";
-import { useDependencies } from "../../framework/hooks/useDependencies.js";
-import { useSdkTypes } from "../../framework/hooks/sdkTypes.js";
+import { NameType, normalizeName } from "../../rlc-common/index.js";
 import { isAzureCoreErrorType } from "../../utils/modelUtils.js";
-import { getTypeExpression, normalizeModelPropertyName } from "../type-expressions/get-type-expression.js";
-import { getClientOptions, isHttpMetadata, isReadOnly } from "@azure-tools/typespec-client-generator-core";
-import { isHeader, isMetadata } from "@typespec/http";
-import { useContext } from "../../contextManager.js";
-import { getHeaderClientOptions, getRestErrorCodeHeader } from "./clientOptionHelpers.js";
-import { getClientParameterName } from "./clientHelpers.js";
+import { getCollectionFormatFromArrayEncoding, getCollectionFormatHelper, getCollectionFormatParseHelper, hasCollectionFormatInfo, hasDualFormatSupport, isBinaryPayload, isMultipartPayload, isXmlPayload, KnownCollectionFormat, } from "../../utils/operationUtil.js";
+import { AzurePollingDependencies } from "../external-dependencies.js";
+import { buildModelDeserializer, buildPropertyDeserializer, } from "../serialization/buildDeserializerFunction.js";
+import { buildModelSerializer, buildPropertySerializer, } from "../serialization/buildSerializerFunction.js";
+import { buildXmlModelDeserializer, buildXmlModelSerializer, hasXmlSerialization, } from "../serialization/buildXmlSerializerFunction.js";
+import { getPropertyWithOverrides, isNormalUnion, isSpecialHandledUnion, } from "../serialization/serializeUtils.js";
+import { 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.
  * A header is skipped when it has the "headerCollectionPrefix" client option set,
@@ -43,7 +43,7 @@ export function getSendPrivateFunction(dpgContext, method, clientType, client) {
         isExported: true,
         name: `_${name}Send`,
         parameters,
-        returnType: resolveReference(dependencies.StreamableMethod)
+        returnType: resolveReference(dependencies.StreamableMethod),
     };
     const operationPath = operation.operation.path;
     const operationMethod = operation.operation.verb.toLowerCase();
@@ -52,15 +52,13 @@ export function getSendPrivateFunction(dpgContext, method, clientType, client) {
     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
             : operation.operation.uriTemplate.replace(/^\//, "");
@@ -74,7 +72,7 @@ export function getSendPrivateFunction(dpgContext, method, clientType, client) {
     statements.push(`return context.path(${pathStr}).${operationMethod}({...${resolveReference(dependencies.operationOptionsToRequestParameters)}(${optionalParamName}), ${getHeaderAndBodyParameters(dpgContext, operation, optionalParamName)}});`);
     return {
         ...functionStatement,
-        statements
+        statements,
     };
 }
 export function getDeserializePrivateFunction(context, method) {
@@ -100,7 +98,7 @@ export function getDeserializePrivateFunction(context, method) {
             // 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 {
@@ -112,14 +110,14 @@ export function getDeserializePrivateFunction(context, method) {
         // instead of just the array element type
         returnType = {
             name: restResponse.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) {
@@ -128,7 +126,7 @@ export function getDeserializePrivateFunction(context, method) {
         const baseType = getTypeExpression(context, response.type);
         returnType = {
             name: response.name ?? "",
-            type: response.optional ? `${baseType} | undefined` : baseType
+            type: response.optional ? `${baseType} | undefined` : baseType,
         };
     }
     else if (isHeadAsBooleanOperation(operation)) {
@@ -144,15 +142,15 @@ export function getDeserializePrivateFunction(context, method) {
     const parameters = [
         {
             name: resultParamName,
-            type: resultParamType
-        }
+            type: resultParamType,
+        },
     ];
     const functionStatement = {
         isAsync: true,
         isExported: true,
         name: `_${name}Deserialize`,
         parameters,
-        returnType: `Promise<${returnType.type}>`
+        returnType: `Promise<${returnType.type}>`,
     };
     const statements = [];
     const createRestErrorReference = resolveReference(dependencies.createRestError);
@@ -192,9 +190,7 @@ export function getDeserializePrivateFunction(context, method) {
         const isXml = isXmlPayload(contentTypes);
         const isDualFormat = hasDualFormatSupport(contentTypes);
         const isMultipart = isMultipartPayload(contentTypes);
-        const useXmlDeserialization = isXml &&
-            deserializedType.kind === "model" &&
-            hasXmlSerialization(deserializedType);
+        const useXmlDeserialization = 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" : "";
         // For dual-format responses, check content-type header at runtime
@@ -208,11 +204,11 @@ export function getDeserializePrivateFunction(context, method) {
             }
             const xmlDeserializerName = buildXmlModelDeserializer(context, deserializedType, {
                 nameOnly: true,
-                skipDiscriminatedUnionSuffix: false
+                skipDiscriminatedUnionSuffix: false,
             });
             const jsonDeserializerName = buildModelDeserializer(context, deserializedType, {
                 nameOnly: true,
-                skipDiscriminatedUnionSuffix: false
+                skipDiscriminatedUnionSuffix: false,
             });
             if (xmlDeserializerName && jsonDeserializerName) {
                 const isXmlContentTypeRef = resolveReference(XmlHelpers.isXmlContentType);
@@ -226,7 +222,7 @@ export function getDeserializePrivateFunction(context, method) {
                 // Fall back to JSON deserializer
                 const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
                     nameOnly: true,
-                    skipDiscriminatedUnionSuffix: false
+                    skipDiscriminatedUnionSuffix: false,
                 });
                 if (deserializeFunctionName) {
                     statements.push(`return ${deserializeFunctionName}(${deserializedRoot})`);
@@ -242,7 +238,7 @@ export function getDeserializePrivateFunction(context, method) {
             }
             const xmlDeserializerName = buildXmlModelDeserializer(context, deserializedType, {
                 nameOnly: true,
-                skipDiscriminatedUnionSuffix: false
+                skipDiscriminatedUnionSuffix: false,
             });
             if (xmlDeserializerName) {
                 statements.push(`return ${xmlDeserializerName}(${deserializedRoot})`);
@@ -251,7 +247,7 @@ export function getDeserializePrivateFunction(context, method) {
                 // Fall back to JSON deserializer if XML deserializer is not available
                 const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
                     nameOnly: true,
-                    skipDiscriminatedUnionSuffix: false
+                    skipDiscriminatedUnionSuffix: false,
                 });
                 if (deserializeFunctionName) {
                     statements.push(`return ${deserializeFunctionName}(${deserializedRoot})`);
@@ -265,7 +261,7 @@ export function getDeserializePrivateFunction(context, method) {
             // JSON response (default) - also handles multipart responses
             const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
                 nameOnly: true,
-                skipDiscriminatedUnionSuffix: false
+                skipDiscriminatedUnionSuffix: false,
             });
             // Handle wrap-non-model-return for non-LRO, non-paging and LRO-only operations
             if (shouldWrap) {
@@ -288,7 +284,7 @@ export function getDeserializePrivateFunction(context, method) {
                 }
                 return {
                     ...functionStatement,
-                    statements
+                    statements,
                 };
             }
             if (deserializeFunctionName) {
@@ -327,7 +323,7 @@ export function getDeserializePrivateFunction(context, method) {
     }
     return {
         ...functionStatement,
-        statements
+        statements,
     };
 }
 /**
@@ -340,8 +336,7 @@ export function getDeserializeHeadersPrivateFunction(context, operation) {
     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);
@@ -350,8 +345,8 @@ export function getDeserializeHeadersPrivateFunction(context, operation) {
     const parameters = [
         {
             name: "result",
-            type: PathUncheckedResponseReference
-        }
+            type: PathUncheckedResponseReference,
+        },
     ];
     const returnType = buildHeaderOnlyResponseType(context, responseHeaders);
     const functionStatement = {
@@ -359,13 +354,13 @@ export function getDeserializeHeadersPrivateFunction(context, operation) {
         isExported: true,
         name: `_${name}DeserializeHeaders`,
         parameters,
-        returnType
+        returnType,
     };
     const statements = [];
     statements.push(`return ${buildHeaderOnlyResponseValue(context, responseHeaders)};`);
     return {
         ...functionStatement,
-        statements
+        statements,
     };
 }
 function getExceptionDetails(context, operation) {
@@ -380,10 +375,9 @@ function getExceptionDetails(context, operation) {
         const statusCode = exception.statusCodes;
         const deserializeFunctionName = buildModelDeserializer(context, exception.type, {
             nameOnly: true,
-            skipDiscriminatedUnionSuffix: false
+            skipDiscriminatedUnionSuffix: false,
         });
-        if (!deserializeFunctionName ||
-            typeof deserializeFunctionName !== "string") {
+        if (!deserializeFunctionName || typeof deserializeFunctionName !== "string") {
             continue;
         }
         // Check if the exception type has XML serialization support
@@ -396,16 +390,14 @@ function getExceptionDetails(context, operation) {
         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;
             }
         }
         // 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;
             defaultXmlDeserializer = xmlDeserializerName;
@@ -416,7 +408,7 @@ function getExceptionDetails(context, operation) {
                 start: statusCode,
                 deserializer: deserializeFunctionName,
                 xmlDeserializer: xmlDeserializerName,
-                isXmlOnly
+                isXmlOnly,
             });
         }
         else {
@@ -425,7 +417,7 @@ function getExceptionDetails(context, operation) {
                 end: statusCode.end,
                 deserializer: deserializeFunctionName,
                 xmlDeserializer: xmlDeserializerName,
-                isXmlOnly
+                isXmlOnly,
             });
         }
     }
@@ -433,7 +425,7 @@ function getExceptionDetails(context, operation) {
         customized,
         defaultDeserializer,
         defaultXmlDeserializer,
-        defaultIsXmlOnly
+        defaultIsXmlOnly,
     };
 }
 /**
@@ -472,8 +464,8 @@ export function getDeserializeExceptionHeadersPrivateFunction(context, operation
     const parameters = [
         {
             name: "result",
-            type: PathUncheckedResponseReference
-        }
+            type: PathUncheckedResponseReference,
+        },
     ];
     const returnType = buildHeaderOnlyResponseType(context, exceptionHeaders);
     const functionStatement = {
@@ -481,13 +473,13 @@ export function getDeserializeExceptionHeadersPrivateFunction(context, operation
         isExported: true,
         name: `_${name}DeserializeExceptionHeaders`,
         parameters,
-        returnType
+        returnType,
     };
     const statements = [];
     statements.push(`return ${buildHeaderOnlyResponseValue(context, exceptionHeaders)};`);
     return {
         ...functionStatement,
-        statements
+        statements,
     };
 }
 function getExceptionDeserializeExpr(exception) {
@@ -515,11 +507,7 @@ function getExceptionThrowStatement(context, operation) {
     const clientOptionHeadersCall = buildClientOptionHeadersCall(operation.operation.exceptions);
     // Build @clientOption("restErrorCodeHeader", ...) code to set error.code from a header
     const restErrorCodeAssignment = buildRestErrorCodeAssignment(operation.operation.exceptions);
-    const allHeaderCalls = [
-        exceptionHeadersCall,
-        clientOptionHeadersCall,
-        restErrorCodeAssignment
-    ]
+    const allHeaderCalls = [exceptionHeadersCall, clientOptionHeadersCall, restErrorCodeAssignment]
         .filter(Boolean)
         .join("\n");
     // Check if any exception has XML deserialization support that requires runtime content-type check
@@ -635,7 +623,8 @@ if (restErrorCodeValue !== undefined) { error.code = restErrorCodeValue; }`;
     return undefined;
 }
 function getOptionalParamsName(parameters) {
-    return (parameters.filter((p) => p.type?.toString().endsWith("operationOptions__"))[0]?.name ?? "options");
+    return (parameters.filter((p) => p.type?.toString().endsWith("operationOptions__"))[0]?.name ??
+        "options");
 }
 function getOperationSignatureParameters(context, method, clientType) {
     const operation = method[1];
@@ -650,14 +639,12 @@ function getOperationSignatureParameters(context, method, clientType) {
                 param.methodParameterSegments[0]?.[0] === p);
         })[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)
         .map((p) => {
         return {
             name: p.name,
-            type: getTypeExpression(context, p.type)
+            type: getTypeExpression(context, p.type),
         };
     })
         .forEach((p) => {
@@ -669,7 +656,7 @@ function getOperationSignatureParameters(context, method, clientType) {
     const optionsParam = {
         name: parameters.has("options") ? "optionalParams" : "options",
         type: optionsType,
-        initializer: "{ requestOptions: {} }"
+        initializer: "{ requestOptions: {} }",
     };
     const finalParameters = [contextParam, ...parameters.values(), optionsParam];
     return finalParameters;
@@ -713,30 +700,26 @@ export function getOperationFunction(context, method, clientType) {
         // 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);
             returnType = {
                 name: type.name ?? "",
-                type: response.optional
-                    ? `${baseCompositeType} | undefined`
-                    : baseCompositeType
+                type: response.optional ? `${baseCompositeType} | undefined` : baseCompositeType,
             };
         }
         else {
             const baseType = getTypeExpression(context, type);
             returnType = {
                 name: type.name ?? "",
-                type: response.optional ? `${baseType} | undefined` : baseType
+                type: response.optional ? `${baseType} | undefined` : baseType,
             };
         }
     }
@@ -744,7 +727,7 @@ export function getOperationFunction(context, method, clientType) {
         // 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)) {
@@ -782,16 +765,13 @@ export function getOperationFunction(context, method, clientType) {
     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 = [];
     // Generate unique local variable names that don't conflict with parameter names
@@ -864,7 +844,7 @@ export function getOperationFunction(context, method, clientType) {
     }
     return {
         ...functionStatement,
-        statements
+        statements,
     };
 }
 function getLroOnlyOperationFunction(context, method, clientType, optionalParamName = "options") {
@@ -886,10 +866,7 @@ function getLroOnlyOperationFunction(context, method, clientType, optionalParamN
         : returnType.type;
     const functionStatement = {
         kind: StructureKind.Function,
-        docs: [
-            ...getDocsFromDescription(operation.doc),
-            ...getFixmeForMultilineDocs(fixme)
-        ],
+        docs: [...getDocsFromDescription(operation.doc), ...getFixmeForMultilineDocs(fixme)],
         isAsync: false,
         isExported: true,
         name,
@@ -897,20 +874,17 @@ function getLroOnlyOperationFunction(context, method, clientType, optionalParamN
         isLro: true,
         lroFinalReturnType: effectiveReturnTypeName,
         parameters,
-        returnType: `${pollerLikeReference}<${operationStateReference}<${effectiveReturnTypeStr}>, ${effectiveReturnTypeStr}>`
+        returnType: `${pollerLikeReference}<${operationStateReference}<${effectiveReturnTypeStr}>, ${effectiveReturnTypeStr}>`,
     };
     const getLongRunningPollerReference = resolveReference(PollingHelpers.GetLongRunningPoller);
-    const lroMetadata = operation.kind === "lro" || operation.kind === "lropaging"
-        ? operation.lroMetadata
-        : undefined;
+    const lroMetadata = 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)
+    const resourceLocationConfig = lroMetadata?.finalStateVia && allowedFinalLocation.includes(lroMetadata?.finalStateVia)
         ? `resourceLocationConfig: "${lroMetadata?.finalStateVia}",`
         : "";
     const apiVersion = getApiVersionExpression(context, operation);
@@ -920,16 +894,14 @@ function getLroOnlyOperationFunction(context, method, clientType, optionalParamN
   return ${getLongRunningPollerReference}(context, _${name}Deserialize, ${getExpectedStatuses(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}>;
   `);
     return {
         ...functionStatement,
-        statements
+        statements,
     };
 }
 function getLroAndPagingOperationFunction(context, method, clientType, optionalParamName = "options") {
@@ -947,14 +919,14 @@ function getLroAndPagingOperationFunction(context, method, clientType, optionalP
             `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
     const allowedLocations = [
         "azure-async-operation",
         "location",
         "original-uri",
-        "operation-location"
+        "operation-location",
     ];
     const resourceLocationConfig = operation.lroMetadata?.finalStateVia &&
         allowedLocations.includes(operation.lroMetadata.finalStateVia)
@@ -967,17 +939,14 @@ function getLroAndPagingOperationFunction(context, method, clientType, optionalP
         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(", ")}}` : "";
     return {
         kind: StructureKind.Function,
-        docs: [
-            ...getDocsFromDescription(operation.doc),
-            ...getFixmeForMultilineDocs(fixme)
-        ],
+        docs: [...getDocsFromDescription(operation.doc), ...getFixmeForMultilineDocs(fixme)],
         isAsync: false,
         isExported: true,
         isLroPaging: true,
@@ -1004,8 +973,8 @@ function getLroAndPagingOperationFunction(context, method, clientType, optionalP
     _${name}Deserialize,
     ${expectedStatuses}${pagingOptionsStr}
   );
-  `
-        ]
+  `,
+        ],
     };
 }
 function buildLroReturnType(context, operation) {
@@ -1014,7 +983,7 @@ function buildLroReturnType(context, operation) {
         const type = metadata.finalResponse.result;
         return {
             name: type.name,
-            type: getTypeExpression(context, type)
+            type: getTypeExpression(context, type),
         };
     }
     return { name: "", type: "void" };
@@ -1023,7 +992,7 @@ function buildLroPagingReturnType(context, operation) {
     if (operation.response.type?.kind === "array") {
         return {
             name: operation.response.type.valueType.name ?? "",
-            type: getTypeExpression(context, operation.response.type.valueType)
+            type: getTypeExpression(context, operation.response.type.valueType),
         };
     }
     return { name: "", type: "void" };
@@ -1039,7 +1008,7 @@ function getPagingOnlyOperationFunction(context, method, clientType) {
         const type = response.type;
         returnType = {
             name: type.valueType.name ?? "",
-            type: getTypeExpression(context, type.valueType)
+            type: getTypeExpression(context, type.valueType),
         };
     }
     const { name, fixme = [] } = getOperationName(operation, context);
@@ -1047,16 +1016,13 @@ function getPagingOnlyOperationFunction(context, method, clientType) {
     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 = [];
     const options = [];
@@ -1096,7 +1062,7 @@ function getPagingOnlyOperationFunction(context, method, clientType) {
       );`);
     return {
         ...functionStatement,
-        statements
+        statements,
     };
 }
 export function getOperationOptionsName(method, includeGroupName = false) {
@@ -1121,7 +1087,7 @@ function getHeaderAndBodyParameters(dpgContext, operation, optionalParamName = "
     const contentTypeParameter = operation.operation.parameters.find(isContentType);
     const parametersImplementation = {
         header: [],
-        body: []
+        body: [],
     };
     for (const param of operationParameters) {
         if (param.kind === "header") {
@@ -1136,13 +1102,12 @@ function getHeaderAndBodyParameters(dpgContext, operation, optionalParamName = "
                 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,
                 });
             }
         }
@@ -1156,8 +1121,7 @@ function getHeaderAndBodyParameters(dpgContext, operation, optionalParamName = "
             .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")}}`;
@@ -1173,7 +1137,7 @@ function buildHeaderParameter(program, paramMap, param, paramAccessor) {
     if (!effectiveOptional && isTypeNullable(param.type) === true) {
         reportDiagnostic(program, {
             code: "nullable-required-header",
-            target: NoTarget
+            target: NoTarget,
         });
         return paramMap;
     }
@@ -1188,9 +1152,7 @@ function buildHeaderParameter(program, paramMap, param, paramAccessor) {
     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, bodyParameter, optionalParamName = "options") {
     if (!bodyParameter || !bodyParameter.type) {
@@ -1207,14 +1169,14 @@ function buildBodyParameter(context, bodyParameter, optionalParamName = "options
         // Use XML serializer
         serializerFunctionName = buildXmlModelSerializer(context, bodyType, {
             nameOnly: true,
-            skipDiscriminatedUnionSuffix: false
+            skipDiscriminatedUnionSuffix: false,
         });
     }
     else {
         // Use JSON serializer (default)
         serializerFunctionName = buildModelSerializer(context, bodyType, {
             nameOnly: true,
-            skipDiscriminatedUnionSuffix: false
+            skipDiscriminatedUnionSuffix: false,
         });
     }
     let bodyNameExpression = getParamAccessor(bodyParameter, optionalParamName);
@@ -1236,16 +1198,14 @@ function buildBodyParameter(context, bodyParameter, optionalParamName = "options
         ? `!${bodyNameExpression}? ${bodyNameExpression}:`
         : "";
     // 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,
         });
         const jsonSerializerName = buildModelSerializer(context, bodyType, {
             nameOnly: true,
-            skipDiscriminatedUnionSuffix: false
+            skipDiscriminatedUnionSuffix: false,
         });
         if (xmlSerializerName && jsonSerializerName) {
             const isXmlContentTypeRef = resolveReference(XmlHelpers.isXmlContentType);
@@ -1276,9 +1236,7 @@ function getEncodingFormat(type) {
  */
 export function getParameterMap(context, param, paramAccessor) {
     // Use lowercase for header names since HTTP headers are case-insensitive
-    const serializedName = param.kind === "header"
-        ? getHeaderSerializedName(param)
-        : getPropertySerializedName(param);
+    const serializedName = param.kind === "header" ? getHeaderSerializedName(param) : getPropertySerializedName(param);
     if (isConstant(param.type) && !isOptional(param)) {
         return `"${serializedName}": ${getConstantValue(param.type)}`;
     }
@@ -1304,9 +1262,9 @@ export function getParameterMap(context, param, paramAccessor) {
         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
     return `"${param.name}": undefined`;
@@ -1316,8 +1274,7 @@ function getCollectionFormatForParam(context, param, paramAccessor, serializedNa
     return `"${serializedName}": ${serializeRequestValue(context, param.type, paramAccessor, !param.optional, format, serializedName, true)}`;
 }
 function isContentType(param) {
-    return (param.kind === "header" &&
-        param.serializedName.toLowerCase() === "content-type");
+    return param.kind === "header" && param.serializedName.toLowerCase() === "content-type";
 }
 function getContentTypeValue(param, optionalParamName = "options") {
     const defaultValue = param.clientDefaultValue;
@@ -1437,22 +1394,21 @@ function getQueryParameters(dpgContext, operation) {
     }
     const operationParameters = operation.operation.parameters.filter((p) => !isContentType(p));
     const parametersImplementation = {
-        query: []
+        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(dpgContext, {
                         ...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),
-                    param
+                    param,
                 });
             }
         }
@@ -1482,9 +1438,7 @@ function getParamAccessor(param, optionalParamName = "options") {
     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)}`;
@@ -1563,15 +1517,14 @@ function getEncodeForModelProperty(context, property) {
                 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)) {
+        if (collectionFormat && hasCollectionFormatInfo(property.kind, collectionFormat)) {
             return collectionFormat;
         }
     }
@@ -1587,8 +1540,7 @@ function isStringEncodableArrayValueType(valueType) {
         return true;
     }
     // String-based enum type
-    if (valueType.kind === "enum" &&
-        valueType.valueType.kind === "string") {
+    if (valueType.kind === "enum" && valueType.valueType.kind === "string") {
         return true;
     }
     return false;
@@ -1596,14 +1548,12 @@ function isStringEncodableArrayValueType(valueType) {
 function getSerializationExpressionForFlatten(context, property, propertyPath) {
     const serializeFunctionName = buildPropertySerializer(context, property, {
         nameOnly: true,
-        skipDiscriminatedUnionSuffix: false
+        skipDiscriminatedUnionSuffix: false,
     });
     if (!serializeFunctionName) {
         return property.optional ? `undefined` : `{}`;
     }
-    const validProps = getAllProperties(context, property.type, getAllAncestors(property.type)).filter((p) => p.kind === "property" &&
-        !isReadOnly(p) &&
-        !isMetadata(context.program, p.__raw));
+    const validProps = getAllProperties(context, property.type, getAllAncestors(property.type)).filter((p) => p.kind === "property" && !isReadOnly(p) && !isMetadata(context.program, p.__raw));
     const optionalPrefix = property.optional
         ? `${resolveReference(SerializationHelpers.areAllPropsUndefined)}(${propertyPath}, [${validProps
             .map((p) => `"${p.name}"`)
@@ -1621,7 +1571,7 @@ export function getSerializationExpression(context, property, propertyPath, enab
     const propertyFullName = getPropertyFullName(context, property, propertyPathWithDot);
     const serializeFunctionName = buildModelSerializer(context, getNullableValidType(property.type), {
         nameOnly: true,
-        skipDiscriminatedUnionSuffix: false
+        skipDiscriminatedUnionSuffix: false,
     });
     // Apply clientDefaultValue for model properties that have one
     const defaultValueSuffix = hasEffectiveClientDefaultValue(property)
@@ -1655,7 +1605,7 @@ export function getRequestModelProperties(context, modelPropertyType, propertyPa
         const property = getPropertyWithOverrides(prop, overrides);
         props.push([
             getPropertySerializedName(property),
-            getSerializationExpression(context, property, propertyPath, enableFlatten)
+            getSerializationExpression(context, property, propertyPath, enableFlatten),
         ]);
     }
     return props;
@@ -1696,19 +1646,17 @@ export function getResponseMapping(context, type, propertyPath = "result.body",
         const dot = propertyPath.endsWith("?") ? "." : "";
         const serializedName = getPropertySerializedName(property);
         const restValue = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}["${serializedName}"]`;
-        const nullOrUndefinedPrefix = property.optional || isTypeNullable(property.type)
-            ? `!${restValue}? ${restValue}: `
-            : "";
+        const nullOrUndefinedPrefix = 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) {
@@ -1755,12 +1703,10 @@ export function serializeRequestValue(context, type, clientValue, required, form
         case "array": {
             if (type.valueType) {
                 const prefix = nullOrUndefinedPrefix + clientValue;
-                const elementNullOrUndefinedPrefix = isTypeNullable(type.valueType) || getOptionalForType(type.valueType)
-                    ? "!p ? p : "
-                    : "";
+                const elementNullOrUndefinedPrefix = 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)})`;
@@ -1799,7 +1745,7 @@ export function serializeRequestValue(context, type, clientValue, required, form
             }
             else if (isSpecialHandledUnion({
                 ...type,
-                isNonExhaustive: context.rlcOptions?.experimentalExtensibleEnums ?? false
+                isNonExhaustive: context.rlcOptions?.experimentalExtensibleEnums ?? false,
             })) {
                 const sdkType = getSdkType(type.__raw);
                 const serializerRefkey = refkey(sdkType, "serializer");
@@ -1863,7 +1809,7 @@ export function deserializeResponseHeadersValue(context, type, restValue, requir
                 const deserializeFunctionName = type
                     ? buildModelDeserializer(context, getNullableValidType(type), {
                         nameOnly: true,
-                        skipDiscriminatedUnionSuffix: false
+                        skipDiscriminatedUnionSuffix: false,
                     })
                     : undefined;
                 if (deserializeFunctionName) {
@@ -1910,14 +1856,13 @@ export function deserializeResponseValue(context, type, restValue, required, for
             const deserializeFunctionName = type.valueType
                 ? buildModelDeserializer(context, getNullableValidType(type.valueType), {
                     nameOnly: true,
-                    skipDiscriminatedUnionSuffix: false
+                    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) {
@@ -1928,8 +1873,7 @@ export function deserializeResponseValue(context, type, restValue, required, for
                         const optionalPrefixForString = 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)}`;
                         }
@@ -1955,14 +1899,13 @@ export function deserializeResponseValue(context, type, restValue, required, for
             const deserializeFunctionName = type.valueType
                 ? buildModelDeserializer(context, getNullableValidType(type.valueType), {
                     nameOnly: true,
-                    skipDiscriminatedUnionSuffix: false
+                    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) {
@@ -1987,7 +1930,7 @@ export function deserializeResponseValue(context, type, restValue, required, for
                 const deserializeFunctionName = type
                     ? buildModelDeserializer(context, getNullableValidType(type), {
                         nameOnly: true,
-                        skipDiscriminatedUnionSuffix: false
+                        skipDiscriminatedUnionSuffix: false,
                     })
                     : undefined;
                 if (deserializeFunctionName) {
@@ -2102,9 +2045,7 @@ export function getPropertySerializationPrefix(context, property, propertyPath)
 export function getPropertyFullName(context, property, propertyPath) {
     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) {
         fullName = `options?.${normalizedPropertyName}`;
@@ -2325,7 +2266,7 @@ export function checkWrapNonModelReturn(context, operation) {
         }
         return {
             shouldWrap: isWrappableType(context, lroResultType),
-            isBinary: false
+            isBinary: false,
         };
     }
     const { type } = operation.response;
@@ -2339,8 +2280,7 @@ export function checkWrapNonModelReturn(context, operation) {
     const contentTypes = operation.operation.responses[0]?.contentTypes ?? [];
     // 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 };
     }
     return { shouldWrap: isWrappableType(context, type), isBinary: false };
@@ -2382,7 +2322,7 @@ export function buildNonModelResponseTypeDeclaration(context, method, isBinary)
         name: typeName,
         type: typeBody,
         isExported: true,
-        leadingTrivia: "\n"
+        leadingTrivia: "\n",
     };
 }
 //# sourceMappingURL=operationHelpers.js.map