@azure-tools/typespec-ts 0.54.1 → 0.55.0-dev.2

package/dist/src/utils/modelUtils.js

@@ -1,1488 +0,0 @@
-// 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 "./mediaTypes.js";
-import { reportDiagnostic } from "../lib.js";
-import { getModelNamespaceName } from "./namespaceUtils.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") {
-        const nonNullOptions = [...type.variants.values()]
-            .map((x) => x.type)
-            .filter((t) => !isNullType(t));
-        if (nonNullOptions.length === 1 &&
-            nonNullOptions[0]?.kind === "Model" &&
-            nonNullOptions[0]?.name === "") {
-            effective = getEffectiveModelType(program, nonNullOptions[0]);
-        }
-        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=modelUtils.js.map