@azure-tools/typespec-java 0.15.18 → 0.16.0

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

@@ -1,36 +1,35 @@
-import { getDoc, getEffectiveModelType, getFormat, getFriendlyName, getKnownValues, getSummary, getVisibility, ignoreDiagnostics, isArrayModelType, isRecordModelType, isUnknownType, getDiscriminator, isNeverType, listServices, getNamespaceFullName, isNullType, getTypeName, getProjectedName, getEncode, getOverloadedOperation, isVoidType, isErrorModel, } from "@typespec/compiler";
+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, getWireName, isApiVersion, isInternal, isSdkBuiltInKind, isSdkIntKind, listClients, listOperationGroups, listOperationsInOperationGroup, shouldGenerateConvenient, shouldGenerateProtocol, } from "@azure-tools/typespec-client-generator-core";
+import { getDoc, getEffectiveModelType, getEncode, getFriendlyName, getNamespaceFullName, getOverloadedOperation, getProjectedName, getSummary, getTypeName, getVisibility, ignoreDiagnostics, isArrayModelType, isErrorModel, isRecordModelType, isVoidType, listServices, } from "@typespec/compiler";
+import { Visibility, getAuthentication, getHeaderFieldOptions, getHttpOperation, getQueryParamOptions, getServers, getStatusCodeDescription, isPathParam, } from "@typespec/http";
 import { getResourceOperation, getSegment } from "@typespec/rest";
-import { getAuthentication, getServers, getStatusCodeDescription, getHttpOperation, getQueryParamOptions, getHeaderFieldOptions, isPathParam, } from "@typespec/http";
 import { getAddedOnVersions, getVersion } from "@typespec/versioning";
-import { isPollingLocation, getPagedResult, getLroMetadata, getUnionAsEnum, } from "@azure-tools/typespec-azure-core";
-import { listClients, listOperationGroups, listOperationsInOperationGroup, isApiVersion, shouldGenerateConvenient, createSdkContext, shouldGenerateProtocol, isInternal, getCrossLanguageDefinitionId, getClientNameOverride, shouldFlattenProperty, getWireName, getDefaultApiVersion, } from "@azure-tools/typespec-client-generator-core";
 import { fail } from "assert";
-import { AnySchema, ArraySchema, BinaryResponse, BinarySchema, BooleanSchema, ByteArraySchema, ChoiceValue, DateTimeSchema, DateSchema, DictionarySchema, Discriminator, HttpHeader, HttpParameter, ImplementationLocation, NumberSchema, ObjectSchema, Parameter, ParameterLocation, Property, Relations, Response, SchemaResponse, SchemaType, StringSchema, TimeSchema, Security, OAuth2SecurityScheme, KeySecurityScheme, OperationGroup, UriSchema, VirtualParameter, GroupSchema, GroupProperty, ApiVersion, SerializationStyle, Metadata, UnixTimeSchema, Language, } from "@autorest/codemodel";
-import { KnownMediaType } from "@azure-tools/codegen";
-import { CodeModel } from "./common/code-model.js";
+import pkg from "lodash";
 import { Client as CodeModelClient, ObjectScheme } from "./common/client.js";
-import { ConvenienceApi, Operation as CodeModelOperation, Request } from "./common/operation.js";
-import { SchemaContext } from "./common/schemas/usage.js";
+import { CodeModel } from "./common/code-model.js";
+import { LongRunningMetadata } from "./common/long-running-metadata.js";
+import { Operation as CodeModelOperation, ConvenienceApi, Request } from "./common/operation.js";
 import { ChoiceSchema, SealedChoiceSchema } from "./common/schemas/choice.js";
 import { ConstantSchema, ConstantValue } from "./common/schemas/constant.js";
 import { OrSchema } from "./common/schemas/relationship.js";
-import { LongRunningMetadata } from "./common/long-running-metadata.js";
 import { DurationSchema } from "./common/schemas/time.js";
-import { PreNamer } from "./prenamer/prenamer.js";
+import { SchemaContext } from "./common/schemas/usage.js";
 import { createPollOperationDetailsSchema, getFileDetailsSchema } from "./external-schemas.js";
 import { ClientContext } from "./models.js";
