@azure-tools/typespec-ts 0.36.0 → 0.37.0

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

@@ -1,13 +1,13 @@
 import { NoTarget } from "@typespec/compiler";
 import { PagingHelpers, PollingHelpers } from "../static-helpers-metadata.js";
-import { getType, isTypeNullable } from "./typeHelpers.js";
+import { getNullableValidType, isSpreadBodyParameter, isTypeNullable } from "./typeHelpers.js";
 import { getClassicalLayerPrefix, getOperationName } from "./namingHelpers.js";
-import { getCollectionFormatHelper, hasCollectionFormatInfo } from "../../utils/operationUtil.js";
+import { getCollectionFormatHelper, hasCollectionFormatInfo, isBinaryPayload } from "../../utils/operationUtil.js";
 import { isNormalUnion, isSpecialHandledUnion } from "../serialization/serializeUtils.js";
 import { getDocsFromDescription, getFixmeForMultilineDocs } from "./docsHelpers.js";
 import { toPascalCase } from "../../utils/casingUtils.js";
 import { AzurePollingDependencies } from "../external-dependencies.js";
-import { NameType } from "@azure-tools/rlc-common";
+import { NameType, normalizeName } from "@azure-tools/rlc-common";
 import { buildModelDeserializer } from "../serialization/buildDeserializerFunction.js";
 import { buildModelSerializer } from "../serialization/buildSerializerFunction.js";
 import { refkey } from "../../framework/refkey.js";
@@ -16,10 +16,11 @@ import { resolveReference } from "../../framework/reference.js";
 import { useDependencies } from "../../framework/hooks/useDependencies.js";
 import { useSdkTypes } from "../../framework/hooks/sdkTypes.js";
 import { isAzureCoreErrorType } from "../../utils/modelUtils.js";
