@azure-tools/typespec-ts 0.33.0 → 0.34.0

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

@@ -1,47 +1,55 @@
-import { NameType, addImportToSpecifier } from "@azure-tools/rlc-common";
 import { NoTarget } from "@typespec/compiler";
 import { PagingHelpers, PollingHelpers } from "../static-helpers-metadata.js";
-import { buildType, getType, isTypeNullable } from "./typeHelpers.js";
+import { getType, isTypeNullable } from "./typeHelpers.js";
 import { getClassicalLayerPrefix, getOperationName } from "./namingHelpers.js";
 import { getCollectionFormatHelper, hasCollectionFormatInfo } from "../../utils/operationUtil.js";
-import { getDeserializeFunctionName, isNormalUnion, isPolymorphicUnion, isSpecialHandledUnion, isSpecialUnionVariant } from "../buildSerializeUtils.js";
+import { isNormalUnion, isSpecialHandledUnion } from "../serialization/serializeUtils.js";
 import { getDocsFromDescription, getFixmeForMultilineDocs } from "./docsHelpers.js";
-import { toCamelCase, toPascalCase } from "../../utils/casingUtils.js";
+import { toPascalCase } from "../../utils/casingUtils.js";
 import { AzurePollingDependencies } from "../external-dependencies.js";
