@typespec/openapi3 0.51.0-dev.1 → 0.51.0-dev.2

package/dist/src/openapi.js

@@ -1,11 +1,13 @@
-import { compilerAssert, emitFile, getAllTags, getAnyExtensionFromPath, getDiscriminatedUnion, getDiscriminator, getDoc, getEncode, getFormat, getKnownValues, getMaxItems, getMaxLength, getMaxValue, getMaxValueExclusive, getMinItems, getMinLength, getMinValue, getMinValueExclusive, getNamespaceFullName, getPattern, getService, getSummary, ignoreDiagnostics, interpolatePath, isArrayModelType, isDeprecated, isErrorType, isGlobalNamespace, isNeverType, isNullType, isRecordModelType, isSecret, isTemplateDeclaration, isVoidType, listServices, navigateTypesInNamespace, projectProgram, resolvePath, TwoLevelMap, } from "@typespec/compiler";
-import { createMetadataInfo, getAuthentication, getHttpService, getServers, getStatusCodeDescription, getVisibilitySuffix, isContentTypeHeader, isOverloadSameEndpoint, reportIfNoRoutes, resolveRequestVisibility, Visibility, } from "@typespec/http";
-import { checkDuplicateTypeName, getExtensions, getExternalDocs, getInfo, getOpenAPITypeName, getParameterKey, isDefaultResponse, isReadonlyProperty, resolveOperationId, shouldInline, } from "@typespec/openapi";
+import { compilerAssert, emitFile, getAllTags, getAnyExtensionFromPath, getDoc, getEncode, getFormat, getKnownValues, getMaxItems, getMaxLength, getMaxValue, getMaxValueExclusive, getMinItems, getMinLength, getMinValue, getMinValueExclusive, getNamespaceFullName, getPattern, getService, getSummary, ignoreDiagnostics, interpolatePath, isArrayModelType, isDeprecated, isErrorType, isGlobalNamespace, isNeverType, isNullType, isSecret, isVoidType, listServices, navigateTypesInNamespace, projectProgram, resolvePath, } from "@typespec/compiler";
+import { createMetadataInfo, getAuthentication, getHttpService, getServers, getStatusCodeDescription, isContentTypeHeader, isOverloadSameEndpoint, reportIfNoRoutes, resolveRequestVisibility, Visibility, } from "@typespec/http";
+import { getExtensions, getExternalDocs, getInfo, getOpenAPITypeName, getParameterKey, isDefaultResponse, isReadonlyProperty, resolveOperationId, shouldInline, } from "@typespec/openapi";
 import { buildVersionProjections } from "@typespec/versioning";
 import { stringify } from "yaml";
-import { getOneOf, getRef } from "./decorators.js";
+import { getRef } from "./decorators.js";
 import { reportDiagnostic } from "./lib.js";
+import { OpenAPI3SchemaEmitter } from "./schema-emitter.js";
 import { deepEquals } from "./util.js";
