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

package/dist/src/schema-emitter.js

@@ -0,0 +1,714 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _OpenAPI3SchemaEmitter_instances, _OpenAPI3SchemaEmitter_metadataInfo, _OpenAPI3SchemaEmitter_visibilityUsage, _OpenAPI3SchemaEmitter_options, _OpenAPI3SchemaEmitter_applyExternalDocs, _OpenAPI3SchemaEmitter_typeNameOptions, _OpenAPI3SchemaEmitter_getVisibilityContext, _OpenAPI3SchemaEmitter_getContentType, _OpenAPI3SchemaEmitter_requiredModelProperties, _OpenAPI3SchemaEmitter_enumSchema, _OpenAPI3SchemaEmitter_unionSchema, _OpenAPI3SchemaEmitter_getDiscriminatorMapping, _OpenAPI3SchemaEmitter_attachExtensions, _OpenAPI3SchemaEmitter_getDefaultValue, _OpenAPI3SchemaEmitter_getSchemaForScalar, _OpenAPI3SchemaEmitter_getSchemaForStdScalars, _OpenAPI3SchemaEmitter_applyConstraints, _OpenAPI3SchemaEmitter_inlineType, _OpenAPI3SchemaEmitter_createDeclaration, _OpenAPI3SchemaEmitter_isStdType, _OpenAPI3SchemaEmitter_applyEncoding, _OpenAPI3SchemaEmitter_mergeFormatAndEncoding;
+import { compilerAssert, getDeprecated, getDiscriminatedUnion, getDiscriminator, getDoc, getEncode, getFormat, getKnownValues, getMaxItems, getMaxLength, getMaxValue, getMaxValueExclusive, getMinItems, getMinLength, getMinValue, getMinValueExclusive, getNamespaceFullName, getPattern, getSummary, getTypeName, ignoreDiagnostics, isArrayModelType, isNeverType, isNullType, isSecret, isTemplateDeclaration, stringTemplateToString, } from "@typespec/compiler";
+import { ArrayBuilder, ObjectBuilder, Placeholder, TypeEmitter, } from "@typespec/compiler/emitter-framework";
+import { getVisibilitySuffix, Visibility } from "@typespec/http";
+import { checkDuplicateTypeName, getExtensions, getExternalDocs, getOpenAPITypeName, isReadonlyProperty, shouldInline, } from "@typespec/openapi";
+import { getOneOf, getRef } from "./decorators.js";
+import { reportDiagnostic } from "./lib.js";
+/**
+ * OpenAPI3 schema emitter. Deals with emitting content of `components/schemas` section.
+ */
+export class OpenAPI3SchemaEmitter extends TypeEmitter {
+    constructor(emitter, metadataInfo, visibilityUsage, options) {
+        super(emitter);
+        _OpenAPI3SchemaEmitter_instances.add(this);
+        _OpenAPI3SchemaEmitter_metadataInfo.set(this, void 0);
+        _OpenAPI3SchemaEmitter_visibilityUsage.set(this, void 0);
+        _OpenAPI3SchemaEmitter_options.set(this, void 0);
+        __classPrivateFieldSet(this, _OpenAPI3SchemaEmitter_metadataInfo, metadataInfo, "f");
+        __classPrivateFieldSet(this, _OpenAPI3SchemaEmitter_visibilityUsage, visibilityUsage, "f");
+        __classPrivateFieldSet(this, _OpenAPI3SchemaEmitter_options, options, "f");
+    }
+    modelDeclarationReferenceContext(model, name) {
+        return this.reduceContext(model);
+    }
+    modelLiteralReferenceContext(model) {
+        return this.reduceContext(model);
+    }
+    scalarDeclarationReferenceContext(scalar, name) {
+        return this.reduceContext(scalar);
+    }
+    enumDeclarationReferenceContext(en, name) {
+        return this.reduceContext(en);
+    }
+    unionDeclarationReferenceContext(union) {
+        return this.reduceContext(union);
+    }
+    reduceContext(type) {
+        const visibility = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getVisibilityContext).call(this);
+        const patch = {};
+        if (visibility !== Visibility.Read && !__classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_metadataInfo, "f").isTransformed(type, visibility)) {
+            patch.visibility = Visibility.Read;
+        }
+        const contentType = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getContentType).call(this);
+        if (contentType === "application/json") {
+            delete patch.contentType;
+        }
+        return patch;
+    }
+    modelDeclaration(model, _) {
+        const program = this.emitter.getProgram();
+        const visibility = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getVisibilityContext).call(this);
+        const schema = new ObjectBuilder({
+            type: "object",
+            required: __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_requiredModelProperties).call(this, model, visibility),
+            properties: this.emitter.emitModelProperties(model),
+        });
+        if (model.indexer) {
+            schema.set("additionalProperties", this.emitter.emitTypeReference(model.indexer.value));
+        }
+        const derivedModels = model.derivedModels.filter(includeDerivedModel);
+        // getSchemaOrRef on all children to push them into components.schemas
+        for (const child of derivedModels) {
+            this.emitter.emitTypeReference(child);
+        }
+        const discriminator = getDiscriminator(program, model);
+        if (discriminator) {
+            const [union] = getDiscriminatedUnion(model, discriminator);
+            const openApiDiscriminator = { ...discriminator };
+            if (union.variants.size > 0) {
+                openApiDiscriminator.mapping = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getDiscriminatorMapping).call(this, union);
+            }
+            schema.discriminator = openApiDiscriminator;
+        }
+        __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_applyExternalDocs).call(this, model, schema);
+        if (model.baseModel) {
+            schema.set("allOf", B.array([this.emitter.emitTypeReference(model.baseModel)]));
+        }
+        const baseName = getOpenAPITypeName(program, model, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_typeNameOptions).call(this));
+        const isMultipart = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getContentType).call(this).startsWith("multipart/");
+        const name = isMultipart ? baseName + "MultiPart" : baseName;
+        return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_createDeclaration).call(this, model, name, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_applyConstraints).call(this, model, schema));
+    }
+    modelLiteral(model) {
+        const schema = new ObjectBuilder({
+            type: "object",
+            properties: this.emitter.emitModelProperties(model),
+            required: __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_requiredModelProperties).call(this, model, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getVisibilityContext).call(this)),
+        });
+        if (model.indexer) {
+            schema.set("additionalProperties", this.emitter.emitTypeReference(model.indexer.value));
+        }
+        return schema;
+    }
+    modelInstantiation(model, name) {
+        name = name !== null && name !== void 0 ? name : getOpenAPITypeName(this.emitter.getProgram(), model, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_typeNameOptions).call(this));
+        if (!name) {
+            return this.modelLiteral(model);
+        }
+        return this.modelDeclaration(model, name);
+    }
+    arrayDeclaration(array, name, elementType) {
+        const schema = new ObjectBuilder({
+            type: "array",
+            items: this.emitter.emitTypeReference(elementType),
+        });
+        return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_createDeclaration).call(this, array, name, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_applyConstraints).call(this, array, schema));
+    }
+    arrayDeclarationReferenceContext(array, name, elementType) {
+        return {
+            visibility: __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getVisibilityContext).call(this) | Visibility.Item,
+        };
+    }
+    arrayLiteral(array, elementType) {
+        return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_inlineType).call(this, array, new ObjectBuilder({
+            type: "array",
+            items: this.emitter.emitTypeReference(elementType),
+        }));
+    }
+    arrayLiteralReferenceContext(array, elementType) {
+        return {
+            visibility: __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getVisibilityContext).call(this) | Visibility.Item,
+        };
+    }
+    modelProperties(model) {
+        const props = new ObjectBuilder();
+        const visibility = this.emitter.getContext().visibility;
+        for (const [name, prop] of model.properties) {
+            if (isNeverType(prop.type)) {
+                // If the property has a type of 'never', don't include it in the schema
+                continue;
+            }
+            if (!__classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_metadataInfo, "f").isPayloadProperty(prop, visibility)) {
+                continue;
+            }
+            const result = this.emitter.emitModelProperty(prop);
+            props.set(name, result);
+        }
+        const discriminator = getDiscriminator(this.emitter.getProgram(), model);
+        if (discriminator && !(discriminator.propertyName in props)) {
+            props.set(discriminator.propertyName, {
+                type: "string",
+                description: `Discriminator property for ${model.name}.`,
+            });
+        }
+        if (Object.keys(props).length === 0) {
+            return this.emitter.result.none();
+        }
+        return props;
+    }
+    modelPropertyLiteral(prop) {
+        const program = this.emitter.getProgram();
+        const isMultipart = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getContentType).call(this).startsWith("multipart/");
+        if (isMultipart &&
+            prop.type.kind === "Scalar" &&
+            prop.type.name === "bytes" &&
+            getEncode(program, prop.type) === undefined &&
+            getEncode(program, prop) === undefined) {
+            return { type: "string", format: "binary" };
+        }
+        const refSchema = this.emitter.emitTypeReference(prop.type, {
+            referenceContext: isMultipart ? { contentType: "application/json" } : {},
+        });
+        if (refSchema.kind !== "code") {
+            throw new Error("Unexpected non-code result from emit reference");
+        }
+        const isRef = refSchema.value instanceof Placeholder || "$ref" in refSchema.value;
+        const schema = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_applyEncoding).call(this, prop, refSchema.value);
+        // Apply decorators on the property to the type's schema
+        const additionalProps = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_applyConstraints).call(this, prop, {});
+        if (prop.default) {
+            additionalProps.default = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getDefaultValue).call(this, prop.type, prop.default);
+        }
+        if (isReadonlyProperty(program, prop)) {
+            additionalProps.readOnly = true;
+        }
+        // Attach any additional OpenAPI extensions
+        __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_attachExtensions).call(this, program, prop, additionalProps);
+        if (schema && isRef) {
+            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;
+            }
+            const merged = new ObjectBuilder(schema);
+            for (const [key, value] of Object.entries(additionalProps)) {
+                merged.set(key, value);
+            }
+            return merged;
+        }
+    }
+    booleanLiteral(boolean) {
+        return { type: "boolean", enum: [boolean.value] };
+    }
+    stringLiteral(string) {
+        return { type: "string", enum: [string.value] };
+    }
+    stringTemplate(string) {
+        const [value, diagnostics] = stringTemplateToString(string);
+        if (diagnostics.length > 0) {
+            this.emitter
+                .getProgram()
+                .reportDiagnostics(diagnostics.map((x) => ({ ...x, severity: "warning" })));
+            return { type: "string" };
+        }
+        return { type: "string", enum: [value] };
+    }
+    numericLiteral(number) {
+        return { type: "number", enum: [number.value] };
+    }
+    enumDeclaration(en, name) {
+        const baseName = getOpenAPITypeName(this.emitter.getProgram(), en, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_typeNameOptions).call(this));
+        return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_createDeclaration).call(this, en, baseName, new ObjectBuilder(__classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_enumSchema).call(this, en)));
+    }
+    enumMember(member) {
+        return this.enumMemberReference(member);
+    }
+    enumMemberReference(member) {
+        // would like to dispatch to the same `literal` codepaths but enum members aren't literal types
+        switch (typeof member.value) {
+            case "undefined":
+                return { type: "string", enum: [member.name] };
+            case "string":
+                return { type: "string", enum: [member.value] };
+            case "number":
+                return { type: "number", enum: [member.value] };
+        }
+    }
+    unionDeclaration(union, name) {
+        const schema = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_unionSchema).call(this, union);
+        return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_createDeclaration).call(this, union, name, schema);
+    }
+    unionLiteral(union) {
+        return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_unionSchema).call(this, union);
+    }
+    unionVariants(union) {
+        const variants = new ArrayBuilder();
+        for (const variant of union.variants.values()) {
+            variants.push(this.emitter.emitType(variant));
+        }
+        return variants;
+    }
+    unionVariant(variant) {
+        return this.emitter.emitTypeReference(variant.type);
+    }
+    modelPropertyReference(prop) {
+        return this.modelPropertyLiteral(prop);
+    }
+    reference(targetDeclaration, pathUp, pathDown, commonScope) {
+        if (targetDeclaration.value instanceof Placeholder) {
+            // I don't think this is possible, confirm.
+            throw new Error("Can't form reference to declaration that hasn't been created yet");
+        }
+        // these will be undefined when creating a self-reference
+        const currentSfScope = pathUp[pathUp.length - 1];
+        const targetSfScope = pathDown[0];
+        if (targetSfScope && currentSfScope && !targetSfScope.sourceFile.meta.shouldEmit) {
+            currentSfScope.sourceFile.meta.bundledRefs.push(targetDeclaration);
+        }
+        return { $ref: `#/components/schemas/${targetDeclaration.name}` };
+    }
+    circularReference(target, scope, cycle) {
+        if (!cycle.containsDeclaration) {
+            reportDiagnostic(this.emitter.getProgram(), {
+                code: "inline-cycle",
+                format: {
+                    type: cycle.toString(),
+                },
+                target: cycle.first.type,
+            });
+            return {};
+        }
+        return super.circularReference(target, scope, cycle);
+    }
+    scalarDeclaration(scalar, name) {
+        const isStd = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_isStdType).call(this, scalar);
+        const schema = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getSchemaForScalar).call(this, scalar);
+        const baseName = getOpenAPITypeName(this.emitter.getProgram(), scalar, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_typeNameOptions).call(this));
+        // Don't create a declaration for std types
+        return isStd ? schema : __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_createDeclaration).call(this, scalar, baseName, new ObjectBuilder(schema));
+    }
+    scalarInstantiation(scalar, name) {
+        return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getSchemaForScalar).call(this, scalar);
+    }
+    tupleLiteral(tuple) {
+        return { type: "array", items: {} };
+    }
+    intrinsic(intrinsic, name) {
+        switch (name) {
+            case "unknown":
+                return {};
+        }
+        throw new Error("Unknown intrinsic type " + name);
+    }
+    programContext(program) {
+        const sourceFile = this.emitter.createSourceFile("openapi");
+        return { scope: sourceFile.globalScope };
+    }
+}
+_OpenAPI3SchemaEmitter_metadataInfo = new WeakMap(), _OpenAPI3SchemaEmitter_visibilityUsage = new WeakMap(), _OpenAPI3SchemaEmitter_options = new WeakMap(), _OpenAPI3SchemaEmitter_instances = new WeakSet(), _OpenAPI3SchemaEmitter_applyExternalDocs = function _OpenAPI3SchemaEmitter_applyExternalDocs(typespecType, target) {
+    const externalDocs = getExternalDocs(this.emitter.getProgram(), typespecType);
+    if (externalDocs) {
+        target.externalDocs = externalDocs;
+    }
+}, _OpenAPI3SchemaEmitter_typeNameOptions = function _OpenAPI3SchemaEmitter_typeNameOptions() {
+    const serviceNamespaceName = this.emitter.getContext().serviceNamespaceName;
+    return {
+        // shorten type names by removing TypeSpec and service namespace
+        namespaceFilter(ns) {
+            const name = getNamespaceFullName(ns);
+            return name !== serviceNamespaceName;
+        },
+    };
+}, _OpenAPI3SchemaEmitter_getVisibilityContext = function _OpenAPI3SchemaEmitter_getVisibilityContext() {
+    var _a;
+    return (_a = this.emitter.getContext().visibility) !== null && _a !== void 0 ? _a : Visibility.Read;
+}, _OpenAPI3SchemaEmitter_getContentType = function _OpenAPI3SchemaEmitter_getContentType() {
+    var _a;
+    return (_a = this.emitter.getContext().contentType) !== null && _a !== void 0 ? _a : "application/json";
+}, _OpenAPI3SchemaEmitter_requiredModelProperties = function _OpenAPI3SchemaEmitter_requiredModelProperties(model, visibility) {
+    const requiredProps = [];
+    for (const prop of model.properties.values()) {
+        if (isNeverType(prop.type)) {
+            // If the property has a type of 'never', don't include it in the schema
+            continue;
+        }
+        if (!__classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_metadataInfo, "f").isPayloadProperty(prop, visibility)) {
+            continue;
+        }
+        if (!__classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_metadataInfo, "f").isOptional(prop, visibility)) {
+            requiredProps.push(prop.name);
+        }
+    }
+    return requiredProps.length > 0 ? requiredProps : undefined;
+}, _OpenAPI3SchemaEmitter_enumSchema = function _OpenAPI3SchemaEmitter_enumSchema(en) {
+    var _a;
+    const program = this.emitter.getProgram();
+    if (en.members.size === 0) {
+        reportDiagnostic(program, { code: "empty-enum", target: en });
+        return {};
+    }
+    const enumTypes = new Set();
+    const enumValues = new Set();
+    for (const member of en.members.values()) {
+        enumTypes.add(typeof member.value === "number" ? "number" : "string");
+        enumValues.add((_a = member.value) !== null && _a !== void 0 ? _a : member.name);
+    }
+    if (enumTypes.size > 1) {
+        reportDiagnostic(program, { code: "enum-unique-type", target: en });
+    }
+    const schema = { type: enumTypes.values().next().value, enum: [...enumValues] };
+    return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_applyConstraints).call(this, en, schema);
+}, _OpenAPI3SchemaEmitter_unionSchema = function _OpenAPI3SchemaEmitter_unionSchema(union) {
+    const program = this.emitter.getProgram();
+    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 = this.emitter.emitTypeReference(variant.type);
+                compilerAssert(enumSchema.kind === "code", "Unexpected enum schema. Should be kind: code");
+                literalVariantEnumByType[variant.type.kind] = enumSchema.value;
+                schemaMembers.push({ schema: enumSchema.value, type: null });
+            }
+            else {
+                literalVariantEnumByType[variant.type.kind].enum.push(variant.type.value);
+            }
+        }
+        else {
+            const enumSchema = this.emitter.emitTypeReference(variant.type);
+            compilerAssert(enumSchema.kind === "code", "Unexpected enum schema. Should be kind: code");
+            schemaMembers.push({ schema: enumSchema.value, 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
+        let schema = schemaMembers[0].schema;
+        const type = schemaMembers[0].type;
+        if (nullable) {
+            if (schema instanceof Placeholder || "$ref" in schema) {
+                // 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 B.object({ type: "object", allOf: B.array([schema]), nullable: true });
+                }
+                else {
+                    return B.object({ oneOf: B.array([schema]), nullable: true });
+                }
+            }
+            else {
+                schema = { ...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 = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getDiscriminatorMapping).call(this, discriminatedUnion);
+        }
+    }
+    return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_applyConstraints).call(this, union, schema);
+}, _OpenAPI3SchemaEmitter_getDiscriminatorMapping = function _OpenAPI3SchemaEmitter_getDiscriminatorMapping(union) {
+    const mapping = {};
+    for (const [key, model] of union.variants.entries()) {
+        const ref = this.emitter.emitTypeReference(model);
+        compilerAssert(ref.kind === "code", "Unexpected ref schema. Should be kind: code");
+        mapping[key] = ref.value.$ref;
+    }
+    return mapping;
+}, _OpenAPI3SchemaEmitter_attachExtensions = function _OpenAPI3SchemaEmitter_attachExtensions(program, type, emitObject) {
+    // Attach any OpenAPI extensions
+    const extensions = getExtensions(program, type);
+    if (extensions) {
+        for (const key of extensions.keys()) {
+            emitObject[key] = extensions.get(key);
+        }
+    }
+}, _OpenAPI3SchemaEmitter_getDefaultValue = function _OpenAPI3SchemaEmitter_getDefaultValue(type, defaultType) {
+    var _a;
+    const program = this.emitter.getProgram();
+    switch (defaultType.kind) {
+        case "String":
+            return defaultType.value;
+        case "Number":
+            return defaultType.value;
+        case "Boolean":
+            return defaultType.value;
+        case "Tuple":
+            compilerAssert(type.kind === "Tuple" || (type.kind === "Model" && isArrayModelType(program, type)), "setting tuple default to non-tuple value");
+            if (type.kind === "Tuple") {
+                return defaultType.values.map((defaultTupleValue, index) => __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getDefaultValue).call(this, type.values[index], defaultTupleValue));
+            }
+            else {
+                return defaultType.values.map((defaultTuplevalue) => __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getDefaultValue).call(this, type.indexer.value, defaultTuplevalue));
+            }
+        case "Intrinsic":
+            return isNullType(defaultType)
+                ? null
+                : reportDiagnostic(program, {
+                    code: "invalid-default",
+                    format: { type: defaultType.kind },
+                    target: defaultType,
+                });
+        case "EnumMember":
+            return (_a = defaultType.value) !== null && _a !== void 0 ? _a : defaultType.name;
+        default:
+            reportDiagnostic(program, {
+                code: "invalid-default",
+                format: { type: defaultType.kind },
+                target: defaultType,
+            });
+    }
+}, _OpenAPI3SchemaEmitter_getSchemaForScalar = function _OpenAPI3SchemaEmitter_getSchemaForScalar(scalar) {
+    let result = {};
+    const isStd = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_isStdType).call(this, scalar);
+    if (isStd) {
+        result = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getSchemaForStdScalars).call(this, scalar);
+    }
+    else if (scalar.baseScalar) {
+        result = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getSchemaForScalar).call(this, scalar.baseScalar);
+    }
+    const withDecorators = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_applyEncoding).call(this, scalar, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_applyConstraints).call(this, 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;
+}, _OpenAPI3SchemaEmitter_getSchemaForStdScalars = function _OpenAPI3SchemaEmitter_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 {};
+    }
+}, _OpenAPI3SchemaEmitter_applyConstraints = function _OpenAPI3SchemaEmitter_applyConstraints(type, original) {
+    const schema = new ObjectBuilder(original);
+    const program = this.emitter.getProgram();
+    const applyConstraint = (fn, key) => {
+        const value = fn(program, type);
+        if (value !== undefined) {
+            schema[key] = value;
+        }
+    };
+    applyConstraint(getMinLength, "minLength");
+    applyConstraint(getMaxLength, "maxLength");
+    applyConstraint(getMinValue, "minimum");
+    applyConstraint(getMaxValue, "maximum");
+    applyConstraint(getPattern, "pattern");
+    applyConstraint(getMinItems, "minItems");
+    applyConstraint(getMaxItems, "maxItems");
+    const minValueExclusive = getMinValueExclusive(program, type);
+    if (minValueExclusive !== undefined) {
+        schema.minimum = minValueExclusive;
+        schema.exclusiveMinimum = true;
+    }
+    const maxValueExclusive = getMaxValueExclusive(program, type);
+    if (maxValueExclusive !== undefined) {
+        schema.maximum = maxValueExclusive;
+        schema.exclusiveMaximum = true;
+    }
+    if (isSecret(program, type)) {
+        schema.format = "password";
+    }
+    // the stdlib applies a format of "url" but json schema wants "uri",
+    // so ignore this format if it's the built-in type.
+    if (!__classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_isStdType).call(this, type) || type.name !== "url") {
+        applyConstraint(getFormat, "format");
+    }
+    applyConstraint(getDoc, "description");
+    applyConstraint(getSummary, "title");
+    applyConstraint((p, t) => (getDeprecated(p, t) !== undefined ? true : undefined), "deprecated");
+    __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_attachExtensions).call(this, program, type, schema);
+    const values = getKnownValues(program, type);
+    if (values) {
+        return new ObjectBuilder({
+            oneOf: [schema, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_enumSchema).call(this, values)],
+        });
+    }
+    return new ObjectBuilder(schema);
+}, _OpenAPI3SchemaEmitter_inlineType = function _OpenAPI3SchemaEmitter_inlineType(type, schema) {
+    if (__classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_options, "f").includeXTypeSpecName !== "never") {
+        schema.set("x-typespec-name", getTypeName(type, __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_typeNameOptions).call(this)));
+    }
+    return schema;
+}, _OpenAPI3SchemaEmitter_createDeclaration = function _OpenAPI3SchemaEmitter_createDeclaration(type, name, schema) {
+    const refUrl = getRef(this.emitter.getProgram(), type);
+    if (refUrl) {
+        return {
+            $ref: refUrl,
+        };
+    }
+    if (shouldInline(this.emitter.getProgram(), type)) {
+        return __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_inlineType).call(this, type, schema);
+    }
+    const title = getSummary(this.emitter.getProgram(), type);
+    if (title) {
+        schema.set("title", title);
+    }
+    const usage = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_visibilityUsage, "f").getUsage(type);
+    const shouldAddSuffix = usage !== undefined && usage.size > 1;
+    const visibility = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getVisibilityContext).call(this);
+    const fullName = name + (shouldAddSuffix ? getVisibilitySuffix(visibility, Visibility.Read) : "");
+    const decl = this.emitter.result.declaration(fullName, schema);
+    checkDuplicateTypeName(this.emitter.getProgram(), type, fullName, Object.fromEntries(decl.scope.declarations.map((x) => [x.name, true])));
+    return decl;
+}, _OpenAPI3SchemaEmitter_isStdType = function _OpenAPI3SchemaEmitter_isStdType(type) {
+    return this.emitter.getProgram().checker.isStdType(type);
+}, _OpenAPI3SchemaEmitter_applyEncoding = function _OpenAPI3SchemaEmitter_applyEncoding(typespecType, target) {
+    const encodeData = getEncode(this.emitter.getProgram(), typespecType);
+    if (encodeData) {
+        const newTarget = new ObjectBuilder(target);
+        const newType = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_getSchemaForStdScalars).call(this, encodeData.type);
+        newTarget.type = newType.type;
+        // If the target already has a format it takes priority. (e.g. int32)
+        newTarget.format = __classPrivateFieldGet(this, _OpenAPI3SchemaEmitter_instances, "m", _OpenAPI3SchemaEmitter_mergeFormatAndEncoding).call(this, newTarget.format, encodeData.encoding, newType.format);
+        return newTarget;
+    }
+    return new ObjectBuilder(target);
+}, _OpenAPI3SchemaEmitter_mergeFormatAndEncoding = function _OpenAPI3SchemaEmitter_mergeFormatAndEncoding(format, encoding, encodeAsFormat) {
+    switch (format) {
+        case undefined:
+            return encodeAsFormat !== null && encodeAsFormat !== void 0 ? encodeAsFormat : encoding;
+        case "date-time":
+            switch (encoding) {
+                case "rfc3339":
+                    return "date-time";
+                case "unixTimestamp":
+                    return "unixtime";
+                case "rfc7231":
+                    return "http-date";
+                default:
+                    return encoding;
+            }
+        case "duration":
+            switch (encoding) {
+                case "ISO8601":
+                    return "duration";
+                default:
+                    return encodeAsFormat !== null && encodeAsFormat !== void 0 ? encodeAsFormat : encoding;
+            }
+        default:
+            return encodeAsFormat !== null && encodeAsFormat !== void 0 ? encodeAsFormat : encoding;
+    }
+};
+function isLiteralType(type) {
+    return type.kind === "Boolean" || type.kind === "String" || type.kind === "Number";
+}
+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));
+}
+const B = {
+    array: (items) => {
+        const builder = new ArrayBuilder();
+        for (const item of items) {
+            builder.push(item);
+        }
+        return builder;
+    },
+    object: (obj) => {
+        const builder = new ObjectBuilder();
+        for (const [key, value] of Object.entries(obj)) {
+            builder.set(key, value);
+        }
+        return builder;
+    },
+};
+//# sourceMappingURL=schema-emitter.js.map