@azure-tools/typespec-java 0.19.3 → 0.20.1

package/dist/src/code-model-builder.js

@@ -1,11 +1,10 @@
 import { AnySchema, ApiVersion, ArraySchema, BinaryResponse, BinarySchema, BooleanSchema, ByteArraySchema, ChoiceValue, DateSchema, DateTimeSchema, DictionarySchema, Discriminator, GroupProperty, GroupSchema, HttpHeader, HttpParameter, ImplementationLocation, KeySecurityScheme, Language, Metadata, NumberSchema, OAuth2SecurityScheme, ObjectSchema, OperationGroup, Parameter, ParameterLocation, Property, Relations, Response, SchemaResponse, SchemaType, Security, SerializationStyle, StringSchema, TimeSchema, UnixTimeSchema, UriSchema, VirtualParameter, } from "@autorest/codemodel";
 import { KnownMediaType } from "@azure-tools/codegen";
-import { getLroMetadata, getPagedResult, isPollingLocation } from "@azure-tools/typespec-azure-core";
-import { createSdkContext, getAllModels, getClientNameOverride, getClientType, getCrossLanguageDefinitionId, getDefaultApiVersion, getHttpOperationWithCache, getWireName, isApiVersion, isSdkBuiltInKind, isSdkIntKind, listClients, listOperationGroups, listOperationsInOperationGroup, shouldGenerateConvenient, shouldGenerateProtocol, getHttpOperationExamples, } from "@azure-tools/typespec-client-generator-core";
-import { getDoc, getEffectiveModelType, getEncode, getFriendlyName, getNamespaceFullName, getOverloadedOperation, getProjectedName, getSummary, getVisibility, isArrayModelType, isErrorModel, isRecordModelType, isVoidType, listServices, } from "@typespec/compiler";
-import { Visibility, getAuthentication, getHeaderFieldName, getPathParamName, getQueryParamName, getServers, getStatusCodeDescription, isBody, isBodyRoot, isHeader, isMultipartBodyProperty, isPathParam, isQueryParam, } from "@typespec/http";
-import { getResourceOperation, getSegment } from "@typespec/rest";
-import { getAddedOnVersions, getVersion } from "@typespec/versioning";
+import { createSdkContext, getAllModels, getClientType, getWireName, isApiVersion, isSdkBuiltInKind, isSdkIntKind, } from "@azure-tools/typespec-client-generator-core";
+import { getDoc, getEffectiveModelType, getNamespaceFullName, getOverloadedOperation, getSummary, getVisibility, isArrayModelType, isRecordModelType, listServices, } from "@typespec/compiler";
+import { Visibility, getAuthentication, getHeaderFieldName, getPathParamName, getQueryParamName, isHeader, isPathParam, isQueryParam, } from "@typespec/http";
+import { getSegment } from "@typespec/rest";
+import { getAddedOnVersions } from "@typespec/versioning";
 import { fail } from "assert";
 import pkg from "lodash";
 import { Client as CodeModelClient } from "./common/client.js";
@@ -19,10 +18,10 @@ import { DurationSchema } from "./common/schemas/time.js";
 import { SchemaContext } from "./common/schemas/usage.js";
 import { createPollOperationDetailsSchema, getFileDetailsSchema } from "./external-schemas.js";
 import { ClientContext } from "./models.js";
-import { ORIGIN_API_VERSION, SPECIAL_HEADER_NAMES, cloneOperationParameter, getServiceVersion, isKnownContentType, isLroNewPollingStrategy, isPayloadProperty, operationIsJsonMergePatch, operationIsMultipart, operationIsMultipleContentTypes, } from "./operation-utils.js";
+import { CONTENT_TYPE_KEY, ORIGIN_API_VERSION, SPECIAL_HEADER_NAMES, cloneOperationParameter, getServiceVersion, isKnownContentType, isLroNewPollingStrategy, isPayloadProperty, operationIsJsonMergePatch, operationIsMultipart, operationIsMultipleContentTypes, } from "./operation-utils.js";
 import { PreNamer } from "./prenamer/prenamer.js";
