@typespec/http-server-csharp 0.58.0-alpha.28 → 0.58.0-alpha.29-dev.3

package/dist/src/lib/utils.js

@@ -1,1580 +0,0 @@
-import { StringBuilder, code, } from "@typespec/asset-emitter";
-import { NoTarget, getFriendlyName, getMinValue, isArrayModelType, isErrorModel, isNullType, isNumericType, isTemplateInstance, isUnknownType, isVoidType, resolveCompilerOptions, resolvePath, serializeValueAsJson, } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/typekit";
-import { Visibility, createMetadataInfo, getHeaderFieldName, isBody, isBodyRoot, isHeader, isMetadata, isPathParam, isQueryParam, isStatusCode, } from "@typespec/http";
-import { getUniqueItems } from "@typespec/json-schema";
-import { camelCase, pascalCase } from "change-case";
-import { createServer } from "net";
-import { getAttributes } from "./attributes.js";
-import { BooleanValue, CSharpCollectionType, CSharpType, CollectionType, NameCasingType, NullValue, NumericValue, StringValue, checkOrAddNamespaceToScope, } from "./interfaces.js";
-import { CSharpServiceOptions, reportDiagnostic } from "./lib.js";
-import { getDoubleType, getEnumType } from "./type-helpers.js";
-const _scalars = new Map();
-export function getCSharpTypeForScalar(program, scalar) {
-    if (_scalars.has(scalar))
-        return _scalars.get(scalar);
-    if (program.checker.isStdType(scalar)) {
-        return getCSharpTypeForStdScalars(program, scalar);
-    }
-    if (scalar.baseScalar) {
-        return getCSharpTypeForScalar(program, scalar.baseScalar);
-    }
-    reportDiagnostic(program, {
-        code: "unrecognized-scalar",
-        format: { typeName: scalar.name },
-        target: scalar,
-    });
-    const result = new CSharpType({
-        name: "object",
-        namespace: "System",
-        isBuiltIn: true,
-        isValueType: false,
-    });
-    _scalars.set(scalar, result);
-    return result;
-}
-export const UnknownType = new CSharpType({
-    name: "JsonNode",
-    namespace: "System.Text.Json.Nodes",
-    isValueType: false,
-    isBuiltIn: false,
-    isClass: true,
-});
-export const RecordType = new CSharpType({
-    name: "JsonObject",
-    namespace: "System.Text.Json.Nodes",
-    isBuiltIn: false,
-    isValueType: false,
-    isClass: true,
-});
-export function getCSharpType(program, type, namespace) {
-    const known = getKnownType(program, type);
-    if (known !== undefined)
-        return { type: known };
-    switch (type.kind) {
-        case "Boolean":
-            return { type: standardScalars.get("boolean"), value: new BooleanValue(type.value) };
-        case "Number":
-            return { type: standardScalars.get("numeric"), value: new NumericValue(type.value) };
-        case "String":
-            return { type: standardScalars.get("string"), value: new StringValue(type.value) };
-        case "EnumMember":
-            const enumValue = type.value === undefined ? type.name : type.value;
-            if (typeof enumValue === "string")
-                return { type: standardScalars.get("string"), value: new StringValue(enumValue) };
-            else
-                return { type: standardScalars.get("numeric"), value: new NumericValue(enumValue) };
-        case "Intrinsic":
-            return getCSharpTypeForIntrinsic(program, type);
-        case "ModelProperty":
-            return getCSharpType(program, type.type, namespace);
-        case "Scalar":
-            return { type: getCSharpTypeForScalar(program, type) };
-        case "Tuple":
-            const resolvedItem = coalesceTypes(program, type.values, namespace);
-            const itemType = resolvedItem.type;
-            return {
-                type: new CSharpType({
-                    name: `${itemType.name}[]`,
-                    namespace: itemType.namespace,
-                    isBuiltIn: itemType.isBuiltIn,
-                    isValueType: false,
-                }),
-            };
-        case "UnionVariant":
-            return getCSharpType(program, type.type, namespace);
-        case "Union":
-            return coalesceTypes(program, [...type.variants.values()].map((v) => v.type), namespace);
-        case "Interface":
-            return {
-                type: new CSharpType({
-                    name: ensureCSharpIdentifier(program, type, type.name, NameCasingType.Class),
-                    namespace: `${namespace}`,
-                    isBuiltIn: false,
-                    isValueType: false,
-                    isClass: true,
-                }),
-            };
-        case "Enum":
-            if (getEnumType(type) === "double")
-                return { type: getDoubleType() };
-            return {
-                type: new CSharpType({
-                    name: ensureCSharpIdentifier(program, type, type.name, NameCasingType.Class),
-                    namespace: `${namespace}`,
-                    isBuiltIn: false,
-                    isValueType: true,
-                }),
-            };
-        case "Model":
-            if (type.indexer !== undefined && isNumericType(program, type.indexer?.key)) {
-                const resolvedItem = getCSharpType(program, type.indexer.value, namespace);
-                if (resolvedItem === undefined)
-                    return undefined;
-                const { type: itemType, value: _ } = resolvedItem;
-                const uniqueItems = getUniqueItems(program, type);
-                const isByte = ["byte", "SByte"].includes(itemType.name);
-                const collectionType = CSharpServiceOptions.getInstance().collectionType;
-                const returnTypeCollection = uniqueItems
-                    ? CollectionType.ISet
-                    : isByte
-                        ? CollectionType.Array
-                        : collectionType;
-                const returnType = returnTypeCollection === CollectionType.Array
-                    ? `${itemType.name}[]`
-                    : `${returnTypeCollection}<${itemType.name}>`;
-                return {
-                    type: new CSharpCollectionType({
-                        name: returnType,
-                        namespace: itemType.namespace,
-                        isBuiltIn: itemType.isBuiltIn,
-                        isValueType: false,
-                        isClass: itemType.isClass,
-                        isCollection: true,
-                    }, returnTypeCollection, itemType.name),
-                };
-            }
-            if (isRecord(type))
-                return {
-                    type: RecordType,
-                };
-            let name = type.name;
-            if (isTemplateInstance(type)) {
-                name = getModelInstantiationName(program, type, name);
-            }
-            return {
-                type: new CSharpType({
-                    name: ensureCSharpIdentifier(program, type, name, NameCasingType.Class),
-                    namespace: `${namespace}`,
-                    isBuiltIn: false,
-                    isValueType: false,
-                    isClass: true,
-                }),
-            };
-        default:
-            return undefined;
-    }
-}
-export function resolveReferenceFromScopes(targetDeclaration, declarationScopes, referenceScopes) {
-    function getSourceFile(scopes) {
-        for (const scope of scopes) {
-            if (scope.kind === "sourceFile") {
-                return { scope: scope, file: scope.sourceFile };
-            }
-        }
-        return undefined;
-    }
-    const decl = getSourceFile(declarationScopes);
-    const ref = getSourceFile(referenceScopes);
-    if (targetDeclaration.name && decl) {
-        const declNs = decl.file.meta["ResolvedNamespace"];
-        if (!ref)
-            return declNs ? `${declNs}.${targetDeclaration.name} ` : undefined;
-        if (checkOrAddNamespaceToScope(declNs, ref.scope)) {
-            return targetDeclaration.name;
-        }
-        return declNs ? `${declNs}.${targetDeclaration.name} ` : undefined;
-    }
-    return undefined;
-}
-export function coalesceTypes(program, types, namespace) {
-    const visited = new Map();
-    let candidateType = undefined;
-    let candidateValue = undefined;
-    for (const type of types) {
-        if (!isNullType(type)) {
-            if (!visited.has(type)) {
-                const resolvedType = getCSharpType(program, type, namespace);
-                if (resolvedType === undefined)
-                    return { type: UnknownType };
-                if (resolvedType.type === UnknownType)
-                    return resolvedType;
-                if (candidateType === undefined) {
-                    candidateType = resolvedType.type;
-                    candidateValue = resolvedType.value;
-                }
-                else {
-                    if (candidateValue !== resolvedType.value)
-                        candidateValue = undefined;
-                    if (candidateType !== resolvedType.type)
-                        return { type: UnknownType };
-                }
-                visited.set(type, resolvedType);
-            }
-        }
-    }
-    return { type: candidateType !== undefined ? candidateType : UnknownType, value: candidateValue };
-}
-export function getKnownType(program, type) {
-    return undefined;
-}
-export function getCSharpTypeForIntrinsic(program, type) {
-    if (isUnknownType(type)) {
-        return { type: UnknownType };
-    }
-    if (isVoidType(type)) {
-        return {
-            type: new CSharpType({
-                name: "void",
-                namespace: "System",
-                isBuiltIn: true,
-                isValueType: false,
-            }),
-        };
-    }
-    if (isNullType(type)) {
-        return {
-            type: new CSharpType({
-                name: "object",
-                namespace: "System",
-                isBuiltIn: true,
-                isValueType: false,
-            }),
-            value: new NullValue(),
-        };
-    }
-    return undefined;
-}
-const standardScalars = new Map([
-    [
-        "bytes",
-        new CSharpType({ name: "byte[]", namespace: "System", isBuiltIn: true, isValueType: false }),
-    ],
-    [
-        "int8",
-        new CSharpType({ name: "SByte", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "uint8",
-        new CSharpType({ name: "Byte", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "int16",
-        new CSharpType({ name: "Int16", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "uint16",
-        new CSharpType({ name: "UInt16", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "int16",
-        new CSharpType({ name: "Int16", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "uint16",
-        new CSharpType({ name: "UInt16", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "int32",
-        new CSharpType({ name: "int", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "uint32",
-        new CSharpType({ name: "UInt32", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "integer",
-        new CSharpType({ name: "long", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "int64",
-        new CSharpType({ name: "long", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "uint64",
-        new CSharpType({ name: "UInt64", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "safeint",
-        new CSharpType({ name: "long", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "float",
-        new CSharpType({ name: "double", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "float64",
-        new CSharpType({ name: "double", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "float32",
-        new CSharpType({ name: "float", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "string",
-        new CSharpType({ name: "string", namespace: "System", isBuiltIn: true, isValueType: false }),
-    ],
-    [
-        "boolean",
-        new CSharpType({ name: "bool", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "plainDate",
-        new CSharpType({ name: "DateTime", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "utcDateTime",
-        new CSharpType({
-            name: "DateTimeOffset",
-            namespace: "System",
-            isBuiltIn: true,
-            isValueType: true,
-        }),
-    ],
-    [
-        "offsetDateTime",
-        new CSharpType({
-            name: "DateTimeOffset",
-            namespace: "System",
-            isBuiltIn: true,
-            isValueType: true,
-        }),
-    ],
-    [
-        "unixTimestamp32",
-        new CSharpType({
-            name: "DateTimeOffset",
-            namespace: "System",
-            isBuiltIn: true,
-            isValueType: true,
-        }),
-    ],
-    [
-        "plainTime",
-        new CSharpType({ name: "DateTime", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "duration",
-        new CSharpType({ name: "TimeSpan", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "numeric",
-        new CSharpType({ name: "object", namespace: "System", isBuiltIn: true, isValueType: false }),
-    ],
-    [
-        "url",
-        new CSharpType({ name: "string", namespace: "System", isBuiltIn: true, isValueType: false }),
-    ],
-    [
-        "decimal",
-        new CSharpType({ name: "decimal", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-    [
-        "decimal128",
-        new CSharpType({ name: "decimal", namespace: "System", isBuiltIn: true, isValueType: true }),
-    ],
-]);
-export function getCSharpTypeForStdScalars(program, scalar) {
-    const cached = _scalars.get(scalar);
-    if (cached !== undefined)
-        return cached;
-    const builtIn = standardScalars.get(scalar.name);
-    if (builtIn !== undefined) {
-        _scalars.set(scalar, builtIn);
-        if (scalar.name === "numeric" || scalar.name === "integer" || scalar.name === "float") {
-            reportDiagnostic(program, {
-                code: "no-numeric",
-                format: { sourceType: scalar.name, targetType: builtIn?.getTypeReference() },
-                target: scalar,
-            });
-        }
-        return builtIn;
-    }
-    reportDiagnostic(program, {
-        code: "unrecognized-scalar",
-        format: { typeName: scalar.name },
-        target: scalar,
-    });
-    return new CSharpType({
-        name: "Object",
-        namespace: "System",
-        isBuiltIn: true,
-        isValueType: false,
-    });
-}
-export function isValueType(program, type) {
-    if (type.kind === "Boolean" ||
-        type.kind === "Number" ||
-        type.kind === "Enum" ||
-        type.kind === "EnumMember")
-        return true;
-    if (type.kind === "Scalar")
-        return getCSharpTypeForScalar(program, type).isValueType;
-    if (type.kind !== "Union")
-        return false;
-    return [...type.variants.values()]
-        .flatMap((v) => v.type)
-        .every((t) => isNullType(t) || isValueType(program, t));
-}
-export function formatComment(text, lineLength = 76, lineEnd = "\n") {
-    function getNextLine(target) {
-        for (let i = lineLength - 1; i > 0; i--) {
-            if ([" ", ";"].includes(target.charAt(i))) {
-                return `${target.substring(0, i)}`;
-            }
-        }
-        for (let i = lineLength - 1; i < target.length; i++) {
-            if ([" ", ";"].includes(target.charAt(i))) {
-                return `${target.substring(0, i)}`;
-            }
-        }
-        return `${target.substring(0, lineLength)}`;
-    }
-    let remaining = text.replaceAll("\n", " ");
-    const lines = [];
-    while (remaining.length > lineLength) {
-        const currentLine = getNextLine(remaining);
-        remaining =
-            remaining.length > currentLine.length ? remaining.substring(currentLine.length + 1) : "";
-        lines.push(`/// ${currentLine}`);
-    }
-    if (remaining.length > 0)
-        lines.push(`/// ${remaining}`);
-    return `///<summary>${lineEnd}${lines.join(lineEnd)}${lineEnd}///</summary>`;
-}
-export function getCSharpIdentifier(name, context = NameCasingType.Class, checkReserved = true) {
-    if (name === undefined)
-        return "Placeholder";
-    name = replaceCSharpReservedWord(name, context);
-    switch (context) {
-        case NameCasingType.Namespace:
-            const parts = [];
-            for (const part of name.split(".")) {
-                parts.push(getCSharpIdentifier(part, NameCasingType.Class));
-            }
-            return parts.join(".");
-        case NameCasingType.Parameter:
-        case NameCasingType.Variable:
-            return `${camelCase(name)}`;
-        default:
-            return `${pascalCase(name)}`;
-    }
-}
-export function ensureCSharpIdentifier(program, target, name, context = NameCasingType.Class) {
-    let location = "";
-    let includeDot = false;
-    switch (target.kind) {
-        case "Enum":
-            location = `enum ${target.name}`;
-            break;
-        case "EnumMember":
-            location = `enum ${target.enum.name}`;
-            break;
-        case "Interface":
-            location = `interface ${target.name}`;
-            break;
-        case "Model":
-            location = `model ${target.name}`;
-            break;
-        case "ModelProperty": {
-            const model = target.model;
-            if (!model) {
-                reportDiagnostic(program, {
-                    code: "missing-type-parent",
-                    format: { type: "ModelProperty", name: target.name },
-                    target: target,
-                });
-            }
-            else {
-                location = `property '${target.name}' in model ${model?.name}`;
-                if (!model.name) {
-                    location = `parameter '${target.name}' in operation`;
-                }
-            }
-            break;
-        }
-        case "Namespace":
-            location = `namespace ${target.name}`;
-            let invalid = false;
-            for (const part of name.split(".")) {
-                if (!isValidCSharpIdentifier(part)) {
-                    invalid = true;
-                }
-            }
-            if (invalid) {
-                reportDiagnostic(program, {
-                    code: "invalid-identifier",
-                    format: { identifier: name, location: location },
-                    target: target.node ?? NoTarget,
-                });
-            }
-            includeDot = true;
-            break;
-        case "Operation": {
-            const parent = target.interface
-                ? `interface ${target.interface.name}`
-                : `namespace ${target.namespace?.name}`;
-            location = `operation ${target.name} in ${parent}`;
-            break;
-        }
-        case "Union":
-            location = `union ${target.name}`;
-            break;
-        case "UnionVariant": {
-            location = `variant ${String(target.name)} in union ${target.union.name}`;
-            break;
-        }
-    }
-    if (!isValidCSharpIdentifier(name, includeDot)) {
-        reportDiagnostic(program, {
-            code: "invalid-identifier",
-            format: { identifier: name, location: location },
-            target: target.node ?? NoTarget,
-        });
-        return getCSharpIdentifier(transformInvalidIdentifier(name), context);
-    }
-    return getCSharpIdentifier(name, context);
-}
-export function getModelAttributes(program, entity, cSharpName) {
-    return getAttributes(program, entity, cSharpName);
-}
-export function getModelDeclarationName(program, model, defaultSuffix) {
-    if (model.name !== null && model.name.length > 0) {
-        return ensureCSharpIdentifier(program, model, model.name, NameCasingType.Class);
-    }
-    if (model.sourceModel && model.sourceModel.name && model.sourceModel.name.length > 0) {
-        return ensureCSharpIdentifier(program, model, `${model.sourceModel.name}${defaultSuffix}`, NameCasingType.Class);
-    }
-    if (model.sourceModels.length > 0) {
-        const sourceNames = model.sourceModels
-            .filter((m) => m.model.name !== undefined && m.model.name.length > 0)
-            .flatMap((m) => ensureCSharpIdentifier(program, model, m.model.name, NameCasingType.Class));
-        if (sourceNames.length > 0) {
-            return `${sourceNames.join()}${defaultSuffix}`;
-        }
-    }
-    return `Model${defaultSuffix}`;
-}
-export function getModelInstantiationName(program, model, name) {
-    const friendlyName = getFriendlyName(program, model);
-    if (friendlyName && friendlyName.length > 0)
-        return friendlyName;
-    if (name === undefined || name.length < 1)
-        name = ensureCSharpIdentifier(program, model, "", NameCasingType.Class);
-    const names = [name];
-    if (model.templateMapper !== undefined) {
-        for (const paramType of model.templateMapper.args) {
-            if (paramType.entityKind === "Type") {
-                switch (paramType.kind) {
-                    case "Enum":
-                    case "EnumMember":
-                    case "Model":
-                    case "ModelProperty":
-                    case "Namespace":
-                    case "Scalar":
-                    case "Union":
-                        names.push(getCSharpIdentifier(paramType?.name ?? paramType.kind, NameCasingType.Class));
-                        break;
-                    default:
-                        names.push(getCSharpIdentifier(paramType.kind, NameCasingType.Class));
-                        break;
-                }
-            }
-        }
-    }
-    return ensureCSharpIdentifier(program, model, names.join(""), NameCasingType.Class);
-}
-export class ModelInfo {
-    visited = [];
-    getAllProperties(program, model) {
-        if (this.visited.includes(model))
-            return undefined;
-        this.visited.push(model);
-        const props = [];
-        for (const prop of model.properties.values())
-            props.push(prop);
-        if (model.baseModel) {
-            const additional = this.getAllProperties(program, model.baseModel);
-            if (additional !== undefined)
-                props.concat(additional);
-        }
-        return props;
-    }
-    filterAllProperties(program, model, filter) {
-        if (this.visited.includes(model))
-            return undefined;
-        this.visited.push(model);
-        for (const prop of model.properties.values()) {
-            if (filter(prop))
-                return prop;
-        }
-        if (model.baseModel !== undefined) {
-            return this.filterAllProperties(program, model.baseModel, filter);
-        }
-        return undefined;
-    }
-}
-export function getPropertySource(program, property) {
-    let result = property.model;
-    while (property.sourceProperty !== undefined) {
-        const current = property.sourceProperty;
-        result = current.model;
-        property = property.sourceProperty;
-    }
-    return result;
-}
-export function getSourceModel(program, model) {
-    const modelTracker = new Set();
-    for (const prop of model.properties.values()) {
-        const source = getPropertySource(program, prop);
-        if (source === undefined)
-            return undefined;
-        modelTracker.add(source);
-    }
-    if (modelTracker.size === 1)
-        return [...modelTracker.values()][0];
-    return undefined;
-}
-export class HttpMetadata {
-    resolveLogicalResponseType(program, response) {
-        const responseType = response.type;
-        const metaInfo = createMetadataInfo(program, {
-            canonicalVisibility: Visibility.Read,
-            canShareProperty: (p) => true,
-        });
-        switch (responseType.kind) {
-            case "Model":
-                if (responseType.indexer && responseType.indexer.key.name !== "string")
-                    return responseType;
-                if (isRecord(responseType))
-                    return responseType;
-                const bodyProp = new ModelInfo().filterAllProperties(program, responseType, (p) => isBody(program, p) || isBodyRoot(program, p));
-                if (bodyProp !== undefined)
-                    return metaInfo.getEffectivePayloadType(bodyProp.type, Visibility.Read);
-                const anyProp = new ModelInfo().filterAllProperties(program, responseType, (p) => !isMetadata(program, p) && !isStatusCode(program, p));
-                if (anyProp === undefined)
-                    return $(program).intrinsic.void;
-                if (responseType.name === "") {
-                    return metaInfo.getEffectivePayloadType(responseType, Visibility.Read);
-                }
-                break;
-        }
-        return responseType;
-    }
-}
-export function getOperationAttributes(program, entity) {
-    return getAttributes(program, entity);
-}
-export function transformInvalidIdentifier(name) {
-    const result = new StringBuilder();
-    for (let i = 0; i < name.length; ++i) {
-        result.pushLiteralSegment(getValidChar(name.charAt(i), i));
-    }
-    return result.segments.join("");
-}
-export function getOperationVerbDecorator(operation) {
-    switch (operation.verb) {
-        case "delete":
-            return "HttpDelete";
-        case "get":
-            return "HttpGet";
-        case "patch":
-            return "HttpPatch";
-        case "post":
-            return "HttpPost";
-        case "put":
-            return "HttpPut";
-        default:
-            return "HttpGet";
-    }
-}
-export function hasNonMetadataProperties(program, model) {
-    const props = [...model.properties.values()].filter((p) => !isMetadata(program, p));
-    return props.length > 0;
-}
-export async function ensureCleanDirectory(program, targetPath) {
-    try {
-        await program.host.stat(targetPath);
-        await program.host.rm(targetPath, { recursive: true });
-    }
-    catch { }
-    await program.host.mkdirp(targetPath);
-}
-export function isValidCSharpIdentifier(identifier, isNamespace = false) {
-    if (!isNamespace)
-        return identifier?.match(/^[A-Za-z_][\w]*$/) !== null;
-    return identifier?.match(/^[A-Za-z_][\w.]*$/) !== null;
-}
-export function replaceCSharpReservedWord(identifier, context) {
-    function generateReplacement(input) {
-        return [input, `${pascalCase(input)}Name`];
-    }
-    const contextualWords = [
-        "add",
-        "allows",
-        "alias",
-        "and",
-        "ascending",
-        "args",
-        "async",
-        "await",
-        "by",
-        "descending",
-        "dynamic",
-        "equals",
-        "field",
-        "file",
-        "from",
-        "get",
-        "global",
-        "group",
-        "init",
-        "into",
-        "join",
-        "let",
-        "managed",
-        "nameof",
-        "nint",
-        "not",
-        "notnull",
-        "nuint",
-        "on",
-        "or",
-        "orderby",
-        "partial",
-        "record",
-        "remove",
-        "required",
-        "scoped",
-        "select",
-        "set",
-        "unmanaged",
-        "value",
-        "var",
-        "when",
-        "where",
-        "with",
-        "yield",
-    ];
-    const reservedWords = [
-        "abstract",
-        "as",
-        "base",
-        "bool",
-        "boolean",
-        "break",
-        "byte",
-        "case",
-        "catch",
-        "char",
-        "checked",
-        "class",
-        "const",
-        "continue",
-        "decimal",
-        "default",
-        "do",
-        "double",
-        "else",
-        "enum",
-        "event",
-        "explicit",
-        "extern",
-        "false",
-        "finally",
-        "fixed",
-        "float",
-        "for",
-        "foreach",
-        "goto",
-        "if",
-        "implicit",
-        "in",
-        "int",
-        "interface",
-        "internal",
-        "is",
-        "lock",
-        "long",
-        "namespace",
-        "new",
-        "null",
-        "object",
-        "operator",
-        "out",
-        "override",
-        "params",
-        "private",
-        "protected",
-        "public",
-        "readonly",
-        "ref",
-        "return",
-        "sbyte",
-        "sealed",
-        "short",
-        "sizeof",
-        "stackalloc",
-        "static",
-        "string",
-        "struct",
-        "switch",
-        "this",
-        "throw",
-        "true",
-        "try",
-        "type",
-        "typeof",
-        "uint",
-        "ulong",
-        "unchecked",
-        "unsafe",
-        "ushort",
-        "using",
-        "virtual",
-        "void",
-        "volatile",
-        "while",
-    ];
-    const reserved = new Map(reservedWords.concat(contextualWords).map((w) => generateReplacement(w)));
-    const check = reserved.get(identifier.toLowerCase());
-    if (check !== undefined) {
-        return getCSharpIdentifier(check, context, false);
-    }
-    return identifier;
-}
-export function getValidChar(target, position) {
-    if (position === 0) {
-        if (target.match(/[A-Za-z_]/))
-            return target;
-        return `Generated_${target.match(/\w/) ? target : ""}`;
-    }
-    if (!target.match(/[\w]/))
-        return "_";
-    return target;
-}
-export function getCSharpStatusCode(entry) {
-    switch (entry) {
-        case 200:
-            return "HttpStatusCode.OK";
-        case 201:
-            return "HttpStatusCode.Created";
-        case 202:
-            return "HttpStatusCode.Accepted";
-        case 204:
-            return "HttpStatusCode.NoContent";
-        default:
-            return undefined;
-    }
-}
-/**
- * Returns the full return statement for a controller action based on the HTTP status code.
- * Maps well-known status codes to their idiomatic ASP.NET Core ControllerBase methods,
- * and falls back to `StatusCode(code, ...)` for all other numeric codes.
- */
-export function getControllerReturnStatement(status, hasValue) {
-    if (typeof status === "number") {
-        switch (status) {
-            case 200:
-                return hasValue ? "return Ok(result);" : "return Ok();";
-            case 202:
-                return hasValue ? "return Accepted(result);" : "return Accepted();";
-            case 204:
-                return "return NoContent();";
-            default:
-                return hasValue ? `return StatusCode(${status}, result);` : `return StatusCode(${status});`;
-        }
-    }
-    // Fallback for ranges and "*"
-    return hasValue ? "return Ok(result);" : "return Ok();";
-}
-export function isEmptyResponseModel(program, model) {
-    if (model.kind !== "Model")
-        return false;
-    if (model.properties.size === 0 && !model.baseModel)
-        return true;
-    return (model.properties.size === 1 &&
-        isStatusCode(program, [...model.properties.values()][0]) &&
-        !isErrorModel(program, model));
-}
-export function isContentTypeHeader(program, parameter) {
-    return (isHeader(program, parameter) &&
-        (parameter.name === "contentType" || getHeaderFieldName(program, parameter) === "Content-type"));
-}
-export function isValidParameter(program, parameter) {
-    return (!isContentTypeHeader(program, parameter) &&
-        (parameter.type.kind !== "Intrinsic" || parameter.type.name !== "never") &&
-        parameter.model?.name === "");
-}
-/** Determine whether the given parameter is http metadata */
-export function isHttpMetadata(program, property) {
-    return (isPathParam(program, property) || isHeader(program, property) || isQueryParam(program, property));
-}
-export function getBusinessLogicCallParameters(parameters) {
-    const builder = new StringBuilder();
-    const blParameters = parameters.filter((p) => p.operationKind === "BusinessLogic" || p.operationKind === "All");
-    let i = 0;
-    for (const param of blParameters) {
-        builder.push(code `${getBusinessLogicCallParameter(param)}${++i < blParameters.length ? ", " : ""}`);
-    }
-    return builder.reduce();
-}
-export function getBusinessLogicDeclParameters(parameters) {
-    const builder = new StringBuilder();
-    const blParameters = parameters.filter((p) => p.operationKind === "BusinessLogic" || p.operationKind === "All");
-    let i = 0;
-    for (const param of blParameters) {
-        builder.push(code `${getBusinessLogicSignatureParameter(param)}${++i < blParameters.length ? ", " : ""}`);
-    }
-    return builder.reduce();
-}
-export function getHttpDeclParameters(parameters) {
-    const builder = new StringBuilder();
-    const blParameters = parameters.filter((p) => p.operationKind === "Http" || p.operationKind === "All");
-    let i = 0;
-    for (const param of blParameters) {
-        builder.push(code `${getHttpSignatureParameter(param)}${++i < blParameters.length ? ", " : ""}`);
-    }
-    return builder.reduce();
-}
-export function getBusinessLogicCallParameter(param) {
-    const builder = new StringBuilder();
-    builder.push(code `${param.callName}`);
-    return builder.reduce();
-}
-export function getBusinessLogicSignatureParameter(param) {
-    const builder = new StringBuilder();
-    builder.push(code `${param.typeName}${param.optional || param.nullable ? "? " : " "}${param.name}`);
-    return builder.reduce();
-}
-export function getHttpSignatureParameter(param) {
-    const builder = new StringBuilder();
-    builder.push(code `${getHttpParameterDecorator(param)}${getBusinessLogicSignatureParameter(param)}${param.defaultValue === undefined ? "" : code ` = ${typeof param.defaultValue === "boolean" ? code `${param.defaultValue.toString()}` : code `${param.defaultValue}`}`}`);
-    return builder.reduce();
-}
-export function getHttpParameterDecorator(parameter) {
-    switch (parameter.httpParameterKind) {
-        case "query":
-            return code `[FromQuery${parameter.httpParameterName ? code `(Name="${parameter.httpParameterName}")` : ""}] `;
-        case "header":
-            return code `[FromHeader${parameter.httpParameterName ? code `(Name="${parameter.httpParameterName}")` : ""}] `;
-        default:
-            return "";
-    }
-}
-export function getParameterKind(parameter) {
-    switch (parameter.type) {
-        case "path":
-            return "path";
-        case "cookie":
-        case "header":
-            return "header";
-        case "query":
-            return "query";
-    }
-}
-export function canHaveDefault(program, type) {
-    switch (type.kind) {
-        case "Boolean":
-        case "EnumMember":
-        case "Enum":
-        case "Number":
-        case "String":
-        case "Scalar":
-        case "StringTemplate":
-            return true;
-        case "ModelProperty":
-            return canHaveDefault(program, type.type);
-        default:
-            return false;
-    }
-}
-export class CSharpOperationHelpers {
-    constructor(inEmitter) {
-        this.emitter = inEmitter;
-        this.#anonymousModels = new Map();
-        this.#opCache = new Map();
-    }
-    emitter;
-    #anonymousModels;
-    #opCache;
-    getResponse(program, operation) {
-        return new CSharpType({
-            name: "void",
-            namespace: "System",
-            isBuiltIn: true,
-            isValueType: true,
-        });
-    }
-    getParameters(program, operation) {
-        function safeConcat(...names) {
-            return names
-                .filter((n) => n !== undefined && n !== null && n.length > 0)
-                .flatMap((s) => getCSharpIdentifier(s, NameCasingType.Class))
-                .join();
-        }
-        const cached = this.#opCache.get(operation.operation);
-        if (cached)
-            return cached;
-        const bodyParam = operation.parameters.body;
-        const isExplicitBodyParam = bodyParam?.property !== undefined;
-        const result = [];
-        if (!cached && operation.verb === "get" && operation.parameters.body !== undefined) {
-            reportDiagnostic(program, {
-                code: "get-request-body",
-                target: operation.operation,
-                format: {},
-            });
-            this.#opCache.set(operation.operation, result);
-            return result;
-        }
-        const validParams = operation.parameters.parameters.filter((p) => isValidParameter(program, p.param));
-        const requiredParams = validParams.filter((p) => p.type === "path" || (!p.param.optional && p.param.defaultValue === undefined));
-        const optionalParams = validParams.filter((p) => p.type !== "path" && (p.param.optional || p.param.defaultValue !== undefined));
-        for (const parameter of requiredParams) {
-            let { typeReference: paramType, defaultValue: paramValue } = this.getTypeInfo(program, parameter.param.type);
-            // cSharp does not allow array defaults in operation parameters
-            if (!canHaveDefault(program, parameter.param)) {
-                paramValue = undefined;
-            }
-            const paramName = ensureCSharpIdentifier(program, parameter.param, parameter.param.name, NameCasingType.Parameter);
-            result.push({
-                isExplicitBody: false,
-                name: paramName,
-                callName: paramName,
-                optional: false,
-                typeName: paramType,
-                defaultValue: paramValue,
-                httpParameterKind: getParameterKind(parameter),
-                httpParameterName: parameter.name,
-                nullable: false,
-                operationKind: "All",
-            });
-        }
-        const overrideParameters = getExplicitBodyParameters(program, operation);
-        if (overrideParameters !== undefined) {
-            for (const overrideParam of overrideParameters) {
-                result.push(overrideParam);
-            }
-        }
-        else if (bodyParam !== undefined && isExplicitBodyParam) {
-            let { typeReference: bodyType, defaultValue: bodyValue, nullableType: isNullable, } = this.getTypeInfo(program, bodyParam.type);
-            if (!canHaveDefault(program, bodyParam.type)) {
-                bodyValue = undefined;
-            }
-            result.push({
-                isExplicitBody: true,
-                httpParameterKind: "body",
-                name: "body",
-                callName: "body",
-                typeName: bodyType,
-                nullable: isNullable,
-                defaultValue: bodyValue,
-                optional: bodyParam.property?.optional ?? false,
-                operationKind: "All",
-            });
-        }
-        else if (bodyParam !== undefined) {
-            switch (bodyParam.type.kind) {
-                case "Model":
-                    let tsBody = bodyParam.type;
-                    if (!bodyParam.type.name) {
-                        tsBody = program.checker.cloneType(bodyParam.type, {
-                            name: safeConcat(operation.operation.interface?.name, operation.operation.name, "Request"),
-                        });
-                    }
-                    const { typeReference: bodyType } = this.getTypeInfo(program, tsBody);
-                    const bodyName = ensureCSharpIdentifier(program, bodyParam.type, "body", NameCasingType.Parameter);
-                    result.push({
-                        isExplicitBody: false,
-                        httpParameterKind: "body",
-                        name: bodyName,
-                        callName: bodyName,
-                        typeName: bodyType,
-                        nullable: false,
-                        defaultValue: undefined,
-                        optional: false,
-                        operationKind: "Http",
-                    });
-                    for (const [propName, propDef] of bodyParam.type.properties) {
-                        let { typeReference: csType, defaultValue: csValue, nullableType: isNullable, } = this.getTypeInfo(program, propDef.type, propDef);
-                        // cSharp does not allow array defaults in operation parameters
-                        if (!canHaveDefault(program, propDef)) {
-                            csValue = undefined;
-                        }
-                        const paramName = ensureCSharpIdentifier(program, propDef, propName, NameCasingType.Parameter);
-                        const refName = ensureCSharpIdentifier(program, propDef, propName, NameCasingType.Property);
-                        result.push({
-                            isExplicitBody: false,
-                            httpParameterKind: "body",
-                            name: paramName,
-                            callName: `body.${refName}`,
-                            typeName: csType,
-                            nullable: isNullable,
-                            defaultValue: csValue,
-                            optional: propDef.optional,
-                            operationKind: "BusinessLogic",
-                        });
-                    }
-                    break;
-                case "ModelProperty":
-                    {
-                        let { typeReference: csType, defaultValue: csValue, nullableType: isNullable, } = this.getTypeInfo(program, bodyParam.type.type, bodyParam.type);
-                        if (!canHaveDefault(program, bodyParam.type)) {
-                            csValue = undefined;
-                        }
-                        const optName = ensureCSharpIdentifier(program, bodyParam.type.type, bodyParam.type.name, NameCasingType.Parameter);
-                        result.push({
-                            isExplicitBody: true,
-                            httpParameterKind: "body",
-                            name: optName,
-                            callName: optName,
-                            typeName: csType,
-                            nullable: isNullable,
-                            defaultValue: csValue,
-                            optional: bodyParam.type.optional,
-                            operationKind: "All",
-                        });
-                    }
-                    break;
-                default: {
-                    let { typeReference: csType, defaultValue: csValue, nullableType: isNullable, } = this.getTypeInfo(program, bodyParam.type);
-                    if (!canHaveDefault(program, bodyParam.type)) {
-                        csValue = undefined;
-                    }
-                    result.push({
-                        isExplicitBody: true,
-                        httpParameterKind: "body",
-                        name: "body",
-                        callName: "body",
-                        typeName: csType,
-                        nullable: isNullable,
-                        defaultValue: csValue,
-                        optional: false,
-                        operationKind: "All",
-                    });
-                }
-            }
-        }
-        for (const parameter of optionalParams) {
-            const { typeReference: paramType, defaultValue: paramValue, nullableType: isNullable, } = this.getTypeInfo(program, parameter.param.type, parameter.param);
-            const optName = ensureCSharpIdentifier(program, parameter.param, parameter.param.name, NameCasingType.Parameter);
-            result.push({
-                isExplicitBody: false,
-                name: optName,
-                callName: optName,
-                optional: true,
-                typeName: paramType,
-                defaultValue: paramValue,
-                httpParameterKind: getParameterKind(parameter),
-                httpParameterName: parameter.name,
-                nullable: isNullable,
-                operationKind: "All",
-            });
-        }
-        return result;
-    }
-    getDefaultValue(program, tsType, defaultValue) {
-        if (defaultValue === undefined)
-            return undefined;
-        switch (tsType.kind) {
-            case "Enum":
-                if (defaultValue.valueKind === "EnumValue") {
-                    const retVal = this.getTypeInfo(program, tsType);
-                    return `${retVal.typeReference}.${ensureCSharpIdentifier(program, defaultValue.value, defaultValue.value.name, NameCasingType.Property)}`;
-                }
-                return JSON.stringify(serializeValueAsJson(this.emitter.getProgram(), defaultValue, tsType));
-            case "Union":
-                const { typeReference: typeRef } = this.getUnionInfo(program, tsType);
-                if (defaultValue.valueKind === "StringValue" && isStringEnumType(program, tsType)) {
-                    const matches = [...tsType.variants].filter((v) => typeof v[0] === "string" &&
-                        v[1].type.kind === "String" &&
-                        v[1].type.value === defaultValue.value);
-                    if (matches.length === 1) {
-                        return `${typeRef}.${ensureCSharpIdentifier(program, matches[0][1], matches[0][0], NameCasingType.Property)}`;
-                    }
-                    return undefined;
-                }
-                if (defaultValue.valueKind === "StringValue") {
-                    return JSON.stringify(serializeValueAsJson(this.emitter.getProgram(), defaultValue, tsType));
-                }
-                return undefined;
-            default:
-                return JSON.stringify(serializeValueAsJson(this.emitter.getProgram(), defaultValue, tsType));
-        }
-    }
-    getTypeInfo(program, tsType, modelProperty) {
-        const myEmitter = this.emitter;
-        function extractStringValue(type, span) {
-            switch (type.kind) {
-                case "String":
-                    return type.value;
-                case "Boolean":
-                    return `${type.value}`;
-                case "Number":
-                    return type.valueAsString;
-                case "StringTemplateSpan":
-                    if (type.isInterpolated) {
-                        return extractStringValue(type.type, span);
-                    }
-                    else {
-                        return type.type.value;
-                    }
-                case "ModelProperty":
-                    return extractStringValue(type.type, span);
-                case "EnumMember":
-                    if (type.value === undefined)
-                        return type.name;
-                    if (typeof type.value === "string")
-                        return type.value;
-                    if (typeof type.value === "number")
-                        return `${type.value}`;
-            }
-            reportDiagnostic(myEmitter.getProgram(), {
-                code: "invalid-interpolation",
-                target: span,
-                format: {},
-            });
-            return "";
-        }
-        switch (tsType.kind) {
-            case "String":
-                return {
-                    typeReference: code `string`,
-                    defaultValue: `"${tsType.value}"`,
-                    nullableType: false,
-                };
-            case "StringTemplate":
-                const template = tsType;
-                if (template.stringValue !== undefined)
-                    return {
-                        typeReference: code `string`,
-                        defaultValue: `"${template.stringValue}"`,
-                        nullableType: false,
-                    };
-                const spanResults = [];
-                for (const span of template.spans) {
-                    spanResults.push(extractStringValue(span, span));
-                }
-                return {
-                    typeReference: code `string`,
-                    defaultValue: `"${spanResults.join("")}"`,
-                    nullableType: false,
-                };
-            case "Boolean":
-                return {
-                    typeReference: code `bool`,
-                    defaultValue: `${tsType.value === true ? true : false}`,
-                    nullableType: false,
-                };
-            case "Number":
-                const [type, value] = findNumericType(tsType);
-                return { typeReference: code `${type}`, defaultValue: `${value}`, nullableType: false };
-            case "Tuple":
-                const defaults = [];
-                const [csharpType, isObject] = coalesceTsTypes(program, tsType.values);
-                if (isObject)
-                    return { typeReference: "object[]", defaultValue: undefined, nullableType: false };
-                for (const value of tsType.values) {
-                    const { defaultValue: itemDefault } = this.getTypeInfo(program, value);
-                    defaults.push(itemDefault);
-                }
-                const collectionType = CSharpServiceOptions.getInstance().collectionType;
-                switch (collectionType) {
-                    case CollectionType.IEnumerable:
-                        return {
-                            typeReference: code `IEnumerable<${csharpType.getTypeReference(myEmitter.getContext()?.scope)}>`,
-                            defaultValue: `new List<${csharpType.getTypeReference(myEmitter.getContext()?.scope)}> {${defaults.join(", ")}}`,
-                            nullableType: csharpType.isNullable,
-                        };
-                    case CollectionType.Array:
-                    default:
-                        return {
-                            typeReference: code `${csharpType.getTypeReference(myEmitter.getContext()?.scope)}[]`,
-                            defaultValue: `[${defaults.join(", ")}]`,
-                            nullableType: csharpType.isNullable,
-                        };
-                }
-            case "Model":
-                let modelResult;
-                const hasUniqueItems = modelProperty
-                    ? getUniqueItems(program, modelProperty) !== undefined
-                    : false;
-                const cachedResult = this.#anonymousModels.get(tsType);
-                if (cachedResult && cachedResult.hasUniqueItems === hasUniqueItems) {
-                    return cachedResult;
-                }
-                if (isRecord(tsType)) {
-                    modelResult = {
-                        typeReference: code `${RecordType.getTypeReference(myEmitter.getContext().scope)}`,
-                        nullableType: false,
-                        hasUniqueItems: hasUniqueItems,
-                    };
-                }
-                else if (isArrayModelType(tsType)) {
-                    const typeReference = code `${this.emitter.emitTypeReference(tsType.indexer.value)}`;
-                    modelResult = isByteType(tsType.indexer.value)
-                        ? {
-                            typeReference: code `${typeReference}[]`,
-                            nullableType: false,
-                            hasUniqueItems: hasUniqueItems,
-                        }
-                        : {
-                            typeReference: hasUniqueItems
-                                ? code `ISet<${typeReference}>`
-                                : code `${this.emitter.emitTypeReference(tsType)}`,
-                            nullableType: false,
-                            hasUniqueItems: hasUniqueItems,
-                        };
-                }
-                else {
-                    modelResult = {
-                        typeReference: code `${this.emitter.emitTypeReference(tsType, this.emitter.getContext())}`,
-                        nullableType: false,
-                        hasUniqueItems: hasUniqueItems,
-                    };
-                }
-                return modelResult;
-            case "ModelProperty":
-                return this.getTypeInfo(program, tsType.type, tsType);
-            case "Enum":
-                if (getEnumType(tsType) === "double")
-                    return { typeReference: getDoubleType().getTypeReference(), nullableType: false };
-                return {
-                    typeReference: code `${this.emitter.emitTypeReference(tsType)}`,
-                    nullableType: false,
-                };
-            case "EnumMember":
-                if (typeof tsType.value === "number") {
-                    const stringValue = tsType.value.toString();
-                    if (stringValue.includes(".") || stringValue.includes("e"))
-                        return { typeReference: "double", defaultValue: stringValue, nullableType: false };
-                    return { typeReference: "int", defaultValue: stringValue, nullableType: false };
-                }
-                if (typeof tsType.value === "string") {
-                    const retVal = this.getTypeInfo(program, tsType.enum);
-                    retVal.defaultValue = `${retVal.typeReference}.${ensureCSharpIdentifier(program, tsType, tsType.name, NameCasingType.Property)}`;
-                    return retVal;
-                }
-                return { typeReference: code `object`, nullableType: false };
-            case "Union":
-                return this.getUnionInfo(program, tsType);
-            case "UnionVariant":
-                if (isStringEnumType(program, tsType.union) &&
-                    tsType.type.kind === "String" &&
-                    typeof tsType.name === "string") {
-                    const retVal = this.getUnionInfo(program, tsType.union);
-                    retVal.defaultValue = `${retVal.typeReference}.${ensureCSharpIdentifier(program, tsType, tsType.name, NameCasingType.Property)}`;
-                    return retVal;
-                }
-                return this.getTypeInfo(program, tsType.type);
-            default:
-                return {
-                    typeReference: code `${this.emitter.emitTypeReference(tsType)}`,
-                    nullableType: false,
-                };
-        }
-    }
-    getUnionInfo(program, union) {
-        const propResult = getNonNullableTsType(union);
-        if (propResult === undefined || isStringEnumType(program, union)) {
-            return {
-                typeReference: code `${this.emitter.emitTypeReference(union)}`,
-                nullableType: [...union.variants.values()].some((v) => isNullType(v.type)),
-            };
-        }
-        const candidate = this.getTypeInfo(program, propResult.type);
-        candidate.nullableType = propResult.nullable;
-        return candidate;
-    }
-}
-export function getExplicitBodyParameters(program, httpOperation) {
-    if (httpOperation.parameters.body && httpOperation.parameters.body.bodyKind === "multipart") {
-        return [
-            {
-                name: "reader",
-                callName: "reader",
-                nullable: false,
-                optional: false,
-                typeName: "MultipartReader",
-                isExplicitBody: false,
-                httpParameterKind: "body",
-                operationKind: "BusinessLogic",
-            },
-        ];
-    }
-    return undefined;
-}
-export function findNumericType(type) {
-    const stringValue = type.valueAsString;
-    if (stringValue.includes(".") || stringValue.includes("e"))
-        return ["double", stringValue];
-    return ["int", stringValue];
-}
-export function isStringEnumType(program, union) {
-    const baseType = coalesceUnionTypes(program, union);
-    if (!baseType.isBuiltIn || baseType.name !== "string")
-        return false;
-    return ![...union.variants.values()].some((v) => (v.type.kind === "String" ||
-        v.type.kind === "StringTemplate" ||
-        v.type.kind === "StringTemplateSpan") &&
-        typeof v.name !== "string");
-}
-export function coalesceUnionTypes(program, union) {
-    const [result, _] = coalesceTsTypes(program, [...union.variants.values()].flatMap((v) => v.type));
-    return result;
-}
-export function getNonNullableTsType(union) {
-    const types = [...union.variants.values()];
-    const nulls = types.flatMap((v) => v.type).filter((t) => isNullType(t));
-    const nonNulls = types.flatMap((v) => v.type).filter((t) => !isNullType(t));
-    if (nonNulls.length === 1)
-        return { type: nonNulls[0], nullable: nulls.length > 0 };
-    return undefined;
-}
-export function coalesceTsTypes(program, types) {
-    const defaultValue = [
-        new CSharpType({
-            name: "object",
-            namespace: "System",
-            isBuiltIn: true,
-            isValueType: false,
-        }),
-        true,
-    ];
-    let current = undefined;
-    let nullable = false;
-    for (const type of types) {
-        let candidate;
-        switch (type.kind) {
-            case "Boolean":
-                candidate = new CSharpType({ name: "bool", namespace: "System", isValueType: true });
-                break;
-            case "StringTemplate":
-            case "String":
-                candidate = new CSharpType({ name: "string", namespace: "System", isValueType: false });
-                break;
-            case "Number":
-                const stringValue = type.valueAsString;
-                if (stringValue.includes(".") || stringValue.includes("e")) {
-                    candidate = new CSharpType({
-                        name: "double",
-                        namespace: "System",
-                        isValueType: true,
-                    });
-                }
-                else {
-                    candidate = new CSharpType({ name: "int", namespace: "System", isValueType: true });
-                }
-                break;
-            case "Union":
-                candidate = coalesceUnionTypes(program, type);
-                break;
-            case "Scalar":
-                candidate = getCSharpTypeForScalar(program, type);
-                break;
-            case "Intrinsic":
-                if (isNullType(type)) {
-                    nullable = true;
-                    candidate = current;
-                }
-                else {
-                    return defaultValue;
-                }
-                break;
-            default:
-                return defaultValue;
-        }
-        current = current ?? candidate;
-        if (current === undefined || (candidate !== undefined && !candidate.equals(current)))
-            return defaultValue;
-    }
-    if (current !== undefined && nullable === true)
-        current.isNullable = true;
-    return current === undefined ? defaultValue : [current, false];
-}
-export function isRecord(type) {
-    return type.kind === "Model" && type.name === "Record" && type.indexer !== undefined;
-}
-export async function getFreePort(minPort, maxPort, tries = 100) {
-    const min = Math.floor(minPort);
-    const max = Math.floor(maxPort);
-    if (tries === 0)
-        return min;
-    const diff = Math.abs(max - min);
-    const port = min + Math.floor(Math.random() * diff);
-    const server = createServer();
-    const free = await checkPort(port);
-    if (free) {
-        return port;
-    }
-    // This seems like a bug? tries-- does nothing?
-    // eslint-disable-next-line no-useless-assignment
-    return await getFreePort(min, max, tries--);
-    async function checkPort(port, timeout = 100) {
-        return new Promise((resolve, _) => {
-            server.on("error", (_) => {
-                server.close();
-                resolve(false);
-            });
-            server.listen(port, async () => {
-                try {
-                    setTimeout(() => resolve(true), timeout);
-                }
-                catch (e) {
-                    resolve(false);
-                }
-                finally {
-                    server.close();
-                }
-            });
-        });
-    }
-}
-export async function getOpenApiConfig(program) {
-    const root = program.projectRoot;
-    const [options, _] = await resolveCompilerOptions(program.host, {
-        cwd: root,
-        entrypoint: resolvePath(root, "main.tsp"),
-    });
-    const oaiOptions = options.options !== undefined && Object.keys(options.options).includes("@typespec/openapi3")
-        ? options.options["@typespec/openapi3"]
-        : undefined;
-    return {
-        emitted: options.emit !== undefined && options.emit.includes("@typespec/openapi3"),
-        outputDir: oaiOptions?.["emitter-output-dir"],
-        fileName: oaiOptions?.["output-file"],
-        options: oaiOptions,
-    };
-}
-export function getStatusCode(program, model) {
-    const statusCodeProperty = new ModelInfo().filterAllProperties(program, model, (p) => isStatusCode(program, p));
-    if (!statusCodeProperty)
-        return undefined;
-    const { type } = statusCodeProperty;
-    switch (type.kind) {
-        case "Union":
-            return {
-                name: statusCodeProperty.name,
-                value: statusCodeProperty.name,
-                requiresConstructorArgument: true,
-            };
-        case "Number":
-            return {
-                value: type.value,
-            };
-        default:
-            return { value: getMinValue(program, statusCodeProperty) ?? `default` };
-    }
-}
-export function isByteType(type) {
-    return type.kind === "Scalar" && ["int8", "uint8"].includes(type.name);
-}
-export function getImports(scope, visited) {
-    if (scope === undefined)
-        return [];
-    if (!visited)
-        visited = new Set();
-    if (visited.has(scope))
-        return [];
-    visited.add(scope);
-    switch (scope.kind) {
-        case "namespace":
-            return getImports(scope.parentScope, visited);
-        case "sourceFile":
-            return [...scope.sourceFile.imports.keys()];
-        default:
-            return [];
-    }
-}
-//# sourceMappingURL=utils.js.map