@typespec/openapi3 0.64.0-dev.1 → 0.64.0-dev.4

package/dist/src/schema-emitter.js

@@ -1,25 +1,28 @@
-import { compilerAssert, explainStringTemplateNotSerializable, getDeprecated, getDiscriminatedUnion, getDiscriminator, getDoc, getEncode, getExamples, getFormat, getKnownValues, getMaxItems, getMaxLength, getMaxValue, getMaxValueExclusive, getMinItems, getMinLength, getMinValue, getMinValueExclusive, getNamespaceFullName, getPattern, getSummary, getTypeName, ignoreDiagnostics, isArrayModelType, isNeverType, isNullType, isSecret, isTemplateDeclaration, resolveEncodedName, serializeValueAsJson, } from "@typespec/compiler";
+import { compilerAssert, explainStringTemplateNotSerializable, getDeprecated, getDiscriminatedUnion, getDiscriminator, getDoc, getEncode, getFormat, getKnownValues, getMaxItems, getMaxLength, getMaxValue, getMinItems, getMinLength, getMinValue, getNamespaceFullName, getPattern, getSummary, getTypeName, ignoreDiagnostics, isArrayModelType, isNeverType, isSecret, resolveEncodedName, } from "@typespec/compiler";
 import { ArrayBuilder, ObjectBuilder, Placeholder, TypeEmitter, } from "@typespec/compiler/emitter-framework";
 import { Visibility, getVisibilitySuffix } from "@typespec/http";
-import { checkDuplicateTypeName, getExtensions, getExternalDocs, getOpenAPITypeName, isReadonlyProperty, shouldInline, } from "@typespec/openapi";
+import { checkDuplicateTypeName, getExternalDocs, getOpenAPITypeName, isReadonlyProperty, shouldInline, } from "@typespec/openapi";
+import { attachExtensions } from "./attach-extensions.js";
 import { getOneOf, getRef } from "./decorators.js";
-import { applyEncoding } from "./encoding.js";
 import { reportDiagnostic } from "./lib.js";
 import { getSchemaForStdScalars } from "./std-scalar-schemas.js";
+import { getDefaultValue, includeDerivedModel, isBytesKeptRaw, isStdType } from "./util.js";
 /**
- * OpenAPI3 schema emitter. Deals with emitting content of `components/schemas` section.
+ * Base OpenAPI3 schema emitter. Deals with emitting content of `components/schemas` section.
  */
