@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/dist/src/utils/model-utils.js

@@ -0,0 +1,1480 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { getUnionAsEnum } from "@azure-tools/typespec-azure-core";
+import { getDefaultApiVersion, getWireName, isApiVersion, } from "@azure-tools/typespec-client-generator-core";
+import { NoTarget, getDiscriminator, getDoc, getEffectiveModelType, getEncode, getFormat, getFriendlyName, getLifecycleVisibilityEnum, getMaxLength, getMaxValue, getMinLength, getMinValue, getPattern, getProperty, getPropertyType, getSummary, getVisibilityForClass, isArrayModelType, isNeverType, isNullType, isNumericType, isRecordModelType, isSecret, isStringType, isTemplateDeclaration, isUnknownType, listServices, } from "@typespec/compiler";
+import { Visibility, getHeaderFieldName, getHttpFileModel, getHttpPart, getPathParamName, getQueryParamName, isBody, isStatusCode, } from "@typespec/http";
+import { NameType, SchemaContext, isArraySchema, normalizeName, } from "../rlc-common/index.js";
+import { KnownMediaType, hasMediaType, isMediaTypeMultipartFormData } from "./media-types.js";
+import { reportDiagnostic } from "../lib.js";
+import { getModelNamespaceName } from "./namespace-utils.js";
+export const BINARY_TYPE_UNION = "string | Uint8Array | ReadableStream<Uint8Array> | NodeReadableStream";
+export const BINARY_AND_FILE_TYPE_UNION = `${BINARY_TYPE_UNION} | File`;
+export function getBinaryType(usage) {
+    return usage.includes(SchemaContext.Output) ? "Uint8Array" : BINARY_TYPE_UNION;
+}
+export function isByteOrByteUnion(dpgContext, type) {
+    const schema = getSchemaForType(dpgContext, type);
+    return isBytesType(schema) || isBytesUnion(schema);
+}
+function isBytesType(schema) {
+    return schema.type === "string" && (schema.format === "bytes" || schema.format === "binary");
+}
+function isBytesUnion(schema) {
+    if (!Array.isArray(schema.enum)) {
+        return false;
+    }
+    for (const ele of schema.enum) {
+        if (isBytesType(ele)) {
+            return true;
+        }
+    }
+    return false;
+}
+function refineByteType(schema) {
+    schema.typeName = getBinaryType([SchemaContext.Input, SchemaContext.Exception]);
+    schema.outputTypeName = getBinaryType([SchemaContext.Output]);
+    return schema;
+}
+export function enrichBinaryTypeInBody(schema) {
+    if (isBytesType(schema)) {
+        refineByteType(schema);
+    }
+    else if (isBytesUnion(schema)) {
+        const inputType = [];
+        for (const item of schema.enum) {
+            if (isBytesType(item)) {
+                refineByteType(item);
+            }
+            // ignore the string type for input because we already have it in bytes union
+            if (getTypeName(item, [SchemaContext.Input]) !== "string") {
+                inputType.push(getTypeName(item, [SchemaContext.Input]));
+            }
+        }
+        // refine the input type
+        schema.typeName = inputType.join(" | ");
+    }
+    return schema;
+}
+export function getSchemaForType(dpgContext, typeInput, options) {
+    const program = dpgContext.program;
+    const { usage } = options ?? {};
+    const type = getEffectiveModelFromType(dpgContext, typeInput);
+    const builtinType = getSchemaForLiteral(type);
+    if (builtinType !== undefined) {
+        // add in description elements for types derived from primitive types (SecureString, etc.)
+        const doc = getDoc(program, type);
+        if (doc) {
+            builtinType.description = doc;
+        }
+        return builtinType;
+    }
+    if (type.kind === "ModelProperty") {
+        return getSchemaForType(dpgContext, type.type, options);
+    }
+    if (type.kind === "Model") {
+        const httpPart = getHttpPart(program, type);
+        if (httpPart) {
+            const fileModel = getHttpFileModel(program, httpPart.type);
+            if (fileModel) {
+                const schema = getSchemaForType(dpgContext, fileModel.contents, options);
+                return {
+                    ...schema,
+                    multipartOptions: {
+                        filenameSchema: {
+                            required: !fileModel.filename.optional,
+                            ...getSchemaForType(dpgContext, fileModel.filename, options),
+                        },
+                        contentTypeSchema: {
+                            required: !fileModel.contentType.optional,
+                            ...getSchemaForType(dpgContext, fileModel.contentType, options),
+                        },
+                    },
+                };
+            }
+            else {
+                // extract body if required
+                const body = (httpPart.type.kind === "Model" &&
+                    [...httpPart.type.properties.values()].find((x) => isBody(program, x))) ||
+                    httpPart.type;
+                return getSchemaForType(dpgContext, body, options);
+            }
+        }
+        const schema = getSchemaForModel(dpgContext, type, options);
+        if (isAnonymousObjectSchema(schema)) {
+            if (Object.keys(schema.properties ?? {}).length === 0) {
+                // Handle empty anonymous model as Record
+                schema.typeName = schema.type === "object" ? "Record<string, unknown>" : "unknown";
+                if (usage && usage.includes(SchemaContext.Output)) {
+                    schema.outputTypeName = schema.type === "object" ? "Record<string, any>" : "any";
+                }
+                schema.type = "unknown";
+            }
+            else {
+                // Handle non-empty anonymous model as inline model
+                if (usage && usage.includes(SchemaContext.Output)) {
+                    schema.outputTypeName = getModelInlineSigniture(schema, {
+                        usage: [SchemaContext.Output],
+                    });
+                }
+                schema.typeName = getModelInlineSigniture(schema, {
+                    usage: [SchemaContext.Input],
+                    multipart: options?.isRequestBody && isMediaTypeMultipartFormData(options?.mediaTypes ?? []),
+                });
+                schema.type = "object";
+            }
+        }
+        else if (!isArrayModelType(type) && !isRecordModelType(type)) {
+            if (usage && usage.includes(SchemaContext.Output)) {
+                schema.outputTypeName = `${schema.name}Output`;
+            }
+            schema.typeName = `${schema.name}`;
+        }
+        schema.usage = usage;
+        return schema;
+    }
+    else if (type.kind === "Union") {
+        return getSchemaForUnion(dpgContext, type, options);
+    }
+    else if (type.kind === "UnionVariant") {
+        return getSchemaForUnionVariant(dpgContext, type, options);
+    }
+    else if (type.kind === "Enum") {
+        return getSchemaForEnum(dpgContext, type);
+    }
+    else if (type.kind === "Scalar") {
+        return getSchemaForScalar(dpgContext, type, options);
+    }
+    else if (type.kind === "EnumMember") {
+        return getSchemaForEnumMember(program, type);
+    }
+    if (isUnknownType(type)) {
+        const returnType = { name: "unknown", type: "unknown" };
+        if (usage && usage.includes(SchemaContext.Output)) {
+            returnType.outputTypeName = "any";
+            returnType.typeName = "unknown";
+        }
+        return returnType;
+    }
+    if (isNeverType(type)) {
+        return { name: "never", type: "never" };
+    }
+    if (isNullType(type)) {
+        return { name: "null", type: "null" };
+    }
+    if (type.kind === "Intrinsic" && type.name === "void") {
+        return { name: "void", type: "void" };
+    }
+    reportDiagnostic(program, {
+        code: "invalid-schema",
+        format: {
+            type: type.kind,
+            property: options?.relevantProperty?.name ?? "",
+        },
+        target: type,
+    });
+    return undefined;
+}
+export function getEffectiveModelFromType(context, type) {
+    /**
+     * If type is an anonymous model, tries to find a named model that has the same
+     * set of properties when non-schema properties are excluded.
+     */
+    if (type.kind === "Model" && type.name === "") {
+        const effective = getEffectiveModelType(context.program, type, (property) => isSchemaProperty(context.program, property));
+        if (effective.name) {
+            return effective;
+        }
+    }
+    return type;
+}
+export function includeDerivedModel(model, needRef = false) {
+    return (!needRef &&
+        !isTemplateDeclaration(model) &&
+        (!model.templateMapper ||
+            !model.templateMapper.args ||
+            model.templateMapper.args?.length === 0 ||
+            model.derivedModels.length > 0));
+}
+function applyEncoding(dpgContext, typespecType, target = {}) {
+    const encodeData = getEncode(dpgContext.program, typespecType);
+    if (encodeData) {
+        const newTarget = { ...target };
+        const newType = getSchemaForScalar(dpgContext, encodeData.type);
+        newTarget["type"] = newType["type"];
+        newTarget["typeName"] = newType["typeName"];
+        newTarget["outputTypeName"] = newType["outputTypeName"];
+        // If the target already has a format it takes priority. (e.g. int32)
+        newTarget["format"] = mergeFormatAndEncoding(newTarget.format, encodeData.encoding, newType["format"]);
+        return newTarget;
+    }
+    return target;
+}
+function mergeFormatAndEncoding(format, encoding, encodeAsFormat) {
+    switch (format) {
+        case undefined:
+            return encodeAsFormat ?? encoding ?? format;
+        case "date-time":
+            return encoding;
+        case "duration":
+        default:
+            return encodeAsFormat ?? encoding ?? format;
+    }
+}
+function getSchemaForScalar(dpgContext, scalar, options) {
+    let result = {};
+    const isStd = dpgContext.program.checker.isStdType(scalar);
+    const { relevantProperty, isRequestBody, isParentRequestBody, mediaTypes: contentTypes, } = options ?? {};
+    if (isStd) {
+        result = getSchemaForStdScalar(dpgContext.program, scalar, {
+            relevantProperty,
+        });
+    }
+    else if (scalar.baseScalar) {
+        result = getSchemaForScalar(dpgContext, scalar.baseScalar);
+    }
+    if (isBinaryAsRequestBody()) {
+        // bytes in the body of application/octet-stream is the raw binary payload/file
+        result.typeName = BINARY_TYPE_UNION;
+        result.outputTypeName = "Uint8Array";
+        return result;
+    }
+    else if (isFormDataBytesInRequestBody()) {
+        // bytes inside a multipart part (for now) is assumed to be file
+        result.typeName = BINARY_AND_FILE_TYPE_UNION;
+        result.outputTypeName = "Uint8Array";
+        return result;
+    }
+    else {
+        // for other cases we would trust the @encode decorator if not present we would treat it as string
+        const withDecorators = applyEncoding(dpgContext, scalar, result ? applyIntrinsicDecorators(dpgContext.program, scalar, result) : undefined);
+        if (withDecorators.type === "string" && withDecorators.format === "binary") {
+            withDecorators.typeName = BINARY_TYPE_UNION;
+            withDecorators.outputTypeName = "Uint8Array";
+        }
+        return withDecorators;
+    }
+    function isBinaryAsRequestBody() {
+        return (hasMediaType(KnownMediaType.Binary, contentTypes) && isRequestBody && isBytesType(result));
+    }
+    function isFormDataBytesInRequestBody() {
+        return (hasMediaType(KnownMediaType.MultipartFormData, contentTypes) &&
+            isParentRequestBody &&
+            isBytesType(result));
+    }
+}
+function getSchemaForUnion(dpgContext, union, options) {
+    const [asEnum, _] = getUnionAsEnum(union);
+    const variants = Array.from(union.variants.values());
+    const values = [];
+    let namedUnionMember = false;
+    if (!(options?.needRef && union.name && !asEnum)) {
+        if (asEnum?.open && asEnum.members.size > 0) {
+            for (const [_, member] of asEnum.members.entries()) {
+                const memberType = getSchemaForType(dpgContext, member.type, {
+                    ...options,
+                    needRef: options?.needRef ?? false,
+                });
+                values.push(memberType);
+                if (memberType.name) {
+                    namedUnionMember = true;
+                }
+            }
+        }
+        else {
+            for (const variant of variants) {
+                // We already know it's not a model type
+                const variantType = getSchemaForType(dpgContext, variant.type, {
+                    ...options,
+                    needRef: isAnonymousModelType(variant.type) ? false : true,
+                });
+                values.push(variantType);
+                if (variantType.typeName) {
+                    namedUnionMember = true;
+                }
+            }
+        }
+    }
+    const schema = {};
+    if (values.length > 0) {
+        schema.enum = values;
+        const unionAlias = asEnum?.open && asEnum?.kind && !namedUnionMember
+            ? asEnum.kind + (asEnum.nullable ? " | null" : "")
+            : values.map((item) => `${getTypeName(item, [SchemaContext.Input]) ?? item}`).join(" | ");
+        const outputUnionAlias = asEnum?.open && asEnum?.kind && !namedUnionMember
+            ? asEnum.kind + (asEnum.nullable ? " | null" : "")
+            : values.map((item) => `${getTypeName(item, [SchemaContext.Output]) ?? item}`).join(" | ");
+        schema.alias = unionAlias;
+        schema.outputAlias = outputUnionAlias;
+    }
+    if (!union.expression) {
+        const unionName = union.name ? normalizeName(union.name, NameType.Interface) : undefined;
+        schema.name = unionName;
+        schema.type = "object";
+        schema.typeName = unionName;
+        schema.outputTypeName = unionName + "Output";
+    }
+    else if (union.expression && !union.name) {
+        schema.type = "union";
+        schema.typeName = schema.alias;
+        schema.outputTypeName = schema.outputAlias;
+        delete schema.alias;
+        delete schema.outputAlias;
+    }
+    else {
+        schema.type = "union";
+        schema.typeName = union.name ?? schema.alias;
+        schema.outputTypeName = union.name ? union.name + "Output" : schema.outputAlias;
+        delete schema.alias;
+        delete schema.outputAlias;
+    }
+    return schema;
+}
+function getSchemaForUnionVariant(dpgContext, variant, options) {
+    return getSchemaForType(dpgContext, variant.type, options);
+}
+// An openapi "string" can be defined in several different ways in typespec
+function isOasString(type) {
+    if (type.kind === "String") {
+        // A string literal
+        return true;
+    }
+    else if (type.kind === "Scalar" && type.name === "string") {
+        // string type
+        return true;
+    }
+    else if (type.kind === "Union") {
+        // A union where all variants are an OasString
+        for (const variant of type.variants) {
+            if (!isOasString(variant[1].type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (type.kind === "UnionVariant") {
+        // A union variant where the type is an OasString
+        return isOasString(type.type);
+    }
+    return false;
+}
+function isStringLiteral(type) {
+    if (type.kind === "Union") {
+        // A union where all variants are an OasString
+        for (const variant of type.variants) {
+            if (!isStringLiteral(variant[1].type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return (type.kind === "String" ||
+        (type.kind === "EnumMember" && typeof (type.value ?? type.name) === "string") ||
+        (type.kind === "UnionVariant" && type.type.kind === "String"));
+}
+// Return any string literal values for type
+function getStringValues(type) {
+    switch (type.kind) {
+        case "String":
+            return [type.value];
+        case "Union":
+            return [...type.variants.values()]
+                .flatMap((x) => getStringValues(x.type))
+                .filter((x) => x !== undefined);
+        case "EnumMember":
+            return typeof type.value !== "number" ? [type.value ?? type.name] : [];
+        case "UnionVariant":
+            return getStringValues(type.type);
+        default:
+            return [];
+    }
+}
+function validateDiscriminator(program, discriminator, derivedModels) {
+    const { propertyName } = discriminator;
+    const retVals = derivedModels.map((t) => {
+        const prop = getProperty(t, propertyName);
+        if (!prop) {
+            reportDiagnostic(program, {
+                code: "discriminator",
+                messageId: "missing",
+                target: t,
+            });
+            return false;
+        }
+        let retval = true;
+        if (!isOasString(prop.type) && prop.type.kind !== "EnumMember" && prop.type.kind !== "Enum") {
+            reportDiagnostic(program, {
+                code: "discriminator",
+                messageId: "type",
+                target: prop,
+            });
+            retval = false;
+        }
+        if (prop.optional) {
+            reportDiagnostic(program, {
+                code: "discriminator",
+                messageId: "required",
+                target: prop,
+            });
+            retval = false;
+        }
+        return retval;
+    });
+    // Map of discriminator value to the model in which it is declared
+    const discriminatorValues = new Map();
+    for (const t of derivedModels) {
+        // Get the discriminator property directly in the child model
+        const prop = t.properties?.get(propertyName);
+        // Issue warning diagnostic if discriminator property missing or is not a string literal
+        if (!prop || !isStringLiteral(prop.type)) {
+            reportDiagnostic(program, {
+                code: "discriminator-value",
+                messageId: "literal",
+                target: prop || t,
+            });
+        }
+        if (prop) {
+            const vals = getStringValues(prop.type);
+            vals.forEach((val) => {
+                if (discriminatorValues.has(val)) {
+                    reportDiagnostic(program, {
+                        code: "discriminator",
+                        messageId: "duplicate",
+                        format: {
+                            val: val,
+                            model1: discriminatorValues.get(val),
+                            model2: t.name,
+                        },
+                        target: prop,
+                    });
+                    retVals.push(false);
+                }
+                else {
+                    discriminatorValues.set(val, t.name);
+                }
+            });
+        }
+    }
+    return retVals.every((v) => v);
+}
+function getSchemaForModel(dpgContext, model, options) {
+    const { usage, needRef, isRequestBody, mediaTypes: contentTypes } = options ?? {};
+    if (isArrayModelType(model)) {
+        return getSchemaForArrayModel(dpgContext, model, options);
+    }
+    const program = dpgContext.program;
+    const isMultipartBody = isMediaTypeMultipartFormData(contentTypes ?? []);
+    const isCoreModel = isAzureCoreErrorType(program, model);
+    const modelSchema = {
+        name: getModelName(dpgContext, model),
+        type: "object",
+        isMultipartBody,
+        description: getDoc(program, model) ?? "",
+        fromCore: isCoreModel,
+    };
+    // normalized the output name
+    modelSchema.name = normalizeName(modelSchema.name, NameType.Interface, true /** shouldGuard */);
+    if (model.name === "Record" && isRecordModelType(model)) {
+        return getSchemaForRecordModel(dpgContext, model, { usage });
+    }
+    modelSchema.typeName = modelSchema.name;
+    if (usage && usage.includes(SchemaContext.Output)) {
+        modelSchema.outputTypeName = modelSchema.name + "Output";
+    }
+    modelSchema.properties = {};
+    // getSchemaOrRef on all children to push them into components.schemas
+    const discriminator = getDiscriminator(program, model);
+    // should respect needRef for derived models unless there's a discriminator in base model
+    const derivedModels = model.derivedModels.filter((dm) => {
+        return includeDerivedModel(dm, discriminator ? false : needRef);
+    });
+    if (derivedModels.length > 0) {
+        modelSchema.children = {
+            all: [],
+            immediate: [],
+        };
+    }
+    for (const child of derivedModels) {
+        const childSchema = getSchemaForType(dpgContext, child, {
+            usage,
+            needRef: true,
+        });
+        for (const [name, prop] of child.properties) {
+            if (name === discriminator?.propertyName) {
+                const propSchema = getSchemaForType(dpgContext, prop.type, {
+                    usage,
+                    needRef: !isAnonymousModelType(prop.type),
+                    relevantProperty: prop,
+                });
+                childSchema.discriminatorValue = propSchema.type.replace(/"/g, "");
+                break;
+            }
+        }
+        modelSchema.children?.all?.push(childSchema);
+        modelSchema.children?.immediate?.push(childSchema);
+    }
+    // Enable option `isPolyParent` and discriminator only when it has valid children
+    if (discriminator &&
+        modelSchema?.children?.all?.length &&
+        modelSchema?.children?.all?.length > 0) {
+        if (!validateDiscriminator(program, discriminator, derivedModels)) {
+            // appropriate diagnostic is generated in the validate function
+            return {};
+        }
+        const { propertyName } = discriminator;
+        modelSchema.discriminator = {
+            name: propertyName,
+            type: "string",
+            description: `Discriminator property for ${model.name}.`,
+        };
+        modelSchema.discriminatorValue = propertyName;
+        modelSchema.isPolyParent = true;
+    }
+    // applyExternalDocs(model, modelSchema);
+    if (needRef) {
+        return modelSchema;
+    }
+    if (isRecordModelType(model)) {
+        modelSchema.parents = {
+            all: [getSchemaForRecordModel(dpgContext, model, { usage })],
+            immediate: [getSchemaForRecordModel(dpgContext, model, { usage })],
+        };
+    }
+    for (const [propName, prop] of model.properties) {
+        const restApiName = getWireName(dpgContext, prop);
+        const name = `"${restApiName ?? propName}"`;
+        if (!isSchemaProperty(program, prop)) {
+            continue;
+        }
+        const propSchema = getSchemaForType(dpgContext, prop.type, {
+            usage,
+            needRef: isAnonymousModelType(prop.type) ? false : true,
+            relevantProperty: prop,
+            isParentRequestBody: isRequestBody,
+            isRequestBody: false,
+            mediaTypes: contentTypes,
+        });
+        if (propSchema === undefined) {
+            continue;
+        }
+        if (!prop.optional) {
+            propSchema.required = true;
+        }
+        const propertyDescription = getFormattedPropertyDoc(program, prop, propSchema);
+        propSchema.usage = usage;
+        // Use the description from ModelProperty not derived from Model Type
+        propSchema.description = propertyDescription;
+        modelSchema.properties[name] = propSchema;
+        // if this property is a discriminator property, remove it to keep autorest validation happy
+        const { propertyName } = getDiscriminator(program, model) || {};
+        if (propertyName && name === `"${propertyName}"` && modelSchema.discriminator) {
+            modelSchema.discriminator = {
+                ...modelSchema.discriminator,
+                ...{
+                    type: propSchema.typeName ?? propSchema.type,
+                    typeName: propSchema.typeName,
+                    outputTypeName: propSchema.outputTypeName,
+                },
+            };
+            continue;
+        }
+        // Apply decorators on the property to the type's schema
+        const newPropSchema = applyIntrinsicDecorators(program, prop, propSchema);
+        if (newPropSchema === undefined) {
+            continue;
+        }
+        // Use the description from ModelProperty not devired from Model Type
+        newPropSchema.description = propertyDescription;
+        // Should the property be marked as readOnly?
+        const vis = getSdkVisibility(program, prop);
+        if (vis && vis.includes(Visibility.Read)) {
+            const mutability = [];
+            if (vis.includes(Visibility.Read)) {
+                if (vis.length > 1) {
+                    mutability.push(SchemaContext.Output);
+                }
+                else {
+                    newPropSchema["readOnly"] = true;
+                }
+            }
+            if (vis.includes(Visibility.Create) || vis.includes(Visibility.Update)) {
+                mutability.push(SchemaContext.Input);
+            }
+            if (mutability.length > 0) {
+                newPropSchema["usage"] = mutability;
+            }
+        }
+        modelSchema.properties[name] = newPropSchema;
+    }
+    if (model.baseModel) {
+        if (modelSchema.parents === undefined) {
+            modelSchema.parents = {
+                all: [],
+                immediate: [],
+            };
+        }
+        modelSchema.parents.all?.push(getSchemaForType(dpgContext, model.baseModel, {
+            usage,
+            needRef: true,
+        }));
+        modelSchema.parents.immediate?.push(getSchemaForType(dpgContext, model.baseModel, {
+            usage,
+            needRef: true,
+        }));
+    }
+    return modelSchema;
+}
+function getSdkVisibility(program, type) {
+    const lifecycle = getLifecycleVisibilityEnum(program);
+    const visibility = getVisibilityForClass(program, type, lifecycle);
+    if (visibility) {
+        const result = [];
+        if (lifecycle.members.get("Read") && visibility.has(lifecycle.members.get("Read"))) {
+            result.push(Visibility.Read);
+        }
+        if (lifecycle.members.get("Create") && visibility.has(lifecycle.members.get("Create"))) {
+            result.push(Visibility.Create);
+        }
+        if (lifecycle.members.get("Update") && visibility.has(lifecycle.members.get("Update"))) {
+            result.push(Visibility.Update);
+        }
+        if (lifecycle.members.get("Delete") && visibility.has(lifecycle.members.get("Delete"))) {
+            result.push(Visibility.Delete);
+        }
+        if (lifecycle.members.get("Query") && visibility.has(lifecycle.members.get("Query"))) {
+            result.push(Visibility.Query);
+        }
+        return result;
+    }
+    return undefined;
+}
+/**
+ * Return the model name for a given model
+ */
+function getModelName(dpgContext, model) {
+    const { program } = dpgContext;
+    // 1. check if this is an anonymous model
+    if (model.name === "") {
+        return "";
+    }
+    // 2. check if there's a friendly name
+    const friendlyName = getFriendlyName(program, model);
+    if (friendlyName) {
+        return friendlyName;
+    }
+    // 3. check if this is an Azure Core error model
+    const isCoreModel = isAzureCoreErrorType(program, model);
+    if (isCoreModel) {
+        return model.name;
+    }
+    // 4. check if this is a model with template arguments
+    let name = model.name;
+    if (model.templateMapper?.args) {
+        // const isPage = getPagedResult(program, model);
+        const templateTypeNames = model.templateMapper.args
+            .map((arg) => (arg.entityKind === "Indeterminate" ? arg.type : arg))
+            .map((arg) => {
+            switch (arg.kind) {
+                case "Model":
+                case "Enum":
+                case "Union":
+                case "Scalar":
+                    return arg.name ?? "";
+                case "String":
+                case "Boolean":
+                case "Number":
+                    return arg.value ?? "";
+                default:
+                    return "";
+            }
+        })
+            .filter((arg) => arg !== "")
+            .join(" ");
+        name = normalizeName(`${name} ${templateTypeNames}`, NameType.Interface);
+    }
+    let fullNamespacePrefix = getModelNamespaceName(dpgContext, model.namespace)
+        .map((nsName) => {
+        return normalizeName(nsName, NameType.Interface);
+    })
+        .join("");
+    if (fullNamespacePrefix.startsWith("AzureResourceManager") ||
+        fullNamespacePrefix.startsWith("AzureCore") ||
+        fullNamespacePrefix.startsWith("TypeSpecRest") ||
+        fullNamespacePrefix.startsWith("TypeSpecHttp")) {
+        fullNamespacePrefix = "";
+    }
+    // 5. check if this model should be namespaced
+    return dpgContext.rlcOptions?.enableModelNamespace ? `${fullNamespacePrefix}${name}` : name;
+}
+// Map an typespec type to an OA schema. Returns undefined when the resulting
+// OA schema is just a regular object schema.
+function getSchemaForLiteral(type) {
+    switch (type.kind) {
+        case "Number":
+            return { type: `${type.value}`, isConstant: true };
+        case "String":
+            return { type: `"${type.value}"`, isConstant: true };
+        case "Boolean":
+            return { type: `${type.value}`, isConstant: true };
+    }
+    if (type.kind === undefined) {
+        if (typeof type === "string") {
+            return { type: `"${type}"` };
+        }
+        else if (typeof type === "number" || typeof type === "boolean") {
+            return { type: `${type}` };
+        }
+    }
+    return undefined;
+}
+function applyIntrinsicDecorators(program, type, target) {
+    const newTarget = { ...target };
+    const docStr = getDoc(program, type);
+    const isString = isStringType(program, getPropertyType(type));
+    const isNumeric = isNumericType(program, getPropertyType(type));
+    if (isString && !target?.documentation && docStr) {
+        newTarget.description = docStr;
+    }
+    const summaryStr = getSummary(program, type);
+    if (isString && !target.summary && summaryStr) {
+        newTarget.summary = summaryStr;
+    }
+    const formatStr = getFormat(program, type);
+    if (isString && !target.format && formatStr) {
+        newTarget.format = formatStr;
+    }
+    const pattern = getPattern(program, type);
+    if (isString && !target.pattern && pattern) {
+        newTarget.pattern = pattern;
+    }
+    const minLength = getMinLength(program, type);
+    if (isString && !target.minLength && minLength !== undefined) {
+        newTarget.minLength = minLength;
+    }
+    const maxLength = getMaxLength(program, type);
+    if (isString && !target.maxLength && maxLength !== undefined) {
+        newTarget.maxLength = maxLength;
+    }
+    const minValue = getMinValue(program, type);
+    if (isNumeric && !target.minimum && minValue !== undefined) {
+        newTarget.minimum = minValue;
+    }
+    const maxValue = getMaxValue(program, type);
+    if (isNumeric && !target.maximum && maxValue !== undefined) {
+        newTarget.maximum = maxValue;
+    }
+    if (isSecret(program, type)) {
+        newTarget.format = "password";
+        newTarget["x-ms-secret"] = true;
+    }
+    return newTarget;
+}
+function getSchemaForEnumMember(program, e) {
+    const value = e.value ?? e.name;
+    const type = enumMemberType(e) === "string" ? `"${value}"` : `${value}`;
+    return { type, description: getDoc(program, e), isConstant: true };
+}
+function getSchemaForEnum(dpgContext, e) {
+    const values = [];
+    const memberValues = Array.from(e.members.values());
+    if (memberValues.length === 0) {
+        return {};
+    }
+    const type = enumMemberType(memberValues[0]);
+    for (const option of memberValues) {
+        if (type !== enumMemberType(option)) {
+            reportDiagnostic(dpgContext.program, {
+                code: "union-unsupported",
+                target: e,
+            });
+            continue;
+        }
+        values.push(getSchemaForType(dpgContext, option));
+    }
+    const schema = {
+        type: "object",
+        name: e.name,
+        typeName: normalizeName(e.name, NameType.Interface),
+        outputTypeName: normalizeName(e.name, NameType.Interface) + "Output",
+        description: getDoc(dpgContext.program, e),
+        memberType: type,
+    };
+    if (values.length > 0) {
+        schema.enum = values;
+        const unionAlias = values
+            .map((item) => `${getTypeName(item, [SchemaContext.Input]) ?? item}`)
+            .join(" | ");
+        schema.alias = unionAlias;
+        schema.outputAlias = unionAlias;
+    }
+    return schema;
+}
+function enumMemberType(member) {
+    const memberValue = member.value;
+    if (typeof memberValue === "number") {
+        return "number";
+    }
+    return "string";
+}
+/**
+ * Map TypeSpec intrinsic models to open api definitions
+ */
+function getSchemaForArrayModel(dpgContext, type, options) {
+    const { program } = dpgContext;
+    const { indexer } = type;
+    const { usage, isParentRequestBody, mediaTypes: contentTypes } = options ?? {};
+    let schema = {};
+    if (!indexer) {
+        return schema;
+    }
+    if (isArrayModelType(type)) {
+        schema = {
+            type: "array",
+            items: getSchemaForType(dpgContext, indexer.value, {
+                usage,
+                isRequestBody: false,
+                mediaTypes: contentTypes,
+                // special handling for array in formdata
+                isParentRequestBody: hasMediaType(KnownMediaType.MultipartFormData, contentTypes)
+                    ? isParentRequestBody
+                    : false,
+                needRef: !isAnonymousModelType(indexer.value),
+            }),
+            description: getDoc(program, type),
+        };
+        if (!program.checker.isStdType(indexer.value) &&
+            !isUnknownType(indexer.value) &&
+            indexer.value?.kind &&
+            schema.items.name &&
+            !schema.items.enum) {
+            schema.typeName = `Array<${schema.items.name}>`;
+            if (usage && usage.includes(SchemaContext.Output)) {
+                schema.outputTypeName = `Array<${schema.items.name}Output>`;
+            }
+        }
+        else {
+            if (schema.items.typeName) {
+                if (schema.items.type === "dictionary") {
+                    schema.typeName = `${schema.items.typeName}[]`;
+                    if (usage && usage.includes(SchemaContext.Output)) {
+                        schema.outputTypeName = `(${schema.items.outputTypeName})[]`;
+                    }
+                }
+                else if (schema.items.type === "union") {
+                    schema.typeName = `(${schema.items.typeName})[]`;
+                    if (usage && usage.includes(SchemaContext.Output)) {
+                        schema.outputTypeName = `(${schema.items.outputTypeName})[]`;
+                    }
+                }
+                else if (schema.items.typeName.includes(BINARY_TYPE_UNION) &&
+                    schema.items.type === "string") {
+                    schema.typeName = `(${schema.items.typeName})[]`;
+                    if (usage && usage.includes(SchemaContext.Output)) {
+                        schema.outputTypeName = `(${schema.items.outputTypeName})[]`;
+                    }
+                }
+                else if (isAnonymousObjectSchema(schema.items)) {
+                    schema.typeName = `${schema.items.typeName}[]`;
+                    if (usage && usage.includes(SchemaContext.Output)) {
+                        schema.outputTypeName = `${schema.items.outputTypeName}[]`;
+                    }
+                }
+                else {
+                    schema.typeName = schema.items.typeName
+                        .split("|")
+                        .map((typeName) => {
+                        return `${typeName}[]`;
+                    })
+                        .join(" | ");
+                    if (schema.items.outputTypeName && usage && usage.includes(SchemaContext.Output)) {
+                        schema.outputTypeName = schema.items.outputTypeName
+                            .split("|")
+                            .map((typeName) => {
+                            return `${typeName}[]`;
+                        })
+                            .join(" | ");
+                    }
+                }
+            }
+            else if (schema.items?.type?.includes("|")) {
+                schema.typeName = `(${schema.items.type})[]`;
+            }
+            else {
+                schema.typeName = `${schema.items.type}[]`;
+            }
+        }
+        schema.usage = usage;
+        return schema;
+    }
+}
+function getSchemaForRecordModel(dpgContext, type, options) {
+    const { program } = dpgContext;
+    const { indexer } = type;
+    const { usage } = options ?? {};
+    let schema = {};
+    if (!indexer) {
+        return schema;
+    }
+    if (isRecordModelType(type)) {
+        const valueType = getSchemaForType(dpgContext, indexer?.value, {
+            usage,
+            needRef: !isAnonymousModelType(indexer.value),
+        });
+        schema = {
+            type: "dictionary",
+            additionalProperties: valueType,
+            description: getDoc(program, type),
+        };
+        if (!program.checker.isStdType(indexer.value) &&
+            !isUnknownType(indexer.value) &&
+            !isUnionType(indexer.value)) {
+            schema.typeName = `Record<string, ${valueType.typeName}>`;
+            schema.valueTypeName = valueType.name;
+            if (usage && usage.includes(SchemaContext.Output)) {
+                schema.outputTypeName = `Record<string, ${valueType.outputTypeName}>`;
+                schema.outputValueTypeName = `${valueType.outputTypeName}`;
+            }
+        }
+        else if (isUnknownType(indexer.value)) {
+            schema.typeName = `Record<string, ${valueType.typeName ?? valueType.type}>`;
+            if (usage && usage.includes(SchemaContext.Output)) {
+                schema.outputTypeName = `Record<string, ${valueType.outputTypeName ?? valueType.type}>`;
+            }
+        }
+        else {
+            schema.typeName = `Record<string, ${getTypeName(valueType, [SchemaContext.Input])}>`;
+            schema.outputTypeName = `Record<string, ${getTypeName(valueType, [SchemaContext.Output])}>`;
+        }
+        schema.usage = usage;
+        return schema;
+    }
+}
+function isUnionType(type) {
+    return type.kind === "Union";
+}
+export function isObjectOrDictType(schema) {
+    return ((schema.type === "object" && schema.properties !== undefined) ||
+        schema.type === "dictionary");
+}
+export function isArrayType(schema) {
+    return schema.type === "array";
+}
+function getSchemaForStdScalar(program, type, options) {
+    const { relevantProperty } = options ?? {};
+    if (!program.checker.isStdType(type)) {
+        return undefined;
+    }
+    /**
+     * lookup for @encode decorator
+     *  if absent use typespec type (or default way of serializing that type)
+     *  if present respect type provided in @encode
+     */
+    let format = undefined;
+    if (relevantProperty) {
+        const encodeData = getEncode(program, relevantProperty);
+        if (encodeData && isEncodeTypeEffective(type, encodeData)) {
+            type = encodeData.type;
+            format = encodeData.encoding;
+        }
+    }
+    const name = type.name;
+    const description = getSummary(program, type);
+    switch (name) {
+        case "bytes":
+            return { type: "string", format: "bytes", description };
+        case "integer":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+            });
+        case "int8":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "int8",
+            });
+        case "int16":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "int16",
+            });
+        case "int32":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "int32",
+            });
+        case "int64":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "int64",
+            });
+        case "safeint":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "safeint",
+            });
+        case "numeric":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+            });
+        case "uint8":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "uint8",
+            });
+        case "uint16":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "uint16",
+            });
+        case "uint32":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "uint32",
+            });
+        case "uint64":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "uint64",
+            });
+        case "float64":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "float64",
+            });
+        case "float32":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "float32",
+            });
+        case "float":
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "float",
+            });
+        case "decimal":
+            reportDiagnostic(program, {
+                code: "decimal-to-number",
+                format: {
+                    propertyName: relevantProperty?.name ?? "",
+                },
+                target: relevantProperty ?? NoTarget,
+            });
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "decimal",
+                description: "decimal",
+            });
+        case "decimal128":
+            reportDiagnostic(program, {
+                code: "decimal-to-number",
+                format: {
+                    propertyName: relevantProperty?.name ?? "",
+                },
+                target: relevantProperty ?? NoTarget,
+            });
+            return applyIntrinsicDecorators(program, type, {
+                type: "number",
+                format: "decimal128",
+                description: "decimal128",
+            });
+        case "string":
+            if (format === "binary") {
+                return {
+                    type: "string",
+                    format: "binary",
+                    description,
+                    typeName: BINARY_TYPE_UNION,
+                    outputTypeName: "Uint8Array",
+                };
+            }
+            return applyIntrinsicDecorators(program, type, {
+                type: "string",
+            });
+        case "boolean":
+            return { type: "boolean", description };
+        case "plainDate":
+            return {
+                type: "string",
+                format,
+                description,
+                typeName: "string",
+                outputTypeName: "string",
+            };
+        case "utcDateTime":
+            return {
+                type: "string",
+                format,
+                description,
+                typeName: "Date | string",
+                outputTypeName: "string",
+            };
+        case "offsetDateTime":
+            return {
+                type: "string",
+                format: "date-time",
+                description,
+                typeName: "string",
+                outputTypeName: "string",
+            };
+        case "plainTime":
+            return {
+                type: "string",
+                format: "time",
+                description,
+                typeName: "string",
+                outputTypeName: "string",
+            };
+        case "duration":
+            return { type: "string", format, description };
+        case "url":
+            return { type: "string", format: "uri" };
+    }
+}
+function isEncodeTypeEffective(type, encodeData) {
+    if (!encodeData) {
+        return false;
+    }
+    const datetimeTypes = ["plaindate", "utcdatetime", "offsetdatetime", "plaintime"];
+    if (datetimeTypes.includes(type.name.toLowerCase()) && encodeData.type.name === "string") {
+        return false;
+    }
+    return true;
+}
+export function getTypeName(schema, usage) {
+    // TODO: Handle more cases
+    return getPriorityName(schema, usage) ?? schema.type ?? "any";
+}
+export function getImportedModelName(schema, usage) {
+    switch (schema.type) {
+        case "array": {
+            const ret = new Set();
+            [schema.items]
+                .filter((i) => !!i)
+                .forEach((i) => getImportedModelName(i, usage).forEach((it) => ret.add(it)));
+            return [...ret];
+        }
+        case "object": {
+            if (isAnonymousObjectSchema(schema)) {
+                const ret = new Set();
+                const properties = schema.properties ?? {};
+                for (const name in properties) {
+                    if (!properties[name]) {
+                        continue;
+                    }
+                    getImportedModelName(properties[name], usage).forEach((it) => ret.add(it));
+                }
+                return [...ret];
+            }
+            return getPriorityName(schema, usage) ? [getPriorityName(schema, usage)] : [];
+        }
+        case "dictionary": {
+            const ret = new Set();
+            [schema.additionalProperties]
+                .filter((i) => !!i)
+                .forEach((i) => getImportedModelName(i, usage).forEach((it) => ret.add(it)));
+            return [...ret];
+        }
+        case "union": {
+            const ret = new Set();
+            (schema.enum ?? [])
+                .filter((i) => !!i)
+                .forEach((i) => getImportedModelName(i, usage).forEach((it) => ret.add(it)));
+            return [...ret];
+        }
+        default:
+            return [];
+    }
+}
+function getPriorityName(schema, usage) {
+    return usage && usage.includes(SchemaContext.Input) && !usage.includes(SchemaContext.Output)
+        ? (schema.typeName ?? schema.name)
+        : (schema.outputTypeName ?? schema.typeName ?? schema.name);
+}
+function getEnumStringDescription(type) {
+    if ((type.name === "string" ||
+        type.alias === "string" ||
+        type.name === "number" ||
+        type.alias === "number" ||
+        type.name === "boolean" ||
+        type.alias === "boolean") &&
+        type.enum &&
+        type.enum.length > 0) {
+        return `Possible values: ${type.enum
+            .map((e) => {
+            return e.type;
+        })
+            .join(", ")}`;
+    }
+    return undefined;
+}
+function getBinaryDescription(type) {
+    if (type?.typeName?.includes(BINARY_TYPE_UNION)) {
+        return `Value may contain any sequence of octets`;
+    }
+    return undefined;
+}
+function getDecimalDescription(type) {
+    if ((type.format === "decimal" || type.format === "decimal128") && type.type === "number") {
+        return `NOTE: This property is represented as a 'number' in JavaScript, but it corresponds to a 'decimal' type in other languages.
+Due to the inherent limitations of floating-point arithmetic in JavaScript, precision issues may arise when performing arithmetic operations.
+If your application requires high precision for arithmetic operations or when round-tripping data back to other languages, consider using a library like decimal.js, which provides an arbitrary-precision Decimal type.
+For simpler cases, where you need to control the number of decimal places for display purposes, you can use the 'toFixed()' method. However, be aware that 'toFixed()' returns a string and may not be suitable for all arithmetic precision requirements.
+Always be cautious with direct arithmetic operations and consider implementing appropriate rounding strategies to maintain accuracy.
+   `;
+    }
+    return undefined;
+}
+export function getFormattedPropertyDoc(program, type, schemaType, sperator = "\n\n") {
+    const propertyDoc = getDoc(program, type);
+    const enhancedDocFromType = getEnumStringDescription(schemaType) ??
+        getDecimalDescription(schemaType) ??
+        getBinaryDescription(schemaType);
+    if (propertyDoc && enhancedDocFromType) {
+        return `${propertyDoc}${sperator}${enhancedDocFromType}`;
+    }
+    return propertyDoc ?? enhancedDocFromType;
+}
+export function getBodyType(route) {
+    const bodyModel = route.parameters.body?.type;
+    return bodyModel;
+}
+export function getValueTypeValue(value) {
+    switch (value.valueKind) {
+        case "ArrayValue":
+            return value.values.map((x) => getValueTypeValue(x));
+        case "BooleanValue":
+        case "StringValue":
+        case "NullValue":
+            return value.value;
+        case "NumericValue":
+            return value.value.asNumber();
+        case "EnumValue":
+            return value.value.value ?? value.value.name;
+        case "ObjectValue":
+            return Object.fromEntries([...value.properties.keys()].map((x) => [
+                x,
+                getValueTypeValue(value.properties.get(x).value),
+            ]));
+        default:
+            // TODO: handle scalar value
+            return undefined;
+    }
+}
+/**
+ * Predict if the default value exists in param, we would follow the rules:
+ * 1. If we have specific default literal in param
+ * 2. If we take the default api-version value into considerations
+ * @param program
+ * @param dpgContext
+ * @param param The param to predict
+ * @returns
+ */
+export function predictDefaultValue(dpgContext, param) {
+    if (!param) {
+        return;
+    }
+    const program = dpgContext.program;
+    const specificDefault = param.defaultValue ? getValueTypeValue(param.defaultValue) : undefined;
+    if (specificDefault) {
+        if (typeof specificDefault === "object") {
+            reportDiagnostic(program, {
+                code: "default-value-object",
+                format: {
+                    propertyName: param.name,
+                },
+                target: param,
+            });
+            return specificDefault.toString();
+        }
+        return specificDefault;
+    }
+    const serviceNamespace = getDefaultService(program, dpgContext.rlcOptions?.isModularLibrary)?.type;
+    if (!serviceNamespace) {
+        return;
+    }
+    const defaultApiVersion = getDefaultApiVersionString(dpgContext);
+    if (param && isApiVersion(dpgContext, param) && defaultApiVersion) {
+        return defaultApiVersion;
+    }
+    return;
+}
+export function getDefaultService(program, isModularLibrary = true) {
+    const services = listServices(program);
+    if (!services || services.length === 0) {
+        reportDiagnostic(program, {
+            code: "no-service-defined",
+            target: NoTarget,
+        });
+    }
+    if (services.length > 1 && !isModularLibrary) {
+        reportDiagnostic(program, {
+            code: "more-than-one-service",
+            target: NoTarget,
+        });
+    }
+    return services[0];
+}
+/**
+ * Return the default api version from the program; undefined if no default
+ */
+export function getDefaultApiVersionString(dpgContext) {
+    const program = dpgContext.program;
+    const isModularLibrary = dpgContext.rlcOptions?.isModularLibrary;
+    return getDefaultService(program, isModularLibrary)
+        ? getDefaultApiVersion(dpgContext, getDefaultService(program, isModularLibrary).type)?.value
+        : undefined;
+}
+export function trimUsage(model) {
+    if (typeof model !== "object") {
+        return model;
+    }
+    const tmpModel = Object.assign({}, model);
+    const tmpModelKeys = Object.keys(tmpModel).filter((item) => {
+        return item !== "usage";
+    });
+    const ordered = tmpModelKeys.sort().reduce((obj, key) => {
+        obj[key] = trimUsage(tmpModel[key]);
+        return obj;
+    }, {});
+    return ordered;
+}
+export function isAzureCoreErrorType(program, t) {
+    if (!t || t.kind !== "Model") {
+        return false;
+    }
+    const effective = getEffectiveSchemaType(program, t);
+    if (!["error", "errorresponse", "innererror"].includes(effective.name.toLowerCase())) {
+        return false;
+    }
+    return isAzureCoreFoundationsNamespace(effective);
+}
+function isAzureCoreFoundationsNamespace(t, skipFoundation = false) {
+    const namespaces = (skipFoundation ? ".Azure.Core" : ".Azure.Core.Foundations").split(".");
+    while (namespaces.length > 0 &&
+        (t?.kind === "Model" || t?.kind === "Enum" || t?.kind === "Union" || t?.kind === "Namespace") &&
+        t.namespace?.name === namespaces.pop()) {
+        t = t.namespace;
+    }
+    return namespaces.length === 0;
+}
+// Check if the schema is an anonymous object
+export function isAnonymousObjectSchema(schema) {
+    return schema.name === "" && schema.type === "object";
+}
+// Check if the type is an anonymous model
+export function isAnonymousModelType(type) {
+    if (type.kind === "Model") {
+        return type.name === "";
+    }
+    return false;
+}
+/**
+ * Get the inline signiture of the model
+ * @param schema object schema detail
+ * @param options other optional parameters
+ * @returns
+ */
+export function getModelInlineSigniture(schema, options = {}) {
+    if (options.multipart) {
+        return getMultipartInlineSignature(schema, options.importedModels, options.usage);
+    }
+    let schemaSignature = `{`;
+    for (const propName in schema.properties) {
+        const propType = schema.properties[propName];
+        const propTypeName = getTypeName(propType, options.usage);
+        if (!propType || !propTypeName) {
+            continue;
+        }
+        if (options.importedModels) {
+            const importNames = getImportedModelName(propType);
+            if (importNames) {
+                importNames.forEach(options.importedModels.add, options.importedModels);
+            }
+        }
+        const isOptional = propType.required ? "" : "?";
+        schemaSignature += `${propName}${isOptional}: ${propTypeName};`;
+    }
+    schemaSignature += `}`;
+    return schemaSignature;
+}
+function getMultipartInlineSignature(schema, importedModels, usage) {
+    const types = Object.entries(schema.properties ?? {})
+        .map(([propertyName, property]) => {
+        let schema;
+        // Flatten arrays for file uploads
+        if (isArraySchema(property) &&
+            property.items &&
+            getTypeName(property.items, usage).includes(BINARY_AND_FILE_TYPE_UNION)) {
+            schema = property.items;
+        }
+        else {
+            schema = property;
+        }
+        const typeName = getTypeName(schema, usage);
+        if (!typeName) {
+            return undefined;
+        }
+        const importNames = getImportedModelName(schema);
+        if (importedModels && importNames) {
+            importNames.forEach(importedModels.add.bind(importedModels));
+        }
+        if (typeName.includes("File")) {
+            return `{ name: ${propertyName}, body: ${typeName}, filename?: string, contentType?: string }`;
+        }
+        else {
+            return `{ name: ${propertyName}, body: ${typeName} }`;
+        }
+    })
+        .filter(Boolean)
+        .join(" | ");
+    return `FormData | Array<${types}>`;
+}
+/**
+ * A "schema property" here is a property that is emitted to OpenAPI schema.
+ *
+ * Headers, parameters, status codes are not schema properties even they are
+ * represented as properties in typespec.
+ */
+export function isSchemaProperty(program, property) {
+    const headerInfo = getHeaderFieldName(program, property);
+    const queryInfo = getQueryParamName(program, property);
+    const pathInfo = getPathParamName(program, property);
+    const statusCodeInfo = isStatusCode(program, property);
+    const isNonVisibility = getSdkVisibility(program, property)?.includes(Visibility.None);
+    return !(headerInfo || queryInfo || pathInfo || statusCodeInfo || isNonVisibility);
+}
+export function getEffectiveSchemaType(program, type) {
+    // If type is an anonymous model, tries to find a named model that has the same properties
+    let effective = undefined;
+    if (type.kind === "Union") {
+        return type;
+    }
+    else if (type.name === "") {
+        effective = getEffectiveModelType(program, type, (property) => isSchemaProperty(program, property));
+    }
+    if (effective?.name) {
+        return effective;
+    }
+    return type;
+}
+export function isBodyRequired(parameter) {
+    return parameter.body?.type && parameter.body?.property?.optional !== true ? true : false;
+}
+export function getCollectionFormat(context, param) {
+    const type = param.param;
+    const encode = getEncode(context.program, param.param);
+    if (type.type.kind === "Model" && isArrayModelType(type.type)) {
+        if (param.explode) {
+            return "multi";
+        }
+        switch (encode?.encoding) {
+            case "ArrayEncoding.pipeDelimited":
+                return "pipes";
+            case "ArrayEncoding.spaceDelimited":
+                return "ssv";
+            default:
+                return "csv";
+        }
+    }
+    return;
+}
+//# sourceMappingURL=model-utils.js.map