+import { resolveVisibilityUsage } from "./visibility-usage.js";
 const defaultFileType = "yaml";
 const defaultOptions = {
     "new-line": "lf",
@@ -14,7 +16,7 @@ const defaultOptions = {
 };
 export async function $onEmit(context) {
     const options = resolveOptions(context);
-    const emitter = createOAPIEmitter(context.program, options);
+    const emitter = createOAPIEmitter(context, options);
     await emitter.emitOpenAPI();
 }
 function findFileTypeFromFilename(filename) {
@@ -44,29 +46,16 @@ export function resolveOptions(context) {
         outputFile: resolvePath(context.emitterOutputDir, outputFile),
     };
 }
-/**
- * Represents a node that will hold a JSON reference. The value is computed
- * at the end so that we can defer decisions about the name that is
- * referenced.
- */
-class Ref {
-    toJSON() {
-        compilerAssert(this.value, "Reference value never set.");
-        return this.value;
-    }
-}
-function createOAPIEmitter(program, options) {
+function createOAPIEmitter(context, options) {
+    let program = context.program;
+    let schemaEmitter;
     let root;
     // Get the service namespace string for use in name shortening
     let serviceNamespace;
     let currentPath;
     let currentEndpoint;
     let metadataInfo;
-    // Keep a map of all Types+Visibility combinations that were encountered
-    // that need schema definitions.
-    let pendingSchemas = new TwoLevelMap();
-    // Reuse a single ref object per Type+Visibility combination.
-    let refs = new TwoLevelMap();
+    let visibilityUsage;
     // Keep track of inline types still in the process of having their schema computed
     // This is used to detect cycles in inline types, which is an
     let inProgressInlineTypes = new Set();
@@ -89,6 +78,16 @@ function createOAPIEmitter(program, options) {
     return { emitOpenAPI };
     function initializeEmitter(service, version) {
         var _a, _b, _c;
+        metadataInfo = createMetadataInfo(program, {
+            canonicalVisibility: Visibility.Read,
+            canShareProperty: (p) => isReadonlyProperty(program, p),
+        });
+        visibilityUsage = resolveVisibilityUsage(program, metadataInfo, service.type);
+        schemaEmitter = context.getAssetEmitter(class extends OpenAPI3SchemaEmitter {
+            constructor(emitter) {
+                super(emitter, metadataInfo, visibilityUsage, options);
+            }
+        });
         const auth = processAuth(service.type);
         root = {
             openapi: "3.0.0",
@@ -117,12 +116,6 @@ function createOAPIEmitter(program, options) {
         }
         serviceNamespace = getNamespaceFullName(service.type);
         currentPath = root.paths;
-        pendingSchemas = new TwoLevelMap();
-        refs = new TwoLevelMap();
-        metadataInfo = createMetadataInfo(program, {
-            canonicalVisibility: Visibility.Read,
-            canShareProperty: (p) => isReadonlyProperty(program, p),
-        });
         inProgressInlineTypes = new Set();
         params = new Map();
         paramModels = new Set();
@@ -169,10 +162,10 @@ function createOAPIEmitter(program, options) {
                     description: getDoc(program, prop),
                 };
                 if (prop.type.kind === "Enum") {
-                    variable.enum = getSchemaForEnum(prop.type).enum;
+                    variable.enum = getSchemaValue(prop.type, Visibility.Read).enum;
                 }
                 else if (prop.type.kind === "Union") {
-                    variable.enum = getSchemaForUnion(prop.type, Visibility.Read).enum;
+                    variable.enum = getSchemaValue(prop.type, Visibility.Read).enum;
                 }
                 else if (prop.type.kind === "String") {
                     variable.enum = [prop.type.value];
@@ -698,35 +691,56 @@ function createOAPIEmitter(program, options) {
     function getResponseHeader(prop) {
         return getOpenAPIParameterBase(prop, Visibility.Read);
     }
-    function getSchemaOrRef(type, visibility) {
-        var _a;
-        const refUrl = getRef(program, type);
-        if (refUrl) {
-            return {
-                $ref: refUrl,
-            };
-        }
-        if (type.kind === "Scalar" && program.checker.isStdType(type)) {
-            return getSchemaForScalar(type);
-        }
-        if (type.kind === "String" || type.kind === "Number" || type.kind === "Boolean") {
-            // For literal types, we just want to emit them directly as well.
-            return getSchemaForLiterals(type);
-        }
-        if (type.kind === "Intrinsic" && type.name === "unknown") {
-            return getSchemaForIntrinsicType(type);
+    function callSchemaEmitter(type, visibility) {
+        const result = emitTypeWithSchemaEmitter(type, visibility);
+        switch (result.kind) {
+            case "code":
+                return result.value;
+            case "declaration":
+                return { $ref: `#/components/schemas/${result.name}` };
+            case "circular":
+                reportDiagnostic(program, {
+                    code: "inline-cycle",
+                    format: { type: getOpenAPITypeName(program, type, typeNameOptions) },
+                    target: type,
+                });
+                return {};
+            case "none":
+                return {};
         }
-        if (type.kind === "EnumMember") {
-            // Enum members are just the OA representation of their values.
-            if (typeof type.value === "number") {
-                return { type: "number", enum: [type.value] };
-            }
-            else {
-                return { type: "string", enum: [(_a = type.value) !== null && _a !== void 0 ? _a : type.name] };
-            }
+    }
+    function getSchemaValue(type, visibility) {
+        const result = emitTypeWithSchemaEmitter(type, visibility);
+        switch (result.kind) {
+            case "code":
+            case "declaration":
+                return result.value;
+            case "circular":
+                reportDiagnostic(program, {
+                    code: "inline-cycle",
+                    format: { type: getOpenAPITypeName(program, type, typeNameOptions) },
+                    target: type,
+                });
+                return {};
+            case "none":
+                return {};
         }
-        if (type.kind === "ModelProperty") {
-            return resolveProperty(type, visibility);
+    }
+    function emitTypeWithSchemaEmitter(type, visibility) {
+        return schemaEmitter.emitType(type, {
+            referenceContext: { visibility, serviceNamespaceName: serviceNamespace },
+        });
+    }
+    function getSchemaOrRef(type, visibility) {
+        if ((type.kind === "Scalar" && program.checker.isStdType(type)) ||
+            type.kind === "String" ||
+            type.kind === "Number" ||
+            type.kind === "Boolean" ||
+            (type.kind === "Intrinsic" && type.name === "unknown") ||
+            type.kind === "EnumMember" ||
+            type.kind === "ModelProperty") {
+            // Those types should just be inlined.
+            return callSchemaEmitter(type, visibility);
         }
         type = metadataInfo.getEffectivePayloadType(type, visibility);
         const name = getOpenAPITypeName(program, type, typeNameOptions);
@@ -737,10 +751,6 @@ function createOAPIEmitter(program, options) {
                 // be caught and handled in emitOpenAPI.
                 throw new ErrorTypeFoundError();
             }
-            // helps to read output and correlate to TypeSpec
-            if (schema && options.includeXTypeSpecName !== "never") {
-                schema["x-typespec-name"] = name;
-            }
             return schema;
         }
         else {
@@ -748,14 +758,7 @@ function createOAPIEmitter(program, options) {
             if (!metadataInfo.isTransformed(type, visibility)) {
                 visibility = Visibility.Read;
             }
-            const pending = pendingSchemas.getOrAdd(type, visibility, () => ({
-                type,
-                visibility,
-                ref: refs.getOrAdd(type, visibility, () => new Ref()),
-            }));
-            return {
-                $ref: pending.ref,
-            };
+            return callSchemaEmitter(type, visibility);
         }
     }
     function getSchemaForInlineType(type, visibility, name) {
@@ -1010,46 +1013,23 @@ function createOAPIEmitter(program, options) {
         }
     }
     function emitSchemas(serviceNamespace) {
-        const processedSchemas = new TwoLevelMap();
-        processSchemas();
         if (!options.omitUnreachableTypes) {
             processUnreferencedSchemas();
         }
-        // Emit the processed schemas. Only now can we compute the names as it
-        // depends on whether we have produced multiple schemas for a single
-        // TYPESPEC type.
-        for (const group of processedSchemas.values()) {
-            for (const [visibility, processed] of group) {
-                let name = getOpenAPITypeName(program, processed.type, typeNameOptions);
-                if (group.size > 1) {
-                    name += getVisibilitySuffix(visibility, Visibility.Read);
-                }
-                checkDuplicateTypeName(program, processed.type, name, root.components.schemas);
-                processed.ref.value = "#/components/schemas/" + encodeURIComponent(name);
-                if (processed.schema) {
-                    root.components.schemas[name] = processed.schema;
-                }
-            }
-        }
-        function processSchemas() {
-            // Process pending schemas. Note that getSchemaForType may pull in new
-            // pending schemas so we iterate until there are no pending schemas
-            // remaining.
-            while (pendingSchemas.size > 0) {
-                for (const [type, group] of pendingSchemas) {
-                    for (const [visibility, pending] of group) {
-                        processedSchemas.getOrAdd(type, visibility, () => ({
-                            ...pending,
-                            schema: getSchemaForType(type, visibility),
-                        }));
-                    }
-                    pendingSchemas.delete(type);
-                }
+        const files = schemaEmitter.getSourceFiles();
+        if (files.length > 0) {
+            compilerAssert(files.length === 1, `Should only have a single file for now but got ${files.length}`);
+            const schemas = root.components.schemas;
+            const declarations = files[0].globalScope.declarations;
+            for (const declaration of declarations) {
+                schemas[declaration.name] = declaration.value;
             }
         }
         function processUnreferencedSchemas() {
             const addSchema = (type) => {
-                if (!processedSchemas.has(type) && !paramModels.has(type) && !shouldInline(program, type)) {
+                if (visibilityUsage.getUsage(type) === undefined &&
+                    !paramModels.has(type) &&
+                    !shouldInline(program, type)) {
                     getSchemaOrRef(type, Visibility.Read);
                 }
             };
@@ -1060,7 +1040,6 @@ function createOAPIEmitter(program, options) {
                 enum: addSchema,
                 union: addSchema,
             }, { skipSubNamespaces });
-            processSchemas();
         }
     }
     function emitTags() {
@@ -1069,187 +1048,7 @@ function createOAPIEmitter(program, options) {
         }
     }
     function getSchemaForType(type, visibility) {
-        const builtinType = getSchemaForLiterals(type);
-        if (builtinType !== undefined)
-            return builtinType;
-        switch (type.kind) {
-            case "Intrinsic":
-                return getSchemaForIntrinsicType(type);
-            case "Model":
-                return getSchemaForModel(type, visibility);
-            case "ModelProperty":
-                return getSchemaForType(type.type, visibility);
-            case "Scalar":
-                return getSchemaForScalar(type);
-            case "Union":
-                return getSchemaForUnion(type, visibility);
-            case "UnionVariant":
-                return getSchemaForUnionVariant(type, visibility);
-            case "Enum":
-                return getSchemaForEnum(type);
-            case "Tuple":
-                return { type: "array", items: {} };
-            case "TemplateParameter":
-                // Note: This should never happen if it does there is a bug in the compiler.
-                reportDiagnostic(program, {
-                    code: "invalid-schema",
-                    format: { type: `${type.node.id.sv} (template parameter)` },
-                    target: type,
-                });
-                return undefined;
-        }
-        reportDiagnostic(program, {
-            code: "invalid-schema",
-            format: { type: type.kind },
-            target: type,
-        });
-        return undefined;
-    }
-    function getSchemaForIntrinsicType(type) {
-        switch (type.name) {
-            case "unknown":
-                return {};
-        }
-        reportDiagnostic(program, {
-            code: "invalid-schema",
-            format: { type: type.name },
-            target: type,
-        });
-        return {};
-    }
-    function getSchemaForEnum(e) {
-        var _a;
-        const values = [];
-        if (e.members.size === 0) {
-            reportDiagnostic(program, { code: "empty-enum", target: e });
-            return {};
-        }
-        const type = enumMemberType(e.members.values().next().value);
-        for (const option of e.members.values()) {
-            if (type !== enumMemberType(option)) {
-                reportDiagnostic(program, { code: "enum-unique-type", target: e });
-                continue;
-            }
-            values.push((_a = option.value) !== null && _a !== void 0 ? _a : option.name);
-        }
-        const schema = { type, description: getDoc(program, e) };
-        if (values.length > 0) {
-            schema.enum = values;
-        }
-        const title = getSummary(program, e);
-        if (title) {
-            schema.title = title;
-        }
-        return schema;
-        function enumMemberType(member) {
-            if (typeof member.value === "number") {
-                return "number";
-            }
-            return "string";
-        }
-    }
-    /**
-     * A TypeSpec union maps to a variety of OA3 structures according to the following rules:
-     *
-     * * A union containing `null` makes a `nullable` schema comprised of the remaining
-     *   union variants.
-     * * A union containing literal types are converted to OA3 enums. All literals of the
-     *   same type are combined into single enums.
-     * * A union that contains multiple items (after removing null and combining like-typed
-     *   literals into enums) is an `anyOf` union unless `oneOf` is applied to the union
-     *   declaration.
-     */
-    function getSchemaForUnion(union, visibility) {
-        if (union.variants.size === 0) {
-            reportDiagnostic(program, { code: "empty-union", target: union });
-            return {};
-        }
-        const variants = Array.from(union.variants.values());
-        const literalVariantEnumByType = {};
-        const ofType = getOneOf(program, union) ? "oneOf" : "anyOf";
-        const schemaMembers = [];
-        let nullable = false;
-        const discriminator = getDiscriminator(program, union);
-        for (const variant of variants) {
-            if (isNullType(variant.type)) {
-                nullable = true;
-                continue;
-            }
-            if (isLiteralType(variant.type)) {
-                if (!literalVariantEnumByType[variant.type.kind]) {
-                    const enumSchema = getSchemaForLiterals(variant.type);
-                    literalVariantEnumByType[variant.type.kind] = enumSchema;
-                    schemaMembers.push({ schema: enumSchema, type: null });
-                }
-                else {
-                    literalVariantEnumByType[variant.type.kind].enum.push(variant.type.value);
-                }
-                continue;
-            }
-            schemaMembers.push({ schema: getSchemaOrRef(variant.type, visibility), type: variant.type });
-        }
-        if (schemaMembers.length === 0) {
-            if (nullable) {
-                // This union is equivalent to just `null` but OA3 has no way to specify
-                // null as a value, so we throw an error.
-                reportDiagnostic(program, { code: "union-null", target: union });
-                return {};
-            }
-            else {
-                // completely empty union can maybe only happen with bugs?
-                compilerAssert(false, "Attempting to emit an empty union");
-            }
-        }
-        if (schemaMembers.length === 1) {
-            // we can just return the single schema member after applying nullable
-            const schema = schemaMembers[0].schema;
-            applyIntrinsicDecorators(union, schema);
-            const title = getSummary(program, union);
-            if (title) {
-                schema.title = title;
-            }
-            const type = schemaMembers[0].type;
-            if (nullable) {
-                if (schema.$ref) {
-                    // but we can't make a ref "nullable", so wrap in an allOf (for models)
-                    // or oneOf (for all other types)
-                    if (type && type.kind === "Model") {
-                        return { type: "object", allOf: [schema], nullable: true };
-                    }
-                    else {
-                        return { oneOf: [schema], nullable: true };
-                    }
-                }
-                else {
-                    schema.nullable = true;
-                }
-            }
-            return schema;
-        }
-        const schema = {
-            [ofType]: schemaMembers.map((m) => m.schema),
-        };
-        if (nullable) {
-            schema.nullable = true;
-        }
-        if (discriminator) {
-            // the decorator validates that all the variants will be a model type
-            // with the discriminator field present.
-            schema.discriminator = { ...discriminator };
-            // Diagnostic already reported in compiler for unions
-            const discriminatedUnion = ignoreDiagnostics(getDiscriminatedUnion(union, discriminator));
-            if (discriminatedUnion.variants.size > 0) {
-                schema.discriminator.mapping = getDiscriminatorMapping(discriminatedUnion, visibility);
-            }
-        }
-        return applyIntrinsicDecorators(union, schema);
-    }
-    function getSchemaForUnionVariant(variant, visibility) {
-        const schema = getSchemaForType(variant.type, visibility);
-        return schema;
-    }
-    function isLiteralType(type) {
-        return type.kind === "Boolean" || type.kind === "String" || type.kind === "Number";
+        return callSchemaEmitter(type, visibility);
     }
     function getDefaultValue(type, defaultType) {
         var _a;
@@ -1286,111 +1085,6 @@ function createOAPIEmitter(program, options) {
                 });
         }
     }
-    function includeDerivedModel(model) {
-        var _a, _b;
-        return (!isTemplateDeclaration(model) &&
-            (((_a = model.templateMapper) === null || _a === void 0 ? void 0 : _a.args) === undefined ||
-                ((_b = model.templateMapper.args) === null || _b === void 0 ? void 0 : _b.length) === 0 ||
-                model.derivedModels.length > 0));
-    }
-    function getSchemaForModel(model, visibility) {
-        const array = getArrayType(model, visibility);
-        if (array) {
-            return array;
-        }
-        const modelSchema = {
-            type: "object",
-            description: getDoc(program, model),
-        };
-        const properties = {};
-        if (isRecordModelType(program, model)) {
-            modelSchema.additionalProperties = getSchemaOrRef(model.indexer.value, visibility);
-        }
-        const derivedModels = model.derivedModels.filter(includeDerivedModel);
-        // getSchemaOrRef on all children to push them into components.schemas
-        for (const child of derivedModels) {
-            getSchemaOrRef(child, visibility);
-        }
-        const discriminator = getDiscriminator(program, model);
-        if (discriminator) {
-            const [union] = getDiscriminatedUnion(model, discriminator);
-            const openApiDiscriminator = { ...discriminator };
-            if (union.variants.size > 0) {
-                openApiDiscriminator.mapping = getDiscriminatorMapping(union, visibility);
-            }
-            modelSchema.discriminator = openApiDiscriminator;
-            properties[discriminator.propertyName] = {
-                type: "string",
-                description: `Discriminator property for ${model.name}.`,
-            };
-        }
-        applyExternalDocs(model, modelSchema);
-        for (const [name, prop] of model.properties) {
-            if (!metadataInfo.isPayloadProperty(prop, visibility)) {
-                continue;
-            }
-            if (isNeverType(prop.type)) {
-                // If the property has a type of 'never', don't include it in the schema
-                continue;
-            }
-            if (!metadataInfo.isOptional(prop, visibility)) {
-                if (!modelSchema.required) {
-                    modelSchema.required = [];
-                }
-                modelSchema.required.push(name);
-            }
-            properties[name] = resolveProperty(prop, visibility);
-        }
-        if (model.baseModel) {
-            const baseSchema = getSchemaOrRef(model.baseModel, visibility);
-            modelSchema.allOf = [baseSchema];
-        }
-        if (Object.keys(properties).length > 0) {
-            modelSchema.properties = properties;
-        }
-        const title = getSummary(program, model);
-        if (title) {
-            modelSchema.title = title;
-        }
-        // Attach any OpenAPI extensions
-        attachExtensions(program, model, modelSchema);
-        return modelSchema;
-    }
-    function resolveProperty(prop, visibility) {
-        const description = getDoc(program, prop);
-        const schema = applyEncoding(prop, getSchemaOrRef(prop.type, visibility));
-        // Apply decorators on the property to the type's schema
-        const additionalProps = applyIntrinsicDecorators(prop, {});
-        if (description) {
-            additionalProps.description = description;
-        }
-        if (prop.default) {
-            additionalProps.default = getDefaultValue(prop.type, prop.default);
-        }
-        if (isReadonlyProperty(program, prop)) {
-            additionalProps.readOnly = true;
-        }
-        // Attach any additional OpenAPI extensions
-        attachExtensions(program, prop, additionalProps);
-        if (schema && "$ref" in schema) {
-            if (Object.keys(additionalProps).length === 0) {
-                return schema;
-            }
-            else {
-                return {
-                    allOf: [schema],
-                    ...additionalProps,
-                };
-            }
-        }
-        else {
-            if (getOneOf(program, prop) && schema.anyOf) {
-                schema.oneOf = schema.anyOf;
-                delete schema.anyOf;
-            }
-            return { ...schema, ...additionalProps };
-        }
-    }
     function attachExtensions(program, type, emitObject) {
         // Attach any OpenAPI extensions
         const extensions = getExtensions(program, type);
@@ -1400,13 +1094,6 @@ function createOAPIEmitter(program, options) {
             }
         }
     }
-    function getDiscriminatorMapping(union, visibility) {
-        const mapping = {};
-        for (const [key, model] of union.variants.entries()) {
-            mapping[key] = getSchemaOrRef(model, visibility).$ref;
-        }
-        return mapping;
-    }
     function applyIntrinsicDecorators(typespecType, target) {
         const newTarget = { ...target };
         const docStr = getDoc(program, typespecType);
@@ -1465,7 +1152,7 @@ function createOAPIEmitter(program, options) {
         const values = getKnownValues(program, typespecType);
         if (values) {
             return {
-                oneOf: [newTarget, getSchemaForEnum(values)],
+                oneOf: [newTarget, callSchemaEmitter(values, Visibility.Read)],
             };
         }
         attachExtensions(program, typespecType, newTarget);
@@ -1475,7 +1162,7 @@ function createOAPIEmitter(program, options) {
         const encodeData = getEncode(program, typespecType);
         if (encodeData) {
             const newTarget = { ...target };
-            const newType = getSchemaForScalar(encodeData.type);
+            const newType = callSchemaEmitter(encodeData.type, Visibility.Read);
             newTarget.type = newType.type;
             // If the target already has a format it takes priority. (e.g. int32)
             newTarget.format = mergeFormatAndEncoding(newTarget.format, encodeData.encoding, newType.format);
@@ -1515,103 +1202,6 @@ function createOAPIEmitter(program, options) {
             target.externalDocs = externalDocs;
         }
     }
-    function getSchemaForLiterals(typespecType) {
-        switch (typespecType.kind) {
-            case "Number":
-                return { type: "number", enum: [typespecType.value] };
-            case "String":
-                return { type: "string", enum: [typespecType.value] };
-            case "Boolean":
-                return { type: "boolean", enum: [typespecType.value] };
-            default:
-                return undefined;
-        }
-    }
-    /**
-     * Map TypeSpec intrinsic models to open api definitions
-     */
-    function getArrayType(typespecType, visibility) {
-        if (isArrayModelType(program, typespecType)) {
-            const array = {
-                type: "array",
-                items: getSchemaOrRef(typespecType.indexer.value, visibility | Visibility.Item),
-            };
-            return applyIntrinsicDecorators(typespecType, array);
-        }
-        return undefined;
-    }
-    function getSchemaForScalar(scalar) {
-        let result = {};
-        const isStd = program.checker.isStdType(scalar);
-        if (isStd) {
-            result = getSchemaForStdScalars(scalar);
-        }
-        else if (scalar.baseScalar) {
-            result = getSchemaForScalar(scalar.baseScalar);
-        }
-        const withDecorators = applyEncoding(scalar, applyIntrinsicDecorators(scalar, result));
-        if (isStd) {
-            // Standard types are going to be inlined in the spec and we don't want the description of the scalar to show up
-            delete withDecorators.description;
-        }
-        return withDecorators;
-    }
-    function getSchemaForStdScalars(scalar) {
-        switch (scalar.name) {
-            case "bytes":
-                return { type: "string", format: "byte" };
-            case "numeric":
-                return { type: "number" };
-            case "integer":
-                return { type: "integer" };
-            case "int8":
-                return { type: "integer", format: "int8" };
-            case "int16":
-                return { type: "integer", format: "int16" };
-            case "int32":
-                return { type: "integer", format: "int32" };
-            case "int64":
-                return { type: "integer", format: "int64" };
-            case "safeint":
-                return { type: "integer", format: "int64" };
-            case "uint8":
-                return { type: "integer", format: "uint8" };
-            case "uint16":
-                return { type: "integer", format: "uint16" };
-            case "uint32":
-                return { type: "integer", format: "uint32" };
-            case "uint64":
-                return { type: "integer", format: "uint64" };
-            case "float":
-                return { type: "number" };
-            case "float64":
-                return { type: "number", format: "double" };
-            case "float32":
-                return { type: "number", format: "float" };
-            case "decimal":
-                return { type: "number", format: "decimal" };
-            case "decimal128":
-                return { type: "number", format: "decimal128" };
-            case "string":
-                return { type: "string" };
-            case "boolean":
-                return { type: "boolean" };
-            case "plainDate":
-                return { type: "string", format: "date" };
-            case "utcDateTime":
-            case "offsetDateTime":
-                return { type: "string", format: "date-time" };
-            case "plainTime":
-                return { type: "string", format: "time" };
-            case "duration":
-                return { type: "string", format: "duration" };
-            case "url":
-                return { type: "string", format: "uri" };
-            default:
-                const _assertNever = scalar.name;
-                return {};
-        }
-    }
     function processAuth(serviceNamespace) {
         const authentication = getAuthentication(program, serviceNamespace);
         if (authentication) {
@@ -1667,9 +1257,7 @@ function serializeDocument(root, fileType) {
         case "json":
             return prettierOutput(JSON.stringify(root, null, 2));
         case "yaml":
-            return stringify(root, (key, value) => {
-                return value instanceof Ref ? value.toJSON() : value;
-            }, {
+            return stringify(root, {
                 singleQuote: true,
                 aliasDuplicateObjects: false,
                 lineWidth: 0,