-export class OpenAPI3SchemaEmitter extends TypeEmitter {
-    #metadataInfo;
-    #visibilityUsage;
-    #options;
-    #xmlModule;
-    constructor(emitter, metadataInfo, visibilityUsage, options, xmlModule) {
+export class OpenAPI3SchemaEmitterBase extends TypeEmitter {
+    _metadataInfo;
+    _visibilityUsage;
+    _options;
+    _jsonSchemaModule;
+    _xmlModule;
+    constructor(emitter, metadataInfo, visibilityUsage, options, optionalDependencies) {
         super(emitter);
-        this.#metadataInfo = metadataInfo;
-        this.#visibilityUsage = visibilityUsage;
-        this.#options = options;
-        this.#xmlModule = xmlModule;
+        this._metadataInfo = metadataInfo;
+        this._visibilityUsage = visibilityUsage;
+        this._options = options;
+        this._jsonSchemaModule = optionalDependencies.jsonSchemaModule;
+        this._xmlModule = optionalDependencies.xmlModule;
     }
     modelDeclarationReferenceContext(model, name) {
         return this.reduceContext(model);
@@ -39,15 +42,28 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
     reduceContext(type) {
         const visibility = this.#getVisibilityContext();
         const patch = {};
-        if (visibility !== Visibility.Read && !this.#metadataInfo.isTransformed(type, visibility)) {
+        if (visibility !== Visibility.Read && !this._metadataInfo.isTransformed(type, visibility)) {
             patch.visibility = Visibility.Read;
         }
-        const contentType = this.#getContentType();
+        const contentType = this.getContentType();
         if (contentType === "application/json") {
             patch.contentType = undefined;
         }
         return patch;
     }
+    applyDiscriminator(type, schema) {
+        const program = this.emitter.getProgram();
+        const discriminator = getDiscriminator(program, type);
+        if (discriminator) {
+            // the decorator validates that all the variants will be a model type
+            // with the discriminator field present.
+            schema.discriminator = { ...discriminator };
+            const discriminatedUnion = ignoreDiagnostics(getDiscriminatedUnion(type, discriminator));
+            if (discriminatedUnion.variants.size > 0) {
+                schema.discriminator.mapping = this.getDiscriminatorMapping(discriminatedUnion);
+            }
+        }
+    }
     modelDeclaration(model, _) {
         const program = this.emitter.getProgram();
         const visibility = this.#getVisibilityContext();
@@ -64,23 +80,15 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
         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 = this.#getDiscriminatorMapping(union);
-            }
-            schema.discriminator = openApiDiscriminator;
-        }
+        this.applyDiscriminator(model, schema);
         this.#applyExternalDocs(model, schema);
         if (model.baseModel) {
-            schema.set("allOf", B.array([this.emitter.emitTypeReference(model.baseModel)]));
+            schema.set("allOf", Builders.array([this.emitter.emitTypeReference(model.baseModel)]));
         }
         const baseName = getOpenAPITypeName(program, model, this.#typeNameOptions());
-        const isMultipart = this.#getContentType().startsWith("multipart/");
+        const isMultipart = this.getContentType().startsWith("multipart/");
         const name = isMultipart ? baseName + "MultiPart" : baseName;
-        return this.#createDeclaration(model, name, this.#applyConstraints(model, schema));
+        return this.#createDeclaration(model, name, this.applyConstraints(model, schema));
     }
     #applyExternalDocs(typespecType, target) {
         const externalDocs = getExternalDocs(this.emitter.getProgram(), typespecType);
@@ -104,7 +112,7 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
     #ignoreMetadataAnnotations() {
         return this.emitter.getContext().ignoreMetadataAnnotations;
     }
-    #getContentType() {
+    getContentType() {
         return this.emitter.getContext().contentType ?? "application/json";
     }
     modelLiteral(model) {
@@ -130,7 +138,7 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
             type: "array",
             items: this.emitter.emitTypeReference(elementType),
         });
-        return this.#createDeclaration(array, name, this.#applyConstraints(array, schema));
+        return this.#createDeclaration(array, name, this.applyConstraints(array, schema));
     }
     arrayDeclarationReferenceContext(array, name, elementType) {
         return {
@@ -155,11 +163,11 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
                 // If the property has a type of 'never', don't include it in the schema
                 continue;
             }
-            if (!this.#metadataInfo.isPayloadProperty(prop, visibility, this.#ignoreMetadataAnnotations())) {
+            if (!this._metadataInfo.isPayloadProperty(prop, visibility, this.#ignoreMetadataAnnotations())) {
                 continue;
             }
-            if (!this.#metadataInfo.isOptional(prop, visibility)) {
-                const encodedName = resolveEncodedName(this.emitter.getProgram(), prop, this.#getContentType());
+            if (!this._metadataInfo.isOptional(prop, visibility)) {
+                const encodedName = resolveEncodedName(this.emitter.getProgram(), prop, this.getContentType());
                 requiredProps.push(encodedName);
             }
         }
@@ -175,13 +183,13 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
         const program = this.emitter.getProgram();
         const props = new ObjectBuilder();
         const visibility = this.emitter.getContext().visibility;
-        const contentType = this.#getContentType();
+        const contentType = this.getContentType();
         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 (!this.#metadataInfo.isPayloadProperty(prop, visibility, this.#ignoreMetadataAnnotations())) {
+            if (!this._metadataInfo.isPayloadProperty(prop, visibility, this.#ignoreMetadataAnnotations())) {
                 continue;
             }
             const result = this.emitter.emitModelProperty(prop);
@@ -200,17 +208,20 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
         }
         return props;
     }
+    getRawBinarySchema() {
+        throw new Error("Method not implemented.");
+    }
     modelPropertyLiteral(prop) {
         const program = this.emitter.getProgram();
-        const isMultipart = this.#getContentType().startsWith("multipart/");
+        const isMultipart = this.getContentType().startsWith("multipart/");
         if (isMultipart) {
             if (isBytesKeptRaw(program, prop.type) && getEncode(program, prop) === undefined) {
-                return { type: "string", format: "binary" };
+                return this.getRawBinarySchema();
             }
             if (prop.type.kind === "Model" &&
                 isArrayModelType(program, prop.type) &&
                 isBytesKeptRaw(program, prop.type.indexer.value)) {
-                return { type: "array", items: { type: "string", format: "binary" } };
+                return { type: "array", items: this.getRawBinarySchema() };
             }
         }
         const refSchema = this.emitter.emitTypeReference(prop.type, {
@@ -231,9 +242,9 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
             return {};
         }
         const isRef = refSchema.value instanceof Placeholder || "$ref" in refSchema.value;
-        const schema = this.#applyEncoding(prop, refSchema.value);
+        const schema = this.applyEncoding(prop, refSchema.value);
         // Apply decorators on the property to the type's schema
-        const additionalProps = this.#applyConstraints(prop, {}, schema);
+        const additionalProps = this.applyConstraints(prop, {}, schema);
         if (prop.defaultValue) {
             additionalProps.default = getDefaultValue(program, prop.defaultValue, prop);
         }
@@ -241,7 +252,7 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
             additionalProps.readOnly = true;
         }
         // Attach any additional OpenAPI extensions
-        this.#attachExtensions(program, prop, additionalProps);
+        attachExtensions(program, prop, additionalProps);
         if (schema && isRef && !(prop.type.kind === "Model" && isArrayModelType(program, prop.type))) {
             if (Object.keys(additionalProps).length === 0) {
                 return schema;
@@ -291,28 +302,11 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
     }
     enumDeclaration(en, name) {
         const baseName = getOpenAPITypeName(this.emitter.getProgram(), en, this.#typeNameOptions());
-        return this.#createDeclaration(en, baseName, new ObjectBuilder(this.#enumSchema(en)));
+        return this.#createDeclaration(en, baseName, new ObjectBuilder(this.enumSchema(en)));
     }
-    #enumSchema(en) {
-        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(member.value ?? member.name);
-        }
-        if (enumTypes.size > 1) {
-            reportDiagnostic(program, { code: "enum-unique-type", target: en });
-        }
-        const schema = {
-            type: enumTypes.values().next().value,
-            enum: [...enumValues],
-        };
-        return this.#applyConstraints(en, schema);
+    enumSchema(en) {
+        // Enums are handled differently between 3.x versions due to the differences in `type`
+        throw new Error("Method not implemented.");
     }
     enumMember(member) {
         return this.enumMemberReference(member);
@@ -329,134 +323,16 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
         }
     }
     unionDeclaration(union, name) {
-        const schema = this.#unionSchema(union);
+        const schema = this.unionSchema(union);
         const baseName = getOpenAPITypeName(this.emitter.getProgram(), union, this.#typeNameOptions());
         return this.#createDeclaration(union, baseName, schema);
     }
-    #unionSchema(union) {
-        const program = this.emitter.getProgram();
-        if (union.variants.size === 0) {
-            reportDiagnostic(program, { code: "empty-union", target: union });
-            return new ObjectBuilder({});
-        }
-        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);
-        const isMultipart = this.#getContentType().startsWith("multipart/");
-        for (const variant of variants) {
-            if (isNullType(variant.type)) {
-                nullable = true;
-                continue;
-            }
-            if (isMultipart && isBytesKeptRaw(program, variant.type)) {
-                schemaMembers.push({ schema: { type: "string", format: "binary" }, type: variant.type });
-                continue;
-            }
-            if (isLiteralType(variant.type)) {
-                if (!literalVariantEnumByType[variant.type.kind]) {
-                    const enumValue = [variant.type.value];
-                    literalVariantEnumByType[variant.type.kind] = enumValue;
-                    schemaMembers.push({
-                        schema: { type: literalType(variant.type), enum: enumValue },
-                        type: null,
-                    });
-                }
-                else {
-                    literalVariantEnumByType[variant.type.kind].push(variant.type.value);
-                }
-            }
-            else {
-                const enumSchema = this.emitter.emitTypeReference(variant.type, {
-                    referenceContext: isMultipart ? { contentType: "application/json" } : {},
-                });
-                compilerAssert(enumSchema.kind === "code", "Unexpected enum schema. Should be kind: code");
-                schemaMembers.push({ schema: enumSchema.value, type: variant.type });
-            }
-        }
-        const wrapWithObjectBuilder = (schemaMember, { mergeUnionWideConstraints }) => {
-            // we can just return the single schema member after applying nullable
-            const schema = schemaMember.schema;
-            const type = schemaMember.type;
-            const additionalProps = mergeUnionWideConstraints
-                ? this.#applyConstraints(union, {})
-                : {};
-            if (mergeUnionWideConstraints && nullable) {
-                additionalProps.nullable = true;
-            }
-            if (Object.keys(additionalProps).length === 0) {
-                return new ObjectBuilder(schema);
-            }
-            else {
-                if ((schema instanceof Placeholder || "$ref" in schema) &&
-                    !(type && shouldInline(program, type))) {
-                    if (type && (type.kind === "Model" || type.kind === "Scalar")) {
-                        return new ObjectBuilder({
-                            type: "object",
-                            allOf: B.array([schema]),
-                            ...additionalProps,
-                        });
-                    }
-                    else {
-                        return new ObjectBuilder({ allOf: B.array([schema]), ...additionalProps });
-                    }
-                }
-                else {
-                    const merged = new ObjectBuilder(schema);
-                    for (const [key, value] of Object.entries(additionalProps)) {
-                        merged.set(key, value);
-                    }
-                    return merged;
-                }
-            }
-        };
-        const checkMerge = (schemaMembers) => {
-            if (nullable) {
-                for (const m of schemaMembers) {
-                    if (m.schema instanceof Placeholder || "$ref" in m.schema) {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        };
-        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 new ObjectBuilder({});
-            }
-            else {
-                // completely empty union can maybe only happen with bugs?
-                compilerAssert(false, "Attempting to emit an empty union");
-            }
-        }
-        if (schemaMembers.length === 1) {
-            return wrapWithObjectBuilder(schemaMembers[0], { mergeUnionWideConstraints: true });
-        }
-        const isMerge = checkMerge(schemaMembers);
-        const schema = {
-            [ofType]: schemaMembers.map((m) => wrapWithObjectBuilder(m, { mergeUnionWideConstraints: isMerge })),
-        };
-        if (!isMerge && 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 = this.#getDiscriminatorMapping(discriminatedUnion);
-            }
-        }
-        return this.#applyConstraints(union, schema);
+    unionSchema(union) {
+        // Unions are handled differently between 3.x versions
+        // mostly due to how nullable properties are handled.
+        throw new Error("Method not implemented.");
     }
-    #getDiscriminatorMapping(union) {
+    getDiscriminatorMapping(union) {
         const mapping = {};
         for (const [key, model] of union.variants.entries()) {
             const ref = this.emitter.emitTypeReference(model);
@@ -466,7 +342,7 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
         return mapping;
     }
     unionLiteral(union) {
-        return this.#unionSchema(union);
+        return this.unionSchema(union);
     }
     unionVariants(union) {
         const variants = new ArrayBuilder();
@@ -481,15 +357,6 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
     modelPropertyReference(prop) {
         return this.modelPropertyLiteral(prop);
     }
-    #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);
-            }
-        }
-    }
     reference(targetDeclaration, pathUp, pathDown, commonScope) {
         if (targetDeclaration.value instanceof Placeholder) {
             // I don't think this is possible, confirm.
@@ -517,11 +384,13 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
         return super.circularReference(target, scope, cycle);
     }
     scalarDeclaration(scalar, name) {
-        const isStd = this.#isStdType(scalar);
+        const isStd = isStdType(this.emitter.getProgram(), scalar);
         const schema = this.#getSchemaForScalar(scalar);
         const baseName = getOpenAPITypeName(this.emitter.getProgram(), scalar, this.#typeNameOptions());
         // Don't create a declaration for std types
-        return isStd ? schema : this.#createDeclaration(scalar, baseName, new ObjectBuilder(schema));
+        return isStd
+            ? schema
+            : this.#createDeclaration(scalar, baseName, new ObjectBuilder(schema));
     }
     scalarInstantiation(scalar, name) {
         return this.#getSchemaForScalar(scalar);
@@ -531,31 +400,26 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
     }
     #getSchemaForScalar(scalar) {
         let result = {};
-        const isStd = this.#isStdType(scalar);
+        const isStd = isStdType(this.emitter.getProgram(), scalar);
         if (isStd) {
-            result = this.#getSchemaForStdScalars(scalar);
+            result = this.getSchemaForStdScalars(scalar);
         }
         else if (scalar.baseScalar) {
             result = this.#getSchemaForScalar(scalar.baseScalar);
         }
-        const withDecorators = this.#applyEncoding(scalar, this.#applyConstraints(scalar, result));
+        const withDecorators = this.applyEncoding(scalar, this.applyConstraints(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;
     }
-    #getSchemaForStdScalars(scalar) {
-        return getSchemaForStdScalars(scalar, this.#options);
+    getSchemaForStdScalars(scalar) {
+        return getSchemaForStdScalars(scalar, this._options);
     }
-    #applySchemaExamples(type, target) {
-        const program = this.emitter.getProgram();
-        const examples = getExamples(program, type);
-        if (examples.length > 0) {
-            target.set("example", serializeValueAsJson(program, examples[0].value, type));
-        }
-    }
-    #applyConstraints(type, original, refSchema) {
+    applyCustomConstraints(type, target, refSchema) { }
+    applyConstraints(type, original, refSchema) {
+        // Apply common constraints
         const schema = new ObjectBuilder(original);
         const program = this.emitter.getProgram();
         const applyConstraint = (fn, key) => {
@@ -564,7 +428,6 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
                 schema[key] = value;
             }
         };
-        this.#applySchemaExamples(type, schema);
         applyConstraint(getMinLength, "minLength");
         applyConstraint(getMaxLength, "maxLength");
         applyConstraint(getMinValue, "minimum");
@@ -572,49 +435,52 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
         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;
+        // apply json schema decorators
+        const jsonSchemaModule = this._jsonSchemaModule;
+        if (jsonSchemaModule) {
+            applyConstraint(jsonSchemaModule.getMultipleOf, "multipleOf");
+            applyConstraint(jsonSchemaModule.getUniqueItems, "uniqueItems");
+            applyConstraint(jsonSchemaModule.getMinProperties, "minProperties");
+            applyConstraint(jsonSchemaModule.getMaxProperties, "maxProperties");
         }
         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 (!this.#isStdType(type) || type.name !== "url") {
+        if (!isStdType(program, type) || type.name !== "url") {
             applyConstraint(getFormat, "format");
         }
         applyConstraint(getDoc, "description");
         applyConstraint(getSummary, "title");
         applyConstraint((p, t) => (getDeprecated(p, t) !== undefined ? true : undefined), "deprecated");
-        if (this.#xmlModule) {
+        this.applyCustomConstraints(type, schema, refSchema);
+        this.applyXml(type, schema, refSchema);
+        attachExtensions(program, type, schema);
+        const values = getKnownValues(program, type);
+        if (values) {
+            return new ObjectBuilder({
+                oneOf: [schema, this.enumSchema(values)],
+            });
+        }
+        return new ObjectBuilder(schema);
+    }
+    applyXml(type, schema, refSchema) {
+        const program = this.emitter.getProgram();
+        if (this._xmlModule) {
             switch (type.kind) {
                 case "Scalar":
                 case "Model":
-                    this.#xmlModule.attachXmlObjectForScalarOrModel(program, type, schema);
+                    this._xmlModule.attachXmlObjectForScalarOrModel(program, type, schema);
                     break;
                 case "ModelProperty":
-                    this.#xmlModule.attachXmlObjectForModelProperty(program, this.#options, type, schema, refSchema);
+                    this._xmlModule.attachXmlObjectForModelProperty(program, this._options, type, schema, refSchema);
                     break;
             }
         }
-        this.#attachExtensions(program, type, schema);
-        const values = getKnownValues(program, type);
-        if (values) {
-            return new ObjectBuilder({
-                oneOf: [schema, this.#enumSchema(values)],
-            });
-        }
-        return new ObjectBuilder(schema);
     }
     #inlineType(type, schema) {
-        if (this.#options.includeXTypeSpecName !== "never") {
+        if (this._options.includeXTypeSpecName !== "never") {
             schema.set("x-typespec-name", getTypeName(type, this.#typeNameOptions()));
         }
         return schema;
@@ -633,7 +499,7 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
         if (title) {
             schema.set("title", title);
         }
-        const usage = this.#visibilityUsage.getUsage(type);
+        const usage = this._visibilityUsage.getUsage(type);
         const shouldAddSuffix = usage !== undefined && usage.size > 1;
         const visibility = this.#getVisibilityContext();
         const fullName = name + (shouldAddSuffix ? getVisibilitySuffix(visibility, Visibility.Read) : "");
@@ -641,51 +507,15 @@ export class OpenAPI3SchemaEmitter extends TypeEmitter {
         checkDuplicateTypeName(this.emitter.getProgram(), type, fullName, Object.fromEntries(decl.scope.declarations.map((x) => [x.name, true])));
         return decl;
     }
-    #isStdType(type) {
-        return this.emitter.getProgram().checker.isStdType(type);
-    }
-    #applyEncoding(typespecType, target) {
-        return applyEncoding(this.emitter.getProgram(), typespecType, target, this.#options);
-    }
-    intrinsic(intrinsic, name) {
-        switch (name) {
-            case "unknown":
-                return {};
-            case "null":
-                return { nullable: true };
-        }
-        reportDiagnostic(this.emitter.getProgram(), {
-            code: "invalid-schema",
-            format: { type: name },
-            target: intrinsic,
-        });
-        return {};
+    applyEncoding(typespecType, target) {
+        throw new Error("Method not implemented.");
     }
     programContext(program) {
         const sourceFile = this.emitter.createSourceFile("openapi");
         return { scope: sourceFile.globalScope };
     }
 }
-function isLiteralType(type) {
-    return type.kind === "Boolean" || type.kind === "String" || type.kind === "Number";
-}
-function literalType(type) {
-    switch (type.kind) {
-        case "String":
-            return "string";
-        case "Number":
-            return "number";
-        case "Boolean":
-            return "boolean";
-    }
-}
-function includeDerivedModel(model) {
-    return (!isTemplateDeclaration(model) &&
-        (model.templateMapper?.args === undefined ||
-            model.templateMapper.args?.length === 0 ||
-            model.derivedModels.length > 0));
-}
-const B = {
+export const Builders = {
     array: (items) => {
         const builder = new ArrayBuilder();
         for (const item of items) {
@@ -701,10 +531,4 @@ const B = {
         return builder;
     },
 };
-export function getDefaultValue(program, defaultType, modelProperty) {
-    return serializeValueAsJson(program, defaultType, modelProperty);
-}
-export function isBytesKeptRaw(program, type) {
-    return type.kind === "Scalar" && type.name === "bytes" && getEncode(program, type) === undefined;
-}
 //# sourceMappingURL=schema-emitter.js.map