-import { getTypeExpression } from "../type-expressions/get-type-expression.js";
-export function getSendPrivateFunction(dpgContext, operation, clientType) {
-    var _a;
-    const parameters = getOperationSignatureParameters(dpgContext, operation, clientType);
+import { getTypeExpression, normalizeModelPropertyName } from "../type-expressions/get-type-expression.js";
+import { isReadOnly } from "@azure-tools/typespec-client-generator-core";
+export function getSendPrivateFunction(dpgContext, client, method, clientType) {
+    const operation = method[1];
+    const parameters = getOperationSignatureParameters(dpgContext, method, clientType);
     const { name } = getOperationName(operation);
     const dependencies = useDependencies();
     const functionStatement = {
@@ -29,18 +30,23 @@ export function getSendPrivateFunction(dpgContext, operation, clientType) {
         parameters,
         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 operationPath = operation.operation.path;
+    const operationMethod = operation.operation.verb.toLowerCase();
+    const optionalParamName = getOptionalParamsName(parameters);
+    const hasQueryApiVersion = operation.operation.parameters.some((p) => p.isApiVersionParam && p.onClient && p.kind === "query");
+    const hasClientApiVersion = client.initialization.properties.some((p) => p.isApiVersionParam && p.onClient && p.kind === "method");
     const statements = [];
-    statements.push(`return context.path("${operationPath}", ${getPathParameters(dpgContext, operation)}).${operationMethod}({...${resolveReference(dependencies.operationOptionsToRequestParameters)}(${optionalParamName}), ${getRequestParameters(dpgContext, operation)}});`);
+    if (hasClientApiVersion && !hasQueryApiVersion) {
+        statements.push(`context.pipeline.removePolicy({ name: "ClientApiVersionPolicy"});`);
+    }
+    statements.push(`return context.path("${operationPath}", ${getPathParameters(dpgContext, operation, optionalParamName)}).${operationMethod}({...${resolveReference(dependencies.operationOptionsToRequestParameters)}(${optionalParamName}), ${getRequestParameters(dpgContext, operation, optionalParamName)}});`);
     return {
         ...functionStatement,
         statements
     };
 }
 export function getDeserializePrivateFunction(context, operation) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     const { name } = getOperationName(operation);
     const dependencies = useDependencies();
     const PathUncheckedResponseReference = resolveReference(dependencies.PathUncheckedResponse);
@@ -55,15 +61,16 @@ export function getDeserializePrivateFunction(context, operation) {
     const isLroOnly = isLroOnlyOperation(operation);
     // TODO: Support operation overloads
     // TODO: Support multiple responses
-    const response = operation.responses[0];
+    const response = operation.response;
+    const restResponse = operation.operation.responses[0];
     let returnType;
-    if (isLroOnly && operation.method.toLowerCase() !== "patch") {
+    if (isLroOnly && operation.operation.verb.toLowerCase() !== "patch") {
         returnType = buildLroReturnType(context, operation);
     }
-    else if ((_a = response === null || response === void 0 ? void 0 : response.type) === null || _a === void 0 ? void 0 : _a.type) {
+    else if (response.type && restResponse) {
         returnType = {
-            name: response.type.name,
-            type: getTypeExpression(context, response.type.tcgcType)
+            name: (_a = restResponse.name) !== null && _a !== void 0 ? _a : "",
+            type: getTypeExpression(context, restResponse.type)
         };
     }
     else {
@@ -81,21 +88,24 @@ export function getDeserializePrivateFunction(context, operation) {
     statements.push(`const expectedStatuses = ${getExpectedStatuses(operation)};`);
     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;
-    const hasLroSubPath = ((_c = operation === null || operation === void 0 ? void 0 : operation.lroMetadata) === null || _c === void 0 ? void 0 : _c.finalResultPath) !== undefined;
+        ? (_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
+            ? restResponse.type
+            : response.type;
+    const lroSubPath = 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.resultPath
+        : undefined;
     const deserializePrefix = "result.body";
-    const deserializedRoot = hasLroSubPath
-        ? `${deserializePrefix}.${(_d = operation === null || operation === void 0 ? void 0 : operation.lroMetadata) === null || _d === void 0 ? void 0 : _d.finalResultPath}`
-        : `${deserializePrefix}`;
-    if (isLroOnly && hasLroSubPath) {
+    const deserializedRoot = `${deserializePrefix}${lroSubPath ? "." + lroSubPath : ""}`;
+    if (isLroOnly && lroSubPath) {
         statements.push(`if(${deserializedRoot.split(".").join("?.")} === undefined) {
         throw createRestError(\`Expected a result in the response at position "${deserializedRoot}"\`, result);
       }
       `);
     }
-    if (deserializedType === null || deserializedType === void 0 ? void 0 : deserializedType.tcgcType) {
-        const deserializeFunctionName = buildModelDeserializer(context, deserializedType.tcgcType, false, true);
+    if (deserializedType) {
+        const contentTypes = (_f = operation.operation.responses[0]) === null || _f === void 0 ? void 0 : _f.contentTypes;
+        const deserializeFunctionName = buildModelDeserializer(context, deserializedType, false, true);
         if (deserializeFunctionName) {
             statements.push(`return ${deserializeFunctionName}(${deserializedRoot})`);
         }
@@ -103,15 +113,14 @@ export function getDeserializePrivateFunction(context, operation) {
             statements.push(`return ${deserializedRoot}`);
         }
         else {
-            statements.push(`return ${deserializeResponseValue(context, deserializedType, deserializedRoot, response.isBinaryPayload ? "binary" : deserializedType.format)}`);
+            statements.push(`return ${deserializeResponseValue(context, deserializedType, deserializedRoot, isBinaryPayload(context, response.type.__raw, contentTypes)
+                ? "binary"
+                : getEncodeForType(deserializedType))}`);
         }
     }
     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;");
     }
@@ -120,34 +129,38 @@ export function getDeserializePrivateFunction(context, operation) {
         statements
     };
 }
-function getOperationSignatureParameters(context, operation, clientType) {
-    var _a;
-    const optionsType = getOperationOptionsName(operation, true);
+function getOptionalParamsName(parameters) {
+    var _a, _b;
+    return ((_b = (_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) !== null && _b !== void 0 ? _b : "options");
+}
+function getOperationSignatureParameters(context, method, clientType) {
+    const operation = method[1];
+    const optionsType = getOperationOptionsName(method, true);
     const parameters = new Map();
     operation.parameters
-        .filter((p) => p.implementation === "Method" &&
-        p.type.type !== "constant" &&
-        p.clientDefaultValue === undefined &&
-        !p.optional)
-        .map((p) => {
+        .filter((p) => {
         var _a;
+        return p.onClient === false &&
+            p.type.kind !== "constant" &&
+            ((_a = operation.operation.parameters.filter((param) => {
+                return (param.correspondingMethodParams.length === 1 &&
+                    param.correspondingMethodParams[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"));
+    } // skip tcgc generated contentType and accept header parameter
+    )
+        .map((p) => {
         return {
-            name: p.clientName,
-            type: getTypeExpression(context, (_a = p.tcgcType) !== null && _a !== void 0 ? _a : p.type.tcgcType)
+            name: p.name,
+            type: getTypeExpression(context, p.type)
         };
     })
         .forEach((p) => {
         parameters.set(p.name, p);
     });
-    if (operation.bodyParameter && operation.bodyParameter.optional === false) {
-        parameters.set((_a = operation.bodyParameter) === null || _a === void 0 ? void 0 : _a.clientName, {
-            hasQuestionToken: operation.bodyParameter.optional,
-            ...{
-                name: operation.bodyParameter.clientName,
-                type: getTypeExpression(context, operation.bodyParameter.type.tcgcType)
-            }
-        });
-    }
     // Add context as the first parameter
     const contextParam = { name: "context", type: clientType };
     // Add the options parameter
@@ -162,45 +175,44 @@ function getOperationSignatureParameters(context, operation, clientType) {
 /**
  * This operation builds and returns the function declaration for an operation.
  */
-export function getOperationFunction(context, operation, clientType) {
-    var _a, _b, _c;
+export function getOperationFunction(context, method, clientType) {
+    var _a;
+    const operation = method[1];
+    // Extract required parameters
+    const parameters = getOperationSignatureParameters(context, method, clientType);
+    const optionalParamName = getOptionalParamsName(parameters);
     if (isPagingOnlyOperation(operation)) {
         // Case 1: paging-only operation
-        return getPagingOnlyOperationFunction(context, operation, clientType);
+        return getPagingOnlyOperationFunction(context, [method[0], operation], clientType);
     }
     else if (isLroOnlyOperation(operation)) {
         // Case 2: lro-only operation
-        return getLroOnlyOperationFunction(context, operation, clientType);
+        return getLroOnlyOperationFunction(context, [method[0], operation], clientType, optionalParamName);
     }
     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(context, operation, clientType);
     // TODO: Support operation overloads
-    const response = operation.responses[0];
+    const response = operation.response;
     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;
+    if (response.type) {
+        const type = response.type;
         returnType = {
-            name: (_c = type.name) !== null && _c !== void 0 ? _c : "",
-            type: getTypeExpression(context, type.tcgcType)
+            name: (_a = type.name) !== null && _a !== void 0 ? _a : "",
+            type: getTypeExpression(context, type)
         };
     }
     const { name, fixme = [] } = getOperationName(operation);
     const functionStatement = {
         docs: [
-            ...getDocsFromDescription(operation.description),
+            ...getDocsFromDescription(operation.doc),
             ...getFixmeForMultilineDocs(fixme)
         ],
         isAsync: true,
         isExported: true,
         name,
-        propertyName: operation.name,
+        propertyName: normalizeName(operation.name, NameType.Property),
         parameters,
         returnType: `Promise<${returnType.type}>`
     };
@@ -214,36 +226,46 @@ export function getOperationFunction(context, operation, clientType) {
         statements
     };
 }
-function getLroOnlyOperationFunction(context, operation, clientType) {
-    var _a, _b;
+function getLroOnlyOperationFunction(context, method, clientType, optionalParamName = "options") {
+    const operation = method[1];
     // Extract required parameters
-    const parameters = getOperationSignatureParameters(context, operation, clientType);
+    const parameters = getOperationSignatureParameters(context, method, clientType);
     const returnType = buildLroReturnType(context, operation);
     const { name, fixme = [] } = getOperationName(operation);
     const pollerLikeReference = resolveReference(AzurePollingDependencies.PollerLike);
     const operationStateReference = resolveReference(AzurePollingDependencies.OperationState);
     const functionStatement = {
         docs: [
-            ...getDocsFromDescription(operation.description),
+            ...getDocsFromDescription(operation.doc),
             ...getFixmeForMultilineDocs(fixme)
         ],
         isAsync: false,
         isExported: true,
         name,
-        propertyName: operation.name,
+        propertyName: normalizeName(operation.name, NameType.Property),
         parameters,
         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 lroMetadata = operation.kind === "lro" || operation.kind === "lropaging"
+        ? operation.lroMetadata
+        : undefined;
+    const allowedFinalLocation = [
+        "azure-async-operation",
+        "location",
+        "original-uri",
+        "operation-location"
+    ];
+    const resourceLocationConfig = (lroMetadata === null || lroMetadata === void 0 ? void 0 : lroMetadata.finalStateVia) &&
+        allowedFinalLocation.includes(lroMetadata === null || lroMetadata === void 0 ? void 0 : lroMetadata.finalStateVia)
+        ? `resourceLocationConfig: "${lroMetadata === null || lroMetadata === void 0 ? void 0 : lroMetadata.finalStateVia}"`
         : "";
     const statements = [];
     statements.push(`
 
   return ${getLongRunningPollerReference}(context, _${name}Deserialize, ${getExpectedStatuses(operation)}, {
-    updateIntervalInMs: options?.updateIntervalInMs,
-    abortSignal: options?.abortSignal,
+    updateIntervalInMs: ${optionalParamName}?.updateIntervalInMs,
+    abortSignal: ${optionalParamName}?.abortSignal,
     getInitialResponse: () => _${name}Send(${parameters
         .map((p) => p.name)
         .join(", ")}),
@@ -257,27 +279,28 @@ function getLroOnlyOperationFunction(context, operation, clientType) {
 }
 function buildLroReturnType(context, operation) {
     const metadata = operation.lroMetadata;
-    if (metadata !== undefined && metadata.finalResult !== undefined) {
-        const type = metadata.finalResult;
+    if (metadata !== undefined && metadata.finalResponse !== undefined) {
+        const type = metadata.finalResponse.result;
         return {
             name: type.name,
-            type: getTypeExpression(context, type.tcgcType)
+            type: getTypeExpression(context, type)
         };
     }
     return { name: "", type: "void" };
 }
-function getPagingOnlyOperationFunction(context, operation, clientType) {
+function getPagingOnlyOperationFunction(context, method, clientType) {
     var _a, _b, _c;
+    const operation = method[1];
     // Extract required parameters
-    const parameters = getOperationSignatureParameters(context, operation, clientType);
+    const parameters = getOperationSignatureParameters(context, method, clientType);
     // TODO: Support operation overloads
-    const response = operation.responses[0];
+    const response = operation.response;
     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;
+    if (response.type && response.type.kind === "array") {
+        const type = response.type;
         returnType = {
-            name: (_c = type.name) !== null && _c !== void 0 ? _c : "",
-            type: getTypeExpression(context, type.tcgcType)
+            name: (_a = type.valueType.name) !== null && _a !== void 0 ? _a : "",
+            type: getTypeExpression(context, type.valueType)
         };
     }
     const { name, fixme = [] } = getOperationName(operation);
@@ -285,23 +308,29 @@ function getPagingOnlyOperationFunction(context, operation, clientType) {
     const buildPagedAsyncIteratorReference = resolveReference(PagingHelpers.BuildPagedAsyncIterator);
     const functionStatement = {
         docs: [
-            ...getDocsFromDescription(operation.description),
+            ...getDocsFromDescription(operation.doc),
             ...getFixmeForMultilineDocs(fixme)
         ],
         isAsync: false,
         isExported: true,
         name,
-        propertyName: operation.name,
+        propertyName: normalizeName(operation.name, NameType.Property),
         parameters,
         returnType: `${pagedAsyncIterableIteratorReference}<${returnType.type}>`
     };
     const statements = [];
     const options = [];
-    if (operation.itemName) {
-        options.push(`itemName: "${operation.itemName}"`);
-    }
-    if (operation.continuationTokenName) {
-        options.push(`nextLinkName: "${operation.continuationTokenName}"`);
+    // TODO pending tcgc issue to fix https://github.com/Azure/typespec-azure/issues/1985
+    const itemName = operation.response.resultPath !== "" && operation.response.resultPath
+        ? operation.response.resultPath
+        : ((_b = operation.__raw_paged_metadata) === null || _b === void 0 ? void 0 : _b.itemsSegments)
+            ? operation.__raw_paged_metadata.itemsSegments[0]
+            : undefined;
+    if (itemName) {
+        options.push(`itemName: "${itemName}"`);
+    }
+    if ((_c = operation.__raw_paged_metadata) === null || _c === void 0 ? void 0 : _c.nextLinkSegments) {
+        options.push(`nextLinkName: "${operation.__raw_paged_metadata.nextLinkSegments[0]}"`);
     }
     statements.push(`return ${buildPagedAsyncIteratorReference}(
       context, 
@@ -315,28 +344,11 @@ function getPagingOnlyOperationFunction(context, operation, clientType) {
         statements
     };
 }
-function extractPagingType(type, itemName) {
-    var _a, _b, _c;
-    if (!itemName) {
-        return undefined;
-    }
-    const allProperties = [
-        ...((_a = type.properties) !== null && _a !== void 0 ? _a : []),
-        ...((_b = type.parents) !== null && _b !== void 0 ? _b : []).flatMap((p) => { var _a; return (_a = p.properties) !== null && _a !== void 0 ? _a : []; })
-    ];
-    const prop = allProperties
-        .filter((prop) => prop.restApiName === itemName)
-        .map((prop) => prop.type);
-    if (prop.length === 0) {
-        return undefined;
-    }
-    return ((_c = prop[0]) === null || _c === void 0 ? void 0 : _c.type) === "list" && prop[0].elementType
-        ? prop[0].elementType
-        : undefined;
-}
-export function getOperationOptionsName(operation, includeGroupName = false) {
+export function getOperationOptionsName(method, includeGroupName = false) {
+    const prefixes = method[0];
+    const operation = method[1];
     const prefix = includeGroupName && operation.name.indexOf("_") === -1
-        ? getClassicalLayerPrefix(operation, NameType.Interface)
+        ? getClassicalLayerPrefix(prefixes, NameType.Interface)
         : "";
     const optionName = `${prefix}${toPascalCase(operation.name)}OptionalParams`;
     return optionName;
@@ -346,54 +358,59 @@ 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) {
-    if (!operation.parameters) {
+function getRequestParameters(dpgContext, operation, optionalParamName = "options") {
+    if (!operation.operation.parameters) {
         return "";
     }
-    const operationParameters = operation.parameters.filter((p) => p.implementation !== "Client" && !isContentType(p));
-    const contentTypeParameter = operation.parameters.find(isContentType);
+    const operationParameters = operation.operation.parameters.filter((p) => (!p.onClient || p.isApiVersionParam) && !isContentType(p));
+    const contentTypeParameter = operation.operation.parameters.find(isContentType);
     const parametersImplementation = {
         header: [],
         query: [],
         body: []
     };
     for (const param of operationParameters) {
-        if (param.location === "header" ||
-            param.location === "query" ||
-            param.location === "body") {
-            parametersImplementation[param.location].push({
-                paramMap: getParameterMap(dpgContext, param),
+        if (param.kind === "header" || param.kind === "query") {
+            // skip tcgc generated contentType and accept non constant type header parameter
+            if (param.isGeneratedName &&
+                !isConstant(param.type) &&
+                (param.name === "contentType" || param.name === "accept")) {
+                continue;
+            }
+            parametersImplementation[param.kind].push({
+                paramMap: getParameterMap(dpgContext, param, optionalParamName),
                 param
             });
         }
     }
     let paramStr = "";
     if (contentTypeParameter) {
-        paramStr = `${getContentTypeValue(contentTypeParameter)},`;
+        paramStr = `${getContentTypeValue(contentTypeParameter, optionalParamName)},`;
     }
     if (parametersImplementation.header.length) {
         paramStr = `${paramStr}\nheaders: {${parametersImplementation.header
-            .map((i) => buildHeaderParameter(dpgContext.program, i.paramMap, i.param))
-            .join(",\n")}},`;
+            .map((i) => buildHeaderParameter(dpgContext.program, i.paramMap, i.param, optionalParamName))
+            .join(",\n")}, ...${optionalParamName}.requestOptions?.headers },`;
     }
     if (parametersImplementation.query.length) {
         paramStr = `${paramStr}\nqueryParameters: {${parametersImplementation.query
             .map((i) => i.paramMap)
             .join(",\n")}},`;
     }
-    if (operation.bodyParameter === undefined &&
+    if (operation.operation.bodyParam === undefined &&
         parametersImplementation.body.length) {
         paramStr = `${paramStr}\nbody: {${parametersImplementation.body
             .map((i) => i.paramMap)
             .join(",\n")}}`;
     }
-    else if (operation.bodyParameter !== undefined) {
-        paramStr = `${paramStr}${buildBodyParameter(dpgContext, operation.bodyParameter)}`;
+    else if (operation.operation.bodyParam !== undefined) {
+        paramStr = `${paramStr}${buildBodyParameter(dpgContext, operation.operation.bodyParam)}`;
     }
     return paramStr;
 }
 // Specially handle the type for headers because we only allow string/number/boolean values
-function buildHeaderParameter(program, paramMap, param) {
+function buildHeaderParameter(program, paramMap, param, optionalParamName = "options") {
+    const paramName = param.name;
     if (!param.optional && isTypeNullable(param.type) === true) {
         reportDiagnostic(program, {
             code: "nullable-required-header",
@@ -403,32 +420,36 @@ function buildHeaderParameter(program, paramMap, param) {
     }
     const conditions = [];
     if (param.optional) {
-        conditions.push(`options?.${param.clientName} !== undefined`);
+        conditions.push(`${optionalParamName}?.${paramName} !== undefined`);
     }
     if (isTypeNullable(param.type) === true) {
-        conditions.push(`options?.${param.clientName} !== null`);
+        conditions.push(`${optionalParamName}?.${paramName} !== null`);
     }
     return conditions.length > 0
         ? `...(${conditions.join(" && ")} ? {${paramMap}} : {})`
         : paramMap;
 }
-function buildBodyParameter(context, bodyParameter) {
-    if (!bodyParameter || !bodyParameter.type.tcgcType) {
+function buildBodyParameter(context, bodyParameter, optionalParamName = "options") {
+    if (!bodyParameter || !bodyParameter.type) {
         return "";
     }
-    const serializerFunctionName = buildModelSerializer(context, bodyParameter.type.tcgcType, false, true);
+    const serializerFunctionName = buildModelSerializer(context, getNullableValidType(bodyParameter.type), false, true);
+    const bodyParamName = normalizeName(bodyParameter.name, NameType.Parameter);
     const bodyNameExpression = bodyParameter.optional
-        ? `options["${bodyParameter.clientName}"]`
-        : bodyParameter.clientName;
-    const nullOrUndefinedPrefix = getPropertySerializationPrefix(bodyParameter, bodyParameter.optional ? "options" : undefined);
-    if (serializerFunctionName) {
+        ? `${optionalParamName}["${bodyParamName}"]`
+        : bodyParamName;
+    const nullOrUndefinedPrefix = getPropertySerializationPrefix(context, bodyParameter, bodyParameter.optional ? optionalParamName : undefined);
+    // if a model being used in both spread and non spread operation, we should only leverage the deserializer in non spread operation
+    if (serializerFunctionName && !isSpreadBodyParameter(bodyParameter)) {
         return `\nbody: ${nullOrUndefinedPrefix}${serializerFunctionName}(${bodyNameExpression}),`;
     }
     else if (isAzureCoreErrorType(context.program, bodyParameter.type.__raw)) {
         return `\nbody: ${nullOrUndefinedPrefix}${bodyNameExpression},`;
     }
-    const serializedBody = serializeRequestValue(context, bodyParameter.type, bodyNameExpression, !bodyParameter.optional, bodyParameter.isBinaryPayload ? "binary" : bodyParameter.format);
-    return `\nbody: ${serializedBody === bodyNameExpression ? "" : nullOrUndefinedPrefix}${serializedBody},`;
+    const serializedBody = serializeRequestValue(context, bodyParameter.type, bodyNameExpression, !bodyParameter.optional, isBinaryPayload(context, bodyParameter.__raw, bodyParameter.contentTypes)
+        ? "binary"
+        : getEncodeForType(bodyParameter.type));
+    return `\nbody: ${serializedBody.startsWith(nullOrUndefinedPrefix) ? "" : nullOrUndefinedPrefix}${serializedBody},`;
 }
 function getEncodingFormat(type) {
     var _a;
@@ -441,138 +462,150 @@ function getEncodingFormat(type) {
 /**
  * This function helps with renames, translating client names to rest api names
  */
-export function getParameterMap(context, param) {
-    if (isConstant(param)) {
-        return getConstantValue(param);
+export function getParameterMap(context, param, optionalParamName = "options") {
+    if (isConstant(param.type)) {
+        return `"${param.name}": ${getConstantValue(param.type)}`;
     }
-    if (hasCollectionFormatInfo(param.location, param.format)) {
-        return getCollectionFormat(context, param);
+    if (hasCollectionFormatInfo(param.kind, param.collectionFormat)) {
+        return getCollectionFormat(context, param, optionalParamName);
     }
     // if the parameter or property is optional, we don't need to handle the default value
     if (isOptional(param)) {
-        return getOptional(context, param);
+        return getOptional(context, param, optionalParamName);
     }
     if (isRequired(param)) {
         return getRequired(context, param);
     }
-    throw new Error(`Parameter ${param.clientName} is not supported`);
+    throw new Error(`Parameter ${param.name} is not supported`);
 }
-function getCollectionFormat(context, param) {
-    var _a, _b;
-    const collectionInfo = getCollectionFormatHelper(param.location, (_a = param.format) !== null && _a !== void 0 ? _a : "");
+function getCollectionFormat(context, param, optionalParamName = "options") {
+    const serializedName = getPropertySerializedName(param);
+    const format = param.collectionFormat;
+    const collectionInfo = getCollectionFormatHelper(param.kind, format !== null && format !== void 0 ? format : "");
     if (!collectionInfo) {
         throw "Has collection format info but without helper function detected";
     }
-    const isMulti = ((_b = param.format) !== null && _b !== void 0 ? _b : "").toLowerCase() === "multi";
-    const additionalParam = isMulti ? `, "${param.restApiName}"` : "";
+    const isMulti = format.toLowerCase() === "multi";
+    const additionalParam = isMulti ? `, "${serializedName}"` : "";
     if (!param.optional) {
-        return `"${param.restApiName}": ${collectionInfo}(${serializeRequestValue(context, param.type, param.clientName, true, param.format)}${additionalParam})`;
+        return `"${serializedName}": ${collectionInfo}(${serializeRequestValue(context, param.type, param.name, true, getEncodeForType(param.type))}${additionalParam})`;
     }
-    return `"${param.restApiName}": options?.${param.clientName} !== undefined ? ${collectionInfo}(${serializeRequestValue(context, param.type, "options?." + param.clientName, false, param.format)}${additionalParam}): undefined`;
+    return `"${serializedName}": ${optionalParamName}?.${param.name} !== undefined ? ${collectionInfo}(${serializeRequestValue(context, param.type, `${optionalParamName}?.${param.name}`, false, getEncodeForType(param.type))}${additionalParam}): undefined`;
 }
 function isContentType(param) {
-    return (param.location === "header" &&
-        param.restApiName.toLowerCase() === "content-type");
+    return (param.kind === "header" &&
+        param.serializedName.toLowerCase() === "content-type");
 }
-function getContentTypeValue(param) {
-    var _a;
-    const defaultValue = (_a = param.clientDefaultValue) !== null && _a !== void 0 ? _a : param.type.clientDefaultValue;
+function getContentTypeValue(param, optionalParamName = "options") {
+    const defaultValue = param.clientDefaultValue;
+    // allow customers to customize the content type if it's guessed by tcgc.
+    if (isConstant(param.type)) {
+        return `contentType: ${getConstantValue(param.type)}`;
+    }
     if (defaultValue) {
-        return `contentType: options.${param.clientName} as any ?? "${defaultValue}"`;
+        return `contentType: ${optionalParamName}.${param.name} as any ?? "${defaultValue}"`;
     }
     else {
         return `contentType: ${!param.optional
             ? "contentType"
-            : "options." + param.clientName + " as any"}`;
+            : `${optionalParamName}.` + param.name + " as any"}`;
     }
 }
 function isRequired(param) {
     return !param.optional;
 }
 function getRequired(context, param) {
-    if (param.type.type === "model") {
-        const { propertiesStr } = getRequestModelMapping(context, param.type, param.clientName);
-        return `"${param.restApiName}": { ${propertiesStr.join(",")} }`;
+    const serializedName = getPropertySerializedName(param);
+    const clientValue = `${param.onClient ? "context." : ""}${param.name}`;
+    if (param.type.kind === "model") {
+        const { propertiesStr } = getRequestModelMapping(context, { ...param.type, optional: param.optional }, clientValue);
+        return `"${serializedName}": { ${propertiesStr.join(",")} }`;
     }
-    return `"${param.restApiName}": ${serializeRequestValue(context, param.type, param.clientName, true, param.format === undefined &&
-        param.location === "header" &&
-        param.type.type === "datetime"
-        ? "headerDefault"
-        : param.format)}`;
+    return `"${serializedName}": ${serializeRequestValue(context, param.type, clientValue, true, getEncodeForType(param.type))}`;
 }
 function getConstantValue(param) {
-    var _a, _b;
-    const defaultValue = (_b = (_a = param.clientDefaultValue) !== null && _a !== void 0 ? _a : param.type.clientDefaultValue) !== null && _b !== void 0 ? _b : param.type.value;
-    if (!defaultValue) {
-        throw new Error(`Constant ${param.clientName} does not have a default value`);
+    if (typeof param.value === "string") {
+        return `"${param.value}"`;
     }
-    return `"${param.restApiName}": ${getType(param.type).name}`;
+    return `${param.value}`;
 }
 function isConstant(param) {
-    return param.type.type === "constant";
+    return param.kind === "constant";
 }
 function isOptional(param) {
     return Boolean(param.optional);
 }
-function getOptional(context, param) {
-    if (param.type.type === "model") {
-        const { propertiesStr, directAssignment } = getRequestModelMapping(context, param.type, "options?." + param.clientName + "?.");
+function getOptional(context, param, optionalParamName) {
+    const serializedName = getPropertySerializedName(param);
+    const paramName = `${param.onClient ? "context." : `${optionalParamName}?.`}${param.name}`;
+    if (param.type.kind === "model") {
+        const { propertiesStr, directAssignment } = getRequestModelMapping(context, { ...param.type, optional: param.optional }, paramName + "?.");
         const serializeContent = directAssignment === true
             ? propertiesStr.join(",")
             : `{${propertiesStr.join(",")}}`;
-        return `"${param.restApiName}": ${serializeContent}`;
-    }
-    if (param.restApiName === "api-version" &&
-        param.location === "query") {
-        return `"${param.restApiName}": ${param.clientDefaultValue
-            ? `options?.${param.clientName} ?? "${param.clientDefaultValue}"`
-            : `options?.${param.clientName}`}`;
+        return `"${serializedName}": ${serializeContent}`;
     }
-    return `"${param.restApiName}": ${serializeRequestValue(context, param.type, `options?.${param.clientName}`, false, param.format === undefined &&
-        param.location === "header" &&
-        param.type.type === "datetime"
-        ? "headerDefault"
-        : param.format)}`;
+    return `"${serializedName}": ${serializeRequestValue(context, param.type, paramName, false, getEncodeForType(param.type))}`;
+}
+/**
+ * Get the encode for SDK type
+ */
+function getEncodeForType(type) {
+    return type.encode;
+}
+/**
+ * Get the optionality for SDK type
+ */
+function getOptionalForType(type) {
+    return type.optional;
 }
 /**
  * Builds the assignment for when a property or parameter has a default value
  */
 function getDefaultValue(param) {
-    var _a;
-    return (_a = param.clientDefaultValue) !== null && _a !== void 0 ? _a : param.type.clientDefaultValue;
+    return param.clientDefaultValue;
 }
 /**
  * Extracts the path parameters
  */
-function getPathParameters(dpgContext, operation) {
-    if (!operation.parameters) {
+function getPathParameters(dpgContext, operation, optionalParamName = "options") {
+    if (!operation.operation.parameters) {
         return "";
     }
     let pathParams = "";
-    for (const param of operation.parameters) {
-        if (param.location === "path") {
+    for (const param of operation.operation.parameters) {
+        if (param.kind === "path") {
             // Path parameters cannot be optional
             if (param.optional) {
                 reportDiagnostic(dpgContext.program, {
                     code: "optional-path-param",
                     target: NoTarget,
                     format: {
-                        paramName: param.clientName
+                        paramName: param
                     }
                 });
             }
-            pathParams += `${pathParams !== "" ? "," : ""} ${getPathParamExpr(param, getDefaultValue(param))}`;
+            pathParams += `${pathParams !== "" ? "," : ""} ${getPathParamExpr(param, getDefaultValue(param), optionalParamName)}`;
         }
     }
     return pathParams;
 }
-function getPathParamExpr(param, defaultValue) {
+function getPathParamExpr(param, defaultValue, optionalParamName = "options") {
+    if (isConstant(param.type)) {
+        return getConstantValue(param.type);
+    }
+    const paramName = param.onClient
+        ? `context.${param.name}`
+        : param.optional
+            ? `${optionalParamName}["${param.name}"]`
+            : param.name;
     const value = defaultValue
         ? typeof defaultValue === "string"
-            ? `options[${param.clientName}] ?? "${defaultValue}"`
-            : `options[${param.clientName}] ?? ${defaultValue}`
-        : param.clientName;
-    if (param.skipUrlEncoding === true) {
+            ? `${paramName} ?? "${defaultValue}"`
+            : `${paramName} ?? ${defaultValue}`
+        : paramName;
+    // TODO allowReserved is not supported in Query and Header parameter yet.
+    if (param.kind === "path" && param.allowReserved === true) {
         return `{value: ${value}, allowReserved: true}`;
     }
     return value;
@@ -592,52 +625,59 @@ export function getRequestModelMapping(context, modelPropertyType, propertyPath
         return { propertiesStr: [] };
     }
     for (const property of properties) {
-        if (property.readonly) {
+        if (property.kind === "property" && isReadOnly(property)) {
             continue;
         }
         const dot = propertyPath.endsWith("?") ? "." : "";
+        const serializedName = getPropertySerializedName(property);
         const propertyPathWithDot = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}`;
-        const nullOrUndefinedPrefix = getPropertySerializationPrefix(property, propertyPath);
-        const propertyFullName = getPropertyFullName(property, propertyPathWithDot);
-        const serializeFunctionName = buildModelSerializer(context, property.type.tcgcType, false, true);
+        const nullOrUndefinedPrefix = getPropertySerializationPrefix(context, property, propertyPath);
+        const propertyFullName = getPropertyFullName(context, property, propertyPathWithDot);
+        const serializeFunctionName = buildModelSerializer(context, getNullableValidType(property.type), false, true);
         if (serializeFunctionName) {
-            props.push(`"${property.restApiName}": ${nullOrUndefinedPrefix}${serializeFunctionName}(${propertyFullName})`);
+            props.push(`"${serializedName}": ${nullOrUndefinedPrefix}${serializeFunctionName}(${propertyFullName})`);
         }
         else if (isAzureCoreErrorType(context.program, property.type.__raw)) {
-            props.push(`"${property.restApiName}": ${nullOrUndefinedPrefix}${propertyFullName}`);
+            props.push(`"${serializedName}": ${nullOrUndefinedPrefix}${propertyFullName}`);
         }
         else {
-            const serializedValue = serializeRequestValue(context, property.type, propertyFullName, !property.optional, property.format);
-            props.push(`"${property.restApiName}": ${serializedValue}`);
+            const serializedValue = serializeRequestValue(context, property.type, propertyFullName, !property.optional, getEncodeForType(property.type));
+            props.push(`"${serializedName}": ${serializedValue}`);
         }
     }
     return { propertiesStr: props };
 }
+function getPropertySerializedName(property) {
+    return property.kind !== "credential" && property.kind !== "method"
+        ? property.serializedName
+        : property.name;
+}
 /**
  * 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(context, type, propertyPath = "result.body") {
-    var _a;
-    const allParents = getAllAncestors(type);
-    const properties = (_a = getAllProperties(type, allParents)) !== null && _a !== void 0 ? _a : [];
+    const allParents = type.kind === "model" ? getAllAncestors(type) : [];
+    const properties = type.kind === "model" ? getAllProperties(type, allParents) : [];
     const props = [];
     for (const property of properties) {
         const dot = propertyPath.endsWith("?") ? "." : "";
-        const restValue = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}["${property.restApiName}"]`;
+        const serializedName = getPropertySerializedName(property);
+        const restValue = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}["${serializedName}"]`;
         const nullOrUndefinedPrefix = property.optional || isTypeNullable(property.type)
             ? `!${restValue}? ${restValue}: `
             : "";
-        const deserializeFunctionName = buildModelDeserializer(context, property.type.tcgcType, false, true);
+        const deserializeFunctionName = buildModelDeserializer(context, getNullableValidType(property.type), false, true);
+        const propertyName = normalizeModelPropertyName(context, property);
         if (deserializeFunctionName) {
-            props.push(`"${property.clientName}": ${nullOrUndefinedPrefix}${deserializeFunctionName}(${restValue})`);
+            props.push(`${propertyName}: ${nullOrUndefinedPrefix}${deserializeFunctionName}(${restValue})`);
         }
         else if (isAzureCoreErrorType(context.program, property.type.__raw)) {
-            props.push(`"${property.clientName}": ${nullOrUndefinedPrefix}${restValue}`);
+            props.push(`${propertyName}: ${nullOrUndefinedPrefix}${restValue}`);
         }
         else {
-            const deserializeValue = deserializeResponseValue(context, property.type, `${propertyPath}${dot}["${property.restApiName}"]`, property.format);
-            props.push(`"${property.clientName}": ${deserializeValue === `${propertyPath}${dot}["${property.restApiName}"]` ? "" : nullOrUndefinedPrefix}${deserializeValue}`);
+            const deserializeValue = deserializeResponseValue(context, property.type, `${propertyPath}${dot}["${serializedName}"]`, getEncodeForType(property.type));
+            props.push(`${propertyName}: ${deserializeValue === `${propertyPath}${dot}["${serializedName}"]` ? "" : nullOrUndefinedPrefix}${deserializeValue}`);
         }
     }
     return props;
@@ -648,56 +688,59 @@ export function getResponseMapping(context, type, propertyPath = "result.body")
  * deserialized correctly
  */
 export function serializeRequestValue(context, type, clientValue, required, format) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const getSdkType = useSdkTypes();
     const dependencies = useDependencies();
-    const nullOrUndefinedPrefix = isTypeNullable(type) || type.optional || !required
+    const nullOrUndefinedPrefix = isTypeNullable(type) || getOptionalForType(type) || !required
         ? `!${clientValue}? ${clientValue}: `
         : "";
-    switch (type.type) {
-        case "datetime":
-            switch ((_a = type.format) !== null && _a !== void 0 ? _a : format) {
+    switch (type.kind) {
+        case "utcDateTime":
+            switch ((_a = type.encode) !== null && _a !== void 0 ? _a : format) {
                 case "rfc7231":
-                case "headerDefault":
                     return `${nullOrUndefinedPrefix}${clientValue}.toUTCString()`;
                 case "unixTimestamp":
                     return `${nullOrUndefinedPrefix}((${clientValue}.getTime() / 1000) | 0)`;
                 case "rfc3339":
                 default:
-                    return `${getNullableCheck(clientValue, type)} ${clientValue}${required ? "" : "?"}.toISOString()`;
+                    return `${nullOrUndefinedPrefix}${clientValue}.toISOString()`;
             }
-        case "list": {
+        case "array": {
             const prefix = nullOrUndefinedPrefix + clientValue;
-            if (type.elementType) {
-                const elementNullOrUndefinedPrefix = isTypeNullable(type.elementType) || type.elementType.optional
+            if (type.valueType) {
+                const elementNullOrUndefinedPrefix = isTypeNullable(type.valueType) || getOptionalForType(type.valueType)
                     ? "!p ? p : "
                     : "";
-                const serializeFunctionName = buildModelSerializer(context, type.elementType.tcgcType, false, true);
+                const serializeFunctionName = buildModelSerializer(context, getNullableValidType(type.valueType), false, true);
                 if (serializeFunctionName) {
                     return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${serializeFunctionName}(p)})`;
                 }
-                else if (isAzureCoreErrorType(context.program, type.elementType.__raw)) {
+                else if (isAzureCoreErrorType(context.program, type.valueType.__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}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${serializeRequestValue(context, type.valueType, "p", true, getEncodeForType(type.valueType))}})`;
                 }
             }
             return clientValue;
         }
-        case "byte-array":
-            if (format !== "binary") {
+        case "bytes":
+            // TODO https://github.com/Azure/typespec-azure/issues/1999
+            if (format !== "binary" && format !== "bytes") {
                 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"}")`;
+                    ? `${getNullableCheck(clientValue, type)} ${uint8ArrayToStringReference}(${clientValue}, "${(_b = getEncodingFormat({ format })) !== null && _b !== void 0 ? _b : "base64"}")`
+                    : `${nullOrUndefinedPrefix} ${uint8ArrayToStringReference}(${clientValue}, "${(_c = getEncodingFormat({ format })) !== null && _c !== void 0 ? _c : "base64"}")`;
             }
             return clientValue;
-        case "combined":
+        case "union":
             if (isNormalUnion(type)) {
                 return `${clientValue}`;
             }
-            else if (isSpecialHandledUnion(type)) {
+            else if (isSpecialHandledUnion({
+                ...type,
+                isNonExhaustive: (_e = (_d = context.rlcOptions) === null || _d === void 0 ? void 0 : _d.experimentalExtensibleEnums) !== null && _e !== void 0 ? _e : false
+            })) {
                 const sdkType = getSdkType(type.__raw);
                 const serializerRefkey = refkey(sdkType, "serializer");
                 const serializeFunctionName = resolveReference(serializerRefkey);
@@ -706,6 +749,10 @@ export function serializeRequestValue(context, type, clientValue, required, form
             else {
                 return `${clientValue} as any`;
             }
+        case "model": // this is to build serialization logic for spread model types
+            return `{${getRequestModelMapping(context, type, "").propertiesStr.join(",")}}`;
+        case "nullable":
+            return serializeRequestValue(context, type.type, clientValue, false, getEncodeForType(type.type));
         default:
             if (clientValue === "constructorParam") {
                 return `${clientValue} as any`;
@@ -721,50 +768,50 @@ export function serializeRequestValue(context, type, clientValue, required, form
 export function deserializeResponseValue(context, type, restValue, format) {
     const dependencies = useDependencies();
     const stringToUint8ArrayReference = resolveReference(dependencies.stringToUint8Array);
-    const nullOrUndefinedPrefix = isTypeNullable(type) || type.optional
+    const nullOrUndefinedPrefix = isTypeNullable(type) || getOptionalForType(type)
         ? `!${restValue}? ${restValue}: `
         : "";
-    switch (type.type) {
-        case "datetime":
-            return `${nullOrUndefinedPrefix} new Date(${type.format === "unixTimestamp" ? `${restValue} * 1000` : restValue})`;
-        case "list": {
+    switch (type.kind) {
+        case "utcDateTime":
+            return `${nullOrUndefinedPrefix} new Date(${type.encode === "unixTimestamp" ? `${restValue} * 1000` : restValue})`;
+        case "array": {
             const prefix = nullOrUndefinedPrefix + restValue;
             let elementNullOrUndefinedPrefix = "";
-            if (type.elementType &&
-                (isTypeNullable(type.elementType) || type.elementType.optional)) {
+            if (type.valueType &&
+                (isTypeNullable(type.valueType) || getOptionalForType(type.valueType))) {
                 elementNullOrUndefinedPrefix = "!p ? p :";
             }
-            const deserializeFunctionName = type.elementType
-                ? buildModelDeserializer(context, type.elementType.tcgcType, false, true)
+            const deserializeFunctionName = type.valueType
+                ? buildModelDeserializer(context, getNullableValidType(type.valueType), false, true)
                 : undefined;
             if (deserializeFunctionName) {
                 return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${deserializeFunctionName}(p)})`;
             }
-            else if (type.elementType &&
-                isAzureCoreErrorType(context.program, type.elementType.__raw)) {
+            else if (type.valueType &&
+                isAzureCoreErrorType(context.program, type.valueType.__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 if (type.valueType) {
+                return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${deserializeResponseValue(context, type.valueType, "p", getEncodeForType(type.valueType))}})`;
             }
             else {
                 return restValue;
             }
         }
-        case "byte-array":
-            if (format !== "binary") {
+        case "bytes":
+            if (format !== "binary" && format !== "bytes") {
                 return `typeof ${restValue} === 'string'
         ? ${stringToUint8ArrayReference}(${restValue}, "${format !== null && format !== void 0 ? format : "base64"}")
         : ${restValue}`;
             }
             return restValue;
-        case "combined":
+        case "union":
             if (isNormalUnion(type)) {
                 return `${restValue}`;
             }
             else if (isSpecialHandledUnion(type)) {
                 const deserializeFunctionName = type
-                    ? buildModelDeserializer(context, type.tcgcType, false, true)
+                    ? buildModelDeserializer(context, getNullableValidType(type), false, true)
                     : undefined;
                 if (deserializeFunctionName) {
                     return `${deserializeFunctionName}(${restValue})`;
@@ -776,32 +823,22 @@ export function deserializeResponseValue(context, type, restValue, format) {
             else {
                 return `${restValue} as any`;
             }
+        case "model": // generate deserialize logic for spread model types
+            return `{${getResponseMapping(context, type, "").join(",")}}`;
+        case "nullable":
+            return deserializeResponseValue(context, type.type, restValue, getEncodeForType(type.type));
         default:
             return restValue;
     }
 }
 export function isLroAndPagingOperation(op) {
-    return op.discriminator === "lropaging";
+    return op.kind === "lropaging";
 }
 export function isLroOnlyOperation(op) {
-    return op.discriminator === "lro";
-}
-export function hasPagingOnlyOperation(clientOrCodeModel, needRLC = false) {
-    let clients = [];
-    if (clientOrCodeModel === null || clientOrCodeModel === void 0 ? void 0 : clientOrCodeModel.operationGroups) {
-        clients = [clientOrCodeModel];
-    }
-    else if (clientOrCodeModel === null || clientOrCodeModel === void 0 ? void 0 : clientOrCodeModel.clients) {
-        clients = clientOrCodeModel.clients;
-    }
-    return clients.some((c) => {
-        var _a;
-        return (needRLC ? c.rlcHelperDetails.hasPaging : false) ||
-            ((_a = c.operationGroups) !== null && _a !== void 0 ? _a : []).some((og) => { var _a; return ((_a = og.operations) !== null && _a !== void 0 ? _a : []).some(isPagingOnlyOperation); });
-    });
+    return op.kind === "lro";
 }
 export function isPagingOnlyOperation(op) {
-    return op.discriminator === "paging";
+    return op.kind === "paging";
 }
 export function getAllProperties(type, parents) {
     var _a;
@@ -811,34 +848,42 @@ export function getAllProperties(type, parents) {
     }
     parents === null || parents === void 0 ? void 0 : parents.forEach((p) => {
         getAllProperties(p).forEach((prop) => {
-            propertiesMap.set(prop.clientName, prop);
+            propertiesMap.set(prop.name, prop);
         });
     });
-    (_a = type.properties) === null || _a === void 0 ? void 0 : _a.forEach((p) => {
-        propertiesMap.set(p.clientName, p);
-    });
+    type.kind === "model" &&
+        ((_a = type.properties) === null || _a === void 0 ? void 0 : _a.filter((p) => {
+            return p.kind === "property";
+        }).forEach((p) => {
+            propertiesMap.set(p.name, p);
+        }));
     return [...propertiesMap.values()];
 }
 export function getAllAncestors(type) {
-    var _a;
     const ancestors = [];
-    (_a = type === null || type === void 0 ? void 0 : type.parents) === null || _a === void 0 ? void 0 : _a.forEach((p) => {
-        ancestors.push(p);
-        ancestors.push(...getAllAncestors(p));
-    });
+    if (type.kind === "model" && type.baseModel) {
+        ancestors.push(type.baseModel);
+        ancestors.push(...getAllAncestors(type.baseModel));
+    }
     return ancestors;
 }
-export function getPropertySerializationPrefix(modularType, propertyPath) {
-    const propertyFullName = getPropertyFullName(modularType, propertyPath);
-    if (modularType.optional || isTypeNullable(modularType.type)) {
-        return `!${propertyFullName} ? ${propertyFullName} :`;
+export function getPropertySerializationPrefix(context, property, propertyPath) {
+    const propertyFullName = getPropertyFullName(context, property, propertyPath);
+    if (property.optional || isTypeNullable(property.type)) {
+        return `!${propertyFullName}? ${propertyFullName}:`;
     }
     return "";
 }
-export function getPropertyFullName(modularType, propertyPath) {
-    let fullName = `${modularType.clientName}`;
-    if (propertyPath) {
-        fullName = `${propertyPath}["${modularType.clientName}"]`;
+export function getPropertyFullName(context, property, propertyPath) {
+    const normalizedPropertyName = normalizeModelPropertyName(context, property)
+        .replace(/^"/g, "")
+        .replace(/"$/g, "");
+    let fullName = normalizedPropertyName;
+    if (propertyPath === "" && property.optional) {
+        fullName = `options?.${normalizedPropertyName}`;
+    }
+    else if (propertyPath) {
+        fullName = `${propertyPath}["${normalizedPropertyName}"]`;
     }
     return fullName;
 }
@@ -847,10 +892,10 @@ export function getPropertyFullName(modularType, propertyPath) {
  * @param operation The operation
  */
 export function getExpectedStatuses(operation) {
-    const statusCodes = operation.responses.flatMap((x) => x.statusCodes.filter((s) => s !== "default"));
+    const statusCodes = operation.operation.responses.map((x) => x.statusCodes);
     // LROs may call the same path but with GET to get the operation status.
     if (isLroOnlyOperation(operation) &&
-        operation.method !== "GET" &&
+        operation.operation.verb !== "get" &&
         !statusCodes.includes(200)) {
         statusCodes.push(200);
     }