-import { stringArrayContainsIgnoreCase, getJavaNamespace, getNamespace, pascalCase, logWarning, trace, } from "./utils.js";
-import { ProcessingCache, isModelReferredInTemplate, pushDistinct, modelContainsDerivedModel, getNameForTemplate, getDurationFormat, hasScalarAsBase, isNullableType, getAccess, getUsage, getUnionDescription, modelIs, getNamePrefixForProperty, isAllValueInteger, isStable, } from "./type-utils.js";
-import { getServiceVersion, operationIsJsonMergePatch, isPayloadProperty, ORIGIN_API_VERSION, SPECIAL_HEADER_NAMES, loadExamples, isLroNewPollingStrategy, operationIsMultipleContentTypes, cloneOperationParameter, operationIsMultipart, isKnownContentType, CONTENT_TYPE_KEY, } from "./operation-utils.js";
-import { isArmCommonType } from "./type-utils.js";
-import pkg from "lodash";
+import { CONTENT_TYPE_KEY, ORIGIN_API_VERSION, SPECIAL_HEADER_NAMES, cloneOperationParameter, getServiceVersion, isKnownContentType, isLroNewPollingStrategy, isPayloadProperty, loadExamples, operationIsJsonMergePatch, operationIsMultipart, operationIsMultipleContentTypes, } from "./operation-utils.js";
+import { PreNamer } from "./prenamer/prenamer.js";
+import { ProcessingCache, getAccess, getDurationFormatFromSdkType, getNameForTemplate, getNamePrefixForProperty, getUnionDescription, getUsage, hasScalarAsBase, isArmCommonType, isModelReferredInTemplate, isNullableType, isStable, modelIs, pushDistinct, } from "./type-utils.js";
+import { getJavaNamespace, getNamespace, logWarning, pascalCase, stringArrayContainsIgnoreCase, trace, } from "./utils.js";
 const { isEqual } = pkg;
 export class CodeModelBuilder {
     constructor(program1, context) {
         var _a, _b;
         this.loggingEnabled = false;
-        this.schemaCache = new ProcessingCache((type, name) => this.processSchemaImpl(type, name));
-        this.typeUnionRefCache = new Map(); // Union means it ref a Union type, null means it does not ref any Union, nndefined means type visited but not completed
+        this.schemaCache = new ProcessingCache((type, name) => this.processSchemaFromSdkTypeImpl(type, name));
+        this.typeUnionRefCache = new Map(); // Union means it ref a Union type, null means it does not ref any Union, undefined means type visited but not completed
         this.operationExamples = new Map();
         this.options = context.options;
         this.program = program1;
@@ -108,7 +107,8 @@ export class CodeModelBuilder {
                     parameter = this.createApiVersionParameter(it.name, ParameterLocation.Uri);
                 }
                 else {
-                    const schema = this.processSchema(it.type, it.name);
+                    const sdkType = getClientType(this.sdkContext, it.type);
+                    const schema = this.processSchemaFromSdkType(sdkType, it.name);
                     this.trackSchemaUsage(schema, {
                         usage: [SchemaContext.Input, SchemaContext.Output /*SchemaContext.Public*/],
                     });
@@ -119,7 +119,6 @@ export class CodeModelBuilder {
                         protocol: {
                             http: new HttpParameter(ParameterLocation.Uri),
                         },
-                        clientDefaultValue: this.getDefaultValue(it.default),
                         language: {
                             default: {
                                 serializedName: it.name,
@@ -219,54 +218,36 @@ export class CodeModelBuilder {
         }
     }
     processModels(clients) {
-        var _a;
-        const processedModels = new Set();
-        for (const client of clients) {
-            const models = Array.from(client.service.models.values());
-            Array.from(client.service.enums.values()).forEach((it) => models.push(it));
-            Array.from(client.service.unions.values()).forEach((it) => models.push(it));
-            (_a = client.service.namespaces) === null || _a === void 0 ? void 0 : _a.forEach((it) => {
-                Array.from(it.models.values()).forEach((it) => models.push(it));
-                Array.from(it.enums.values()).forEach((it) => models.push(it));
-                Array.from(it.unions.values()).forEach((it) => models.push(it));
+        const processedSdkModels = new Set();
+        // lambda to mark model as public
+        const modelAsPublic = (model) => {
+            const schema = this.processSchemaFromSdkType(model, "");
+            this.trackSchemaUsage(schema, {
+                usage: [SchemaContext.Public],
             });
-            // lambda to mark model as public
-            const modelAsPublic = (model) => {
-                // check it does not contain Union
-                // const union = unionReferredByType(this.program, model, this.typeUnionRefCache);
-                // if (union) {
-                //   const errorMsg = `Model '${getTypeName(
-                //     model,
-                //     this.typeNameOptions,
-                //   )}' cannot be set as access=public, as it refers Union '${getUnionDescription(union, this.typeNameOptions)}'`;
-                //   throw new Error(errorMsg);
-                // }
-                const schema = this.processSchema(model, "");
-                this.trackSchemaUsage(schema, {
-                    usage: [SchemaContext.Public],
-                });
-            };
-            for (const model of models) {
-                if (!processedModels.has(model)) {
-                    const access = getAccess(model);
-                    if (access === "public") {
-                        modelAsPublic(model);
-                    }
-                    else if (access === "internal") {
-                        const schema = this.processSchema(model, "");
-                        this.trackSchemaUsage(schema, {
-                            usage: [SchemaContext.Internal],
-                        });
-                    }
-                    const usage = getUsage(model);
-                    if (usage) {
-                        const schema = this.processSchema(model, "");
-                        this.trackSchemaUsage(schema, {
-                            usage: usage,
-                        });
-                    }
-                    processedModels.add(model);
+        };
+        const sdkModels = getAllModels(this.sdkContext);
+        // process sdk models
+        for (const model of sdkModels) {
+            if (!processedSdkModels.has(model)) {
+                const access = getAccess(model.__raw);
+                if (access === "public") {
+                    modelAsPublic(model);
+                }
+                else if (access === "internal") {
+                    const schema = this.processSchemaFromSdkType(model, model.name);
+                    this.trackSchemaUsage(schema, {
+                        usage: [SchemaContext.Internal],
+                    });
+                }
+                const usage = getUsage(model.__raw);
+                if (usage) {
+                    const schema = this.processSchemaFromSdkType(model, "");
+                    this.trackSchemaUsage(schema, {
+                        usage: usage,
+                    });
                 }
+                processedSdkModels.add(model);
             }
         }
     }
@@ -684,7 +665,8 @@ export class CodeModelBuilder {
                 }
                 else {
                     const pollType = this.findResponseBody(lroMetadata.pollingInfo.responseModel);
-                    pollingSchema = this.processSchema(pollType, "pollResult");
+                    const sdkType = getClientType(this.sdkContext, pollType);
+                    pollingSchema = this.processSchemaFromSdkType(sdkType, "pollResult");
                 }
             }
             // finalSchema
@@ -695,25 +677,24 @@ export class CodeModelBuilder {
                 lroMetadata.finalEnvelopeResult !== "void") {
                 const finalResult = useNewPollStrategy ? lroMetadata.finalResult : lroMetadata.finalEnvelopeResult;
                 const finalType = this.findResponseBody(finalResult);
-                finalSchema = this.processSchema(finalType, "finalResult");
+                const sdkType = getClientType(this.sdkContext, finalType);
+                finalSchema = this.processSchemaFromSdkType(sdkType, "finalResult");
             }
             // track usage
             if (pollingSchema) {
                 this.trackSchemaUsage(pollingSchema, { usage: [SchemaContext.Output] });
-                if (op.internalApi) {
-                    this.trackSchemaUsage(pollingSchema, { usage: [SchemaContext.Internal] });
-                }
-                else if (op.convenienceApi) {
-                    this.trackSchemaUsage(pollingSchema, { usage: [SchemaContext.Public] });
+                if (op.convenienceApi) {
+                    this.trackSchemaUsage(pollingSchema, {
+                        usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public],
+                    });
                 }
             }
             if (finalSchema) {
                 this.trackSchemaUsage(finalSchema, { usage: [SchemaContext.Output] });
-                if (op.internalApi) {
-                    this.trackSchemaUsage(pollingSchema, { usage: [SchemaContext.Internal] });
-                }
-                else if (op.convenienceApi) {
-                    this.trackSchemaUsage(finalSchema, { usage: [SchemaContext.Public] });
+                if (op.convenienceApi) {
+                    this.trackSchemaUsage(finalSchema, {
+                        usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public],
+                    });
                 }
             }
             op.lroMetadata = new LongRunningMetadata(true, pollingSchema, finalSchema, pollingStrategy);
@@ -775,16 +756,18 @@ export class CodeModelBuilder {
         else {
             // schema
             let schema;
+            const sdkType = 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"))) {
+                (hasScalarAsBase(param.param.type, "utcDateTime") || hasScalarAsBase(param.param.type, "offsetDateTime")) &&
+                (sdkType.kind === "utcDateTime" || sdkType.kind === "offsetDateTime")) {
                 // utcDateTime in header maps to rfc7231
-                schema = this.processDateTimeSchema(param.param.type, param.param.name, true);
+                schema = this.processDateTimeSchemaFromSdkType(sdkType, param.param.name, true);
             }
             else {
-                schema = this.processSchema(param.param, param.param.name);
+                schema = this.processSchemaFromSdkType(sdkType, param.param.name);
             }
             // skip-url-encoding
             let extensions = undefined;
@@ -857,7 +840,6 @@ export class CodeModelBuilder {
                         explode: explode,
                     }),
                 },
-                // clientDefaultValue: this.getDefaultValue(param.param.default),
                 language: {
                     default: {
                         serializedName: param.name,
@@ -867,11 +849,8 @@ export class CodeModelBuilder {
             });
             op.addParameter(parameter);
             this.trackSchemaUsage(schema, { usage: [SchemaContext.Input] });
-            if (op.internalApi) {
-                this.trackSchemaUsage(schema, { usage: [SchemaContext.Internal] });
-            }
-            else if (op.convenienceApi) {
-                this.trackSchemaUsage(schema, { usage: [SchemaContext.Public] });
+            if (op.convenienceApi) {
+                this.trackSchemaUsage(schema, { usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public] });
             }
             if (param.name.toLowerCase() === CONTENT_TYPE_KEY) {
                 let mediaTypes = ["application/json"];
@@ -995,11 +974,10 @@ export class CodeModelBuilder {
                     nullable: true,
                 });
                 this.trackSchemaUsage(requestConditionsSchema, { usage: [SchemaContext.Input] });
-                if (op.internalApi) {
-                    this.trackSchemaUsage(requestConditionsSchema, { usage: [SchemaContext.Internal] });
-                }
-                else if (op.convenienceApi) {
-                    this.trackSchemaUsage(requestConditionsSchema, { usage: [SchemaContext.Public] });
+                if (op.convenienceApi) {
+                    this.trackSchemaUsage(requestConditionsSchema, {
+                        usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public],
+                    });
                 }
                 // update group schema for properties
                 for (const parameter of request.parameters) {
@@ -1030,6 +1008,7 @@ export class CodeModelBuilder {
         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);
         let schema;
         if (unknownRequestBody &&
             body.kind === "ModelProperty" &&
@@ -1039,8 +1018,9 @@ export class CodeModelBuilder {
             schema = this.processBinarySchema(body.type);
         }
         else {
-            schema = this.processSchema(body, body.name);
+            schema = this.processSchemaFromSdkType(sdkType, body.name);
         }
+        const isAnonymousModel = sdkType.kind === "model" && sdkType.isGeneratedName === true;
         const parameter = new Parameter(this.getName(body), this.getDoc(body), schema, {
             summary: this.getSummary(body),
             implementation: ImplementationLocation.Method,
@@ -1048,26 +1028,20 @@ export class CodeModelBuilder {
             protocol: {
                 http: new HttpParameter(ParameterLocation.Body),
             },
-            // clientDefaultValue: this.getDefaultValue(body.default),
         });
         op.addParameter(parameter);
         this.trackSchemaUsage(schema, { usage: [SchemaContext.Input] });
-        if (op.internalApi) {
-            this.trackSchemaUsage(schema, { usage: [SchemaContext.Internal] });
-        }
-        else if (op.convenienceApi) {
-            this.trackSchemaUsage(schema, { usage: [SchemaContext.Public] });
+        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)) {
             this.trackSchemaUsage(schema, { usage: [SchemaContext.JsonMergePatch] });
         }
         if (op.convenienceApi && operationIsMultipart(httpOperation)) {
-            if (schema instanceof ObjectSchema) {
-                this.processMultipartFormDataSchema(schema);
-            }
             this.trackSchemaUsage(schema, { serializationFormats: [KnownMediaType.Multipart] });
         }
-        if (schema instanceof ObjectSchema && !schema.language.default.name) {
+        if (schema instanceof ObjectSchema && isAnonymousModel) {
             // anonymous model
             // name the schema for documentation
             schema.language.default.name = pascalCase(op.language.default.name) + "Request";
@@ -1147,11 +1121,10 @@ export class CodeModelBuilder {
                         }));
                     });
                     this.trackSchemaUsage(optionBagSchema, { usage: [SchemaContext.Input] });
-                    if (op.internalApi) {
-                        this.trackSchemaUsage(optionBagSchema, { usage: [SchemaContext.Internal] });
-                    }
-                    else if (op.convenienceApi) {
-                        this.trackSchemaUsage(optionBagSchema, { usage: [SchemaContext.Public] });
+                    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, {
@@ -1182,7 +1155,8 @@ export class CodeModelBuilder {
             for (const response of resp.responses.values()) {
                 if (response.headers) {
                     for (const [key, header] of Object.entries(response.headers)) {
-                        const schema = this.processSchema(header, key);
+                        const sdkType = getClientType(this.sdkContext, header);
+                        const schema = this.processSchemaFromSdkType(sdkType, key);
                         headers.push(new HttpHeader(key, schema, {
                             language: {
                                 default: {
@@ -1266,7 +1240,8 @@ export class CodeModelBuilder {
                         schema = op.lroMetadata.pollResultType;
                     }
                     else {
-                        schema = this.processSchema(bodyType, op.language.default.name + "Response");
+                        const sdkType = getClientType(this.sdkContext, bodyType);
+                        schema = this.processSchemaFromSdkType(sdkType, op.language.default.name + "Response");
                     }
                 }
                 response = new SchemaResponse(schema, {
@@ -1314,11 +1289,10 @@ export class CodeModelBuilder {
             op.addResponse(response);
             if (response instanceof SchemaResponse) {
                 this.trackSchemaUsage(response.schema, { usage: [SchemaContext.Output] });
-                if (op.internalApi) {
-                    this.trackSchemaUsage(response.schema, { usage: [SchemaContext.Internal] });
-                }
-                else if (trackConvenienceApi) {
-                    this.trackSchemaUsage(response.schema, { usage: [SchemaContext.Public] });
+                if (trackConvenienceApi) {
+                    this.trackSchemaUsage(response.schema, {
+                        usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public],
+                    });
                 }
             }
         }
@@ -1344,229 +1318,150 @@ export class CodeModelBuilder {
             (resp.statusCodes === "*" ? "An unexpected error response" : getStatusCodeDescription(resp.statusCodes)) ||
             "");
     }
-    processSchema(type, nameHint) {
+    processSchemaFromSdkType(type, nameHint) {
         return this.schemaCache.process(type, nameHint) || fail("Unable to process schema.");
     }
-    processSchemaImpl(type, nameHint) {
-        switch (type.kind) {
-            case "Intrinsic":
-                if (isUnknownType(type)) {
-                    return this.processAnySchema(type, nameHint);
-                }
-                else {
-                    throw new Error(`Unrecognized intrinsic type: '${type.name}'.`);
-                }
-            case "String":
-                return this.processConstantSchemaForLiteral(type, nameHint);
-            case "Number":
-                return this.processConstantSchemaForLiteral(type, nameHint);
-            case "Boolean":
-                return this.processConstantSchemaForLiteral(type, nameHint);
-            case "Enum":
-                return this.processChoiceSchema(type, this.getName(type), true);
-            case "Union":
-                return this.processUnionSchema(type, this.getName(type, nameHint));
-            case "ModelProperty": {
-                let schema = undefined;
-                const knownValues = getKnownValues(this.program, type);
-                if (knownValues) {
-                    // use it for extensible enum
-                    schema = this.processChoiceSchema(knownValues, this.getName(knownValues), false);
-                }
-                else {
-                    const schemaNameHint = type.type.kind === "Scalar" && this.program.checker.isStdType(type.type)
-                        ? nameHint // std scalar won't need a nameHint
-                        : pascalCase(getNamePrefixForProperty(type)) + pascalCase(nameHint);
-                    schema = this.processSchema(type.type, schemaNameHint);
-                }
-                return this.applyModelPropertyDecorators(type, nameHint, schema);
+    processSchemaFromSdkTypeImpl(type, nameHint) {
+        if (isSdkBuiltInKind(type.kind)) {
+            return this.processBuiltInFromSdkType(type, nameHint);
+        }
+        else {
+            switch (type.kind) {
+                case "enum":
+                    return this.processChoiceSchemaFromSdkType(type, type.name);
+                case "enumvalue":
+                    return this.processConstantSchemaFromEnumValueFromSdkType(type, nameHint);
+                case "union":
+                    return this.processUnionSchemaFromSdkType(type, type.name);
+                case "model":
+                    return this.processObjectSchemaFromSdkType(type, type.name);
+                case "dict":
+                    return this.processDictionarySchemaFromSdkType(type, nameHint);
+                case "array":
+                    return this.processArraySchemaFromSdkType(type, nameHint);
+                case "duration":
+                    return this.processDurationSchemaFromSdkType(type, nameHint, getDurationFormatFromSdkType(type));
+                case "constant":
+                    return this.processConstantSchemaFromSdkType(type, nameHint);
+                case "utcDateTime":
+                case "offsetDateTime":
+                    if (type.encode === "unixTimestamp") {
+                        return this.processUnixTimeSchemaFromSdkType(type, nameHint);
+                    }
+                    else {
+                        return this.processDateTimeSchemaFromSdkType(type, nameHint, type.encode === "rfc7231");
+                    }
             }
-            case "Scalar":
-                return this.processScalar(type, undefined, nameHint);
-            case "Model":
-                if (isArrayModelType(this.program, type)) {
-                    return this.processArraySchema(type, nameHint);
-                }
-                else if (isRecordModelType(this.program, type) && type.properties.size == 0) {
-                    // "pure" Record that does not have properties in it
-                    return this.processDictionarySchema(type, nameHint);
-                }
-                else {
-                    return this.processObjectSchema(type, this.getName(type, nameHint));
-                }
-            case "EnumMember":
-                // e.g. "type: TypeEnum.EnumValue1"
-                return this.processConstantSchemaForEnumMember(type, this.getName(type));
-            case "UnionVariant":
-                // e.g. "type: Union.Variant1"
-                if (type.type.kind === "String" || type.type.kind === "Number" || type.type.kind === "Boolean") {
-                    return this.processConstantSchemaForUnionVariant(type, this.getName(type));
-                }
-                else {
-                    throw new Error(`Unsupported type reference to UnionVariant.`);
-                }
         }
         throw new Error(`Unrecognized type: '${type.kind}'.`);
     }
-    processScalar(type, formatFromDerived, nameHint) {
-        const scalarName = type.name;
-        if (this.program.checker.isStdType(type)) {
-            nameHint = scalarName;
-            switch (scalarName) {
-                case "string": {
-                    const format = formatFromDerived !== null && formatFromDerived !== void 0 ? formatFromDerived : getFormat(this.program, type);
-                    if (format) {
-                        return this.processFormatString(type, format, nameHint);
-                    }
-                    return this.processStringSchema(type, nameHint);
-                }
+    processBuiltInFromSdkType(type, nameHint) {
+        nameHint = nameHint || type.kind;
+        if (isSdkIntKind(type.kind)) {
+            const integerSize = type.kind === "safeint" || type.kind.includes("int64") ? 64 : 32;
+            return this.processIntegerSchemaFromSdkType(type, nameHint, integerSize);
+        }
+        else {
+            switch (type.kind) {
+                case "any":
+                    return this.processAnySchemaFromSdkType();
+                case "string":
+                case "password":
+                case "guid":
+                case "ipAddress":
+                case "uuid":
+                case "ipV4Address":
+                case "ipV6Address":
+                case "eTag":
+                case "armId":
+                case "azureLocation":
+                    return this.processStringSchemaFromSdkType(type, type.kind);
+                case "float":
+                case "float32":
+                case "float64":
+                    return this.processNumberSchemaFromSdkType(type, nameHint);
+                case "decimal":
+                case "decimal128":
+                    return this.processDecimalSchemaFromSdkType(type, nameHint);
                 case "bytes":
-                    return this.processByteArraySchema(type, nameHint, false);
+                    return this.processByteArraySchemaFromSdkType(type, nameHint);
                 case "boolean":
-                    return this.processBooleanSchema(type, nameHint);
+                    return this.processBooleanSchemaFromSdkType(type, nameHint);
                 case "plainTime":
-                    return this.processTimeSchema(type, nameHint);
+                    return this.processTimeSchemaFromSdkType(type, nameHint);
                 case "plainDate":
-                    return this.processDateSchema(type, nameHint);
-                case "utcDateTime":
-                case "offsetDateTime":
-                    return this.processDateTimeSchema(type, nameHint, false);
-                case "duration":
-                    return this.processDurationSchema(type, nameHint);
+                    return this.processDateSchemaFromSdkType(type, nameHint);
                 case "url":
-                    return this.processUrlSchema(type, nameHint);
-            }
-            if (scalarName.startsWith("decimal")) {
-                // decimal
-                return this.processDecimalSchema(type, nameHint);
-            }
-            else if (scalarName.startsWith("int") || scalarName.startsWith("uint") || scalarName === "safeint") {
-                // integer
-                const integerSize = scalarName === "safeint" || scalarName.includes("int64") ? 64 : 32;
-                return this.processIntegerSchema(type, nameHint, integerSize);
-            }
-            else if (scalarName.startsWith("float")) {
-                // float point
-                return this.processNumberSchema(type, nameHint);
-            }
-            else {
-                throw new Error(`Unrecognized scalar type: '${scalarName}'.`);
-            }
-        }
-        else {
-            const knownValues = getKnownValues(this.program, type);
-            if (knownValues) {
-                // use it for extensible enum
-                return this.processChoiceSchema(knownValues, this.getName(type), false);
-            }
-            else {
-                const encode = getEncode(this.program, type);
-                if (encode) {
-                    // process as encode
-                    if (encode.encoding === "seconds" && hasScalarAsBase(type, "duration")) {
-                        return this.processDurationSchema(type, nameHint, getDurationFormat(encode));
-                    }
-                    else if ((encode.encoding === "rfc3339" || encode.encoding === "rfc7231" || encode.encoding === "unixTimestamp") &&
-                        (hasScalarAsBase(type, "utcDateTime") || hasScalarAsBase(type, "offsetDateTime"))) {
-                        if (encode.encoding === "unixTimestamp") {
-                            return this.processUnixTimeSchema(type, nameHint);
-                        }
-                        else {
-                            return this.processDateTimeSchema(type, nameHint, encode.encoding === "rfc7231");
-                        }
-                    }
-                    else if (encode.encoding === "base64url" && hasScalarAsBase(type, "bytes")) {
-                        return this.processByteArraySchema(type, nameHint, true);
-                    }
-                }
-                if (type.baseScalar) {
-                    // fallback to baseScalar
-                    const schema = this.processScalar(type.baseScalar, getFormat(this.program, type), nameHint);
-                    const doc = getDoc(this.program, type);
-                    const summary = getSummary(this.program, type);
-                    if (doc) {
-                        schema.language.default.description = doc;
-                    }
-                    if (summary) {
-                        schema.summary = summary;
-                    }
-                    return schema;
-                }
-                else {
-                    throw new Error(`Unrecognized scalar type: '${scalarName}'.`);
-                }
+                case "uri":
+                    return this.processUrlSchemaFromSdkType(type, nameHint);
             }
         }
     }
-    processAnySchema(type, name) {
+    processAnySchemaFromSdkType() {
         return this.anySchema;
     }
-    processStringSchema(type, name) {
-        return this.codeModel.schemas.add(new StringSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processStringSchemaFromSdkType(type, name) {
+        return this.codeModel.schemas.add(new StringSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processByteArraySchema(type, name, base64Encoded) {
-        return this.codeModel.schemas.add(new ByteArraySchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processByteArraySchemaFromSdkType(type, name) {
+        const base64Encoded = type.encode === "base64url";
+        return this.codeModel.schemas.add(new ByteArraySchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
             format: base64Encoded ? "base64url" : "byte",
         }));
     }
-    processIntegerSchema(type, name, precision) {
-        return this.codeModel.schemas.add(new NumberSchema(name, this.getDoc(type), SchemaType.Integer, precision, {
-            summary: this.getSummary(type),
+    processIntegerSchemaFromSdkType(type, name, precision) {
+        return this.codeModel.schemas.add(new NumberSchema(name, this.getDoc(type.__raw), SchemaType.Integer, precision, {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processNumberSchema(type, name) {
-        return this.codeModel.schemas.add(new NumberSchema(name, this.getDoc(type), SchemaType.Number, 64, {
-            summary: this.getSummary(type),
+    processNumberSchemaFromSdkType(type, name) {
+        return this.codeModel.schemas.add(new NumberSchema(name, this.getDoc(type.__raw), SchemaType.Number, 64, {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processDecimalSchema(type, name) {
+    processDecimalSchemaFromSdkType(type, name) {
         // "Infinity" maps to "BigDecimal" in Java
-        return this.codeModel.schemas.add(new NumberSchema(name, this.getDoc(type), SchemaType.Number, Infinity, {
-            summary: this.getSummary(type),
+        return this.codeModel.schemas.add(new NumberSchema(name, this.getDoc(type.__raw), SchemaType.Number, Infinity, {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processBooleanSchema(type, name) {
-        return this.codeModel.schemas.add(new BooleanSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processBooleanSchemaFromSdkType(type, name) {
+        return this.codeModel.schemas.add(new BooleanSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processArraySchema(type, name) {
-        const elementSchema = this.processSchema(type.indexer.value, name);
-        return this.codeModel.schemas.add(new ArraySchema(name, this.getDoc(type), elementSchema, {
-            summary: this.getSummary(type),
+    processArraySchemaFromSdkType(type, name) {
+        const elementSchema = this.processSchemaFromSdkType(type.valueType, name);
+        return this.codeModel.schemas.add(new ArraySchema(name, this.getDoc(type.__raw), elementSchema, {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processDictionarySchema(type, name) {
-        const dictSchema = new DictionarySchema(name, this.getDoc(type), null, {
-            summary: this.getSummary(type),
+    processDictionarySchemaFromSdkType(type, name) {
+        const dictSchema = new DictionarySchema(name, type.details ? type.details : "", null, {
+            summary: type.description,
         });
         // cache this now before we accidentally recurse on this type.
         if (!this.schemaCache.has(type)) {
             this.schemaCache.set(type, dictSchema);
         }
-        const elementSchema = this.processSchema(type.indexer.value, name);
+        const elementSchema = this.processSchemaFromSdkType(type.valueType, name);
         dictSchema.elementType = elementSchema;
-        if (type.indexer.value.kind === "Union") {
-            dictSchema.nullableItems =
-                Array.from(type.indexer.value.variants.values()).findIndex((it) => isNullType(it.type)) >= 0;
-        }
+        dictSchema.nullableItems = type.nullableValues;
         return this.codeModel.schemas.add(dictSchema);
     }
-    processChoiceSchema(type, name, sealed) {
-        const namespace = getNamespace(type);
-        const valueType = typeof type.members.values().next().value.value === "number"
-            ? isAllValueInteger(Array.from(type.members.values()).map((it) => it.value))
-                ? this.integerSchema
-                : this.doubleSchema
-            : this.stringSchema;
+    processChoiceSchemaFromSdkType(type, name) {
+        var _a;
+        const rawEnumType = type.__raw;
+        const namespace = getNamespace(rawEnumType);
+        const valueType = this.processSchemaFromSdkType(type.valueType, type.valueType.kind);
         const choices = [];
-        type.members.forEach((it) => { var _a; return choices.push(new ChoiceValue(it.name, this.getDoc(it), (_a = it.value) !== null && _a !== void 0 ? _a : it.name)); });
-        const schemaType = sealed ? SealedChoiceSchema : ChoiceSchema;
-        const schema = new schemaType(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+        type.values.forEach((it) => { var _a, _b; return choices.push(new ChoiceValue(it.name, (_a = it.description) !== null && _a !== void 0 ? _a : "", (_b = it.value) !== null && _b !== void 0 ? _b : it.name)); });
+        const schemaType = type.isFixed ? SealedChoiceSchema : ChoiceSchema;
+        const schema = new schemaType(type.name ? type.name : name, (_a = type.description) !== null && _a !== void 0 ? _a : "", {
+            summary: this.getSummary(rawEnumType),
             choiceType: valueType,
             choices: choices,
             language: {
@@ -1578,118 +1473,64 @@ export class CodeModelBuilder {
                 },
             },
         });
-        schema.crossLanguageDefinitionId = getCrossLanguageDefinitionId(type);
+        schema.crossLanguageDefinitionId = type.crossLanguageDefinitionId;
         return this.codeModel.schemas.add(schema);
     }
-    processConstantSchemaForLiteral(type, name) {
-        const valueType = type.kind === "String"
-            ? this.stringSchema
-            : type.kind === "Boolean"
-                ? this.booleanSchema
-                : isAllValueInteger([type.value])
-                    ? this.integerSchema
-                    : this.doubleSchema;
-        return this.codeModel.schemas.add(new ConstantSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processConstantSchemaFromSdkType(type, name) {
+        const valueType = this.processSchemaFromSdkType(type.valueType, type.valueType.kind);
+        return this.codeModel.schemas.add(new ConstantSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
             valueType: valueType,
             value: new ConstantValue(type.value),
         }));
     }
-    processConstantSchemaForEnumMember(type, name) {
+    processConstantSchemaFromEnumValueFromSdkType(type, name) {
         var _a;
-        const valueType = this.processSchema(type.enum, this.getName(type.enum));
-        return this.codeModel.schemas.add(new ConstantSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+        const valueType = this.processSchemaFromSdkType(type.enumType, type.enumType.name);
+        return this.codeModel.schemas.add(new ConstantSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
             valueType: valueType,
             value: new ConstantValue((_a = type.value) !== null && _a !== void 0 ? _a : type.name),
         }));
     }
-    processConstantSchemaForUnionVariant(type, name) {
-        var _a;
-        const valueType = this.processSchema(type.union, this.getName(type.union));
-        return this.codeModel.schemas.add(new ConstantSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
-            valueType: valueType,
-            value: new ConstantValue((_a = type.type.value) !== null && _a !== void 0 ? _a : type.name),
-        }));
-    }
-    processChoiceSchemaForUnion(type, unionEnum, name) {
-        // variants is Literal
-        const sealed = !unionEnum.open;
-        const variants = [...unionEnum.flattenedMembers.values()];
-        const kindIsString = typeof variants[0].value === "string";
-        const valueType = kindIsString
-            ? this.stringSchema
-            : isAllValueInteger(variants.map((it) => it.value))
-                ? this.integerSchema
-                : this.doubleSchema;
-        const choices = [];
-        for (const [name, member] of unionEnum.flattenedMembers.entries()) {
-            // get name from "UnionVariant | EnumMember"
-            let valueName = this.getName(member.type);
-            const valueDoc = this.getDoc(member.type);
-            if (!valueName) {
-                // fallback the name to the dict
-                valueName = typeof name === "string" ? name : `${member.value}`;
-            }
-            // TODO: may need to use getWireName on "member.value"
-            choices.push(new ChoiceValue(valueName, valueDoc, member.value));
-        }
-        const namespace = getNamespace(type);
-        const schemaType = sealed ? SealedChoiceSchema : ChoiceSchema;
-        const schema = new schemaType(name, this.getDoc(type), {
-            summary: this.getSummary(type),
-            choiceType: valueType,
-            choices: choices,
-            language: {
-                default: {
-                    namespace: namespace,
-                },
-                java: {
-                    namespace: getJavaNamespace(namespace),
-                },
-            },
-        });
-        schema.crossLanguageDefinitionId = getCrossLanguageDefinitionId(type);
-        return this.codeModel.schemas.add(schema);
-    }
-    processUnixTimeSchema(type, name) {
-        return this.codeModel.schemas.add(new UnixTimeSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processUnixTimeSchemaFromSdkType(type, name) {
+        return this.codeModel.schemas.add(new UnixTimeSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processDateTimeSchema(type, name, rfc1123) {
-        return this.codeModel.schemas.add(new DateTimeSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processDateTimeSchemaFromSdkType(type, name, rfc1123) {
+        return this.codeModel.schemas.add(new DateTimeSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
             format: rfc1123 ? "date-time-rfc1123" : "date-time",
         }));
     }
-    processDateSchema(type, name) {
-        return this.codeModel.schemas.add(new DateSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processDateSchemaFromSdkType(type, name) {
+        return this.codeModel.schemas.add(new DateSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processTimeSchema(type, name) {
-        return this.codeModel.schemas.add(new TimeSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processTimeSchemaFromSdkType(type, name) {
+        return this.codeModel.schemas.add(new TimeSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processDurationSchema(type, name, format = "duration-rfc3339") {
-        return this.codeModel.schemas.add(new DurationSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processDurationSchemaFromSdkType(type, name, format = "duration-rfc3339") {
+        return this.codeModel.schemas.add(new DurationSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
             format: format,
         }));
     }
-    processUrlSchema(type, name) {
-        return this.codeModel.schemas.add(new UriSchema(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processUrlSchemaFromSdkType(type, name) {
+        return this.codeModel.schemas.add(new UriSchema(name, this.getDoc(type.__raw), {
+            summary: this.getSummary(type.__raw),
         }));
     }
-    processObjectSchema(type, name) {
-        var _a, _b, _c;
-        const namespace = getNamespace(type);
-        const objectSchema = new ObjectScheme(name, this.getDoc(type), {
-            summary: this.getSummary(type),
+    processObjectSchemaFromSdkType(type, name) {
+        var _a;
+        const rawModelType = type.__raw;
+        const namespace = getNamespace(rawModelType);
+        const objectSchema = new ObjectScheme(name, this.getDoc(rawModelType), {
+            summary: this.getSummary(rawModelType),
             language: {
                 default: {
                     namespace: namespace,
@@ -1699,47 +1540,23 @@ export class CodeModelBuilder {
                 },
             },
         });
-        objectSchema.crossLanguageDefinitionId = getCrossLanguageDefinitionId(type);
+        objectSchema.crossLanguageDefinitionId = type.crossLanguageDefinitionId;
         this.codeModel.schemas.add(objectSchema);
         // cache this now before we accidentally recurse on this type.
         if (!this.schemaCache.has(type)) {
             this.schemaCache.set(type, objectSchema);
         }
         // discriminator
-        let discriminatorPropertyName = undefined;
-        const discriminator = getDiscriminator(this.program, type);
-        if (discriminator) {
-            discriminatorPropertyName = discriminator.propertyName;
-            // find the discriminator property from model
-            // the property is required for getting its serializedName
-            let discriminatorProperty = Array.from(type.properties.values()).find((it) => it.name === discriminatorPropertyName);
-            if (!discriminatorProperty) {
-                // try find the discriminator property from any of its derived models
-                for (const deriveModel of type.derivedModels) {
-                    discriminatorProperty = Array.from(deriveModel.properties.values()).find((it) => it.name === discriminatorPropertyName);
-                    if (discriminatorProperty) {
-                        // found
-                        break;
-                    }
-                }
-            }
-            if (discriminatorProperty) {
-                objectSchema.discriminator = new Discriminator(this.processModelProperty(discriminatorProperty));
-                objectSchema.discriminator.property.isDiscriminator = true;
-            }
-            else {
-                // fallback to property name, if cannot find the discriminator property
-                objectSchema.discriminator = new Discriminator(new Property(discriminatorPropertyName, discriminatorPropertyName, this.stringSchema, {
-                    isDiscriminator: true,
-                    required: true,
-                    serializedName: discriminatorPropertyName,
-                }));
+        if (type.discriminatedSubtypes && type.discriminatorProperty) {
+            objectSchema.discriminator = new Discriminator(this.processModelPropertyFromSdkType(type.discriminatorProperty));
+            for (const discriminatorValue in type.discriminatedSubtypes) {
+                const subType = type.discriminatedSubtypes[discriminatorValue];
+                this.processSchemaFromSdkType(subType, subType.name);
             }
-            objectSchema.discriminator.propertyName = discriminatorPropertyName;
         }
-        // parent
+        // type is a subtype
         if (type.baseModel) {
-            const parentSchema = this.processSchema(type.baseModel, this.getName(type.baseModel));
+            const parentSchema = this.processSchemaFromSdkType(type.baseModel, type.baseModel.name);
             objectSchema.parents = new Relations();
             objectSchema.parents.immediate.push(parentSchema);
             if (parentSchema instanceof ObjectSchema) {
@@ -1756,69 +1573,34 @@ export class CodeModelBuilder {
                     });
                 }
             }
-            else {
-                // parentSchema could be DictionarySchema, which means the model is "additionalProperties"
-                pushDistinct(objectSchema.parents.all, parentSchema);
-            }
+            objectSchema.discriminatorValue = type.discriminatorValue;
         }
-        else if (isRecordModelType(this.program, type)) {
-            // "pure" Record processed elsewhere
-            // "mixed" Record that have properties, treat the model as "additionalProperties"
-            /* type should have sourceModel, as
-            model Type is Record<> {
-              prop1: string
-            }
-            */
-            const parentSchema = type.sourceModel
-                ? this.processSchema(type.sourceModel, this.getName(type.sourceModel))
-                : // process self as pure Record (instead of Model = Record + properties), do not use cache
-                    this.processDictionarySchema(type, this.getName(type));
-            objectSchema.parents = new Relations();
+        if (type.additionalProperties) {
+            // model has additional property
+            const sdkDictType = {
+                kind: "dict",
+                keyType: {
+                    kind: "string",
+                    encode: "string",
+                    nullable: false,
+                },
+                description: type.description,
+                nullableValues: false,
+                nullable: false,
+                valueType: type.additionalProperties,
+            };
+            const parentSchema = this.processSchemaFromSdkType(sdkDictType, "Record");
+            objectSchema.parents = (_a = objectSchema.parents) !== null && _a !== void 0 ? _a : new Relations();
             objectSchema.parents.immediate.push(parentSchema);
             pushDistinct(objectSchema.parents.all, parentSchema);
-        }
-        // value of the discriminator property
-        if (objectSchema.parents) {
-            const parentWithDiscriminator = objectSchema.parents.all.find((it) => it instanceof ObjectSchema && it.discriminator);
-            if (parentWithDiscriminator) {
-                discriminatorPropertyName = parentWithDiscriminator.discriminator.propertyName;
-                const discriminatorProperty = Array.from(type.properties.values()).find((it) => it.name === discriminatorPropertyName &&
-                    (it.type.kind === "String" || it.type.kind === "EnumMember" || it.type.kind === "UnionVariant"));
-                if (discriminatorProperty) {
-                    if (discriminatorProperty.type.kind === "String") {
-                        // value as StringLiteral
-                        objectSchema.discriminatorValue = discriminatorProperty.type.value;
-                    }
-                    else if (discriminatorProperty.type.kind === "EnumMember") {
-                        // value as EnumMember
-                        // lint requires value be string
-                        objectSchema.discriminatorValue =
-                            (_a = discriminatorProperty.type.value) !== null && _a !== void 0 ? _a : discriminatorProperty.type.name;
-                    }
-                    else if (discriminatorProperty.type.kind === "UnionVariant") {
-                        // value as UnionVariant
-                        objectSchema.discriminatorValue =
-                            (_b = discriminatorProperty.type.type.value) !== null && _b !== void 0 ? _b : discriminatorProperty.type.name;
-                    }
-                }
-                else {
-                    // it is possible that the property is Union, e.g. 'kind: "type1" | "type2"'; but such Type appears not to be a concrete model.
-                    // fallback to name of the Model
-                    objectSchema.discriminatorValue = name;
-                }
-            }
+            objectSchema.discriminatorValue = type.discriminatorValue;
         }
         // properties
-        for (const prop of type.properties.values()) {
-            if (prop.name === discriminatorPropertyName || // skip the discriminator property
-                isNeverType(prop.type) || // skip property of type "never"
-                !isPayloadProperty(this.program, prop)) {
-                continue;
+        for (const prop of type.properties) {
+            if (prop.kind === "property" && !prop.discriminator) {
+                objectSchema.addProperty(this.processModelPropertyFromSdkType(prop));
             }
-            objectSchema.addProperty(this.processModelProperty(prop));
         }
-        // process all children
-        (_c = type.derivedModels) === null || _c === void 0 ? void 0 : _c.filter(modelContainsDerivedModel).forEach((it) => this.processSchema(it, this.getName(it)));
         return objectSchema;
     }
     getEffectiveSchemaType(type) {
@@ -1839,81 +1621,12 @@ export class CodeModelBuilder {
         }
         return type;
     }
-    applyModelPropertyDecorators(prop, nameHint, schema) {
-        // if (schema instanceof StringSchema) {
-        //   const decorators = {
-        //     minLength: getMinLength(this.program, prop),
-        //     maxLength: getMaxLength(this.program, prop),
-        //     pattern: getPattern(this.program, prop),
-        //   };
-        //   if (Object.values(decorators).some((it) => it !== undefined)) {
-        //     schema = new StringSchema(schema.language.default.name, schema.language.default.description, {
-        //       language: schema.language,
-        //       summary: schema.summary,
-        //       extensions: schema.extensions,
-        //       ...decorators,
-        //     });
-        //   }
-        // } else if (schema instanceof NumberSchema) {
-        //   const decorators = {
-        //     minimum: getMinValue(this.program, prop),
-        //     maximum: getMaxValue(this.program, prop),
-        //   };
-        //   if (Object.values(decorators).some((it) => it !== undefined)) {
-        //     schema = new NumberSchema(
-        //       schema.language.default.name,
-        //       schema.language.default.description,
-        //       schema.type,
-        //       schema.precision,
-        //       {
-        //         language: schema.language,
-        //         summary: schema.summary,
-        //         extensions: schema.extensions,
-        //         ...decorators,
-        //       },
-        //     );
-        //   }
-        // }
-        const format = getFormat(this.program, prop);
-        if (format) {
-            // TODO: deprecate format
-            if (prop.type.kind === "Scalar" && schema instanceof StringSchema) {
-                schema = this.processFormatString(prop.type, format, nameHint);
-            }
-        }
-        else {
-            // encode
-            const encode = getEncode(this.program, prop);
-            if (encode) {
-                let type = prop.type;
-                if (prop.type.kind === "Union" && isNullableType(prop.type)) {
-                    const nonNullVariants = Array.from(prop.type.variants.values()).filter((it) => !isNullType(it.type));
-                    type = nonNullVariants[0].type;
-                }
-                if (type && type.kind === "Scalar") {
-                    if (encode.encoding === "seconds" && hasScalarAsBase(type, "duration")) {
-                        schema = this.processDurationSchema(type, nameHint, getDurationFormat(encode));
-                    }
-                    else if ((encode.encoding === "rfc3339" || encode.encoding === "rfc7231" || encode.encoding === "unixTimestamp") &&
-                        (hasScalarAsBase(type, "utcDateTime") || hasScalarAsBase(type, "offsetDateTime"))) {
-                        if (encode.encoding === "unixTimestamp") {
-                            return this.processUnixTimeSchema(type, nameHint);
-                        }
-                        else {
-                            return this.processDateTimeSchema(type, nameHint, encode.encoding === "rfc7231");
-                        }
-                    }
-                    else if (encode.encoding === "base64url" && hasScalarAsBase(type, "bytes")) {
-                        return this.processByteArraySchema(type, nameHint, true);
-                    }
-                }
-            }
-        }
-        return schema;
-    }
-    processModelProperty(prop) {
-        const schema = this.processSchema(prop, prop.name);
-        let nullable = isNullableType(prop.type);
+    processModelPropertyFromSdkType(prop) {
+        const rawModelPropertyType = prop.__raw;
+        // TODO: This case is related with literal.tsp, once TCGC supports giving a name, we can use TCGC generatedName
+        const schemaNameHint = pascalCase(getNamePrefixForProperty(rawModelPropertyType)) + pascalCase(prop.name);
+        let schema = this.processSchemaFromSdkType(prop.type, schemaNameHint);
+        let nullable = prop.nullable;
         let extensions = undefined;
         if (this.isSecret(prop)) {
             extensions = extensions !== null && extensions !== void 0 ? extensions : {};
@@ -1921,66 +1634,43 @@ export class CodeModelBuilder {
             // if the property does not return in response, it had to be nullable
             nullable = true;
         }
-        if (shouldFlattenProperty(this.sdkContext, prop)) {
+        if (prop.kind === "property" && prop.flatten) {
             extensions = extensions !== null && extensions !== void 0 ? extensions : {};
             extensions["x-ms-client-flatten"] = true;
         }
-        return new Property(this.getName(prop), this.getDoc(prop), schema, {
-            summary: this.getSummary(prop),
+        if (prop.kind === "property" && prop.isMultipartFileInput) {
+            schema = this.processMultipartFormDataFilePropertySchemaFromSdkType(prop, this.namespace);
+        }
+        return new Property(prop.name, this.getDoc(rawModelPropertyType), schema, {
+            summary: this.getSummary(rawModelPropertyType),
             required: !prop.optional,
             nullable: nullable,
             readOnly: this.isReadOnly(prop),
-            // clientDefaultValue: this.getDefaultValue(prop.default),
-            serializedName: this.getSerializedName(prop),
+            serializedName: prop.kind === "property" ? prop.serializedName : undefined,
             extensions: extensions,
         });
     }
-    processFormatString(type, format, nameHint) {
-        switch (format) {
-            case "byte":
-                return this.processByteArraySchema(type, nameHint, true);
-            case "binary":
-                return this.processByteArraySchema(type, nameHint, false);
-            case "date-time":
-                return this.processDateTimeSchema(type, nameHint, false);
-            case "date-time-rfc1123":
-                return this.processDateTimeSchema(type, nameHint, true);
-            case "password":
-            case "url":
-            case "uuid":
-            case "eTag":
-                return this.processStringSchema(type, nameHint);
-            default:
-                this.logWarning(`Unrecognized string format: '${format}'.`);
-                return this.processStringSchema(type, nameHint);
-        }
-    }
-    processUnionSchema(type, name) {
-        const nonNullVariants = Array.from(type.variants.values()).filter((it) => !isNullType(it.type));
-        if (nonNullVariants.length === 1) {
-            // nullable
-            return this.processSchema(nonNullVariants[0].type, name);
-        }
-        const unionEnum = ignoreDiagnostics(getUnionAsEnum(type));
-        if (unionEnum) {
-            // enum
-            return this.processChoiceSchemaForUnion(type, unionEnum, name);
+    processUnionSchemaFromSdkType(type, name) {
+        var _a;
+        if (!(type.__raw && type.__raw.kind === "Union")) {
+            throw new Error(`Invalid type for union: '${type.kind}'.`);
         }
+        const rawUnionType = type.__raw;
         // TODO: name from typespec-client-generator-core
-        const namespace = getNamespace(type);
-        const baseName = pascalCase(name) + "Model";
-        this.logWarning(`Convert TypeSpec Union '${getUnionDescription(type, this.typeNameOptions)}' to Class '${baseName}'`);
-        const unionSchema = new OrSchema(baseName + "Base", this.getDoc(type), {
-            summary: this.getSummary(type),
+        const namespace = getNamespace(rawUnionType);
+        const baseName = (_a = type.name) !== null && _a !== void 0 ? _a : pascalCase(name) + "Model";
+        this.logWarning(`Convert TypeSpec Union '${getUnionDescription(rawUnionType, this.typeNameOptions)}' to Class '${baseName}'`);
+        const unionSchema = new OrSchema(baseName + "Base", this.getDoc(rawUnionType), {
+            summary: this.getSummary(rawUnionType),
         });
         unionSchema.anyOf = [];
-        nonNullVariants.forEach((it) => {
-            const variantName = this.getUnionVariantName(it.type, { depth: 0 });
+        type.values.forEach((it) => {
+            const variantName = this.getUnionVariantName(it.__raw, { depth: 0 });
             const modelName = variantName + baseName;
             const propertyName = "value";
             // these ObjectSchema is not added to codeModel.schemas
-            const objectSchema = new ObjectSchema(modelName, this.getDoc(type), {
-                summary: this.getSummary(type),
+            const objectSchema = new ObjectSchema(modelName, this.getDoc(rawUnionType), {
+                summary: this.getSummary(rawUnionType),
                 language: {
                     default: {
                         namespace: namespace,
@@ -1990,11 +1680,10 @@ export class CodeModelBuilder {
                     },
                 },
             });
-            const variantSchema = this.processSchema(it.type, variantName);
-            objectSchema.addProperty(new Property(propertyName, this.getDoc(type), variantSchema, {
-                summary: this.getSummary(type),
+            const variantSchema = this.processSchemaFromSdkType(it, variantName);
+            objectSchema.addProperty(new Property(propertyName, this.getDoc(rawUnionType), variantSchema, {
+                summary: this.getSummary(rawUnionType),
                 required: true,
-                nullable: true,
                 readOnly: false,
             }));
             unionSchema.anyOf.push(objectSchema);
@@ -2008,6 +1697,9 @@ export class CodeModelBuilder {
     }
     getUnionVariantName(type, option) {
         var _a;
+        if (type === undefined) {
+            throw new Error("type is undefined.");
+        }
         switch (type.kind) {
             case "Scalar": {
                 const scalarName = type.name;
@@ -2062,40 +1754,26 @@ export class CodeModelBuilder {
                 throw new Error(`Unrecognized type for union variable: '${type.kind}'.`);
         }
     }
-    processMultipartFormDataSchema(schema) {
-        if (schema.properties) {
-            for (const property of schema.properties) {
-                if (property.schema instanceof ByteArraySchema) {
-                    property.schema = getFileDetailsSchema(property.language.default.name, schema.language.default.namespace, this.codeModel.schemas, this.binarySchema, this.stringSchema);
-                }
-                else if (property.schema instanceof ArraySchema && property.schema.elementType instanceof ByteArraySchema) {
-                    property.schema = new ArraySchema(property.language.default.name, property.language.default.description, getFileDetailsSchema(property.language.default.name, schema.language.default.namespace, this.codeModel.schemas, this.binarySchema, this.stringSchema));
-                }
-            }
+    processMultipartFormDataFilePropertySchemaFromSdkType(property, namespace) {
+        var _a;
+        if (property.type.kind === "bytes") {
+            return getFileDetailsSchema(property.name, namespace, this.codeModel.schemas, this.binarySchema, this.stringSchema);
         }
-    }
-    getDefaultValue(type) {
-        if (type) {
-            switch (type.kind) {
-                case "String":
-                    return type.value;
-                case "Number":
-                    return type.value;
-                case "Boolean":
-                    return type.value;
-                // case "Tuple":
-                //   return type.values.map(getDefaultValue);
-            }
+        else if (property.type.kind === "array" && property.type.valueType.kind === "bytes") {
+            return new ArraySchema(property.name, (_a = property.description) !== null && _a !== void 0 ? _a : "", getFileDetailsSchema(property.name, namespace, this.codeModel.schemas, this.binarySchema, this.stringSchema));
         }
-        return undefined;
+        throw new Error(`Invalid type for multipart form data: '${property.type.kind}'.`);
     }
     getDoc(target) {
-        return getDoc(this.program, target) || "";
+        return target ? getDoc(this.program, target) || "" : "";
     }
     getSummary(target) {
-        return getSummary(this.program, target);
+        return target ? getSummary(this.program, target) : undefined;
     }
     getName(target, nameHint = undefined) {
+        if (!target) {
+            return nameHint || "";
+        }
         // 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") {
@@ -2139,13 +1817,12 @@ export class CodeModelBuilder {
         return getWireName(this.sdkContext, target);
     }
     isReadOnly(target) {
-        // const key = isKey(this.program, target);
-        const segment = getSegment(this.program, target) !== undefined;
+        const segment = target.__raw ? getSegment(this.program, target.__raw) !== undefined : false;
         if (segment) {
             return true;
         }
         else {
-            const visibility = getVisibility(this.program, target);
+            const visibility = target.__raw ? getVisibility(this.program, target.__raw) : undefined;
             if (visibility) {
                 return (!visibility.includes("write") &&
                     !visibility.includes("create") &&
@@ -2159,9 +1836,8 @@ export class CodeModelBuilder {
         }
     }
     isSecret(target) {
-        const visibility = getVisibility(this.program, target);
-        if (visibility) {
-            return !visibility.includes("read");
+        if (target.kind === "property" && target.visibility) {
+            return !target.visibility.includes(Visibility.Read);
         }
         else {
             return false;
@@ -2352,22 +2028,5 @@ export class CodeModelBuilder {
     isArm() {
         return Boolean(this.codeModel.arm);
     }
-    isSchemaUsageEmpty(schema) {
-        if (schema instanceof ObjectSchema ||
-            schema instanceof GroupSchema ||
-            schema instanceof ChoiceSchema ||
-            schema instanceof SealedChoiceSchema ||
-            schema instanceof OrSchema ||
-            schema instanceof ConstantSchema) {
-            return !(schema.usage && schema.usage.length > 0);
-        }
-        else if (schema instanceof DictionarySchema) {
-            return this.isSchemaUsageEmpty(schema.elementType);
-        }
-        else if (schema instanceof ArraySchema) {
-            return this.isSchemaUsageEmpty(schema.elementType);
-        }
-        return false;
-    }
 }
 //# sourceMappingURL=code-model-builder.js.map