+import { NameType } from "@azure-tools/rlc-common";
+import { buildModelDeserializer } from "../serialization/buildDeserializerFunction.js";
+import { buildModelSerializer } from "../serialization/buildSerializerFunction.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";
-export function getSendPrivateFunction(dpgContext, operation, clientType, runtimeImports) {
+import { useSdkTypes } from "../../framework/hooks/sdkTypes.js";
+import { isAzureCoreErrorType } from "../../utils/modelUtils.js";
+import { getTypeExpression } from "../type-expressions/get-type-expression.js";
+export function getSendPrivateFunction(dpgContext, operation, clientType) {
     var _a;
-    const parameters = getOperationSignatureParameters(operation, clientType);
+    const parameters = getOperationSignatureParameters(dpgContext, operation, clientType);
     const { name } = getOperationName(operation);
+    const dependencies = useDependencies();
     const functionStatement = {
         isAsync: false,
         isExported: true,
         name: `_${name}Send`,
         parameters,
-        returnType: "StreamableMethod"
+        returnType: resolveReference(dependencies.StreamableMethod)
     };
     const operationPath = operation.url;
     const operationMethod = operation.method.toLowerCase();
     const optionalParamName = (_a = parameters.filter((p) => { var _a; return (_a = p.type) === null || _a === void 0 ? void 0 : _a.toString().endsWith("OptionalParams"); })[0]) === null || _a === void 0 ? void 0 : _a.name;
     const statements = [];
-    statements.push(`return context.path("${operationPath}", ${getPathParameters(operation)}).${operationMethod}({...operationOptionsToRequestParameters(${optionalParamName}), ${getRequestParameters(dpgContext, operation, runtimeImports)}});`);
+    statements.push(`return context.path("${operationPath}", ${getPathParameters(dpgContext, operation)}).${operationMethod}({...${resolveReference(dependencies.operationOptionsToRequestParameters)}(${optionalParamName}), ${getRequestParameters(dpgContext, operation)}});`);
     return {
         ...functionStatement,
         statements
     };
 }
-export function getDeserializePrivateFunction(operation, runtimeImports) {
+export function getDeserializePrivateFunction(context, operation) {
     var _a, _b, _c, _d;
     const { name } = getOperationName(operation);
+    const dependencies = useDependencies();
+    const PathUncheckedResponseReference = resolveReference(dependencies.PathUncheckedResponse);
     const parameters = [
         {
             name: "result",
-            type: "PathUncheckedResponse"
+            type: PathUncheckedResponseReference
         }
     ];
-    addImportToSpecifier("restClient", runtimeImports, "PathUncheckedResponse");
     // TODO: Support LRO + paging operation
     // https://github.com/Azure/autorest.typescript/issues/2313
     const isLroOnly = isLroOnlyOperation(operation);
@@ -50,10 +58,13 @@ export function getDeserializePrivateFunction(operation, runtimeImports) {
     const response = operation.responses[0];
     let returnType;
     if (isLroOnly && operation.method.toLowerCase() !== "patch") {
-        returnType = buildLroReturnType(operation);
+        returnType = buildLroReturnType(context, operation);
     }
     else if ((_a = response === null || response === void 0 ? void 0 : response.type) === null || _a === void 0 ? void 0 : _a.type) {
-        returnType = buildType(response.type.name, response.type, response.type.format);
+        returnType = {
+            name: response.type.name,
+            type: getTypeExpression(context, response.type.tcgcType)
+        };
     }
     else {
         returnType = { name: "", type: "void" };
@@ -66,9 +77,9 @@ export function getDeserializePrivateFunction(operation, runtimeImports) {
         returnType: `Promise<${returnType.type}>`
     };
     const statements = [];
+    const createRestErrorReference = resolveReference(dependencies.createRestError);
     statements.push(`const expectedStatuses = ${getExpectedStatuses(operation)};`);
-    statements.push(`if(!expectedStatuses.includes(result.status)){`, `throw createRestError(result);`, "}");
-    addImportToSpecifier("restClient", runtimeImports, "createRestError");
+    statements.push(`if(!expectedStatuses.includes(result.status)){`, `throw ${createRestErrorReference}(result);`, "}");
     const deserializedType = isLroOnly
         ? (_b = operation === null || operation === void 0 ? void 0 : operation.lroMetadata) === null || _b === void 0 ? void 0 : _b.finalResult
         : response.type;
@@ -83,36 +94,33 @@ export function getDeserializePrivateFunction(operation, runtimeImports) {
       }
       `);
     }
-    const allParents = deserializedType ? getAllAncestors(deserializedType) : [];
-    const properties = deserializedType
-        ? getAllProperties(deserializedType, allParents)
-        : [];
-    if ((deserializedType === null || deserializedType === void 0 ? void 0 : deserializedType.type) === "any" ||
-        (deserializedType === null || deserializedType === void 0 ? void 0 : deserializedType.type) === "dict" ||
-        ((deserializedType === null || deserializedType === void 0 ? void 0 : deserializedType.type) === "model" &&
-            allParents.some((p) => p.type === "dict")) ||
-        response.isBinaryPayload) {
-        // TODO: Fix this any cast when implementing handling dict.
-        statements.push(`return ${deserializedRoot} as any`);
-    }
-    else if (deserializedType &&
-        properties.length > 0 &&
-        !deserializedType.aliasType) {
-        statements.push(`return {`, getResponseMapping(deserializedType, deserializedRoot, runtimeImports).join(","), `}`);
-    }
-    else if (returnType.type === "void" || deserializedType === undefined) {
-        statements.push(`return;`);
+    if (deserializedType === null || deserializedType === void 0 ? void 0 : deserializedType.tcgcType) {
+        const deserializeFunctionName = buildModelDeserializer(context, deserializedType.tcgcType, false, true);
+        if (deserializeFunctionName) {
+            statements.push(`return ${deserializeFunctionName}(${deserializedRoot})`);
+        }
+        else if (isAzureCoreErrorType(context.program, deserializedType.__raw)) {
+            statements.push(`return ${deserializedRoot}`);
+        }
+        else {
+            statements.push(`return ${deserializeResponseValue(context, deserializedType, deserializedRoot, response.isBinaryPayload ? "binary" : deserializedType.format)}`);
+        }
+    }
+    else if (returnType.type === "void") {
+        statements.push("return;");
+    }
+    else if (deserializedType) {
+        statements.push(`return ${deserializeResponseValue(context, deserializedType, deserializedRoot, response.isBinaryPayload ? "binary" : deserializedType.format)}`);
     }
     else {
-        statements.push(`return ${deserializeResponseValue(deserializedType, deserializedRoot, runtimeImports, false, // TODO: Calculate if required
-        [deserializedType], deserializedType.format)}`);
+        statements.push("return;");
     }
     return {
         ...functionStatement,
         statements
     };
 }
-function getOperationSignatureParameters(operation, clientType) {
+function getOperationSignatureParameters(context, operation, clientType) {
     var _a;
     const optionsType = getOperationOptionsName(operation, true);
     const parameters = new Map();
@@ -121,14 +129,23 @@ function getOperationSignatureParameters(operation, clientType) {
         p.type.type !== "constant" &&
         p.clientDefaultValue === undefined &&
         !p.optional)
-        .map((p) => buildType(p.clientName, p.type, p.format))
+        .map((p) => {
+        var _a;
+        return {
+            name: p.clientName,
+            type: getTypeExpression(context, (_a = p.tcgcType) !== null && _a !== void 0 ? _a : p.type.tcgcType)
+        };
+    })
         .forEach((p) => {
         parameters.set(p.name, p);
     });
-    if (operation.bodyParameter) {
+    if (operation.bodyParameter && operation.bodyParameter.optional === false) {
         parameters.set((_a = operation.bodyParameter) === null || _a === void 0 ? void 0 : _a.clientName, {
             hasQuestionToken: operation.bodyParameter.optional,
-            ...buildType(operation.bodyParameter.clientName, operation.bodyParameter.type, operation.bodyParameter.type.format)
+            ...{
+                name: operation.bodyParameter.clientName,
+                type: getTypeExpression(context, operation.bodyParameter.type.tcgcType)
+            }
         });
     }
     // Add context as the first parameter
@@ -145,28 +162,34 @@ function getOperationSignatureParameters(operation, clientType) {
 /**
  * This operation builds and returns the function declaration for an operation.
  */
-export function getOperationFunction(operation, clientType) {
-    var _a, _b;
+export function getOperationFunction(context, operation, clientType) {
+    var _a, _b, _c;
     if (isPagingOnlyOperation(operation)) {
         // Case 1: paging-only operation
-        return getPagingOnlyOperationFunction(operation, clientType);
+        return getPagingOnlyOperationFunction(context, operation, clientType);
     }
     else if (isLroOnlyOperation(operation)) {
         // Case 2: lro-only operation
-        return getLroOnlyOperationFunction(operation, clientType);
+        return getLroOnlyOperationFunction(context, operation, clientType);
     }
     else if (isLroAndPagingOperation(operation)) {
         // Case 3: both paging + lro operation is not supported yet so handle them as normal operation and customization may be needed
         // https://github.com/Azure/autorest.typescript/issues/2313
     }
+    if (operation.name === "floatSeconds") {
+        operation;
+    }
     // Extract required parameters
-    const parameters = getOperationSignatureParameters(operation, clientType);
+    const parameters = getOperationSignatureParameters(context, operation, clientType);
     // TODO: Support operation overloads
     const response = operation.responses[0];
     let returnType = { name: "", type: "void" };
     if ((_a = response.type) === null || _a === void 0 ? void 0 : _a.type) {
         const type = (_b = extractPagingType(response.type, operation.itemName)) !== null && _b !== void 0 ? _b : response.type;
-        returnType = buildType(type.name, type, type.format);
+        returnType = {
+            name: (_c = type.name) !== null && _c !== void 0 ? _c : "",
+            type: getTypeExpression(context, type.tcgcType)
+        };
     }
     const { name, fixme = [] } = getOperationName(operation);
     const functionStatement = {
@@ -191,10 +214,11 @@ export function getOperationFunction(operation, clientType) {
         statements
     };
 }
-function getLroOnlyOperationFunction(operation, clientType) {
+function getLroOnlyOperationFunction(context, operation, clientType) {
+    var _a, _b;
     // Extract required parameters
-    const parameters = getOperationSignatureParameters(operation, clientType);
-    const returnType = buildLroReturnType(operation);
+    const parameters = getOperationSignatureParameters(context, operation, clientType);
+    const returnType = buildLroReturnType(context, operation);
     const { name, fixme = [] } = getOperationName(operation);
     const pollerLikeReference = resolveReference(AzurePollingDependencies.PollerLike);
     const operationStateReference = resolveReference(AzurePollingDependencies.OperationState);
@@ -211,6 +235,9 @@ function getLroOnlyOperationFunction(operation, clientType) {
         returnType: `${pollerLikeReference}<${operationStateReference}<${returnType.type}>, ${returnType.type}>`
     };
     const getLongRunningPollerReference = resolveReference(PollingHelpers.GetLongRunningPoller);
+    const resourceLocationConfig = ((_a = operation.lroMetadata) === null || _a === void 0 ? void 0 : _a.finalStateVia)
+        ? `resourceLocationConfig: "${(_b = operation.lroMetadata) === null || _b === void 0 ? void 0 : _b.finalStateVia}"`
+        : "";
     const statements = [];
     statements.push(`
 
@@ -219,7 +246,8 @@ function getLroOnlyOperationFunction(operation, clientType) {
     abortSignal: options?.abortSignal,
     getInitialResponse: () => _${name}Send(${parameters
         .map((p) => p.name)
-        .join(", ")})
+        .join(", ")}),
+    ${resourceLocationConfig}
   }) as ${pollerLikeReference}<${operationStateReference}<${returnType.type}>, ${returnType.type}>;
   `);
     return {
@@ -227,24 +255,30 @@ function getLroOnlyOperationFunction(operation, clientType) {
         statements
     };
 }
-function buildLroReturnType(operation) {
+function buildLroReturnType(context, operation) {
     const metadata = operation.lroMetadata;
     if (metadata !== undefined && metadata.finalResult !== undefined) {
         const type = metadata.finalResult;
-        return buildType(type.name, type, type.format);
+        return {
+            name: type.name,
+            type: getTypeExpression(context, type.tcgcType)
+        };
     }
     return { name: "", type: "void" };
 }
-function getPagingOnlyOperationFunction(operation, clientType) {
-    var _a, _b;
+function getPagingOnlyOperationFunction(context, operation, clientType) {
+    var _a, _b, _c;
     // Extract required parameters
-    const parameters = getOperationSignatureParameters(operation, clientType);
+    const parameters = getOperationSignatureParameters(context, operation, clientType);
     // TODO: Support operation overloads
     const response = operation.responses[0];
     let returnType = { name: "", type: "void" };
     if ((_a = response.type) === null || _a === void 0 ? void 0 : _a.type) {
         const type = (_b = extractPagingType(response.type, operation.itemName)) !== null && _b !== void 0 ? _b : response.type;
-        returnType = buildType(type.name, type, type.format);
+        returnType = {
+            name: (_c = type.name) !== null && _c !== void 0 ? _c : "",
+            type: getTypeExpression(context, type.tcgcType)
+        };
     }
     const { name, fixme = [] } = getOperationName(operation);
     const pagedAsyncIterableIteratorReference = resolveReference(PagingHelpers.PagedAsyncIterableIterator);
@@ -312,7 +346,7 @@ export function getOperationOptionsName(operation, includeGroupName = false) {
  * RLC internally. This will translate High Level parameters into the RLC ones.
  * Figuring out what goes in headers, body, path and qsp.
  */
-function getRequestParameters(dpgContext, operation, runtimeImports) {
+function getRequestParameters(dpgContext, operation) {
     if (!operation.parameters) {
         return "";
     }
@@ -328,7 +362,7 @@ function getRequestParameters(dpgContext, operation, runtimeImports) {
             param.location === "query" ||
             param.location === "body") {
             parametersImplementation[param.location].push({
-                paramMap: getParameterMap(param, runtimeImports),
+                paramMap: getParameterMap(dpgContext, param),
                 param
             });
         }
@@ -354,7 +388,7 @@ function getRequestParameters(dpgContext, operation, runtimeImports) {
             .join(",\n")}}`;
     }
     else if (operation.bodyParameter !== undefined) {
-        paramStr = `${paramStr}${buildBodyParameter(operation.bodyParameter, runtimeImports)}`;
+        paramStr = `${paramStr}${buildBodyParameter(dpgContext, operation.bodyParameter)}`;
     }
     return paramStr;
 }