-import { ProcessingCache, getAccess, getDurationFormatFromSdkType, getNonNullSdkType, getUnionDescription, getUsage, hasScalarAsBase, isArmCommonType, isModelReferredInTemplate, isNullableType, isStable, modelIs, pushDistinct, } from "./type-utils.js";
-import { getNamespace, logWarning, pascalCase, stringArrayContainsIgnoreCase, trace } from "./utils.js";
+import { ProcessingCache, getAccess, getDurationFormatFromSdkType, getNonNullSdkType, getUnionDescription, getUsage, isStable, modelIs, pushDistinct, } from "./type-utils.js";
+import { getNamespace, logWarning, pascalCase, removeClientSuffix, stringArrayContainsIgnoreCase, trace, } from "./utils.js";
 const { isEqual } = pkg;
 export class CodeModelBuilder {
     constructor(program1, context) {
@@ -77,7 +76,9 @@ export class CodeModelBuilder {
         });
     }
     async build() {
-        this.sdkContext = await createSdkContext(this.emitterContext, "@azure-tools/typespec-java");
+        this.sdkContext = await createSdkContext(this.emitterContext, "@azure-tools/typespec-java", {
+            versioning: { previewStringRegex: /$/ },
+        }); // include all versions and do the filter by ourselves
         // auth
         // TODO: it is not very likely, but different client could have different auth
         const auth = getAuthentication(this.program, this.serviceNamespace);
@@ -89,8 +90,8 @@ export class CodeModelBuilder {
             this.codeModel.arm = true;
             this.options["group-etag-headers"] = false;
         }
-        const clients = this.processClients();
-        this.processModels(clients);
+        this.processClients();
+        this.processModels();
         this.processSchemaUsage();
         if (this.options.namer) {
             this.codeModel = new PreNamer(this.codeModel).init().process();
@@ -98,64 +99,41 @@ export class CodeModelBuilder {
         this.deduplicateSchemaName();
         return this.codeModel;
     }
-    processHost(server) {
+    processHostParameters(sdkPathParameters) {
         const hostParameters = [];
-        if (server && !this.isArmSynthesizedServer(server)) {
-            server.parameters.forEach((it) => {
-                let parameter;
-                if (isApiVersion(this.sdkContext, it)) {
-                    parameter = this.createApiVersionParameter(it.name, ParameterLocation.Uri);
-                }
-                else {
-                    const sdkType = getClientType(this.sdkContext, it.type);
-                    const schema = this.processSchemaFromSdkType(sdkType, it.name);
-                    this.trackSchemaUsage(schema, {
-                        usage: [SchemaContext.Input, SchemaContext.Output /*SchemaContext.Public*/],
-                    });
-                    parameter = new Parameter(this.getName(it), this.getDoc(it), schema, {
-                        implementation: ImplementationLocation.Client,
-                        origin: "modelerfour:synthesized/host",
-                        required: !it.optional,
-                        protocol: {
-                            http: new HttpParameter(ParameterLocation.Uri),
-                        },
-                        language: {
-                            default: {
-                                serializedName: it.name,
-                            },
-                        },
-                        extensions: {
-                            // TODO: deprecate this logic of string/url for x-ms-skip-url-encoding
-                            "x-ms-skip-url-encoding": schema instanceof UriSchema,
+        let parameter;
+        sdkPathParameters.forEach((arg) => {
+            var _a;
+            if (arg.isApiVersionParam) {
+                parameter = this.createApiVersionParameter(arg.name, ParameterLocation.Uri);
+            }
+            else {
+                const schema = this.processSchemaFromSdkType(arg.type, arg.name);
+                this.trackSchemaUsage(schema, {
+                    usage: [SchemaContext.Input, SchemaContext.Output /*SchemaContext.Public*/],
+                });
+                parameter = new Parameter(arg.name, (_a = arg.description) !== null && _a !== void 0 ? _a : "", schema, {
+                    implementation: ImplementationLocation.Client,
+                    origin: "modelerfour:synthesized/host",
+                    required: true,
+                    protocol: {
+                        http: new HttpParameter(ParameterLocation.Uri),
+                    },
+                    language: {
+                        default: {
+                            serializedName: arg.name,
                         },
-                        // // make the logic same as TCGC, which takes the server-side default of host as client-side default
-                        // clientDefaultValue: getDefaultValue(it.defaultValue),
-                    });
-                }
-                hostParameters.push(this.codeModel.addGlobalParameter(parameter));
-            });
-            return hostParameters;
-        }
-        else {
-            // use "endpoint"
-            hostParameters.push(this.codeModel.addGlobalParameter(new Parameter("endpoint", "Server parameter", this.stringSchema, {
-                implementation: ImplementationLocation.Client,
-                origin: "modelerfour:synthesized/host",
-                required: true,
-                protocol: {
-                    http: new HttpParameter(ParameterLocation.Uri),
-                },
-                language: {
-                    default: {
-                        serializedName: "endpoint",
                     },
-                },
-                extensions: {
-                    "x-ms-skip-url-encoding": true,
-                },
-            })));
-            return hostParameters;
-        }
+                    // TODO: deprecate this logic of string/url for x-ms-skip-url-encoding
+                    extensions: {
+                        "x-ms-skip-url-encoding": schema instanceof UriSchema,
+                    },
+                    clientDefaultValue: arg.clientDefaultValue,
+                });
+            }
+            hostParameters.push(this.codeModel.addGlobalParameter(parameter));
+        });
+        return hostParameters;
     }
     processAuth(auth) {
         const securitySchemes = [];
@@ -210,16 +188,7 @@ export class CodeModelBuilder {
     isBranded() {
         return !this.options["flavor"] || this.options["flavor"].toLocaleLowerCase() === "azure";
     }
-    isInternal(operation) {
-        const access = getAccess(operation);
-        if (access) {
-            return access === "internal";
-        }
-        else {
-            return false;
-        }
-    }
-    processModels(clients) {
+    processModels() {
         const processedSdkModels = new Set();
         // lambda to mark model as public
         const modelAsPublic = (model) => {
@@ -305,33 +274,37 @@ export class CodeModelBuilder {
                     schemaUsage.splice(index, 1);
                 }
             }
-            // Internal on Anonymous
-            if (schemaUsage === null || schemaUsage === void 0 ? void 0 : schemaUsage.includes(SchemaContext.Anonymous)) {
-                const index = schemaUsage.indexOf(SchemaContext.Internal);
-                if (index < 0) {
-                    schemaUsage.push(SchemaContext.Internal);
+            // Internal on PublicSpread, but Public takes precedence
+            if (schemaUsage === null || schemaUsage === void 0 ? void 0 : schemaUsage.includes(SchemaContext.PublicSpread)) {
+                // remove PublicSpread as it now served its purpose
+                schemaUsage.splice(schemaUsage.indexOf(SchemaContext.PublicSpread), 1);
+                // Public would override PublicSpread, hence do nothing if this schema is Public
+                if (!(schemaUsage === null || schemaUsage === void 0 ? void 0 : schemaUsage.includes(SchemaContext.Public))) {
+                    // set the model as Internal, so that it is not exposed to user
+                    if (!schemaUsage.includes(SchemaContext.Internal)) {
+                        schemaUsage.push(SchemaContext.Internal);
+                    }
                 }
             }
         }
     }
     processClients() {
-        var _a, _b;
-        const clients = listClients(this.sdkContext);
+        var _a, _b, _c;
         // preprocess group-etag-headers
         this.options["group-etag-headers"] = (_a = this.options["group-etag-headers"]) !== null && _a !== void 0 ? _a : true;
-        for (const client of clients) {
+        const sdkPackage = this.sdkContext.sdkPackage;
+        for (const client of sdkPackage.clients) {
             let clientName = client.name;
-            let clientSubNamespace = undefined;
             let javaNamespace = this.getJavaNamespace(this.namespace);
             const clientFullName = client.name;
             const clientNameSegments = clientFullName.split(".");
             if (clientNameSegments.length > 1) {
                 clientName = clientNameSegments.at(-1);
-                clientSubNamespace = clientNameSegments.slice(0, -1).join(".");
+                const clientSubNamespace = clientNameSegments.slice(0, -1).join(".");
                 javaNamespace = this.getJavaNamespace(this.namespace + "." + clientSubNamespace);
             }
-            const codeModelClient = new CodeModelClient(clientName, this.getDoc(client.type), {
-                summary: this.getSummary(client.type),
+            const codeModelClient = new CodeModelClient(clientName, (_b = client.details) !== null && _b !== void 0 ? _b : "", {
+                summary: client.description,
                 language: {
                     default: {
                         namespace: this.namespace,
@@ -345,111 +318,144 @@ export class CodeModelBuilder {
             });
             codeModelClient.crossLanguageDefinitionId = client.crossLanguageDefinitionId;
             // versioning
-            const versioning = getVersion(this.program, client.service);
-            if (versioning && versioning.getVersions()) {
-                // @versioned in versioning
+            const versions = client.apiVersions;
+            if (versions && versions.length > 0) {
                 if (!this.sdkContext.apiVersion || ["all", "latest"].includes(this.sdkContext.apiVersion)) {
-                    this.apiVersion = getDefaultApiVersion(this.sdkContext, client.service);
+                    this.apiVersion = versions[versions.length - 1];
                 }
                 else {
-                    this.apiVersion = versioning.getVersions().find((it) => it.value === this.sdkContext.apiVersion);
+                    this.apiVersion = versions.find((it) => it === this.sdkContext.apiVersion);
                     if (!this.apiVersion) {
                         throw new Error("Unrecognized api-version: " + this.sdkContext.apiVersion);
                     }
                 }
                 codeModelClient.apiVersions = [];
-                for (const version of this.getFilteredApiVersions(this.apiVersion, versioning.getVersions(), this.options["service-version-exclude-preview"])) {
+                for (const version of this.getFilteredApiVersions(this.apiVersion, versions, this.options["service-version-exclude-preview"])) {
                     const apiVersion = new ApiVersion();
-                    apiVersion.version = version.value;
+                    apiVersion.version = version;
                     codeModelClient.apiVersions.push(apiVersion);
                 }
             }
-            // server
+            // client initialization
             let baseUri = "{endpoint}";
-            const servers = getServers(this.program, client.service);
-            if (servers && servers.length === 1 && !this.isArmSynthesizedServer(servers[0])) {
-                baseUri = servers[0].url;
-            }
-            const hostParameters = this.processHost((servers === null || servers === void 0 ? void 0 : servers.length) === 1 ? servers[0] : undefined);
-            codeModelClient.addGlobalParameters(hostParameters);
+            let hostParameters = [];
+            client.initialization.properties.forEach((initializationProperty) => {
+                if (initializationProperty.kind === "endpoint") {
+                    let sdkPathParameters = [];
+                    if (initializationProperty.type.kind === "union") {
+                        if (initializationProperty.type.values.length === 2) {
+                            // only get the sdkPathParameters from the endpoint whose serverUrl is not {"endpoint"}
+                            for (const endpointType of initializationProperty.type.values) {
+                                if (endpointType.kind === "endpoint" && endpointType.serverUrl !== "{endpoint}") {
+                                    sdkPathParameters = endpointType.templateArguments;
+                                    baseUri = endpointType.serverUrl;
+                                }
+                            }
+                        }
+                        else if (initializationProperty.type.values.length > 2) {
+                            throw new Error("Multiple server url defined for one client is not supported yet.");
+                        }
+                    }
+                    else if (initializationProperty.type.kind === "endpoint") {
+                        sdkPathParameters = initializationProperty.type.templateArguments;
+                        baseUri = initializationProperty.type.serverUrl;
+                    }
+                    hostParameters = this.processHostParameters(sdkPathParameters);
+                    codeModelClient.addGlobalParameters(hostParameters);
+                }
+            });
             const clientContext = new ClientContext(baseUri, hostParameters, codeModelClient.globalParameters, codeModelClient.apiVersions);
-            clientContext.preProcessOperations(this.sdkContext, client);
-            const operationGroups = listOperationGroups(this.sdkContext, client, true);
-            const operationWithoutGroup = listOperationsInOperationGroup(this.sdkContext, client);
+            // preprocess operation groups and operations
+            // operations without operation group
+            const serviceMethodsWithoutSubClient = this.listServiceMethodsUnderClient(client);
             let codeModelGroup = new OperationGroup("");
-            for (const operation of operationWithoutGroup) {
-                if (!this.needToSkipProcessingOperation(operation, clientContext)) {
-                    codeModelGroup.addOperation(this.processOperation("", operation, clientContext));
+            for (const serviceMethod of serviceMethodsWithoutSubClient) {
+                if (!this.needToSkipProcessingOperation(serviceMethod.__raw, clientContext)) {
+                    codeModelGroup.addOperation(this.processOperation(serviceMethod, clientContext, ""));
                 }
             }
-            if (((_b = codeModelGroup.operations) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+            if (((_c = codeModelGroup.operations) === null || _c === void 0 ? void 0 : _c.length) > 0) {
                 codeModelClient.operationGroups.push(codeModelGroup);
             }
-            for (const operationGroup of operationGroups) {
-                const operations = listOperationsInOperationGroup(this.sdkContext, operationGroup);
+            // operations under operation groups
+            const subClients = this.listSubClientsUnderClient(client, true, true);
+            for (const subClient of subClients) {
+                const serviceMethods = this.listServiceMethodsUnderClient(subClient);
                 // operation group with no operation is skipped
-                if (operations.length > 0) {
-                    // groupPath would be in format of "[<SubNamespace>.]<ClientName>.Chat.Completions"
-                    let operationGroupPath = operationGroup.groupPath;
-                    if (clientSubNamespace && operationGroup.groupPath.startsWith(clientSubNamespace + ".")) {
-                        // remove SubNamespace
-                        operationGroupPath = operationGroupPath.slice((clientSubNamespace + ".").length);
-                    }
-                    const groupPath = operationGroupPath.split(".");
-                    let operationGroupName;
-                    if (groupPath.length > 1) {
-                        // remove ClientName
-                        operationGroupName = groupPath.slice(1).join("");
-                    }
-                    else {
-                        operationGroupName = groupPath[0];
-                    }
-                    codeModelGroup = new OperationGroup(operationGroupName);
-                    for (const operation of operations) {
-                        if (!this.needToSkipProcessingOperation(operation, clientContext)) {
-                            codeModelGroup.addOperation(this.processOperation(operationGroupName, operation, clientContext));
+                if (serviceMethods.length > 0) {
+                    codeModelGroup = new OperationGroup(subClient.name);
+                    for (const serviceMethod of serviceMethods) {
+                        if (!this.needToSkipProcessingOperation(serviceMethod.__raw, clientContext)) {
+                            codeModelGroup.addOperation(this.processOperation(serviceMethod, clientContext, subClient.name));
                         }
                     }
                     codeModelClient.operationGroups.push(codeModelGroup);
                 }
             }
             this.codeModel.clients.push(codeModelClient);
-        }
-        // postprocess for ServiceVersion
-        let apiVersionSameForAllClients = true;
-        let sharedApiVersions = undefined;
-        for (const client of this.codeModel.clients) {
-            const apiVersions = client.apiVersions;
-            if (!apiVersions) {
-                // client does not have apiVersions
-                apiVersionSameForAllClients = false;
+            // postprocess for ServiceVersion
+            let apiVersionSameForAllClients = true;
+            let sharedApiVersions = undefined;
+            for (const client of this.codeModel.clients) {
+                const apiVersions = client.apiVersions;
+                if (!apiVersions) {
+                    // client does not have apiVersions
+                    apiVersionSameForAllClients = false;
+                }
+                else if (!sharedApiVersions) {
+                    // first client, set it to sharedApiVersions
+                    sharedApiVersions = apiVersions;
+                }
+                else {
+                    apiVersionSameForAllClients = isEqual(sharedApiVersions, apiVersions);
+                }
+                if (!apiVersionSameForAllClients) {
+                    break;
+                }
             }
-            else if (!sharedApiVersions) {
-                // first client, set it to sharedApiVersions
-                sharedApiVersions = apiVersions;
+            if (apiVersionSameForAllClients) {
+                const serviceVersion = getServiceVersion(this.codeModel);
+                for (const client of this.codeModel.clients) {
+                    client.serviceVersion = serviceVersion;
+                }
             }
             else {
-                apiVersionSameForAllClients = isEqual(sharedApiVersions, apiVersions);
-            }
-            if (!apiVersionSameForAllClients) {
-                break;
+                for (const client of this.codeModel.clients) {
+                    const apiVersions = client.apiVersions;
+                    if (apiVersions) {
+                        client.serviceVersion = getServiceVersion(client);
+                    }
+                }
             }
         }
-        if (apiVersionSameForAllClients) {
-            const serviceVersion = getServiceVersion(this.codeModel);
-            for (const client of this.codeModel.clients) {
-                client.serviceVersion = serviceVersion;
+    }
+    listSubClientsUnderClient(client, includeNestedOperationGroups, isRootClient) {
+        const operationGroups = [];
+        for (const method of client.methods) {
+            if (method.kind === "clientaccessor") {
+                const subClient = method.response;
+                if (!isRootClient) {
+                    // if it is not root client, append the parent client's name
+                    subClient.name = removeClientSuffix(client.name) + removeClientSuffix(pascalCase(subClient.name));
+                }
+                operationGroups.push(subClient);
+                if (includeNestedOperationGroups) {
+                    for (const operationGroup of this.listSubClientsUnderClient(subClient, includeNestedOperationGroups, false)) {
+                        operationGroups.push(operationGroup);
+                    }
+                }
             }
         }
-        else {
-            for (const client of this.codeModel.clients) {
-                const apiVersions = client.apiVersions;
-                if (apiVersions) {
-                    client.serviceVersion = getServiceVersion(client);
-                }
+        return operationGroups;
+    }
+    listServiceMethodsUnderClient(client) {
+        const methods = [];
+        for (const method of client.methods) {
+            if (method.kind !== "clientaccessor") {
+                methods.push(method);
             }
         }
-        return clients;
+        return methods;
     }
     /**
      * Filter api-versions for "ServiceVersion".
@@ -467,20 +473,12 @@ export class CodeModelBuilder {
             .slice(0, versions.indexOf(pinnedApiVersion) + 1)
             .filter((version) => !excludePreview || !isStable(pinnedApiVersion) || isStable(version));
     }
-    /**
-     * `@armProviderNamespace` currently will add a default server if not defined globally:
-     * https://github.com/Azure/typespec-azure/blob/8b8d7c05f168d9305a09691c4fedcb88f4a57652/packages/typespec-azure-resource-manager/src/namespace.ts#L121-L128
-     * TODO: if the synthesized server has the right hostParameter, we can use that instead
-     *
-     * @param server returned by getServers
-     * @returns whether it's synthesized by `@armProviderNamespace`
-     */
-    isArmSynthesizedServer(server) {
-        return this.isArm() && (!server.parameters || server.parameters.size == 0);
-    }
     needToSkipProcessingOperation(operation, clientContext) {
         // don't generate protocol and convenience method for overloaded operations
         // issue link: https://github.com/Azure/autorest.java/issues/1958#issuecomment-1562558219 we will support generate overload methods for non-union type in future (TODO issue: https://github.com/Azure/autorest.java/issues/2160)
+        if (operation === undefined) {
+            return true;
+        }
         if (getOverloadedOperation(this.program, operation)) {
             this.trace(`Operation '${operation.name}' is temporary skipped, as it is an overloaded operation`);
             return true;
@@ -493,9 +491,9 @@ export class CodeModelBuilder {
     supportsAdvancedVersioning() {
         return Boolean(this.options["advanced-versioning"]);
     }
-    getOperationExample(operation) {
+    getOperationExample(sdkMethod) {
         var _a, _b;
-        const httpOperationExamples = getHttpOperationExamples(this.sdkContext, operation);
+        const httpOperationExamples = sdkMethod.operation.examples;
         if (httpOperationExamples && httpOperationExamples.length > 0) {
             const operationExamples = {};
             for (const example of httpOperationExamples) {
@@ -503,8 +501,7 @@ export class CodeModelBuilder {
                 // example.filePath is relative path from sdkContext.examplesDir
                 // this is not a URL format (file:// or https://)
                 operationExample["x-ms-original-file"] = example.filePath;
-                operationExamples[(_b = (_a = operationExample.title) !== null && _a !== void 0 ? _a : operationExample.operationId) !== null && _b !== void 0 ? _b : operation.operation.name] =
-                    operationExample;
+                operationExamples[(_b = (_a = operationExample.title) !== null && _a !== void 0 ? _a : operationExample.operationId) !== null && _b !== void 0 ? _b : sdkMethod.name] = operationExample;
             }
             return operationExamples;
         }
@@ -512,58 +509,47 @@ export class CodeModelBuilder {
             return undefined;
         }
     }
-    processOperation(groupName, operation, clientContext) {
+    processOperation(sdkMethod, clientContext, groupName) {
         var _a;
-        const op = getHttpOperationWithCache(this.sdkContext, operation);
+        const operationName = sdkMethod.name;
+        const httpOperation = sdkMethod.operation;
+        const operationId = groupName ? `${groupName}_${operationName}` : `${operationName}`;
         const operationGroup = this.codeModel.getOperationGroup(groupName);
-        const operationName = this.getName(operation);
-        const opId = groupName ? `${groupName}_${operationName}` : `${operationName}`;
-        const operationExamples = this.getOperationExample(op);
-        const codeModelOperation = new CodeModelOperation(operationName, this.getDoc(operation), {
-            operationId: opId,
-            summary: this.getSummary(operation),
+        const operationExamples = this.getOperationExample(sdkMethod);
+        const codeModelOperation = new CodeModelOperation(operationName, (_a = sdkMethod.details) !== null && _a !== void 0 ? _a : "", {
+            operationId: operationId,
+            summary: sdkMethod.description,
             extensions: {
                 "x-ms-examples": operationExamples,
             },
         });
-        codeModelOperation.crossLanguageDefinitionId = getCrossLanguageDefinitionId(this.sdkContext, operation);
-        codeModelOperation.internalApi = this.isInternal(operation);
-        const convenienceApiName = this.getConvenienceApiName(operation);
-        let generateConvenienceApi = Boolean(convenienceApiName);
-        let generateProtocolApi = shouldGenerateProtocol(this.sdkContext, operation);
+        codeModelOperation.crossLanguageDefinitionId = sdkMethod.crossLanguageDefintionId;
+        codeModelOperation.internalApi = sdkMethod.access === "internal";
+        const convenienceApiName = this.getConvenienceApiName(sdkMethod);
+        let generateConvenienceApi = sdkMethod.generateConvenient;
+        let generateProtocolApi = sdkMethod.generateProtocol;
         let apiComment = undefined;
         if (generateConvenienceApi) {
             // check if the convenience API need to be disabled for some special cases
-            if (operationIsMultipart(op)) {
+            if (operationIsMultipart(httpOperation)) {
                 // do not generate protocol method for multipart/form-data, as it be very hard for user to prepare the request body as BinaryData
                 generateProtocolApi = false;
-                apiComment = `Protocol API requires serialization of parts with content-disposition and data, as operation '${op.operation.name}' is 'multipart/form-data'`;
+                apiComment = `Protocol API requires serialization of parts with content-disposition and data, as operation '${operationName}' is 'multipart/form-data'`;
                 this.logWarning(apiComment);
             }
-            else if (operationIsMultipleContentTypes(op)) {
+            else if (operationIsMultipleContentTypes(httpOperation)) {
                 // and multiple content types
                 // issue link: https://github.com/Azure/autorest.java/issues/1958#issuecomment-1562558219
                 generateConvenienceApi = false;
-                apiComment = `Convenience API is not generated, as operation '${op.operation.name}' is multiple content-type`;
+                apiComment = `Convenience API is not generated, as operation '${operationName}' is multiple content-type`;
                 this.logWarning(apiComment);
             }
-            else if (operationIsJsonMergePatch(op) && this.options["stream-style-serialization"] === false) {
+            else if (operationIsJsonMergePatch(httpOperation) && this.options["stream-style-serialization"] === false) {
                 // do not generate convenient method for json merge patch operation if stream-style-serialization is not enabled
                 generateConvenienceApi = false;
-                apiComment = `Convenience API is not generated, as operation '${op.operation.name}' is 'application/merge-patch+json' and stream-style-serialization is not enabled`;
+                apiComment = `Convenience API is not generated, as operation '${operationName}' is 'application/merge-patch+json' and stream-style-serialization is not enabled`;
                 this.logWarning(apiComment);
             }
-            // else {
-            //   const union = operationRefersUnion(this.program, op, this.typeUnionRefCache);
-            //   if (union) {
-            //     // and Union
-            //     generateConvenienceApi = false;
-            //     apiComment = `Convenience API is not generated, as operation '${
-            //       op.operation.name
-            //     }' refers Union '${getUnionDescription(union, this.typeNameOptions)}'`;
-            //     this.logWarning(apiComment);
-            //   }
-            // }
         }
         if (generateConvenienceApi && convenienceApiName) {
             codeModelOperation.convenienceApi = new ConvenienceApi(convenienceApiName);
@@ -577,75 +563,76 @@ export class CodeModelBuilder {
         codeModelOperation.addRequest(new Request({
             protocol: {
                 http: {
-                    path: op.path,
-                    method: op.verb,
+                    path: httpOperation.path,
+                    method: httpOperation.verb,
                     uri: clientContext.baseUri,
                 },
             },
         }));
         // host
         clientContext.hostParameters.forEach((it) => codeModelOperation.addParameter(it));
-        // parameters
-        op.parameters.parameters.map((it) => this.processParameter(codeModelOperation, it, clientContext));
-        // "accept" header
-        this.addAcceptHeaderParameter(codeModelOperation, op.responses);
-        // body
-        if (op.parameters.body) {
-            if (op.parameters.body.property) {
-                if (!isVoidType(op.parameters.body.property.type)) {
-                    this.processParameterBody(codeModelOperation, op, op.parameters.body.property);
+        // path/query/header parameters
+        for (const param of httpOperation.parameters) {
+            // if it's paged operation with request body, skip content-type header added by TCGC, as next link call should not have content type header
+            if ((sdkMethod.kind === "paging" || sdkMethod.kind === "lropaging") &&
+                httpOperation.bodyParam &&
+                param.kind === "header") {
+                if (param.serializedName.toLocaleLowerCase() === CONTENT_TYPE_KEY) {
+                    continue;
                 }
             }
-            else if (op.parameters.body.type) {
-                let bodyType = op.parameters.body.type;
-                if (bodyType.kind === "Model") {
-                    // try use resource type as round-trip model
-                    const resourceType = (_a = getResourceOperation(this.program, operation)) === null || _a === void 0 ? void 0 : _a.resourceType;
-                    if (resourceType && op.responses && op.responses.length > 0) {
-                        const resp = op.responses[0];
-                        if (resp.responses && resp.responses.length > 0 && resp.responses[0].body) {
-                            const responseBody = resp.responses[0].body;
-                            const bodyTypeInResponse = this.findResponseBody(responseBody.type);
-                            // response body type is resource type, and request body type (if templated) contains resource type
-                            if (bodyTypeInResponse === resourceType && isModelReferredInTemplate(bodyType, resourceType)) {
-                                bodyType = resourceType;
-                            }
-                        }
-                    }
-                    this.processParameterBody(codeModelOperation, op, bodyType);
+            // if the request body is optional, skip content-type header added by TCGC
+            // TODO: add optional content type to code-model, and support optional content-type from codegen, https://github.com/Azure/autorest.java/issues/2930
+            if (httpOperation.bodyParam && httpOperation.bodyParam.optional) {
+                if (param.serializedName.toLocaleLowerCase() === CONTENT_TYPE_KEY) {
+                    continue;
                 }
             }
+            this.processParameter(codeModelOperation, param, clientContext);
+        }
+        // body
+        if (httpOperation.bodyParam && httpOperation.__raw && httpOperation.bodyParam.type.__raw) {
+            this.processParameterBody(codeModelOperation, httpOperation.__raw, httpOperation, httpOperation.bodyParam);
         }
         // group ETag header parameters, if exists
         if (this.options["group-etag-headers"]) {
-            this.processEtagHeaderParameters(codeModelOperation, op);
+            this.processEtagHeaderParameters(codeModelOperation, sdkMethod.operation);
         }
         // lro metadata
-        const lroMetadata = this.processLroMetadata(codeModelOperation, op);
+        let lroMetadata = new LongRunningMetadata(false);
+        if (sdkMethod.kind === "lro" || sdkMethod.kind === "lropaging") {
+            lroMetadata = this.processLroMetadata(codeModelOperation, sdkMethod);
+        }
         // responses
-        op.responses.map((it) => this.processResponse(codeModelOperation, it, lroMetadata.longRunning));
+        for (const [code, response] of sdkMethod.operation.responses) {
+            this.processResponse(codeModelOperation, code, response, lroMetadata.longRunning, false);
+        }
+        // exception
+        for (const [code, response] of sdkMethod.operation.exceptions) {
+            this.processResponse(codeModelOperation, code, response, lroMetadata.longRunning, true);
+        }
         // check for paged
-        this.processRouteForPaged(codeModelOperation, op.responses);
+        this.processRouteForPaged(codeModelOperation, sdkMethod.operation.responses, sdkMethod);
         // check for long-running operation
-        this.processRouteForLongRunning(codeModelOperation, operation, op.responses, lroMetadata);
+        this.processRouteForLongRunning(codeModelOperation, sdkMethod.operation.responses, lroMetadata);
         operationGroup.addOperation(codeModelOperation);
         return codeModelOperation;
     }
-    processRouteForPaged(op, responses) {
-        var _a, _b, _c, _d;
-        for (const response of responses) {
-            if (response.responses && response.responses.length > 0 && response.responses[0].body) {
-                const responseBody = response.responses[0].body;
-                const bodyType = this.findResponseBody(responseBody.type);
-                if (bodyType.kind === "Model") {
-                    const pagedResult = getPagedResult(this.program, bodyType);
-                    if (pagedResult) {
+    processRouteForPaged(op, responses, sdkMethod) {
+        var _a, _b;
+        if (sdkMethod.kind === "paging" || sdkMethod.kind === "lropaging") {
+            for (const [_, response] of responses) {
+                const bodyType = response.type;
+                if (bodyType && bodyType.kind === "model") {
+                    const itemName = sdkMethod.response.resultPath;
+                    const nextLinkName = sdkMethod.nextLinkPath;
+                    if (itemName && nextLinkName) {
                         op.extensions = (_a = op.extensions) !== null && _a !== void 0 ? _a : {};
                         op.extensions["x-ms-pageable"] = {
-                            itemName: (_b = pagedResult.itemsProperty) === null || _b === void 0 ? void 0 : _b.name,
-                            nextLinkName: (_c = pagedResult.nextLinkProperty) === null || _c === void 0 ? void 0 : _c.name,
+                            itemName: itemName,
+                            nextLinkName: nextLinkName,
                         };
-                        (_d = op.responses) === null || _d === void 0 ? void 0 : _d.forEach((r) => {
+                        (_b = op.responses) === null || _b === void 0 ? void 0 : _b.forEach((r) => {
                             if (r instanceof SchemaResponse) {
                                 this.trackSchemaUsage(r.schema, { usage: [SchemaContext.Paged] });
                             }
@@ -656,18 +643,17 @@ export class CodeModelBuilder {
             }
         }
     }
-    processLroMetadata(op, httpOperation) {
-        const operation = httpOperation.operation;
+    processLroMetadata(op, sdkMethod) {
         const trackConvenienceApi = Boolean(op.convenienceApi);
-        const lroMetadata = getLroMetadata(this.program, operation);
+        const lroMetadata = sdkMethod.__raw_lro_metadata;
         // needs lroMetadata.statusMonitorStep, as getLroMetadata would return for @pollingOperation operation
         if (lroMetadata && lroMetadata.pollingInfo && lroMetadata.statusMonitorStep) {
             let pollingSchema = undefined;
             let finalSchema = undefined;
             let pollingStrategy = undefined;
             let finalResultPropertySerializedName = undefined;
-            const verb = httpOperation.verb;
-            const useNewPollStrategy = isLroNewPollingStrategy(httpOperation, lroMetadata);
+            const verb = sdkMethod.operation.verb;
+            const useNewPollStrategy = isLroNewPollingStrategy(sdkMethod.operation.__raw, lroMetadata);
             if (useNewPollStrategy) {
                 // use OperationLocationPollingStrategy
                 pollingStrategy = new Metadata({
@@ -728,24 +714,13 @@ export class CodeModelBuilder {
         }
         return new LongRunningMetadata(false);
     }
-    processRouteForLongRunning(op, operation, responses, lroMetadata) {
-        var _a, _b;
+    processRouteForLongRunning(op, responses, lroMetadata) {
+        var _a;
         if (lroMetadata.longRunning) {
             op.extensions = (_a = op.extensions) !== null && _a !== void 0 ? _a : {};
             op.extensions["x-ms-long-running-operation"] = true;
             return;
         }
-        for (const resp of responses) {
-            if (resp.responses && resp.responses.length > 0 && resp.responses[0].headers) {
-                for (const [_, header] of Object.entries(resp.responses[0].headers)) {
-                    if (isPollingLocation(this.program, header)) {
-                        op.extensions = (_b = op.extensions) !== null && _b !== void 0 ? _b : {};
-                        op.extensions["x-ms-long-running-operation"] = true;
-                        break;
-                    }
-                }
-            }
-        }
     }
     processParameter(op, param, clientContext) {
         var _a, _b;
@@ -754,65 +729,52 @@ export class CodeModelBuilder {
             if (this.isArm()) {
                 // Currently we assume ARM tsp only have one client and one api-version.
                 // TODO: How will service define mixed api-versions(like those in Compute RP)?
-                const apiVersion = (_a = this.apiVersion) === null || _a === void 0 ? void 0 : _a.value;
+                const apiVersion = this.apiVersion;
                 if (!this._armApiVersionParameter) {
-                    this._armApiVersionParameter = this.createApiVersionParameter("api-version", param.type === "query" ? ParameterLocation.Query : ParameterLocation.Path, apiVersion);
+                    this._armApiVersionParameter = this.createApiVersionParameter("api-version", param.kind === "query" ? ParameterLocation.Query : ParameterLocation.Path, apiVersion);
                     clientContext.addGlobalParameter(this._armApiVersionParameter);
                 }
                 op.addParameter(this._armApiVersionParameter);
             }
             else {
-                const parameter = param.type === "query" ? this.apiVersionParameter : this.apiVersionParameterInPath;
+                const parameter = param.kind === "query" ? this.apiVersionParameter : this.apiVersionParameterInPath;
                 op.addParameter(parameter);
                 clientContext.addGlobalParameter(parameter);
             }
         }
-        else if (this.isSubscriptionId(param)) {
+        else if (param.kind === "path" && param.onClient && this.isSubscriptionId(param)) {
             const parameter = this.subscriptionIdParameter(param);
             op.addParameter(parameter);
             clientContext.addGlobalParameter(parameter);
         }
-        else if (SPECIAL_HEADER_NAMES.has(param.name.toLowerCase())) {
+        else if (param.kind === "header" && SPECIAL_HEADER_NAMES.has(param.serializedName.toLowerCase())) {
             // special headers
-            op.specialHeaders = (_b = op.specialHeaders) !== null && _b !== void 0 ? _b : [];
-            if (!stringArrayContainsIgnoreCase(op.specialHeaders, param.name)) {
-                op.specialHeaders.push(param.name);
+            op.specialHeaders = (_a = op.specialHeaders) !== null && _a !== void 0 ? _a : [];
+            if (!stringArrayContainsIgnoreCase(op.specialHeaders, param.serializedName)) {
+                op.specialHeaders.push(param.serializedName);
             }
         }
         else {
             // schema
-            let schema;
-            const sdkType = getNonNullSdkType(getClientType(this.sdkContext, param.param));
-            if (param.type === "header" &&
-                param.param.type.kind === "Scalar" &&
-                getEncode(this.program, param.param) === undefined &&
-                getEncode(this.program, param.param.type) === undefined &&
-                (hasScalarAsBase(param.param.type, "utcDateTime") || hasScalarAsBase(param.param.type, "offsetDateTime")) &&
-                (sdkType.kind === "utcDateTime" || sdkType.kind === "offsetDateTime")) {
-                // utcDateTime in header maps to rfc7231
-                schema = this.processDateTimeSchemaFromSdkType(sdkType, param.param.name, true);
-            }
-            else {
-                schema = this.processSchemaFromSdkType(sdkType, param.param.name);
-            }
+            const sdkType = getNonNullSdkType(param.type);
+            const schema = this.processSchemaFromSdkType(sdkType, param.name);
             let extensions = undefined;
-            // skip-url-encoding
-            if (param.type === "path") {
+            if (param.kind === "path") {
                 if (param.allowReserved) {
                     extensions = extensions !== null && extensions !== void 0 ? extensions : {};
                     extensions["x-ms-skip-url-encoding"] = true;
                 }
             }
             // TODO: deprecate this logic of string/url for x-ms-skip-url-encoding
-            if ((param.type === "query" || param.type === "path") &&
-                param.param.type.kind === "Scalar" &&
+            if ((param.kind === "query" || param.kind === "path") &&
+                isSdkBuiltInKind(sdkType.kind) &&
                 schema instanceof UriSchema) {
                 extensions = extensions !== null && extensions !== void 0 ? extensions : {};
                 extensions["x-ms-skip-url-encoding"] = true;
             }
-            if (this.supportsAdvancedVersioning()) {
+            if (this.supportsAdvancedVersioning() && param.__raw) {
                 // versioning
-                const addedOn = getAddedOnVersions(this.program, param.param);
+                const addedOn = getAddedOnVersions(this.program, param.__raw);
                 if (addedOn) {
                     extensions = extensions !== null && extensions !== void 0 ? extensions : {};
                     extensions["x-ms-versioning-added"] = clientContext.getAddedVersions(addedOn);
@@ -821,62 +783,59 @@ export class CodeModelBuilder {
             // format if array
             let style = undefined;
             let explode = undefined;
-            if (param.param.type.kind === "Model" && isArrayModelType(this.program, param.param.type)) {
-                if (param.type === "query") {
-                    // eslint-disable-next-line deprecation/deprecation
-                    const queryParamFormat = param === null || param === void 0 ? void 0 : param.format;
-                    if (queryParamFormat) {
-                        switch (queryParamFormat) {
-                            case "csv":
-                                style = SerializationStyle.Simple;
-                                break;
-                            case "ssv":
-                                style = SerializationStyle.SpaceDelimited;
-                                break;
-                            case "tsv":
-                                style = SerializationStyle.TabDelimited;
-                                break;
-                            case "pipes":
-                                style = SerializationStyle.PipeDelimited;
-                                break;
-                            case "multi":
-                                style = SerializationStyle.Form;
-                                explode = true;
-                                break;
-                            default:
-                                this.logWarning(`Unrecognized query parameter format: '${queryParamFormat}'.`);
-                                break;
-                        }
+            if (sdkType.kind === "array") {
+                if (param.kind === "query") {
+                    const format = param.collectionFormat;
+                    switch (format) {
+                        case "csv":
+                        case "simple":
+                            style = SerializationStyle.Simple;
+                            break;
+                        case "ssv":
+                            style = SerializationStyle.SpaceDelimited;
+                            break;
+                        case "tsv":
+                            style = SerializationStyle.TabDelimited;
+                            break;
+                        case "pipes":
+                            style = SerializationStyle.PipeDelimited;
+                            break;
+                        case "multi":
+                        case "form":
+                            style = SerializationStyle.Form;
+                            explode = true;
+                            break;
                     }
                 }
-                else if (param.type === "header") {
-                    if (param.format) {
-                        switch (param.format) {
-                            case "csv":
-                                style = SerializationStyle.Simple;
-                                break;
-                            default:
-                                this.logWarning(`Unrecognized header parameter format: '${param.format}'.`);
-                                break;
-                        }
+                else if (param.kind === "header") {
+                    const format = param.collectionFormat;
+                    switch (format) {
+                        case "csv":
+                            style = SerializationStyle.Simple;
+                            break;
+                        default:
+                            if (format) {
+                                this.logWarning(`Unrecognized header parameter format: '${format}'.`);
+                            }
+                            break;
                     }
                 }
             }
-            const nullable = isNullableType(param.param.type);
-            const parameter = new Parameter(this.getName(param.param), this.getDoc(param.param), schema, {
-                summary: this.getSummary(param.param),
+            const nullable = param.type.kind === "nullable";
+            const parameter = new Parameter(param.name, (_b = param.details) !== null && _b !== void 0 ? _b : "", schema, {
+                summary: param.description,
                 implementation: ImplementationLocation.Method,
-                required: !param.param.optional,
+                required: !param.optional,
                 nullable: nullable,
                 protocol: {
-                    http: new HttpParameter(param.type, {
+                    http: new HttpParameter(param.kind, {
                         style: style,
                         explode: explode,
                     }),
                 },
                 language: {
                     default: {
-                        serializedName: this.getSerializedName(param.param),
+                        serializedName: param.serializedName, // it uses param.name previously, but better to use param.serializedName directly
                     },
                 },
                 extensions: extensions,
@@ -888,43 +847,6 @@ export class CodeModelBuilder {
             }
         }
     }
-    addAcceptHeaderParameter(op, responses) {
-        var _a, _b, _c;
-        if ((_a = op.parameters) === null || _a === void 0 ? void 0 : _a.some((it) => { var _a; return ((_a = it.language.default.serializedName) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "accept"; })) {
-            // parameters already include "accept" header
-            return;
-        }
-        const produces = new Set();
-        for (const resp of responses) {
-            if (resp.responses && resp.responses.length > 0) {
-                for (const response of resp.responses) {
-                    (_b = response.body) === null || _b === void 0 ? void 0 : _b.contentTypes.forEach((it) => produces.add(it));
-                }
-            }
-        }
-        if (produces.size === 0) {
-            produces.add("application/json");
-        }
-        const acceptTypes = Array.from(produces.values()).join(", ");
-        const acceptSchema = ((_c = this.codeModel.schemas.constants) === null || _c === void 0 ? void 0 : _c.find((it) => it.language.default.name === "accept" && it.value.value === acceptTypes)) ||
-            this.codeModel.schemas.add(new ConstantSchema("accept", `Accept: ${acceptTypes}`, {
-                valueType: this.stringSchema,
-                value: new ConstantValue(acceptTypes),
-            }));
-        op.addParameter(new Parameter("accept", "Accept header", acceptSchema, {
-            implementation: ImplementationLocation.Method,
-            origin: "modelerfour:synthesized/accept",
-            required: true,
-            protocol: {
-                http: new HttpParameter(ParameterLocation.Header),
-            },
-            language: {
-                default: {
-                    serializedName: "accept",
-                },
-            },
-        }));
-    }
     processEtagHeaderParameters(op, httpOperation) {
         if (op.convenienceApi && op.parameters && op.signatureParameters) {
             const etagHeadersNames = new Set([
@@ -975,7 +897,7 @@ export class CodeModelBuilder {
                         request.signatureParameters.push(clonedParameter);
                     }
                 }
-                const namespace = getNamespace(httpOperation.operation);
+                const namespace = getNamespace(httpOperation.__raw.operation); // TODO: SdkHttpOperation does not have namespace
                 const schemaName = groupToRequestConditions ? "RequestConditions" : "MatchConditions";
                 const schemaDescription = groupToRequestConditions
                     ? "Specifies HTTP options for conditional requests based on modification time."
@@ -1026,274 +948,272 @@ export class CodeModelBuilder {
             }
         }
     }
-    processParameterBody(op, httpOperation, body) {
+    processParameterBody(op, rawHttpOperation, sdkHttpOperation, sdkBody) {
         var _a, _b, _c;
         // set contentTypes to mediaTypes
-        op.requests[0].protocol.http.mediaTypes = httpOperation.parameters.body.contentTypes;
-        const parameters = httpOperation.operation.parameters;
+        op.requests[0].protocol.http.mediaTypes = sdkBody.contentTypes;
         const unknownRequestBody = op.requests[0].protocol.http.mediaTypes &&
             op.requests[0].protocol.http.mediaTypes.length > 0 &&
             !isKnownContentType(op.requests[0].protocol.http.mediaTypes);
-        const sdkType = getClientType(this.sdkContext, body, httpOperation.operation);
+        const sdkType = sdkBody.type;
         let schema;
-        if (unknownRequestBody &&
-            body.kind === "ModelProperty" &&
-            body.type.kind === "Scalar" &&
-            body.type.name === "bytes") {
-            // handle binary request body
-            schema = this.processBinarySchema(body.type);
+        if (unknownRequestBody && sdkType.kind === "bytes") {
+            // if it's unknown request body, handle binary request body
+            schema = this.processBinarySchemaFromSdkType(sdkType);
         }
         else {
-            schema = this.processSchemaFromSdkType(sdkType, body.name);
-        }
-        // Explicit body parameter @body or @bodyRoot would result to body.kind === "ModelProperty"
-        // Implicit body parameter would result to body.kind === "Model"
-        // see https://typespec.io/docs/libraries/http/cheat-sheet#data-types
-        const bodyParameterFlatten = sdkType.kind === "model" && body.kind === "Model" && !this.isArm();
-        const parameterName = body.kind === "Model" ? (sdkType.kind === "model" ? sdkType.name : "") : this.getName(body);
-        const parameter = new Parameter(parameterName, this.getDoc(body), schema, {
-            summary: this.getSummary(body),
+            schema = this.processSchemaFromSdkType(getNonNullSdkType(sdkType), sdkBody.name);
+        }
+        const parameterName = sdkBody.name;
+        const parameter = new Parameter(parameterName, (_a = sdkBody.description) !== null && _a !== void 0 ? _a : "", schema, {
+            summary: sdkBody.details,
             implementation: ImplementationLocation.Method,
-            required: body.kind === "Model" || !body.optional,
+            required: !sdkBody.optional,
             protocol: {
                 http: new HttpParameter(ParameterLocation.Body),
             },
         });
         op.addParameter(parameter);
+        const jsonMergePatch = operationIsJsonMergePatch(sdkHttpOperation);
+        const schemaIsPublicBeforeProcess = schema instanceof ObjectSchema && ((_b = schema.usage) === null || _b === void 0 ? void 0 : _b.includes(SchemaContext.Public));
         this.trackSchemaUsage(schema, { usage: [SchemaContext.Input] });
         if (op.convenienceApi) {
             // model/schema does not need to be Public or Internal, if it is not to be used in convenience API
             this.trackSchemaUsage(schema, { usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public] });
         }
-        if (operationIsJsonMergePatch(httpOperation)) {
+        if (jsonMergePatch) {
             this.trackSchemaUsage(schema, { usage: [SchemaContext.JsonMergePatch] });
         }
-        if (op.convenienceApi && operationIsMultipart(httpOperation)) {
+        if (op.convenienceApi && operationIsMultipart(sdkHttpOperation)) {
             this.trackSchemaUsage(schema, { serializationFormats: [KnownMediaType.Multipart] });
         }
-        if (schema instanceof ObjectSchema && bodyParameterFlatten) {
-            // flatten body parameter
-            // name the schema for documentation
-            schema.language.default.name = pascalCase(op.language.default.name) + "Request";
-            if (!parameter.language.default.name) {
-                // name the parameter for documentation
-                parameter.language.default.name = "request";
-            }
-            if (operationIsJsonMergePatch(httpOperation)) {
-                // skip model flatten, if "application/merge-patch+json"
-                schema.language.default.name = pascalCase(op.language.default.name) + "PatchRequest";
-                return;
-            }
-            this.trackSchemaUsage(schema, { usage: [SchemaContext.Anonymous] });
-            if (op.convenienceApi && op.parameters) {
-                op.convenienceApi.requests = [];
-                const request = new Request({
-                    protocol: op.requests[0].protocol,
-                });
-                request.parameters = [];
-                op.convenienceApi.requests.push(request);
-                for (const [_, opParameter] of parameters.properties) {
-                    const serializedName = this.getSerializedName(opParameter);
-                    const paramLocation = this.getParameterLocation(opParameter);
-                    let existParameter;
-                    if (paramLocation === "BodyProperty") {
-                        // property of body, it won't match existing parameter (whose paramLocation be body, path, query, header)
-                        existParameter = undefined;
+        if (op.convenienceApi) {
+            // Explicit body parameter @body or @bodyRoot would result to the existance of rawHttpOperation.parameters.body.property
+            // Implicit body parameter would result to rawHttpOperation.parameters.body.property be undefined
+            // see https://typespec.io/docs/libraries/http/cheat-sheet#data-types
+            const bodyParameterFlatten = schema instanceof ObjectSchema &&
+                sdkType.kind === "model" &&
+                !((_c = rawHttpOperation.parameters.body) === null || _c === void 0 ? void 0 : _c.property) &&
+                !this.isArm();
+            if (schema instanceof ObjectSchema && bodyParameterFlatten) {
+                // flatten body parameter
+                const parameters = sdkHttpOperation.parameters;
+                const bodyParameter = sdkHttpOperation.bodyParam;
+                if (!parameter.language.default.name) {
+                    // name the parameter for documentation
+                    parameter.language.default.name = "request";
+                }
+                if (jsonMergePatch) {
+                    // skip model flatten, if "application/merge-patch+json"
+                    if (sdkType.isGeneratedName) {
+                        schema.language.default.name = pascalCase(op.language.default.name) + "PatchRequest";
                     }
-                    else {
-                        existParameter = op.parameters.find((it) => {
-                            var _a;
-                            const sameParamLocation = paramLocation === ((_a = it.protocol.http) === null || _a === void 0 ? void 0 : _a.in);
-                            const sameSerializedName = it.language.default.serializedName === serializedName;
-                            if (paramLocation === ParameterLocation.Body) {
-                                // body, same paramLocation, as there could only be 1 body in operation
-                                return sameParamLocation;
-                            }
-                            else {
-                                // path, query, header, require same serializedName and same paramLocation
-                                return sameParamLocation && sameSerializedName;
-                            }
-                        });
+                    return;
+                }
+                const schemaUsage = schema.usage;
+                if (!schemaIsPublicBeforeProcess && (schemaUsage === null || schemaUsage === void 0 ? void 0 : schemaUsage.includes(SchemaContext.Public))) {
+                    // Public added in this op, change it to PublicSpread
+                    // This means that if this op would originally add Public to this schema, it adds PublicSpread instead
+                    schemaUsage === null || schemaUsage === void 0 ? void 0 : schemaUsage.splice(schemaUsage === null || schemaUsage === void 0 ? void 0 : schemaUsage.indexOf(SchemaContext.Public), 1);
+                    this.trackSchemaUsage(schema, { usage: [SchemaContext.PublicSpread] });
+                }
+                if (op.convenienceApi && op.parameters) {
+                    op.convenienceApi.requests = [];
+                    const request = new Request({
+                        protocol: op.requests[0].protocol,
+                    });
+                    request.parameters = [];
+                    op.convenienceApi.requests.push(request);
+                    // header/query/path params
+                    for (const opParameter of parameters) {
+                        this.addParameterOrBodyPropertyToCodeModelRequest(opParameter, op, request, schema, parameter);
                     }
-                    if (existParameter) {
-                        // parameter
-                        if (existParameter.implementation === ImplementationLocation.Method &&
-                            ((_b = (_a = existParameter.origin) === null || _a === void 0 ? void 0 : _a.startsWith("modelerfour:synthesized/")) !== null && _b !== void 0 ? _b : true) &&
-                            !(existParameter.schema instanceof ConstantSchema)) {
-                            request.parameters.push(cloneOperationParameter(existParameter));
+                    // body param
+                    if (bodyParameter) {
+                        if (bodyParameter.type.kind === "model") {
+                            for (const bodyProperty of bodyParameter.type.properties) {
+                                if (bodyProperty.kind === "property") {
+                                    this.addParameterOrBodyPropertyToCodeModelRequest(bodyProperty, op, request, schema, parameter);
+                                }
+                            }
                         }
                     }
-                    else {
-                        // property from anonymous model
-                        const existBodyProperty = (_c = schema.properties) === null || _c === void 0 ? void 0 : _c.find((it) => it.serializedName === serializedName);
-                        if (existBodyProperty &&
-                            !existBodyProperty.readOnly &&
-                            !(existBodyProperty.schema instanceof ConstantSchema)) {
-                            request.parameters.push(new VirtualParameter(existBodyProperty.language.default.name, existBodyProperty.language.default.description, existBodyProperty.schema, {
-                                originalParameter: parameter,
-                                targetProperty: existBodyProperty,
-                                language: {
-                                    default: {
-                                        serializedName: existBodyProperty.serializedName,
-                                    },
+                    request.signatureParameters = request.parameters;
+                    if (request.signatureParameters.length > 6) {
+                        // create an option bag
+                        const name = op.language.default.name + "Options";
+                        const namespace = getNamespace(rawHttpOperation.operation);
+                        // option bag schema
+                        const optionBagSchema = this.codeModel.schemas.add(new GroupSchema(name, `Options for ${op.language.default.name} API`, {
+                            language: {
+                                default: {
+                                    namespace: namespace,
+                                },
+                                java: {
+                                    namespace: this.getJavaNamespace(namespace),
                                 },
-                                summary: existBodyProperty.summary,
-                                implementation: ImplementationLocation.Method,
-                                required: existBodyProperty.required,
-                                nullable: existBodyProperty.nullable,
-                            }));
-                        }
-                    }
-                }
-                request.signatureParameters = request.parameters;
-                if (request.signatureParameters.length > 6) {
-                    // create an option bag
-                    const name = op.language.default.name + "Options";
-                    const namespace = getNamespace(httpOperation.operation);
-                    // option bag schema
-                    const optionBagSchema = this.codeModel.schemas.add(new GroupSchema(name, `Options for ${op.language.default.name} API`, {
-                        language: {
-                            default: {
-                                namespace: namespace,
-                            },
-                            java: {
-                                namespace: this.getJavaNamespace(namespace),
                             },
-                        },
-                    }));
-                    request.parameters.forEach((it) => {
-                        optionBagSchema.add(new GroupProperty(it.language.default.name, it.language.default.description, it.schema, {
-                            originalParameter: [it],
-                            summary: it.summary,
-                            required: it.required,
-                            nullable: it.nullable,
-                            readOnly: false,
-                            serializedName: it.language.default.serializedName,
                         }));
-                    });
-                    this.trackSchemaUsage(optionBagSchema, { usage: [SchemaContext.Input] });
-                    if (op.convenienceApi) {
-                        this.trackSchemaUsage(optionBagSchema, {
-                            usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public],
+                        request.parameters.forEach((it) => {
+                            optionBagSchema.add(new GroupProperty(it.language.default.name, it.language.default.description, it.schema, {
+                                originalParameter: [it],
+                                summary: it.summary,
+                                required: it.required,
+                                nullable: it.nullable,
+                                readOnly: false,
+                                serializedName: it.language.default.serializedName,
+                            }));
+                        });
+                        this.trackSchemaUsage(optionBagSchema, { usage: [SchemaContext.Input] });
+                        if (op.convenienceApi) {
+                            this.trackSchemaUsage(optionBagSchema, {
+                                usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public],
+                            });
+                        }
+                        // option bag parameter
+                        const optionBagParameter = new Parameter("options", optionBagSchema.language.default.description, optionBagSchema, {
+                            implementation: ImplementationLocation.Method,
+                            required: true,
+                            nullable: false,
                         });
+                        request.signatureParameters = [optionBagParameter];
+                        request.parameters.forEach((it) => (it.groupedBy = optionBagParameter));
+                        request.parameters.push(optionBagParameter);
                     }
-                    // option bag parameter
-                    const optionBagParameter = new Parameter("options", optionBagSchema.language.default.description, optionBagSchema, {
-                        implementation: ImplementationLocation.Method,
-                        required: true,
-                        nullable: false,
-                    });
-                    request.signatureParameters = [optionBagParameter];
-                    request.parameters.forEach((it) => (it.groupedBy = optionBagParameter));
-                    request.parameters.push(optionBagParameter);
                 }
             }
         }
     }
+    addParameterOrBodyPropertyToCodeModelRequest(opParameter, op, request, schema, originalParameter) {
+        var _a, _b, _c, _d, _e;
+        const serializedName = opParameter.serializedName;
+        let existParameter;
+        if (opParameter.kind !== "property") {
+            // not body property
+            // header/query/path, same location and same serializedName
+            existParameter = (_a = op.parameters) === null || _a === void 0 ? void 0 : _a.find((it) => { var _a; return ((_a = it.protocol.http) === null || _a === void 0 ? void 0 : _a.in) === opParameter.kind && it.language.default.serializedName === serializedName; });
+        }
+        request.parameters = (_b = request.parameters) !== null && _b !== void 0 ? _b : [];
+        if (existParameter) {
+            // parameter
+            if (existParameter.implementation === ImplementationLocation.Method &&
+                ((_d = (_c = existParameter.origin) === null || _c === void 0 ? void 0 : _c.startsWith("modelerfour:synthesized/")) !== null && _d !== void 0 ? _d : true) &&
+                !(existParameter.schema instanceof ConstantSchema)) {
+                request.parameters.push(cloneOperationParameter(existParameter));
+            }
+        }
+        else {
+            // property from anonymous model
+            const existBodyProperty = (_e = schema.properties) === null || _e === void 0 ? void 0 : _e.find((it) => it.serializedName === serializedName);
+            if (existBodyProperty && !existBodyProperty.readOnly && !(existBodyProperty.schema instanceof ConstantSchema)) {
+                request.parameters.push(new VirtualParameter(existBodyProperty.language.default.name, existBodyProperty.language.default.description, existBodyProperty.schema, {
+                    originalParameter: originalParameter,
+                    targetProperty: existBodyProperty,
+                    language: {
+                        default: {
+                            serializedName: existBodyProperty.serializedName,
+                        },
+                    },
+                    summary: existBodyProperty.summary,
+                    implementation: ImplementationLocation.Method,
+                    required: existBodyProperty.required,
+                    nullable: existBodyProperty.nullable,
+                }));
+            }
+        }
+    }
     findResponseBody(bodyType) {
         // find a type that possibly without http metadata like @statusCode
         return this.getEffectiveSchemaType(bodyType);
     }
-    processResponse(op, resp, longRunning) {
+    processResponse(op, statusCode, sdkResponse, longRunning, isErrorResponse) {
+        var _a;
         // TODO: what to do if more than 1 response?
         // It happens when the response type is Union, on one status code.
-        let response;
+        // let response: Response;
         let headers = undefined;
-        if (resp.responses && resp.responses.length > 0) {
-            // headers
-            headers = [];
-            for (const response of resp.responses.values()) {
-                if (response.headers) {
-                    for (const [key, header] of Object.entries(response.headers)) {
-                        const sdkType = getClientType(this.sdkContext, header);
-                        const schema = this.processSchemaFromSdkType(sdkType, key);
-                        headers.push(new HttpHeader(key, schema, {
-                            language: {
-                                default: {
-                                    name: key,
-                                    description: this.getDoc(header),
-                                },
-                            },
-                        }));
-                    }
-                }
-            }
-        }
-        let responseBody = undefined;
-        let bodyType = undefined;
-        let trackConvenienceApi = Boolean(op.convenienceApi);
-        if (resp.responses && resp.responses.length > 0 && resp.responses[0].body) {
-            responseBody = resp.responses[0].body;
-        }
-        if (responseBody) {
-            const unknownResponseBody = responseBody.contentTypes.length > 0 && !isKnownContentType(responseBody.contentTypes);
-            bodyType = this.findResponseBody(responseBody.type);
-            if (unknownResponseBody && bodyType.kind === "Scalar" && bodyType.name === "bytes") {
-                // binary
-                response = new BinaryResponse({
-                    protocol: {
-                        http: {
-                            statusCodes: this.getStatusCodes(resp.statusCodes),
-                            headers: headers,
-                            mediaTypes: responseBody.contentTypes,
-                            knownMediaType: KnownMediaType.Binary,
-                        },
-                    },
+        // headers
+        headers = [];
+        if (sdkResponse.headers) {
+            for (const header of sdkResponse.headers) {
+                const schema = this.processSchemaFromSdkType(header.type, header.serializedName);
+                headers.push(new HttpHeader(header.serializedName, schema, {
                     language: {
                         default: {
-                            name: op.language.default.name + "Response",
-                            description: this.getResponseDescription(resp),
+                            name: header.serializedName,
+                            description: (_a = header.description) !== null && _a !== void 0 ? _a : header.details,
                         },
                     },
-                });
+                }));
             }
-            else {
-                // schema (usually JSON)
-                let schema = undefined;
-                if (longRunning) {
-                    // LRO uses the LroMetadata for poll/final result, not the response of activation request
-                    trackConvenienceApi = false;
-                }
-                if (!schema) {
-                    const sdkType = getClientType(this.sdkContext, bodyType);
-                    schema = this.processSchemaFromSdkType(sdkType, op.language.default.name + "Response");
-                }
-                response = new SchemaResponse(schema, {
-                    protocol: {
-                        http: {
-                            statusCodes: this.getStatusCodes(resp.statusCodes),
-                            headers: headers,
-                            mediaTypes: responseBody.contentTypes,
-                        },
+        }
+        const bodyType = sdkResponse.type;
+        let trackConvenienceApi = Boolean(op.convenienceApi);
+        const unknownResponseBody = sdkResponse.contentTypes && sdkResponse.contentTypes.length > 0 && !isKnownContentType(sdkResponse.contentTypes);
+        let response;
+        if (unknownResponseBody && bodyType && bodyType.kind === "bytes") {
+            // binary
+            response = new BinaryResponse({
+                protocol: {
+                    http: {
+                        statusCodes: this.getStatusCodes(statusCode),
+                        headers: headers,
+                        mediaTypes: sdkResponse.contentTypes,
+                        knownMediaType: KnownMediaType.Binary,
                     },
-                    language: {
-                        default: {
-                            name: op.language.default.name + "Response",
-                            description: this.getResponseDescription(resp),
-                        },
+                },
+                language: {
+                    default: {
+                        name: op.language.default.name + "Response",
+                        description: sdkResponse.description,
                     },
-                });
+                },
+            });
+        }
+        else if (bodyType) {
+            // schema (usually JSON)
+            let schema = undefined;
+            if (longRunning) {
+                // LRO uses the LroMetadata for poll/final result, not the response of activation request
+                trackConvenienceApi = false;
+            }
+            if (!schema) {
+                schema = this.processSchemaFromSdkType(bodyType, op.language.default.name + "Response");
             }
+            response = new SchemaResponse(schema, {
+                protocol: {
+                    http: {
+                        statusCodes: this.getStatusCodes(statusCode),
+                        headers: headers,
+                        mediaTypes: sdkResponse.contentTypes,
+                    },
+                },
+                language: {
+                    default: {
+                        name: op.language.default.name + "Response",
+                        description: sdkResponse.description,
+                    },
+                },
+            });
         }
         else {
             // not binary nor schema, usually NoContent
             response = new Response({
                 protocol: {
                     http: {
-                        statusCodes: this.getStatusCodes(resp.statusCodes),
+                        statusCodes: this.getStatusCodes(statusCode),
                         headers: headers,
                     },
                 },
                 language: {
                     default: {
                         name: op.language.default.name + "Response",
-                        description: this.getResponseDescription(resp),
+                        description: sdkResponse.description,
                     },
                 },
             });
         }
-        if (resp.statusCodes === "*" || (bodyType && isErrorModel(this.program, bodyType))) {
-            // "*", or the model is @error
+        if (isErrorResponse) {
             op.addException(response);
             if (response instanceof SchemaResponse) {
                 this.trackSchemaUsage(response.schema, { usage: [SchemaContext.Exception] });
@@ -1327,11 +1247,6 @@ export class CodeModelBuilder {
                 .map((it) => it.toString());
         }
     }
-    getResponseDescription(resp) {
-        return (resp.description ||
-            (resp.statusCodes === "*" ? "An unexpected error response" : getStatusCodeDescription(resp.statusCodes)) ||
-            "");
-    }
     processSchemaFromSdkType(type, nameHint) {
         return this.schemaCache.process(type, nameHint) || fail("Unable to process schema.");
     }
@@ -1744,9 +1659,10 @@ export class CodeModelBuilder {
         });
         return this.codeModel.schemas.add(unionSchema);
     }
-    processBinarySchema(type) {
-        return this.codeModel.schemas.add(new BinarySchema(this.getDoc(type), {
-            summary: this.getSummary(type),
+    processBinarySchemaFromSdkType(type) {
+        var _a;
+        return this.codeModel.schemas.add(new BinarySchema((_a = type.description) !== null && _a !== void 0 ? _a : "", {
+            summary: type.details,
         }));
     }
     getUnionVariantName(type, option) {
@@ -1834,30 +1750,6 @@ export class CodeModelBuilder {
     getSummary(target) {
         return target ? getSummary(this.program, target) : undefined;
     }
-    getName(target, nameHint = undefined) {
-        // TODO: once getLibraryName API in typespec-client-generator-core can get projected name from language and client, as well as can handle template case, use getLibraryName API
-        const emitterClientName = getClientNameOverride(this.sdkContext, target);
-        if (emitterClientName && typeof emitterClientName === "string") {
-            return emitterClientName;
-        }
-        // TODO: deprecate getProjectedName
-        const languageProjectedName = getProjectedName(this.program, target, "java");
-        if (languageProjectedName) {
-            return languageProjectedName;
-        }
-        const clientProjectedName = getProjectedName(this.program, target, "client");
-        if (clientProjectedName) {
-            return clientProjectedName;
-        }
-        const friendlyName = getFriendlyName(this.program, target);
-        if (friendlyName) {
-            return friendlyName;
-        }
-        if (typeof target.name === "symbol") {
-            return "";
-        }
-        return target.name || "";
-    }
     getSerializedName(target) {
         if (isHeader(this.program, target)) {
             return getHeaderFieldName(this.program, target);
@@ -1873,25 +1765,6 @@ export class CodeModelBuilder {
             return getWireName(this.sdkContext, target);
         }
     }
-    getParameterLocation(target) {
-        if (isHeader(this.program, target)) {
-            return ParameterLocation.Header;
-        }
-        else if (isQueryParam(this.program, target)) {
-            return ParameterLocation.Query;
-        }
-        else if (isPathParam(this.program, target)) {
-            return ParameterLocation.Path;
-        }
-        else if (isBody(this.program, target) ||
-            isBodyRoot(this.program, target) ||
-            isMultipartBodyProperty(this.program, target)) {
-            return ParameterLocation.Body;
-        }
-        else {
-            return "BodyProperty";
-        }
-    }
     isReadOnly(target) {
         const segment = target.__raw ? getSegment(this.program, target.__raw) !== undefined : false;
         if (segment) {
@@ -1943,10 +1816,10 @@ export class CodeModelBuilder {
             return undefined;
         }
     }
-    getConvenienceApiName(op) {
-        // check @convenienceMethod
-        if (shouldGenerateConvenient(this.sdkContext, op)) {
-            return this.getName(op);
+    getConvenienceApiName(sdkMethod) {
+        // check @convenienceAPI
+        if (sdkMethod.generateConvenient) {
+            return sdkMethod.name;
         }
         else {
             return undefined;
@@ -2028,16 +1901,11 @@ export class CodeModelBuilder {
             (this._apiVersionParameterInPath = this.createApiVersionParameter("apiVersion", ParameterLocation.Path)));
     }
     isSubscriptionId(param) {
-        var _a;
-        return ("subscriptionId".toLocaleLowerCase() === ((_a = param === null || param === void 0 ? void 0 : param.name) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) &&
-            param.param &&
-            isArmCommonType(param.param) &&
-            isPathParam(this.program, param.param));
+        return "subscriptionId".toLocaleLowerCase() === param.serializedName.toLocaleLowerCase();
     }
     subscriptionIdParameter(parameter) {
         if (!this._subscriptionParameter) {
-            const param = parameter.param;
-            const description = getDoc(this.program, param);
+            const description = parameter.description;
             this._subscriptionParameter = new Parameter("subscriptionId", description ? description : "The ID of the target subscription.", this.stringSchema, {
                 implementation: ImplementationLocation.Client,
                 required: true,
@@ -2054,7 +1922,7 @@ export class CodeModelBuilder {
         return this._subscriptionParameter;
     }
     propagateSchemaUsage(schema) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const processedSchemas = new Set();
         const innerApplySchemaUsage = (schema, schemaUsage) => {
             this.trackSchemaUsage(schema, schemaUsage);
@@ -2110,9 +1978,18 @@ export class CodeModelBuilder {
             }
         };
         // Exclude context that not to be propagated
+        const updatedSchemaUsage = (_a = schema.usage) === null || _a === void 0 ? void 0 : _a.filter((it) => it !== SchemaContext.Paged && it !== SchemaContext.PublicSpread);
+        const indexSpread = (_b = schema.usage) === null || _b === void 0 ? void 0 : _b.indexOf(SchemaContext.PublicSpread);
+        if (updatedSchemaUsage &&
+            indexSpread &&
+            indexSpread >= 0 &&
+            !((_c = schema.usage) === null || _c === void 0 ? void 0 : _c.includes(SchemaContext.Public))) {
+            // Propagate Public, if schema is PublicSpread
+            updatedSchemaUsage.push(SchemaContext.Public);
+        }
         const schemaUsage = {
-            usage: (_a = schema.usage) === null || _a === void 0 ? void 0 : _a.filter((it) => it !== SchemaContext.Paged && it !== SchemaContext.Anonymous),
-            serializationFormats: (_b = schema.serializationFormats) === null || _b === void 0 ? void 0 : _b.filter((it) => it !== KnownMediaType.Multipart),
+            usage: updatedSchemaUsage,
+            serializationFormats: (_d = schema.serializationFormats) === null || _d === void 0 ? void 0 : _d.filter((it) => it !== KnownMediaType.Multipart),
         };
         // Propagate the usage of the initial schema itself
         innerPropagateSchemaUsage(schema, schemaUsage);