@azure-tools/typespec-ts 0.49.0 → 0.49.1

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

@@ -2,7 +2,7 @@ import { StructureKind } from "ts-morph";
 import { NoTarget } from "@typespec/compiler";
 import { PagingHelpers, PollingHelpers, SerializationHelpers, UrlTemplateHelpers, XmlHelpers } from "../static-helpers-metadata.js";
 import { getNullableValidType, isSpreadBodyParameter, isTypeNullable } from "./typeHelpers.js";
-import { getClassicalLayerPrefix, getOperationName } from "./namingHelpers.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";
@@ -18,11 +18,12 @@ 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 { isHttpMetadata, isReadOnly } from "@azure-tools/typespec-client-generator-core";
-import { isMetadata } from "@typespec/http";
+import { getClientOptions, isHttpMetadata, isReadOnly } from "@azure-tools/typespec-client-generator-core";
+import { isHeader, isMetadata } from "@typespec/http";
 import { useContext } from "../../contextManager.js";
 import { isExtensibleEnum } from "../type-expressions/get-enum-expression.js";
-export function getSendPrivateFunction(dpgContext, method, clientType) {
+import { emitInlineModel } from "../type-expressions/get-model-expression.js";
+export function getSendPrivateFunction(dpgContext, method, clientType, client) {
     const operation = method[1];
     const parameters = getOperationSignatureParameters(dpgContext, method, clientType);
     const { name } = getOperationName(operation);
@@ -44,12 +45,21 @@ export function getSendPrivateFunction(dpgContext, method, clientType) {
         ...getQueryParameters(dpgContext, operation)
     ];
     if (urlTemplateParams.length > 0) {
-        statements.push(`const path = ${resolveReference(UrlTemplateHelpers.parseTemplate)}("${operation.operation.uriTemplate}", {
+        // 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 uriTemplate = includeRootSlash
+            ? operation.operation.uriTemplate
+            : operation.operation.uriTemplate.replace(/^\//, "");
+        statements.push(`const ${pathVarName} = ${resolveReference(UrlTemplateHelpers.parseTemplate)}("${uriTemplate}", {
         ${urlTemplateParams.join(",\n")}
         },{
       allowReserved: ${optionalParamName}?.requestOptions?.skipUrlEncoding
     });`);
-        pathStr = "path";
+        pathStr = pathVarName;
     }
     statements.push(`return context.path(${pathStr}).${operationMethod}({...${resolveReference(dependencies.operationOptionsToRequestParameters)}(${optionalParamName}), ${getHeaderAndBodyParameters(dpgContext, operation, optionalParamName)}});`);
     return {
@@ -58,7 +68,7 @@ export function getSendPrivateFunction(dpgContext, method, clientType) {
     };
 }
 export function getDeserializePrivateFunction(context, operation) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const { name } = getOperationName(operation);
     const dependencies = useDependencies();
     const PathUncheckedResponseReference = resolveReference(dependencies.PathUncheckedResponse);
@@ -70,6 +80,7 @@ export function getDeserializePrivateFunction(context, operation) {
     ];
     const isLroOnly = isLroOnlyOperation(operation);
     const isLroAndPaging = isLroAndPagingOperation(operation);
+    const isPagingOnly = isPagingOnlyOperation(operation);
     // TODO: Support operation overloads
     // TODO: Support multiple responses
     const response = operation.response;
@@ -78,12 +89,20 @@ export function getDeserializePrivateFunction(context, operation) {
     if (isLroOnly || isLroAndPaging) {
         returnType = buildLroReturnType(context, operation);
     }
-    else if (response.type && restResponse) {
+    else if (isPagingOnly && (restResponse === null || restResponse === void 0 ? void 0 : restResponse.type)) {
+        // For paging operations, use the full response model (e.g., _OperationListResult)
+        // instead of just the array element type
         returnType = {
             name: (_a = restResponse.name) !== null && _a !== void 0 ? _a : "",
             type: getTypeExpression(context, restResponse.type)
         };
     }
+    else if (response.type) {
+        returnType = {
+            name: (_b = response.name) !== null && _b !== void 0 ? _b : "",
+            type: getTypeExpression(context, response.type)
+        };
+    }
     else {
         returnType = { name: "", type: "void" };
     }
@@ -99,12 +118,12 @@ export function getDeserializePrivateFunction(context, operation) {
     statements.push(`const expectedStatuses = ${getExpectedStatuses(operation)};`);
     statements.push(`if(!expectedStatuses.includes(result.status)){`, `${getExceptionThrowStatement(context, operation)}`, "}");
     const deserializedType = isLroOnly || isLroAndPaging
-        ? (_c = (_b = operation === null || operation === void 0 ? void 0 : operation.lroMetadata) === null || _b === void 0 ? void 0 : _b.finalResponse) === null || _c === void 0 ? void 0 : _c.result
-        : restResponse
+        ? (_d = (_c = operation === null || operation === void 0 ? void 0 : operation.lroMetadata) === null || _c === void 0 ? void 0 : _c.finalResponse) === null || _d === void 0 ? void 0 : _d.result
+        : isPagingOnly && (restResponse === null || restResponse === void 0 ? void 0 : restResponse.type)
             ? restResponse.type
             : response.type;
     const lroSubSegments = isLroOnly
-        ? (_e = (_d = operation === null || operation === void 0 ? void 0 : operation.lroMetadata) === null || _d === void 0 ? void 0 : _d.finalResponse) === null || _e === void 0 ? void 0 : _e.resultSegments
+        ? (_f = (_e = operation === null || operation === void 0 ? void 0 : operation.lroMetadata) === null || _e === void 0 ? void 0 : _e.finalResponse) === null || _f === void 0 ? void 0 : _f.resultSegments
         : undefined;
     let lroSubPath;
     if (lroSubSegments && lroSubSegments.length > 0) {
@@ -123,7 +142,7 @@ export function getDeserializePrivateFunction(context, operation) {
       `);
     }
     if (deserializedType) {
-        const contentTypes = (_g = (_f = operation.operation.responses[0]) === null || _f === void 0 ? void 0 : _f.contentTypes) !== null && _g !== void 0 ? _g : [];
+        const contentTypes = (_h = (_g = operation.operation.responses[0]) === null || _g === void 0 ? void 0 : _g.contentTypes) !== null && _h !== void 0 ? _h : [];
         const isXml = isXmlPayload(contentTypes);
         const isDualFormat = hasDualFormatSupport(contentTypes);
         const isMultipart = isMultipartPayload(contentTypes);
@@ -216,9 +235,48 @@ export function getDeserializePrivateFunction(context, operation) {
         statements
     };
 }
+/**
+ * Generates a private function to deserialize response headers.
+ * Only generated when response headers are present and include-headers-in-response is enabled.
+ */
+export function getDeserializeHeadersPrivateFunction(context, operation) {
+    var _a;
+    const responseHeaders = getResponseHeaders(operation.operation.responses);
+    const isResponseHeadersEnabled = ((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.includeHeadersInResponse) === true;
+    // Only generate if headers exist and feature is enabled
+    if (responseHeaders.length === 0 || !isResponseHeadersEnabled) {
+        return undefined;
+    }
+    const { name } = getOperationName(operation);
+    const dependencies = useDependencies();
+    const PathUncheckedResponseReference = resolveReference(dependencies.PathUncheckedResponse);
+    const parameters = [
+        {
+            name: "result",
+            type: PathUncheckedResponseReference
+        }
+    ];
+    const returnType = buildHeaderOnlyResponseType(context, responseHeaders);
+    const functionStatement = {
+        isAsync: false,
+        isExported: true,
+        name: `_${name}DeserializeHeaders`,
+        parameters,
+        returnType
+    };
+    const statements = [];
+    statements.push(`return ${buildHeaderOnlyResponseValue(context, responseHeaders)};`);
+    return {
+        ...functionStatement,
+        statements
+    };
+}
 function getExceptionDetails(context, operation) {
+    var _a;
     const customized = [];
     let defaultDeserializer;
+    let defaultXmlDeserializer;
+    let defaultIsXmlOnly;
     for (const exception of operation.operation.exceptions) {
         if (!exception.type) {
             continue;
@@ -232,56 +290,124 @@ function getExceptionDetails(context, operation) {
             typeof deserializeFunctionName !== "string") {
             continue;
         }
+        // Check if the exception type has XML serialization support
+        // Use exception contentTypes when available, otherwise check the type itself
+        const exceptionContentTypes = (_a = exception.contentTypes) !== null && _a !== void 0 ? _a : [];
+        const exceptionIsXml = isXmlPayload(exceptionContentTypes);
+        const exceptionIsDualFormat = hasDualFormatSupport(exceptionContentTypes);
+        const typeHasXml = exception.type.kind === "model" && hasXmlSerialization(exception.type);
+        let xmlDeserializerName;
+        if (exception.type.kind === "model" && (typeHasXml || exceptionIsXml)) {
+            const xmlName = buildXmlModelDeserializer(context, exception.type, {
+                nameOnly: true,
+                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;
         if (statusCode === "*") {
             defaultDeserializer = deserializeFunctionName;
+            defaultXmlDeserializer = xmlDeserializerName;
+            defaultIsXmlOnly = isXmlOnly;
         }
         else if (typeof statusCode === "number") {
             customized.push({
                 start: statusCode,
-                deserializer: deserializeFunctionName
+                deserializer: deserializeFunctionName,
+                xmlDeserializer: xmlDeserializerName,
+                isXmlOnly
             });
         }
         else {
             customized.push({
                 start: statusCode.start,
                 end: statusCode.end,
-                deserializer: deserializeFunctionName
+                deserializer: deserializeFunctionName,
+                xmlDeserializer: xmlDeserializerName,
+                isXmlOnly
             });
         }
     }
-    return { customized, defaultDeserializer };
+    return {
+        customized,
+        defaultDeserializer,
+        defaultXmlDeserializer,
+        defaultIsXmlOnly
+    };
+}
+function getExceptionDeserializeExpr(exception) {
+    if (!exception.xmlDeserializer) {
+        return `${exception.deserializer}(result.body)`;
+    }
+    if (exception.isXmlOnly) {
+        return `${exception.xmlDeserializer}(result.body)`;
+    }
+    return `isXml ? ${exception.xmlDeserializer}(result.body) : ${exception.deserializer}(result.body)`;
 }
 function getExceptionThrowStatement(context, operation) {
     const statements = [];
     const createRestErrorReference = resolveReference(useDependencies().createRestError);
-    const { customized, defaultDeserializer } = getExceptionDetails(context, operation);
+    const { customized, defaultDeserializer, defaultXmlDeserializer, defaultIsXmlOnly } = getExceptionDetails(context, operation);
+    // Check if any exception has XML deserialization support that requires runtime content-type check
+    const hasAnyDualFormatXml = (defaultXmlDeserializer !== undefined && !defaultIsXmlOnly) ||
+        customized.some((e) => e.xmlDeserializer !== undefined && !e.isXmlOnly);
     if (customized.length > 0) {
         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 statusCode = Number.parseInt(result.status);`);
         const stats = customized.map((exception) => {
+            const deserializeExpr = getExceptionDeserializeExpr(exception);
             if (exception.end) {
                 return `if(statusCode >= ${exception.start} && statusCode <= ${exception.end}) {
-              error.details = ${exception.deserializer}(result.body);
+              error.details = ${deserializeExpr};
           }`;
             }
             else {
                 return `if(statusCode === ${exception.start}) {
-             error.details = ${exception.deserializer}(result.body);
+             error.details = ${deserializeExpr};
           }`;
             }
         });
         statements.push(stats.join("\nelse "));
         if (defaultDeserializer) {
+            const defaultDeserializeExpr = !defaultXmlDeserializer
+                ? `${defaultDeserializer}(result.body)`
+                : defaultIsXmlOnly
+                    ? `${defaultXmlDeserializer}(result.body)`
+                    : `isXml ? ${defaultXmlDeserializer}(result.body) : ${defaultDeserializer}(result.body)`;
             statements.push(`else {
-        error.details = ${defaultDeserializer}(result.body);
+        error.details = ${defaultDeserializeExpr};
       }`);
         }
         statements.push("throw error;");
     }
     else {
         if (defaultDeserializer) {
-            statements.push(`const error = ${createRestErrorReference}(result);
-      error.details = ${defaultDeserializer}(result.body);`);
+            if (defaultXmlDeserializer) {
+                if (defaultIsXmlOnly) {
+                    statements.push(`const error = ${createRestErrorReference}(result);
+          error.details = ${defaultXmlDeserializer}(result.body);`);
+                }
+                else {
+                    const isXmlContentTypeRef = resolveReference(XmlHelpers.isXmlContentType);
+                    statements.push(`const error = ${createRestErrorReference}(result);
+          const responseContentType = result.headers?.["content-type"] ?? "";
+          error.details = ${isXmlContentTypeRef}(responseContentType) ? ${defaultXmlDeserializer}(result.body) : ${defaultDeserializer}(result.body);`);
+                }
+            }
+            else {
+                statements.push(`const error = ${createRestErrorReference}(result);
+        error.details = ${defaultDeserializer}(result.body);`);
+            }
             statements.push("throw error;");
         }
         else {
@@ -309,7 +435,6 @@ function getOperationSignatureParameters(context, method, clientType) {
                     ((_a = param.methodParameterSegments[0]) === null || _a === void 0 ? void 0 : _a.length) === 1 &&
                     ((_b = param.methodParameterSegments[0]) === null || _b === void 0 ? void 0 : _b[0]) === p);
             })[0]) === null || _a === void 0 ? void 0 : _a.kind) !== "cookie" &&
-            p.clientDefaultValue === undefined &&
             !p.optional &&
             !(p.isGeneratedName &&
                 (p.name === "contentType" || p.name === "accept"));
@@ -339,7 +464,7 @@ function getOperationSignatureParameters(context, method, clientType) {
  * This operation builds and returns the function declaration for an operation.
  */
 export function getOperationFunction(context, method, clientType) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const operation = method[1];
     // Extract required parameters
     const parameters = getOperationSignatureParameters(context, method, clientType);
@@ -358,12 +483,34 @@ export function getOperationFunction(context, method, clientType) {
     }
     // TODO: Support operation overloads
     const response = operation.response;
+    const responseHeaders = getResponseHeaders(operation.operation.responses);
+    const hasHeaderOnlyResponse = !response.type && responseHeaders.length > 0;
+    const isResponseHeadersEnabled = ((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.includeHeadersInResponse) === true;
     let returnType = { name: "", type: "void" };
     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) {
+            // Build a composite type that includes both model and additional header properties
+            returnType = {
+                name: (_b = type.name) !== null && _b !== void 0 ? _b : "",
+                type: `${buildCompositeResponseType(context, type, responseHeaders)}`
+            };
+        }
+        else {
+            returnType = {
+                name: (_c = type.name) !== null && _c !== void 0 ? _c : "",
+                type: getTypeExpression(context, type)
+            };
+        }
+    }
+    else if (hasHeaderOnlyResponse && isResponseHeadersEnabled) {
+        // Here we handle returning headers when the operation return type is void
         returnType = {
-            name: (_a = type.name) !== null && _a !== void 0 ? _a : "",
-            type: getTypeExpression(context, type)
+            name: "",
+            type: `${buildHeaderOnlyResponseType(context, responseHeaders)}`
         };
     }
     const { name, fixme = [] } = getOperationName(operation);
@@ -381,17 +528,37 @@ export function getOperationFunction(context, method, clientType) {
         returnType: `Promise<${returnType.type}>`
     };
     const statements = [];
+    // Generate unique local variable names that don't conflict with parameter names
+    const paramNames = new Set(parameters.map((p) => p.name));
+    const resultVarName = generateLocallyUniqueName("result", paramNames);
     const parameterList = parameters.map((p) => p.name).join(", ");
     // Special case for binary-only bodies: use helper to call streaming methods so that Core doesn't poison the response body by
     // doing a UTF-8 decode on the raw bytes.
-    if (((_b = response === null || response === void 0 ? void 0 : response.type) === null || _b === void 0 ? void 0 : _b.kind) === "bytes" && response.type.encode === "bytes") {
-        statements.push(`const streamableMethod = _${name}Send(${parameterList});`);
-        statements.push(`const result = await ${resolveReference(SerializationHelpers.getBinaryResponse)}(streamableMethod);`);
+    if (((_d = response === null || response === void 0 ? void 0 : response.type) === null || _d === void 0 ? void 0 : _d.kind) === "bytes" && response.type.encode === "bytes") {
+        const streamableMethodVarName = generateLocallyUniqueName("streamableMethod", paramNames);
+        statements.push(`const ${streamableMethodVarName} = _${name}Send(${parameterList});`);
+        statements.push(`const ${resultVarName} = await ${resolveReference(SerializationHelpers.getBinaryResponse)}(${streamableMethodVarName});`);
     }
     else {
-        statements.push(`const result = await _${name}Send(${parameterList});`);
+        statements.push(`const ${resultVarName} = await _${name}Send(${parameterList});`);
+    }
+    // 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 (responseHeaders.length > 0 && isResponseHeadersEnabled) {
+        const headersVarName = generateLocallyUniqueName("headers", paramNames);
+        statements.push(`const ${headersVarName} = _${name}DeserializeHeaders(result);`);
+        // If there is no body payload just return the headers
+        if (hasHeaderOnlyResponse) {
+            statements.push(`return {...${headersVarName} };`);
+        }
+        else {
+            const payloadVarName = generateLocallyUniqueName("payload", paramNames);
+            statements.push(`const ${payloadVarName} = await _${name}Deserialize(${resultVarName});`);
+            statements.push(`return { ...${payloadVarName}, ...${headersVarName} };`);
+        }
+    }
+    else {
+        statements.push(`return _${name}Deserialize(${resultVarName});`);
     }
-    statements.push(`return _${name}Deserialize(result);`);
     return {
         ...functionStatement,
         statements
@@ -434,7 +601,7 @@ function getLroOnlyOperationFunction(context, method, clientType, optionalParamN
         allowedFinalLocation.includes(lroMetadata === null || lroMetadata === void 0 ? void 0 : lroMetadata.finalStateVia)
         ? `resourceLocationConfig: "${lroMetadata === null || lroMetadata === void 0 ? void 0 : lroMetadata.finalStateVia}",`
         : "";
-    const apiVersion = getApiVersionExpression(operation);
+    const apiVersion = getApiVersionExpression(context, operation);
     const statements = [];
     statements.push(`
 
@@ -460,7 +627,7 @@ function getLroAndPagingOperationFunction(context, method, clientType, optionalP
     const { name, fixme = [] } = getOperationName(operation);
     const returnType = buildLroPagingReturnType(context, operation);
     // Get apiVersion expression for both LRO poller and paging options
-    const apiVersion = getApiVersionExpression(operation);
+    const apiVersion = getApiVersionExpression(context, operation);
     // Build paging options from metadata
     const pagingOptions = [
         operation.response.resultSegments &&
@@ -593,7 +760,7 @@ function getPagingOnlyOperationFunction(context, method, clientType) {
     }).join(".");
     // Check for nextLinkVerb from TCGC pagingMetadata (supports @Legacy.nextLinkVerb decorator)
     const nextLinkMethod = operation.pagingMetadata.nextLinkVerb;
-    const apiVersion = getApiVersionExpression(operation);
+    const apiVersion = getApiVersionExpression(context, operation);
     if (itemName) {
         options.push(`itemName: "${itemName}"`);
     }
@@ -726,10 +893,23 @@ function buildBodyParameter(context, bodyParameter, optionalParamName = "options
         });
     }
     const bodyParamName = normalizeName(bodyParameter.name, NameType.Parameter, true);
-    const bodyNameExpression = bodyParameter.optional
+    let bodyNameExpression = bodyParameter.optional
         ? `${optionalParamName}["${bodyParamName}"]`
         : bodyParamName;
-    const nullOrUndefinedPrefix = getPropertySerializationPrefix(context, bodyParameter, bodyParameter.optional ? optionalParamName : undefined);
+    // Check if body parameter has a client default value with matching type
+    const hasClientDefault = bodyParameter.optional &&
+        bodyParameter.clientDefaultValue !== undefined &&
+        isDefaultValueTypeMatch(bodyParameter, bodyParameter.clientDefaultValue);
+    // Apply client default value if present for optional body parameters
+    if (hasClientDefault) {
+        const formattedDefault = formatDefaultValue(bodyParameter.clientDefaultValue);
+        bodyNameExpression = `(${bodyNameExpression} ?? ${formattedDefault})`;
+    }
+    // Only apply nullOrUndefinedPrefix if there's no client default value
+    // because the default value already handles null/undefined cases
+    const nullOrUndefinedPrefix = hasClientDefault
+        ? ""
+        : getPropertySerializationPrefix(context, bodyParameter, bodyParameter.optional ? optionalParamName : undefined);
     // For dual-format operations, check the contentType option at runtime
     if (isDualFormat &&
         bodyType.kind === "model" &&
@@ -771,6 +951,7 @@ function getEncodingFormat(type) {
  * This function helps with renames, translating client names to rest api names
  */
 export function getParameterMap(context, param, optionalParamName = "options") {
+    var _a;
     // Use lowercase for header names since HTTP headers are case-insensitive
     const serializedName = param.kind === "header"
         ? getHeaderSerializedName(param)
@@ -780,6 +961,10 @@ export function getParameterMap(context, param, optionalParamName = "options") {
     }
     // Special case for api-version parameters with default values
     if (param.isApiVersionParam && param.clientDefaultValue) {
+        // For multi-service, use only the default value (don't reference context.apiVersion)
+        if ((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.isMultiService) {
+            return `"${serializedName}": "${param.clientDefaultValue}"`;
+        }
         return `"${serializedName}": ${param.onClient ? "context." : ""}${param.name} ?? "${param.clientDefaultValue}"`;
     }
     if (hasCollectionFormatInfo(param.kind, param.collectionFormat)) {
@@ -822,7 +1007,7 @@ function getContentTypeValue(param, optionalParamName = "options") {
     }
     else {
         return `contentType: ${!param.optional
-            ? "contentType"
+            ? normalizeName(param.name, NameType.Property)
             : `${optionalParamName}.` + param.name + " as any"}`;
     }
 }
@@ -851,12 +1036,18 @@ function isOptional(param) {
 }
 function getOptional(context, param, optionalParamName, serializedName) {
     const paramName = `${param.onClient ? "context." : `${optionalParamName}?.`}${param.name}`;
+    // Apply client default value if present and type matches
+    const defaultSuffix = param.clientDefaultValue !== undefined &&
+        isDefaultValueTypeMatch(param, param.clientDefaultValue)
+        ? ` ?? ${formatDefaultValue(param.clientDefaultValue)}`
+        : "";
     if (param.type.kind === "model") {
         const propertiesStr = getRequestModelMapping(context, { ...param.type, optional: param.optional }, paramName + "?.");
         const serializeContent = `{${propertiesStr.join(",")}}`;
         return `"${serializedName}": ${serializeContent}`;
     }
-    return `"${serializedName}": ${serializeRequestValue(context, param.type, paramName, false, getEncodeForType(param.type), serializedName, true)}`;
+    const serializedValue = serializeRequestValue(context, param.type, paramName, false, getEncodeForType(param.type), serializedName, true);
+    return `"${serializedName}": ${serializedValue}${defaultSuffix}`;
 }
 /**
  * Get the encode for SDK type
@@ -1068,7 +1259,7 @@ export function getRequestModelProperties(context, modelPropertyType, propertyPa
 export function getRequestModelMapping(context, modelPropertyType, propertyPath = "body", overrides, enableFlatten = true) {
     return getRequestModelProperties(context, modelPropertyType, propertyPath, overrides, enableFlatten).map(([name, value]) => `"${name}": ${value}`);
 }
-function getPropertySerializedName(property) {
+export function getPropertySerializedName(property) {
     var _a, _b;
     return ((_b = (property.kind === "property"
         ? (_a = property.serializationOptions.json) === null || _a === void 0 ? void 0 : _a.name
@@ -1227,6 +1418,63 @@ export function serializeRequestValue(context, type, clientValue, required, form
             return clientValue;
     }
 }
+/**
+ * Wrapper of deserializeResponseValue, this is used to handle the special cases for response header deserialization, since response header only supports primitive types, we will have a simpler deserialization logic comparing to response body, and we also need to handle the null/undefined cases differently since if a header is missing, the value will be undefined instead of null.
+ * Note: that this has been added to isolate these changes behind the feature flag. Once the feature flag is removed, we can consider merging this back to deserializeResponseValue if the special handling logic is not needed anymore.
+ */
+export function deserializeResponseHeadersValue(context, type, restValue, required, format, recursionDepth = 0) {
+    const nullOrUndefinedPrefix = isTypeNullable(type) || getOptionalForType(type) || !required
+        ? `${restValue} === undefined || ${restValue} === null ? ${restValue}: `
+        : "";
+    switch (type.kind) {
+        case "constant":
+            return `${restValue} as any`;
+        case "boolean":
+            return `${nullOrUndefinedPrefix} ${restValue}.trim().toLowerCase() === "true"`;
+        case "int16":
+        case "int32":
+        case "int64":
+        case "uint16":
+        case "uint32":
+        case "uint64":
+        case "float":
+        case "decimal":
+        case "decimal128":
+        case "float32":
+        case "float64":
+        case "int8":
+        case "integer":
+        case "numeric":
+        case "safeint":
+        case "uint8":
+            return `${nullOrUndefinedPrefix} Number(${restValue})`;
+        case "enum":
+            if (isNormalUnion(type)) {
+                return `${restValue}`;
+            }
+            else if (isSpecialHandledUnion(type)) {
+                const deserializeFunctionName = type
+                    ? buildModelDeserializer(context, getNullableValidType(type), {
+                        nameOnly: true,
+                        skipDiscriminatedUnionSuffix: false
+                    })
+                    : undefined;
+                if (deserializeFunctionName) {
+                    return `${deserializeFunctionName}(${restValue})`;
+                }
+                else {
+                    return `${restValue} as any`;
+                }
+            }
+            else {
+                return `${restValue} as any`;
+            }
+        default: {
+            const val = deserializeResponseValue(context, type, restValue, true, format, recursionDepth);
+            return `${nullOrUndefinedPrefix} ${val}`;
+        }
+    }
+}
 /**
  * This function helps converting strings into JS complex types recursively.
  * We need to drill down into Array elements to make sure that the element type is
@@ -1391,6 +1639,43 @@ export function getAllAncestors(type) {
     }
     return ancestors;
 }
+/**
+ * Checks if a clientDefaultValue type matches the parameter type.
+ * Returns true if the default value type is compatible with the parameter type.
+ */
+function isDefaultValueTypeMatch(param, defaultValue) {
+    const defaultType = typeof defaultValue;
+    const paramType = param.type;
+    // Map JavaScript types to TypeSpec types
+    if (defaultType === "string") {
+        return paramType.kind === "string" || paramType.kind === "enum";
+    }
+    if (defaultType === "number") {
+        return (paramType.kind === "int32" ||
+            paramType.kind === "int64" ||
+            paramType.kind === "float32" ||
+            paramType.kind === "float64" ||
+            paramType.kind === "numeric" ||
+            paramType.kind === "integer" ||
+            paramType.kind === "float" ||
+            paramType.kind === "decimal");
+    }
+    if (defaultType === "boolean") {
+        return paramType.kind === "boolean";
+    }
+    // For other types, don't apply the default
+    return false;
+}
+/**
+ * Formats a default value for code generation.
+ * Strings are wrapped in quotes, other values are used as-is.
+ */
+function formatDefaultValue(defaultValue) {
+    if (typeof defaultValue === "string") {
+        return `"${defaultValue}"`;
+    }
+    return String(defaultValue);
+}
 export function getPropertySerializationPrefix(context, property, propertyPath) {
     const propertyFullName = getPropertyFullName(context, property, propertyPath);
     if (property.optional || isTypeNullable(property.type)) {
@@ -1436,18 +1721,104 @@ export function getExpectedStatuses(operation) {
 }
 /**
  * Gets the apiVersion expression with default value fallback for query parameters.
+ * @param dpgContext - The SDK context
  * @param operation - The operation to get the apiVersion parameter from
  * @returns The apiVersion expression string, or undefined if no apiVersion query param exists
  */
-function getApiVersionExpression(operation) {
+function getApiVersionExpression(dpgContext, operation) {
+    var _a;
     const queryApiVersionParam = operation.operation.parameters.find((p) => p.kind === "query" && p.isApiVersionParam);
     if (!queryApiVersionParam) {
         return undefined;
     }
+    // For multi-service, use only the default value (don't reference context.apiVersion)
+    if ((_a = dpgContext.rlcOptions) === null || _a === void 0 ? void 0 : _a.isMultiService) {
+        return queryApiVersionParam.clientDefaultValue
+            ? `"${queryApiVersionParam.clientDefaultValue}"`
+            : undefined;
+    }
     const paramAccess = `${queryApiVersionParam.onClient ? "context." : ""}${queryApiVersionParam.name}`;
     const defaultValueSuffix = queryApiVersionParam.clientDefaultValue
         ? ` ?? "${queryApiVersionParam.clientDefaultValue}"`
         : "";
     return `${paramAccess}${defaultValueSuffix}`;
 }
+/**
+ * Extracts and deduplicates all response headers from operation responses.
+ * @param responses - The operation responses
+ * @returns Array of unique response headers
+ */
+export function getResponseHeaders(responses) {
+    var _a, _b;
+    const headerMap = new Map();
+    for (const response of responses !== null && responses !== void 0 ? responses : []) {
+        for (const header of (_a = response.headers) !== null && _a !== void 0 ? _a : []) {
+            const key = (_b = header.serializedName) !== null && _b !== void 0 ? _b : header.name;
+            if (!headerMap.has(key)) {
+                headerMap.set(key, header);
+            }
+        }
+    }
+    return Array.from(headerMap.values());
+}
+/**
+ * Builds a composite return type for operations that return both a model and additional headers.
+ * Combines model properties and header properties into an inline object type.
+ * @param context - The SDK context
+ * @param modelType - The model type
+ * @param headers - The response headers that are NOT in the model
+ * @returns The composite type expression as a string (e.g., "{ name: string; email: string; requestId: string }")
+ */
+function buildCompositeResponseType(context, modelType, headers) {
+    const allParents = getAllAncestors(modelType);
+    const modelProps = getAllProperties(context, modelType, allParents);
+    // Collect header property names already in the model to avoid duplicates
+    const modelHeaderNames = new Set();
+    for (const property of modelProps) {
+        if (isHeader(context.program, property.__raw)) {
+            modelHeaderNames.add(property.name.toLowerCase());
+        }
+    }
+    // Add only additional host response header properties not already in model
+    for (const header of headers) {
+        if (modelHeaderNames.has(header.name.toLowerCase())) {
+            continue;
+        }
+        modelProps.push(header);
+    }
+    return emitInlineModel(context, modelProps);
+}
+/**
+ * Builds an inline type string for header-only responses.
+ * @param context - The SDK context
+ * @param headers - The response headers
+ * @returns The inline type expression as a string (e.g., "{ requestId: string; optionalHeader?: string }")
+ */
+function buildHeaderOnlyResponseType(context, headers) {
+    const properties = [];
+    for (const header of headers) {
+        const headerName = normalizeModelPropertyName(context, header);
+        const headerType = getTypeExpression(context, header.type);
+        const isOptional = header.optional ? "?" : "";
+        properties.push(`${headerName}${isOptional}: ${headerType}`);
+    }
+    return `{ ${properties.join("; ")} }`;
+}
+/**
+ * Builds the object literal expression for a header-only response.
+ * Handles type conversions for headers (string to boolean, Date, number, Uint8Array).
+ * @param operation - The service operation
+ * @param headers - The response headers
+ * @returns JavaScript expression string for the header-only response object
+ */
+function buildHeaderOnlyResponseValue(context, headers) {
+    const props = headers.map((header) => {
+        var _a;
+        const headerName = ((_a = header.serializedName) !== null && _a !== void 0 ? _a : header.name).toLowerCase();
+        const key = normalizeModelPropertyName(context, header);
+        const value = deserializeResponseHeadersValue(context, header.type, `result.headers[${JSON.stringify(headerName)}]`, !header.optional, getEncodeForType(header.type), 0);
+        return `${key}: ${value}`;
+    });
+    return `{ ${props.join(", ")} }`;
+}
 //# sourceMappingURL=operationHelpers.js.map