@@ -378,86 +412,23 @@ function buildHeaderParameter(program, paramMap, param) {
         ? `...(${conditions.join(" && ")} ? {${paramMap}} : {})`
         : paramMap;
 }
-function buildBodyParameter(bodyParameter, runtimeImports) {
-    var _a, _b;
-    if (!bodyParameter) {
+function buildBodyParameter(context, bodyParameter) {
+    if (!bodyParameter || !bodyParameter.type.tcgcType) {
         return "";
     }
-    const allParents = getAllAncestors(bodyParameter.type);
-    if (bodyParameter.type.type === "model" &&
-        !bodyParameter.type.aliasType &&
-        !allParents.some((p) => p.type === "dict")) {
-        const { propertiesStr: bodyParts } = getRequestModelMapping(bodyParameter.type, bodyParameter.clientName, runtimeImports, [bodyParameter.type]);
-        if (bodyParameter && bodyParts.length > 0) {
-            const optionalBody = bodyParameter.optional
-                ? `${bodyParameter.clientName} === undefined ? ${bodyParameter.clientName} : `
-                : "";
-            return `\nbody: ${optionalBody}{${bodyParts.join(",\n")}},`;
-        }
-        else if (bodyParameter && bodyParts.length === 0) {
-            return `\nbody: ${bodyParameter.clientName},`;
-        }
-    }
-    else if (isDiscriminatedUnion(bodyParameter.type.tcgcType)) {
-        const serializerName = toCamelCase(`${bodyParameter.type.name}Serializer`);
-        addImportToSpecifier("modularModel", runtimeImports, serializerName);
-        return `\nbody: ${serializerName}(${bodyParameter.clientName}),`;
-    }
-    else if ((bodyParameter.type.type === "model" &&
-        (bodyParameter.type.aliasType ||
-            allParents.some((p) => p.type === "dict"))) ||
-        bodyParameter.type.type === "dict") {
-        const elementSerializerName = ((_a = bodyParameter.type.elementType) === null || _a === void 0 ? void 0 : _a.type) === "model"
-            ? toCamelCase(`${bodyParameter.type.elementType.name}Serializer`)
-            : "";
-        let modelSerializerName = "";
-        if (bodyParameter.type.type !== "dict") {
-            modelSerializerName = toCamelCase(`${bodyParameter.type.name}Serializer`);
-        }
-        if (modelSerializerName) {
-            return `\nbody: ${modelSerializerName}(${bodyParameter.clientName}),`;
-        }
-        else {
-            // Need to do this so that Records are compatible with additional properties of other types
-            // this should check for compatibility mode once we support the additionalProperties property
-            return `\nbody: serializeRecord(${bodyParameter.clientName} as any, ${elementSerializerName}) as any,`;
-        }
-    }
-    if (bodyParameter.type.type === "list") {
-        if (((_b = bodyParameter.type.elementType) === null || _b === void 0 ? void 0 : _b.type) === "model" &&
-            !bodyParameter.type.elementType.aliasType) {
-            const { propertiesStr: bodyParts, directAssignment } = getRequestModelMapping(bodyParameter.type.elementType, "p", runtimeImports, [bodyParameter.type.elementType]);
-            const mapBody = directAssignment === true
-                ? bodyParts.join(", ")
-                : `{ ${bodyParts.join(", ")} }`;
-            let bodyElementStatement = "";
-            if (isTypeNullable(bodyParameter.type.elementType) ||
-                bodyParameter.type.elementType.optional) {
-                bodyElementStatement = `!p ? p : `;
-            }
-            return `\nbody: (${bodyParameter.clientName} ?? []).map((p) => { 
-      return ${bodyElementStatement}${mapBody};
-      }),`;
-        }
-        return `\nbody: ${bodyParameter.clientName},`;
+    const serializerFunctionName = buildModelSerializer(context, bodyParameter.type.tcgcType, false, true);
+    const bodyNameExpression = bodyParameter.optional
+        ? `options["${bodyParameter.clientName}"]`
+        : bodyParameter.clientName;
+    const nullOrUndefinedPrefix = getPropertySerializationPrefix(bodyParameter, bodyParameter.optional ? "options" : undefined);
+    if (serializerFunctionName) {
+        return `\nbody: ${nullOrUndefinedPrefix}${serializerFunctionName}(${bodyNameExpression}),`;
     }
-    if (bodyParameter.type.type === "byte-array" &&
-        !bodyParameter.isBinaryPayload) {
-        const dependencies = useDependencies();
-        const uint8ArrayToStringReference = resolveReference(dependencies.uint8ArrayToString);
-        return bodyParameter.optional
-            ? `body: typeof ${bodyParameter.clientName} === 'string'
-    ? ${uint8ArrayToStringReference}(${bodyParameter.clientName}, "${getEncodingFormat(bodyParameter)}")
-    : ${bodyParameter.clientName}`
-            : `body: ${uint8ArrayToStringReference}(${bodyParameter.clientName}, "${getEncodingFormat(bodyParameter)}")`;
+    else if (isAzureCoreErrorType(context.program, bodyParameter.type.__raw)) {
+        return `\nbody: ${nullOrUndefinedPrefix}${bodyNameExpression},`;
     }
-    else if (bodyParameter.isBinaryPayload) {
-        return `\nbody: ${bodyParameter.clientName},`;
-    }
-    if (bodyParameter) {
-        return `\nbody: ${bodyParameter.clientName},`;
-    }
-    return "";
+    const serializedBody = serializeRequestValue(context, bodyParameter.type, bodyNameExpression, !bodyParameter.optional, bodyParameter.isBinaryPayload ? "binary" : bodyParameter.format);
+    return `\nbody: ${serializedBody === bodyNameExpression ? "" : nullOrUndefinedPrefix}${serializedBody},`;
 }
 function getEncodingFormat(type) {
     var _a;
@@ -470,23 +441,23 @@ function getEncodingFormat(type) {
 /**
  * This function helps with renames, translating client names to rest api names
  */
-export function getParameterMap(param, runtimeImports) {
+export function getParameterMap(context, param) {
     if (isConstant(param)) {
         return getConstantValue(param);
     }
     if (hasCollectionFormatInfo(param.location, param.format)) {
-        return getCollectionFormat(param, runtimeImports);
+        return getCollectionFormat(context, param);
     }
     // if the parameter or property is optional, we don't need to handle the default value
     if (isOptional(param)) {
-        return getOptional(param, runtimeImports);
+        return getOptional(context, param);
     }
     if (isRequired(param)) {
-        return getRequired(param, runtimeImports);
+        return getRequired(context, param);
     }
     throw new Error(`Parameter ${param.clientName} is not supported`);
 }
-function getCollectionFormat(param, runtimeImports) {
+function getCollectionFormat(context, param) {
     var _a, _b;
     const collectionInfo = getCollectionFormatHelper(param.location, (_a = param.format) !== null && _a !== void 0 ? _a : "");
     if (!collectionInfo) {
@@ -495,9 +466,9 @@ function getCollectionFormat(param, runtimeImports) {
     const isMulti = ((_b = param.format) !== null && _b !== void 0 ? _b : "").toLowerCase() === "multi";
     const additionalParam = isMulti ? `, "${param.restApiName}"` : "";
     if (!param.optional) {
-        return `"${param.restApiName}": ${collectionInfo}(${serializeRequestValue(param.type, param.clientName, runtimeImports, true, [param.type], param.format)}${additionalParam})`;
+        return `"${param.restApiName}": ${collectionInfo}(${serializeRequestValue(context, param.type, param.clientName, true, param.format)}${additionalParam})`;
     }
-    return `"${param.restApiName}": options?.${param.clientName} !== undefined ? ${collectionInfo}(${serializeRequestValue(param.type, "options?." + param.clientName, runtimeImports, false, [param.type], param.format)}${additionalParam}): undefined`;
+    return `"${param.restApiName}": options?.${param.clientName} !== undefined ? ${collectionInfo}(${serializeRequestValue(context, param.type, "options?." + param.clientName, false, param.format)}${additionalParam}): undefined`;
 }
 function isContentType(param) {
     return (param.location === "header" &&
@@ -518,12 +489,12 @@ function getContentTypeValue(param) {
 function isRequired(param) {
     return !param.optional;
 }
-function getRequired(param, runtimeImports) {
+function getRequired(context, param) {
     if (param.type.type === "model") {
-        const { propertiesStr } = getRequestModelMapping(param.type, param.clientName, runtimeImports, [param.type]);
+        const { propertiesStr } = getRequestModelMapping(context, param.type, param.clientName);
         return `"${param.restApiName}": { ${propertiesStr.join(",")} }`;
     }
-    return `"${param.restApiName}": ${serializeRequestValue(param.type, param.clientName, runtimeImports, true, [param.type], param.format === undefined &&
+    return `"${param.restApiName}": ${serializeRequestValue(context, param.type, param.clientName, true, param.format === undefined &&
         param.location === "header" &&
         param.type.type === "datetime"
         ? "headerDefault"
@@ -543,9 +514,9 @@ function isConstant(param) {
 function isOptional(param) {
     return Boolean(param.optional);
 }
-function getOptional(param, runtimeImports) {
+function getOptional(context, param) {
     if (param.type.type === "model") {
-        const { propertiesStr, directAssignment } = getRequestModelMapping(param.type, "options?." + param.clientName + "?", runtimeImports, [param.type]);
+        const { propertiesStr, directAssignment } = getRequestModelMapping(context, param.type, "options?." + param.clientName + "?.");
         const serializeContent = directAssignment === true
             ? propertiesStr.join(",")
             : `{${propertiesStr.join(",")}}`;
@@ -557,7 +528,7 @@ function getOptional(param, runtimeImports) {
             ? `options?.${param.clientName} ?? "${param.clientDefaultValue}"`
             : `options?.${param.clientName}`}`;
     }
-    return `"${param.restApiName}": ${serializeRequestValue(param.type, `options?.${param.clientName}`, runtimeImports, false, [param.type], param.format === undefined &&
+    return `"${param.restApiName}": ${serializeRequestValue(context, param.type, `options?.${param.clientName}`, false, param.format === undefined &&
         param.location === "header" &&
         param.type.type === "datetime"
         ? "headerDefault"
@@ -567,124 +538,77 @@ function getOptional(param, runtimeImports) {
  * Builds the assignment for when a property or parameter has a default value
  */
 function getDefaultValue(param) {
-    var _a, _b;
-    return ((_a = param.clientDefaultValue) !== null && _a !== void 0 ? _a : param.type.clientDefaultValue) !==
-        undefined
-        ? `${param.optional ? "??" : ""} "${(_b = param.clientDefaultValue) !== null && _b !== void 0 ? _b : param.type.clientDefaultValue}"`
-        : "";
+    var _a;
+    return (_a = param.clientDefaultValue) !== null && _a !== void 0 ? _a : param.type.clientDefaultValue;
 }
 /**
  * Extracts the path parameters
  */
-function getPathParameters(operation) {
+function getPathParameters(dpgContext, operation) {
     if (!operation.parameters) {
         return "";
     }
     let pathParams = "";
     for (const param of operation.parameters) {
         if (param.location === "path") {
-            if (!param.optional) {
-                pathParams += `${pathParams !== "" ? "," : ""} ${param.clientName}`;
-                continue;
-            }
-            const defaultValue = getDefaultValue(param);
-            pathParams += `${pathParams !== "" ? "," : ""} options.${param.clientName}`;
-            if (defaultValue) {
-                pathParams += ` ?? "${defaultValue}"`;
+            // Path parameters cannot be optional
+            if (param.optional) {
+                reportDiagnostic(dpgContext.program, {
+                    code: "optional-path-param",
+                    target: NoTarget,
+                    format: {
+                        paramName: param.clientName
+                    }
+                });
             }
+            pathParams += `${pathParams !== "" ? "," : ""} ${getPathParamExpr(param, getDefaultValue(param))}`;
         }
     }
     return pathParams;
 }
+function getPathParamExpr(param, defaultValue) {
+    const value = defaultValue
+        ? typeof defaultValue === "string"
+            ? `options[${param.clientName}] ?? "${defaultValue}"`
+            : `options[${param.clientName}] ?? ${defaultValue}`
+        : param.clientName;
+    if (param.skipUrlEncoding === true) {
+        return `{value: ${value}, allowReserved: true}`;
+    }
+    return value;
+}
 function getNullableCheck(name, type) {
     if (!isTypeNullable(type)) {
         return "";
     }
     return `${name} === null ? null :`;
 }
-export function getRequestModelMapping(modelPropertyType, propertyPath = "body", runtimeImports, typeStack = []) {
-    var _a, _b;
+export function getRequestModelMapping(context, modelPropertyType, propertyPath = "body") {
+    var _a;
     const props = [];
     const allParents = getAllAncestors(modelPropertyType);
     const properties = (_a = getAllProperties(modelPropertyType, allParents)) !== null && _a !== void 0 ? _a : [];
     if (properties.length <= 0) {
         return { propertiesStr: [] };
     }
-    let serializerName = "name" in modelPropertyType && modelPropertyType.name
-        ? `${toCamelCase(modelPropertyType.name)}Serializer`
-        : undefined;
-    if (isSpecialHandledUnion(modelPropertyType)) {
-        serializerName =
-            serializerName !== null && serializerName !== void 0 ? serializerName : getDeserializeFunctionName(modelPropertyType, "serialize");
-        const definition = `${serializerName}(${propertyPath.replace(/\?$/, "")})`;
-        props.push(definition);
-        return { propertiesStr: props, directAssignment: true };
-    }
     for (const property of properties) {
         if (property.readonly) {
             continue;
         }
+        const dot = propertyPath.endsWith("?") ? "." : "";
+        const propertyPathWithDot = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}`;
         const nullOrUndefinedPrefix = getPropertySerializationPrefix(property, propertyPath);
-        const propertyFullName = getPropertyFullName(property, propertyPath);
-        if (property.type.type === "model") {
-            let definition;
-            if (property.type.coreTypeInfo === "ErrorType") {
-                definition = `"${property.restApiName}": ${getNullableCheck(propertyFullName, property.type)} ${!property.optional ? "" : `!${propertyFullName} ? undefined :`} ${propertyFullName}`;
-            }
-            else if (typeStack.includes(property.type)) {
-                const isSpecialModel = isSpecialUnionVariant(property.type);
-                definition = `"${property.restApiName}": ${!property.optional
-                    ? `${propertyFullName}${isSpecialModel ? " as any" : ""}`
-                    : `!${propertyFullName} ? undefined : ${propertyFullName}${isSpecialModel ? " as any" : ""}`}`;
-            }
-            else if (isPolymorphicUnion(property.type)) {
-                const deserializeFunctionName = property.type.name
-                    ? `${toCamelCase(property.type.name)}Serializer`
-                    : getDeserializeFunctionName(property.type, "serialize");
-                definition = `"${property.restApiName}": ${nullOrUndefinedPrefix}${deserializeFunctionName}(${propertyFullName})`;
-            }
-            else {
-                if (property.type.name) {
-                    serializerName = `${toCamelCase(property.type.name)}Serializer`;
-                    definition = `"${property.restApiName}": ${nullOrUndefinedPrefix}${serializerName}(${propertyPath}.${property.clientName})`;
-                }
-                else {
-                    const { propertiesStr, directAssignment } = getRequestModelMapping(property.type, `${propertyPath}.${property.clientName}${property.optional ? "?" : ""}`, runtimeImports, [...typeStack, property.type]);
-                    const serializeContent = directAssignment === true
-                        ? propertiesStr.join(",")
-                        : `{${propertiesStr.join(",")}}`;
-                    definition = `"${property.restApiName}": ${getNullableCheck(propertyFullName, property.type)} ${!property.optional ? "" : `!${propertyFullName} ? undefined :`} ${serializeContent}`;
-                }
-            }
-            props.push(definition);
-        }
-        else if (typeStack.includes(property.type)) {
-            const isSpecialModel = isSpecialUnionVariant(property.type);
-            const definition = `"${property.restApiName}": ${!property.optional
-                ? `${propertyFullName}${isSpecialModel ? " as any" : ""}`
-                : `!${propertyFullName} ? undefined : ${propertyFullName}${isSpecialModel ? " as any" : ""}`}`;
-            props.push(definition);
-        }
-        else if (property.type.type === "dict") {
-            const modelName = (_b = property.type.elementType) === null || _b === void 0 ? void 0 : _b.name;
-            serializerName = modelName ? `${toCamelCase(modelName)}Serializer` : "";
-            // definition = `"${property.restApiName}": ${nullOrUndefinedPrefix}${serializerName}(${propertyPath}.${property.clientName})`;
-            const statement = `"${property.restApiName}": ${nullOrUndefinedPrefix} serializeRecord(${propertyFullName} as any, ${serializerName}) as any`;
-            // addImportToSpecifier(
-            //   "serializerHelpers",
-            //   runtimeImports,
-            //   "serializeRecord"
-            // );
-            addImportToSpecifier("modularModel", runtimeImports, serializerName);
-            props.push(statement);
+        const propertyFullName = getPropertyFullName(property, propertyPathWithDot);
+        const serializeFunctionName = buildModelSerializer(context, property.type.tcgcType, false, true);
+        if (serializeFunctionName) {
+            props.push(`"${property.restApiName}": ${nullOrUndefinedPrefix}${serializeFunctionName}(${propertyFullName})`);
         }
-        else if (modelPropertyType.type === "enum") {
-            props.push(`"${property.restApiName}": ${nullOrUndefinedPrefix}${propertyPath}.${property.clientName}`);
+        else if (isAzureCoreErrorType(context.program, property.type.__raw)) {
+            props.push(`"${property.restApiName}": ${nullOrUndefinedPrefix}${propertyFullName}`);
         }
         else {
-            const dot = propertyPath.endsWith("?") ? "." : "";
-            const clientValue = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}["${property.clientName}"]`;
-            props.push(`"${property.restApiName}": ${serializeRequestValue(property.type, clientValue, runtimeImports, !property.optional, [...typeStack, property.type], property.format)}`);
+            const serializedValue = serializeRequestValue(context, property.type, propertyFullName, !property.optional, property.format);
+            props.push(`"${property.restApiName}": ${serializedValue}`);
         }
     }
     return { propertiesStr: props };
@@ -693,53 +617,29 @@ export function getRequestModelMapping(modelPropertyType, propertyPath = "body",
  * This function helps translating an RLC response to an HLC response,
  * extracting properties from body and headers and building the HLC response object
  */
-export function getResponseMapping(type, propertyPath = "result.body", runtimeImports, typeStack = []) {
+export function getResponseMapping(context, type, propertyPath = "result.body") {
     var _a;
     const allParents = getAllAncestors(type);
     const properties = (_a = getAllProperties(type, allParents)) !== null && _a !== void 0 ? _a : [];
-    if (typeStack.length <= 0) {
-        typeStack.push(type);
-    }
     const props = [];
     for (const property of properties) {
-        // TODO: Do we need to also add headers in the result type?
-        const propertyFullName = `${propertyPath}.${property.restApiName}`;
-        if (property.type.type === "model") {
-            let definition;
-            if (property.type.coreTypeInfo === "ErrorType") {
-                definition = `"${property.clientName}": ${getNullableCheck(propertyFullName, property.type)} ${!property.optional ? "" : `!${propertyFullName} ? undefined :`} ${propertyFullName}`;
-            }
-            else if (typeStack.includes(property.type)) {
-                const isSpecialModel = isSpecialUnionVariant(property.type);
-                definition = `"${property.clientName}": ${!property.optional
-                    ? `${propertyFullName}${isSpecialModel ? " as any" : ""}`
-                    : `!${propertyFullName} ? undefined : ${propertyFullName}${isSpecialModel ? " as any" : ""}`}`;
-            }
-            else if (isSpecialHandledUnion(property.type)) {
-                const nullOrUndefinedPrefix = getPropertySerializationPrefix(property, propertyPath);
-                const deserializeFunctionName = getDeserializeFunctionName(property.type, "deserialize");
-                definition = `"${property.clientName}": ${nullOrUndefinedPrefix}${deserializeFunctionName}(${propertyFullName})`;
-            }
-            else {
-                definition = `"${property.clientName}": ${getNullableCheck(propertyFullName, property.type)} ${!property.optional ? "" : `!${propertyFullName} ? undefined :`} {${getResponseMapping(property.type, `${propertyPath}.${property.restApiName}${property.optional ? "?" : ""}`, runtimeImports, [...typeStack, property.type])}}`;
-            }
-            props.push(definition);
+        const dot = propertyPath.endsWith("?") ? "." : "";
+        const restValue = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}["${property.restApiName}"]`;
+        const nullOrUndefinedPrefix = property.optional || isTypeNullable(property.type)
+            ? `!${restValue}? ${restValue}: `
+            : "";
+        const deserializeFunctionName = buildModelDeserializer(context, property.type.tcgcType, false, true);
+        if (deserializeFunctionName) {
+            props.push(`"${property.clientName}": ${nullOrUndefinedPrefix}${deserializeFunctionName}(${restValue})`);
+        }
+        else if (isAzureCoreErrorType(context.program, property.type.__raw)) {
+            props.push(`"${property.clientName}": ${nullOrUndefinedPrefix}${restValue}`);
         }
         else {
-            const dot = propertyPath.endsWith("?") ? "." : "";
-            const restValue = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}["${property.restApiName}"]`;
-            if (typeStack.includes(property.type)) {
-                const isSpecialModel = isSpecialUnionVariant(property.type);
-                props.push(`"${property.clientName}": ${!property.optional
-                    ? `${propertyFullName}${isSpecialModel ? " as any" : ""}`
-                    : `!${propertyFullName} ? undefined : ${propertyFullName}${isSpecialModel ? " as any" : ""}`}`);
-            }
-            else {
-                props.push(`"${property.clientName}": ${deserializeResponseValue(property.type, restValue, runtimeImports, property.optional !== undefined ? !property.optional : false, [...typeStack, property.type], property.format)}`);
-            }
+            const deserializeValue = deserializeResponseValue(context, property.type, `${propertyPath}${dot}["${property.restApiName}"]`, property.format);
+            props.push(`"${property.clientName}": ${deserializeValue === `${propertyPath}${dot}["${property.restApiName}"]` ? "" : nullOrUndefinedPrefix}${deserializeValue}`);
         }
     }
-    typeStack.pop();
     return props;
 }
 /**
@@ -747,86 +647,70 @@ export function getResponseMapping(type, propertyPath = "result.body", runtimeIm
  * We need to drill down into Array elements to make sure that the element type is
  * deserialized correctly
  */
-export function deserializeResponseValue(type, restValue, runtimeImports, required, typeStack = [], format) {
-    var _a, _b, _c, _d, _e;
-    const requiredPrefix = required === false ? `${restValue} === undefined` : "";
-    const nullablePrefix = isTypeNullable(type) ? `${restValue} === null` : "";
+export function serializeRequestValue(context, type, clientValue, required, format) {
+    var _a, _b, _c, _d;
+    const getSdkType = useSdkTypes();
     const dependencies = useDependencies();
-    const stringToUint8ArrayReference = resolveReference(dependencies.stringToUint8Array);
-    const requiredOrNullablePrefix = requiredPrefix !== "" && nullablePrefix !== ""
-        ? `(${requiredPrefix} || ${nullablePrefix})`
-        : `${requiredPrefix}${nullablePrefix}`;
+    const nullOrUndefinedPrefix = isTypeNullable(type) || type.optional || !required
+        ? `!${clientValue}? ${clientValue}: `
+        : "";
     switch (type.type) {
         case "datetime":
-            return required
-                ? isTypeNullable(type)
-                    ? `${restValue} === null ? null : new Date(${restValue})`
-                    : `new Date(${restValue})`
-                : `${restValue} !== undefined? new Date(${restValue}): undefined`;
+            switch ((_a = type.format) !== null && _a !== void 0 ? _a : format) {
+                case "rfc7231":
+                case "headerDefault":
+                    return `${nullOrUndefinedPrefix}${clientValue}.toUTCString()`;
+                case "unixTimestamp":
+                    return `${nullOrUndefinedPrefix}${clientValue}.getTime()`;
+                case "rfc3339":
+                default:
+                    return `${getNullableCheck(clientValue, type)} ${clientValue}${required ? "" : "?"}.toISOString()`;
+            }
         case "list": {
-            const prefix = required && !isTypeNullable(type)
-                ? `${restValue}`
-                : `${requiredOrNullablePrefix} ? ${restValue} : ${restValue}`;
-            if (((_a = type.elementType) === null || _a === void 0 ? void 0 : _a.type) === "model") {
-                if (!type.elementType.aliasType) {
-                    const elementNullOrUndefinedPrefix = isTypeNullable(type.elementType) || type.elementType.optional
-                        ? "!p ? p :"
-                        : "";
-                    return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}{${getResponseMapping(type.elementType, "p", runtimeImports, [...typeStack, type.elementType])}}})`;
+            const prefix = nullOrUndefinedPrefix + clientValue;
+            if (type.elementType) {
+                const elementNullOrUndefinedPrefix = isTypeNullable(type.elementType) || type.elementType.optional
+                    ? "!p ? p : "
+                    : "";
+                const serializeFunctionName = buildModelSerializer(context, type.elementType.tcgcType, false, true);
+                if (serializeFunctionName) {
+                    return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${serializeFunctionName}(p)})`;
                 }
-                else if (isPolymorphicUnion(type.elementType)) {
-                    let nullOrUndefinedPrefix = "";
-                    if (isTypeNullable(type.elementType)) {
-                        nullOrUndefinedPrefix = `!p ? p :`;
-                    }
-                    const deserializeFunctionName = getDeserializeFunctionName(type.elementType, "deserialize");
-                    return `${prefix}.map((p: any) => ${nullOrUndefinedPrefix}${deserializeFunctionName}(p))`;
+                else if (isAzureCoreErrorType(context.program, type.elementType.__raw)) {
+                    return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}p})`;
+                }
+                else {
+                    return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${serializeRequestValue(context, type.elementType, "p", true, (_b = type.elementType) === null || _b === void 0 ? void 0 : _b.format)}})`;
                 }
-                return `${prefix}`;
-            }
-            else if (needsDeserialize(type.elementType) &&
-                !((_b = type.elementType) === null || _b === void 0 ? void 0 : _b.aliasType)) {
-                return `${prefix}.map((p: any) => ${deserializeResponseValue(type.elementType, "p", runtimeImports, true, [...typeStack, type.elementType], (_c = type.elementType) === null || _c === void 0 ? void 0 : _c.format)})`;
-            }
-            else {
-                return restValue;
             }
+            return clientValue;
         }
         case "byte-array":
             if (format !== "binary") {
-                return `typeof ${restValue} === 'string'
-        ? ${stringToUint8ArrayReference}(${restValue}, "${format !== null && format !== void 0 ? format : "base64"}")
-        : ${restValue}`;
+                const uint8ArrayToStringReference = resolveReference(dependencies.uint8ArrayToString);
+                return required
+                    ? `${getNullableCheck(clientValue, type)} ${uint8ArrayToStringReference}(${clientValue}, "${(_c = getEncodingFormat({ format })) !== null && _c !== void 0 ? _c : "base64"}")`
+                    : `${nullOrUndefinedPrefix} ${uint8ArrayToStringReference}(${clientValue}, "${(_d = getEncodingFormat({ format })) !== null && _d !== void 0 ? _d : "base64"}")`;
             }
-            return restValue;
+            return clientValue;
         case "combined":
             if (isNormalUnion(type)) {
-                return `${restValue}`;
+                return `${clientValue}`;
             }
             else if (isSpecialHandledUnion(type)) {
-                const deserializeFunctionName = getDeserializeFunctionName(type, "deserialize");
-                return `${deserializeFunctionName}(${restValue})`;
+                const sdkType = getSdkType(type.__raw);
+                const serializerRefkey = refkey(sdkType, "serializer");
+                const serializeFunctionName = resolveReference(serializerRefkey);
+                return `${serializeFunctionName}(${clientValue})`;
             }
             else {
-                return `${restValue} as any`;
-            }
-        case "enum":
-            if (!type.isFixed && !type.isNonExhaustive) {
-                return `${restValue} as ${type.name}`;
-            }
-            return restValue;
-        case "model":
-            if (type.discriminator) {
-                const discriminatorProp = (_d = type.properties) === null || _d === void 0 ? void 0 : _d.filter((p) => p.restApiName === type.discriminator);
-                if ((discriminatorProp === null || discriminatorProp === void 0 ? void 0 : discriminatorProp.length) === 1 &&
-                    ((_e = discriminatorProp[0]) === null || _e === void 0 ? void 0 : _e.type.isFixed) === false &&
-                    discriminatorProp[0].type.isNonExhaustive === false) {
-                    return `${restValue} as ${type.name}`;
-                }
+                return `${clientValue} as any`;
             }
-            return restValue;
         default:
-            return restValue;
+            if (clientValue === "constructorParam") {
+                return `${clientValue} as any`;
+            }
+            return clientValue;
     }
 }
 /**
@@ -834,97 +718,68 @@ export function deserializeResponseValue(type, restValue, runtimeImports, requir
  * We need to drill down into Array elements to make sure that the element type is
  * deserialized correctly
  */
-export function serializeRequestValue(type, clientValue, runtimeImports, required, typeStack = [], format) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const requiredPrefix = required === false ? `${clientValue} === undefined` : "";
-    const nullablePrefix = isTypeNullable(type) ? `${clientValue} === null` : "";
-    const requiredOrNullablePrefix = requiredPrefix !== "" && nullablePrefix !== ""
-        ? `(${requiredPrefix} || ${nullablePrefix})`
-        : `${requiredPrefix}${nullablePrefix}`;
+export function deserializeResponseValue(context, type, restValue, format) {
+    const dependencies = useDependencies();
+    const stringToUint8ArrayReference = resolveReference(dependencies.stringToUint8Array);
+    const nullOrUndefinedPrefix = isTypeNullable(type) || type.optional
+        ? `!${restValue}? ${restValue}: `
+        : "";
     switch (type.type) {
         case "datetime":
-            switch ((_a = type.format) !== null && _a !== void 0 ? _a : format) {
-                case "rfc7231":
-                case "headerDefault":
-                    return `${clientValue}${required ? "" : "?"}.toUTCString()`;
-                case "unixTimestamp":
-                    return `${clientValue}${required ? "" : "?"}.getTime()`;
-                case "rfc3339":
-                default:
-                    return `${getNullableCheck(clientValue, type)} ${clientValue}${required ? "" : "?"}.toISOString()`;
-            }
+            return `${nullOrUndefinedPrefix} new Date(${restValue})`;
         case "list": {
-            const prefix = required && !isTypeNullable(type)
-                ? `${clientValue}`
-                : `${requiredOrNullablePrefix}? ${clientValue}: ${clientValue}`;
-            if (((_b = type.elementType) === null || _b === void 0 ? void 0 : _b.type) === "model" && !type.elementType.aliasType) {
-                const elementNullOrUndefinedPrefix = isTypeNullable(type.elementType) || type.elementType.optional
-                    ? "!p ? p :"
-                    : "";
-                if (!type.elementType.name) {
-                    // If it is an anonymous model we need to serialize inline
-                    const { propertiesStr } = getRequestModelMapping(type.elementType, "p", runtimeImports, [...typeStack, type.elementType]);
-                    return `${prefix}.map(p => { return ${elementNullOrUndefinedPrefix}{${propertiesStr}}})`;
-                }
-                else {
-                    // When it is not anonymous we can hand it off to the serializer function
-                    return `${prefix}.map(${toCamelCase(type.elementType.name + "Serializer")})`;
-                }
+            const prefix = nullOrUndefinedPrefix + restValue;
+            let elementNullOrUndefinedPrefix = "";
+            if (type.elementType &&
+                (isTypeNullable(type.elementType) || type.elementType.optional)) {
+                elementNullOrUndefinedPrefix = "!p ? p :";
             }
-            else if (needsDeserialize(type.elementType) &&
-                !((_c = type.elementType) === null || _c === void 0 ? void 0 : _c.aliasType)) {
-                return `${prefix}.map(p => ${serializeRequestValue(type.elementType, "p", runtimeImports, true, [...typeStack, type.elementType], (_d = type.elementType) === null || _d === void 0 ? void 0 : _d.format)})`;
+            const deserializeFunctionName = type.elementType
+                ? buildModelDeserializer(context, type.elementType.tcgcType, false, true)
+                : undefined;
+            if (deserializeFunctionName) {
+                return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${deserializeFunctionName}(p)})`;
             }
-            else if (((_e = type.elementType) === null || _e === void 0 ? void 0 : _e.type) === "model" &&
-                isPolymorphicUnion(type.elementType)) {
-                let nullOrUndefinedPrefix = "";
-                if (isTypeNullable(type.elementType)) {
-                    nullOrUndefinedPrefix = `!p ? p :`;
-                }
-                const serializeFunctionName = ((_f = type.elementType) === null || _f === void 0 ? void 0 : _f.name)
-                    ? `${toCamelCase(type.elementType.name)}Serializer`
-                    : getDeserializeFunctionName(type.elementType, "serialize");
-                return `${prefix}.map(p => ${nullOrUndefinedPrefix}${serializeFunctionName}(p))`;
+            else if (type.elementType &&
+                isAzureCoreErrorType(context.program, type.elementType.__raw)) {
+                return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}p})`;
+            }
+            else if (type.elementType) {
+                return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${deserializeResponseValue(context, type.elementType, "p", type.format)}})`;
             }
             else {
-                return clientValue;
+                return restValue;
             }
         }
         case "byte-array":
             if (format !== "binary") {
-                const dependencies = useDependencies();
-                const uint8ArrayToStringReference = resolveReference(dependencies.uint8ArrayToString);
-                return required
-                    ? `${getNullableCheck(clientValue, type)} ${uint8ArrayToStringReference}(${clientValue}, "${(_g = getEncodingFormat({ format })) !== null && _g !== void 0 ? _g : "base64"}")`
-                    : `${clientValue} !== undefined ? ${uint8ArrayToStringReference}(${clientValue}, "${(_h = getEncodingFormat({ format })) !== null && _h !== void 0 ? _h : "base64"}"): undefined`;
+                return `typeof ${restValue} === 'string'
+        ? ${stringToUint8ArrayReference}(${restValue}, "${format !== null && format !== void 0 ? format : "base64"}")
+        : ${restValue}`;
             }
-            return clientValue;
+            return restValue;
         case "combined":
             if (isNormalUnion(type)) {
-                return `${clientValue}`;
+                return `${restValue}`;
             }
             else if (isSpecialHandledUnion(type)) {
-                const serializeFunctionName = type.name
-                    ? `${toCamelCase(type.name)}Serializer`
-                    : getDeserializeFunctionName(type, "serialize");
-                return `${serializeFunctionName}(${clientValue})`;
+                const deserializeFunctionName = type
+                    ? buildModelDeserializer(context, type.tcgcType, false, true)
+                    : undefined;
+                if (deserializeFunctionName) {
+                    return `${deserializeFunctionName}(${restValue})`;
+                }
+                else {
+                    return `${restValue} as any`;
+                }
             }
             else {
-                return `${clientValue} as any`;
+                return `${restValue} as any`;
             }
         default:
-            if (clientValue === "constructorParam") {
-                return `${clientValue} as any`;
-            }
-            return clientValue;
+            return restValue;
     }
 }
-function needsDeserialize(type) {
-    return ((type === null || type === void 0 ? void 0 : type.type) === "datetime" ||
-        (type === null || type === void 0 ? void 0 : type.type) === "model" ||
-        (type === null || type === void 0 ? void 0 : type.type) === "list" ||
-        (type === null || type === void 0 ? void 0 : type.type) === "byte-array");
-}
 export function isLroAndPagingOperation(op) {
     return op.discriminator === "lropaging";
 }
@@ -983,18 +838,10 @@ export function getPropertySerializationPrefix(modularType, propertyPath) {
 export function getPropertyFullName(modularType, propertyPath) {
     let fullName = `${modularType.clientName}`;
     if (propertyPath) {
-        fullName = `${propertyPath}.${modularType.clientName}`;
+        fullName = `${propertyPath}["${modularType.clientName}"]`;
     }
     return fullName;
 }
-export function isDiscriminatedUnion(type) {
-    if (!type) {
-        return false;
-    }
-    return Boolean(type.kind === "model" &&
-        type.discriminatorProperty &&
-        type.discriminatedSubtypes);
-}
 /**
  * Get an expression representing an array of expected status codes for the operation
  * @param operation The operation