@typespec/http-server-csharp 0.58.0-alpha.9 → 0.58.0-dev.0

package/dist/src/lib/service.js

@@ -1,52 +1,138 @@
-import { getDoc, getNamespaceFullName, getService, isErrorModel, isNeverType, isNullType, isTemplateDeclaration, isVoidType, } from "@typespec/compiler";
-import { CodeTypeEmitter, StringBuilder, code, createAssetEmitter, } from "@typespec/compiler/emitter-framework";
+import { CodeTypeEmitter, StringBuilder, code, createAssetEmitter, } from "@typespec/asset-emitter";
+import { getDoc, getNamespaceFullName, getService, isErrorModel, isNeverType, isNullType, isNumericType, isTemplateDeclaration, isVoidType, resolvePath, serializeValueAsJson, } from "@typespec/compiler";
 import { createRekeyableMap } from "@typespec/compiler/utils";
-import { Visibility, createMetadataInfo, getHeaderFieldName, getHttpOperation, getHttpPart, isHeader, isPathParam, isQueryParam, isStatusCode, } from "@typespec/http";
+import { getHeaderFieldName, getHttpOperation, getHttpPart, isHeader, isStatusCode, } from "@typespec/http";
+import { getUniqueItems } from "@typespec/json-schema";
 import { getResourceOperation } from "@typespec/rest";
 import { execFile } from "child_process";
+import path from "path";
+import { getEncodedNameAttribute } from "./attributes.js";
 import { GeneratedFileHeader, GeneratedFileHeaderWithNullable, getSerializationSourceFiles, } from "./boilerplate.js";
-import { CSharpSourceType, CSharpType, NameCasingType, } from "./interfaces.js";
-import { reportDiagnostic } from "./lib.js";
+import { getProjectDocs } from "./doc.js";
+import { CSharpSourceType, CSharpType, CollectionType, NameCasingType, checkOrAddNamespaceToScope, } from "./interfaces.js";
+import { CSharpServiceOptions, reportDiagnostic } from "./lib.js";
+import { getProjectHelpers } from "./project.js";
 import { getBusinessLogicImplementations, getScaffoldingHelpers, } from "./scaffolding.js";
-import { getRecordType, isKnownReferenceType } from "./type-helpers.js";
-import { HttpMetadata, UnknownType, coalesceTypes, ensureCSharpIdentifier, ensureCleanDirectory, formatComment, getCSharpIdentifier, getCSharpStatusCode, getCSharpType, getCSharpTypeForIntrinsic, getCSharpTypeForScalar, getModelAttributes, getModelInstantiationName, getOperationVerbDecorator, isValueType, } from "./utils.js";
+import { getEnumType, getRecordType, isKnownReferenceType } from "./type-helpers.js";
+import { CSharpOperationHelpers, HttpMetadata, ModelInfo, UnknownType, coalesceTypes, coalesceUnionTypes, ensureCSharpIdentifier, ensureCleanDirectory, formatComment, getBusinessLogicCallParameters, getBusinessLogicDeclParameters, getCSharpIdentifier, getCSharpStatusCode, getCSharpType, getCSharpTypeForIntrinsic, getCSharpTypeForScalar, getControllerReturnStatement, getFreePort, getHttpDeclParameters, getImports, getModelAttributes, getModelDeclarationName, getModelInstantiationName, getOpenApiConfig, getOperationVerbDecorator, getStatusCode, isEmptyResponseModel, isRecord, isStringEnumType, isValueType, resolveReferenceFromScopes, } from "./utils.js";
 export async function $onEmit(context) {
     let _unionCounter = 0;
     const controllers = new Map();
     const NoResourceContext = "RPCOperations";
-    const doNotEmit = context.program.compilerOptions.noEmit || false;
+    const doNotEmit = context.program.compilerOptions.dryRun || false;
+    CSharpServiceOptions.getInstance().initialize(context.options);
+    function getFileWriter(program) {
+        return async (path) => !!(await program.host.stat(resolvePath(path)).catch((_) => false));
+    }
     class CSharpCodeEmitter extends CodeTypeEmitter {
         #metadateMap = new Map();
         #generatedFileHeaderWithNullable = GeneratedFileHeaderWithNullable;
         #generatedFileHeader = GeneratedFileHeader;
         #sourceTypeKey = "sourceType";
-        #libraryFiles = getSerializationSourceFiles(this.emitter);
-        #baseNamespace = undefined;
+        #nsKey = "ResolvedNamespace";
+        #namespaces = new Map();
         #emitterOutputType = context.options["output-type"];
         #emitMocks = context.options["emit-mocks"];
         #useSwagger = context.options["use-swaggerui"] || false;
         #openapiPath = context.options["openapi-path"] || "openapi/openapi.yaml";
         #mockRegistrations = new Map();
-        #mockHelpers = this.#emitMocks === "all"
-            ? getScaffoldingHelpers(this.emitter, this.#useSwagger, this.#openapiPath)
-            : [];
-        #mockFiles = [];
-        #metaInfo = createMetadataInfo(this.emitter.getProgram(), {
-            canonicalVisibility: Visibility.Read,
-            canShareProperty: (p) => true,
-        });
+        #opHelpers = new CSharpOperationHelpers(this.emitter);
+        #fileExists = getFileWriter(this.emitter.getProgram());
+        #getOrAddNamespaceForType(type) {
+            const program = this.emitter.getProgram();
+            switch (type.kind) {
+                case "Boolean":
+                case "String":
+                case "StringTemplate":
+                case "Number":
+                case "Scalar":
+                case "Intrinsic":
+                case "FunctionParameter":
+                case "ScalarConstructor":
+                case "StringTemplateSpan":
+                case "TemplateParameter":
+                case "Tuple":
+                case "FunctionType":
+                    return undefined;
+                case "EnumMember":
+                    return this.#getOrAddNamespaceForType(type.enum);
+                case "ModelProperty":
+                case "UnionVariant":
+                    return this.#getOrAddNamespaceForType(type.type);
+                case "Model":
+                    if (isRecord(type) && type.indexer)
+                        return this.#getOrAddNamespaceForType(type.indexer.value);
+                    if (type.indexer !== undefined && isNumericType(program, type.indexer?.key))
+                        return this.#getOrAddNamespaceForType(type.indexer.value);
+                    return this.#getOrAddNamespace(type.namespace);
+                case "Union":
+                    if (isStringEnumType(program, type))
+                        return this.#getOrAddNamespace(type.namespace);
+                    const unionType = this.#coalesceTsUnion(type);
+                    if (unionType === undefined)
+                        return undefined;
+                    return this.#getOrAddNamespaceForType(unionType);
+                default:
+                    return this.#getOrAddNamespace(type.namespace);
+            }
+        }
+        #coalesceTsUnion(union) {
+            let result = undefined;
+            for (const [_, variant] of union.variants) {
+                if (!isNullType(variant.type)) {
+                    if (result !== undefined && result !== variant.type)
+                        return undefined;
+                    result = variant.type;
+                }
+            }
+            return result;
+        }
+        #getOrAddNamespace(typespecNamespace) {
+            if (!typespecNamespace?.name)
+                return this.#getDefaultNamespace();
+            let resolvedNamespace = this.#namespaces.get(typespecNamespace);
+            if (resolvedNamespace !== undefined)
+                return resolvedNamespace;
+            const nsName = getNamespaceFullName(typespecNamespace);
+            resolvedNamespace = ensureCSharpIdentifier(this.emitter.getProgram(), typespecNamespace, nsName, NameCasingType.Namespace);
+            this.#namespaces.set(typespecNamespace, resolvedNamespace);
+            return resolvedNamespace;
+        }
+        #getDefaultNamespace() {
+            return "TypeSpec.Service";
+        }
         arrayDeclaration(array, name, elementType) {
-            return this.emitter.result.declaration(ensureCSharpIdentifier(this.emitter.getProgram(), array, name), code `${this.emitter.emitTypeReference(elementType)}[]`);
+            return this.collectionDeclaration(elementType, array);
         }
         arrayLiteral(array, elementType) {
-            return this.emitter.result.rawCode(code `${this.emitter.emitTypeReference(elementType)}[]`);
+            this.emitter.emitType(elementType, this.emitter.getContext());
+            const csType = getCSharpType(this.emitter.getProgram(), array, this.#getOrAddNamespaceForType(elementType));
+            if (csType?.type) {
+                return code `${csType.type.getTypeReference(this.emitter.getContext()?.scope)}`;
+            }
+            return this.collectionDeclaration(elementType, array);
+        }
+        collectionDeclaration(elementType, array) {
+            const isUniqueItems = getUniqueItems(this.emitter.getProgram(), array);
+            const collectionType = isUniqueItems
+                ? CollectionType.ISet
+                : CSharpServiceOptions.getInstance().collectionType;
+            switch (collectionType) {
+                case CollectionType.ISet:
+                    return code `ISet<${this.emitter.emitTypeReference(elementType, this.emitter.getContext())}>`;
+                case CollectionType.IEnumerable:
+                    return code `IEnumerable<${this.emitter.emitTypeReference(elementType, this.emitter.getContext())}>`;
+                case CollectionType.Array:
+                default:
+                    return code `${this.emitter.emitTypeReference(elementType, this.emitter.getContext())}[]`;
+            }
         }
         booleanLiteral(boolean) {
-            return this.emitter.result.rawCode(code `${boolean.value === true ? "true" : "false"}`);
+            return code `${boolean.value === true ? "true" : "false"}`;
         }
         unionLiteral(union) {
-            const csType = this.#coalesceUnionTypes(union);
-            return this.emitter.result.rawCode(csType && csType.isBuiltIn ? csType.name : "object");
+            const csType = coalesceUnionTypes(this.emitter.getProgram(), union);
+            return this.emitter.result.rawCode(csType ? csType.getTypeReference(this.emitter.getContext()?.scope) : "object");
         }
         declarationName(declarationType) {
             switch (declarationType.kind) {
@@ -60,7 +146,7 @@ export async function $onEmit(context) {
                     return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Model":
                     if (!declarationType.name)
-                        return `Model${_unionCounter++}`;
+                        return getModelDeclarationName(this.emitter.getProgram(), declarationType, `${_unionCounter++}`);
                     return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Operation":
                     return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
@@ -74,16 +160,15 @@ export async function $onEmit(context) {
             }
         }
         enumDeclaration(en, name) {
+            if (getEnumType(en) === "double")
+                return "";
             const program = this.emitter.getProgram();
             const enumName = ensureCSharpIdentifier(program, en, name);
             const namespace = this.emitter.getContext().namespace;
             const doc = getDoc(this.emitter.getProgram(), en);
             const attributes = getModelAttributes(program, en, enumName);
             this.#metadateMap.set(en, new CSharpType({ name: enumName, namespace: namespace }));
-            return this.emitter.result.declaration(enumName, code `${this.#generatedFileHeader}
-        
-        ${this.#emitUsings()}
-        
+            return this.emitter.result.declaration(enumName, code `
         namespace ${namespace}
         {
 
@@ -91,40 +176,48 @@ export async function $onEmit(context) {
             ${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}
             public enum ${enumName}
             {
-              ${this.emitter.emitEnumMembers(en)};
+              ${this.emitter.emitEnumMembers(en)}
             }
         } `);
         }
         enumDeclarationContext(en) {
+            if (getEnumType(en) === "double")
+                return this.emitter.getContext();
             const enumName = ensureCSharpIdentifier(this.emitter.getProgram(), en, en.name);
-            const enumFile = this.emitter.createSourceFile(`models/${enumName}.cs`);
+            const enumFile = this.emitter.createSourceFile(`generated/models/${enumName}.cs`);
             enumFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
-            const enumNamespace = `${this.#getOrSetBaseNamespace(en)}.Models`;
-            return {
-                namespace: enumNamespace,
-                file: enumFile,
-                scope: enumFile.globalScope,
-            };
+            const enumNamespace = this.#getOrAddNamespace(en.namespace);
+            return this.#createEnumContext(enumNamespace, enumFile, enumName);
         }
         enumMembers(en) {
+            const enumType = getEnumType(en);
             const result = new StringBuilder();
             let i = 0;
             for (const [name, member] of en.members) {
                 i++;
                 const memberName = ensureCSharpIdentifier(this.emitter.getProgram(), member, name);
                 this.#metadateMap.set(member, { name: memberName });
-                result.push(code `${ensureCSharpIdentifier(this.emitter.getProgram(), member, name)} = "${member.value ? member.value : name}"`);
-                if (i < en.members.size)
-                    result.pushLiteralSegment(", ");
+                if (enumType === "string") {
+                    result.push(code `
+          [JsonStringEnumMemberName("${member.value ? member.value : name}")]
+          ${ensureCSharpIdentifier(this.emitter.getProgram(), member, name)}`);
+                    if (i < en.members.size)
+                        result.pushLiteralSegment(",\n");
+                }
+                else if (member.value !== undefined) {
+                    result.push(code `
+          ${ensureCSharpIdentifier(this.emitter.getProgram(), member, name)} = ${member.value.toString()}`);
+                    if (i < en.members.size)
+                        result.pushLiteralSegment(",\n");
+                }
             }
             return this.emitter.result.rawCode(result.reduce());
         }
         intrinsic(intrinsic, name) {
             switch (intrinsic.name) {
                 case "unknown":
-                    return this.emitter.result.rawCode(code `System.Text.Json.Nodes.JsonNode`);
                 case "null":
-                    return this.emitter.result.rawCode(code `System.Text.Json.Nodes.JsonNode`);
+                    return this.emitter.result.rawCode(code `${UnknownType.getTypeReference(this.emitter.getContext().scope)}`);
                 case "ErrorType":
                 case "never":
                     reportDiagnostic(this.emitter.getProgram(), {
@@ -135,7 +228,7 @@ export async function $onEmit(context) {
                     return "";
                 case "void":
                     const type = getCSharpTypeForIntrinsic(this.emitter.getProgram(), intrinsic);
-                    return this.emitter.result.rawCode(`${type?.type.getTypeReference()}`);
+                    return this.emitter.result.rawCode(`${type?.type.getTypeReference(this.emitter.getContext().scope)}`);
             }
         }
         #emitUsings(file) {
@@ -153,39 +246,143 @@ export async function $onEmit(context) {
                 parts.forEach((p) => this.emitter.emitType(p));
                 return "";
             }
-            const className = ensureCSharpIdentifier(this.emitter.getProgram(), model, name);
+            const isErrorType = isErrorModel(this.emitter.getProgram(), model);
+            if (model.baseModel && model.baseModel.namespace !== model.namespace) {
+                const resolvedNs = this.#getOrAddNamespaceForType(model.baseModel);
+                if (resolvedNs)
+                    checkOrAddNamespaceToScope(resolvedNs, this.emitter.getContext().scope);
+            }
+            const baseModelRef = model.baseModel
+                ? code `: ${this.emitter.emitTypeReference(model.baseModel, this.emitter.getContext())}`
+                : "";
+            const baseClass = baseModelRef || (isErrorType ? ": HttpServiceException" : "");
             const namespace = this.emitter.getContext().namespace;
+            const className = ensureCSharpIdentifier(this.emitter.getProgram(), model, name);
             const doc = getDoc(this.emitter.getProgram(), model);
             const attributes = getModelAttributes(this.emitter.getProgram(), model, className);
+            const exceptionConstructor = isErrorType
+                ? this.getModelExceptionConstructor(this.emitter.getProgram(), model, name, className)
+                : "";
             this.#metadateMap.set(model, new CSharpType({ name: className, namespace: namespace }));
-            const decl = this.emitter.result.declaration(className, code `${this.#generatedFileHeader}
-
-      ${this.#emitUsings()}
-      
+            const decl = this.emitter.result.declaration(className, code `
       namespace ${namespace} {
 
-      ${doc ? `${formatComment(doc)}\n` : ""}${`${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}${attributes?.length > 0 ? "\n" : ""}`}public partial class ${className} ${model.baseModel ? code `: ${this.emitter.emitTypeReference(model.baseModel)}` : ""} {
-      ${this.emitter.emitModelProperties(model)}
+      ${doc ? `${formatComment(doc)}\n` : ""}${`${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}${attributes?.length > 0 ? "\n" : ""}`}public partial class ${className} ${baseClass} {
+      ${exceptionConstructor ? `${exceptionConstructor}\n` : ""}${this.emitter.emitModelProperties(model)}
     }
    } `);
             return decl;
         }
+        getModelExceptionConstructor(program, model, modelName, className) {
+            if (!isErrorModel(program, model))
+                return undefined;
+            const constructor = this.getExceptionConstructorData(program, model, modelName);
+            const isParent = !!model.derivedModels?.length;
+            return `public ${className}(${constructor.properties}) : base(${constructor.statusCode?.value ?? `400`}${constructor.header ? `, \n\t\t headers: new(){${constructor.header}}` : ""}${constructor.value ? `, \n\t\t value: new{${constructor.value}}` : ""}) 
+        { ${constructor.body ? `\n${constructor.body}` : ""}\n\t}${isParent ? `\npublic ${className}(int statusCode, object? value = null, Dictionary<string, string>? headers = default): base(statusCode, value, headers) {}\n` : ""}`;
+        }
+        isDuplicateExceptionName(name) {
+            const exceptionPropertyNames = [
+                "value",
+                "headers",
+                "stacktrace",
+                "source",
+                "message",
+                "innerexception",
+                "hresult",
+                "data",
+                "targetsite",
+                "helplink",
+            ];
+            return exceptionPropertyNames.includes(name.toLowerCase());
+        }
+        getExceptionConstructorData(program, model, modelName) {
+            const allProperties = new ModelInfo().getAllProperties(program, model) ?? [];
+            const propertiesWithDefaults = allProperties.map((prop) => {
+                const { defaultValue: typeDefault } = this.#findPropertyType(prop);
+                const defaultValue = prop.defaultValue
+                    ? code `${JSON.stringify(serializeValueAsJson(program, prop.defaultValue, prop))}`
+                    : typeDefault;
+                return { prop, defaultValue };
+            });
+            const sortedProperties = propertiesWithDefaults
+                .filter(({ prop }) => !isStatusCode(program, prop))
+                .sort(({ prop: a, defaultValue: aDefault }, { prop: b, defaultValue: bDefault }) => {
+                if (!a.optional && !aDefault && (b.optional || bDefault))
+                    return -1;
+                if (!b.optional && !bDefault && (a.optional || aDefault))
+                    return 1;
+                return 0;
+            });
+            const properties = [];
+            const body = [];
+            const header = [];
+            const value = [];
+            const statusCode = getStatusCode(program, model);
+            if (statusCode?.requiresConstructorArgument) {
+                properties.push(`int ${statusCode.value}`);
+            }
+            for (const { prop, defaultValue } of sortedProperties) {
+                let propertyName = ensureCSharpIdentifier(program, prop, prop.name);
+                if (modelName === propertyName || this.isDuplicateExceptionName(propertyName)) {
+                    propertyName = `${propertyName}Prop`;
+                }
+                const type = getCSharpType(program, prop.type);
+                properties.push(`${type?.type.name} ${prop.name}${defaultValue ? ` = ${defaultValue}` : `${prop.optional ? " = default" : ""}`}`);
+                body.push(`\t\t${propertyName} = ${prop.name};`);
+                if (isHeader(program, prop)) {
+                    const headerName = getHeaderFieldName(program, prop);
+                    header.push(`{"${headerName}", ${prop.name}}`);
+                }
+                else {
+                    value.push(`${prop.name} = ${prop.name}`);
+                }
+            }
+            return {
+                properties: properties.join(", "),
+                body: body.join("\n"),
+                header: header.join(", "),
+                value: value.join(","),
+                statusCode: statusCode,
+            };
+        }
         modelDeclarationContext(model, name) {
+            function getSourceModels(source, visited = new Set()) {
+                const result = [];
+                if (visited.has(source))
+                    return [];
+                result.push(source);
+                visited.add(source);
+                for (const candidate of source.sourceModels) {
+                    result.push(...getSourceModels(candidate.model, visited));
+                }
+                return result;
+            }
+            function getModelNamespace(model) {
+                const sourceModels = getSourceModels(model);
+                if (sourceModels.length === 0)
+                    return undefined;
+                return sourceModels
+                    .filter((m) => m.namespace !== undefined)
+                    .flatMap((s) => s.namespace)
+                    .reduce((c, n) => (c === n ? c : undefined));
+            }
             if (this.#isMultipartModel(model))
-                return {};
+                return this.emitter.getContext();
             const modelName = ensureCSharpIdentifier(this.emitter.getProgram(), model, name);
-            const modelFile = this.emitter.createSourceFile(`models/${modelName}.cs`);
+            const modelFile = this.emitter.createSourceFile(`generated/models/${modelName}.cs`);
             modelFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
-            const modelNamespace = `${this.#getOrSetBaseNamespace(model)}.Models`;
+            const ns = model.namespace ?? getModelNamespace(model);
+            const modelNamespace = this.#getOrAddNamespace(ns);
             return this.#createModelContext(modelNamespace, modelFile, modelName);
         }
         modelInstantiationContext(model) {
             if (this.#isMultipartModel(model))
-                return {};
+                return this.emitter.getContext();
             const modelName = getModelInstantiationName(this.emitter.getProgram(), model, model.name);
-            const sourceFile = this.emitter.createSourceFile(`models/${modelName}.cs`);
+            const sourceFile = this.emitter.createSourceFile(`generated/models/${modelName}.cs`);
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
-            const modelNamespace = `${this.#getOrSetBaseNamespace(model)}.Models`;
+            const modelNamespace = this.#getOrAddNamespace(model.namespace);
             const context = this.#createModelContext(modelNamespace, sourceFile, model.name);
             context.instantiationName = modelName;
             return context;
@@ -199,12 +396,33 @@ export async function $onEmit(context) {
             const program = this.emitter.getProgram();
             const recordType = getRecordType(program, model);
             if (recordType !== undefined) {
-                return code `Dictionary<string, ${this.emitter.emitTypeReference(recordType)}>`;
+                const valueType = this.#getSimpleType(recordType);
+                return code `Dictionary<string, ${valueType ? valueType?.getTypeReference() : this.emitter.emitTypeReference(recordType)}>`;
             }
             const context = this.emitter.getContext();
             const className = context.instantiationName ?? name;
             return this.modelDeclaration(model, className);
         }
+        #getSimpleType(type) {
+            switch (type.kind) {
+                case "Model":
+                    if (!isRecord(type))
+                        return undefined;
+                    return getCSharpType(this.emitter.getProgram(), type)?.type;
+                case "Boolean":
+                case "Intrinsic":
+                case "ModelProperty":
+                case "Number":
+                case "Scalar":
+                case "String":
+                case "StringTemplate":
+                case "StringTemplateSpan":
+                case "Tuple":
+                    return getCSharpType(this.emitter.getProgram(), type)?.type;
+                default:
+                    return undefined;
+            }
+        }
         #getMultipartParts(model) {
             const parts = [...model.properties.values()]
                 .flatMap((p) => getHttpPart(this.emitter.getProgram(), p.type)?.type)
@@ -243,9 +461,6 @@ export async function $onEmit(context) {
             });
             return this.modelDeclaration(model, modelName);
         }
-        #isRecord(type) {
-            return type.kind === "Model" && type.name === "Record" && type.indexer !== undefined;
-        }
         #isInheritedProperty(property) {
             const visited = [];
             function isInherited(model, propertyName) {
@@ -266,23 +481,33 @@ export async function $onEmit(context) {
         modelPropertyLiteral(property) {
             if (isStatusCode(this.emitter.getProgram(), property))
                 return "";
-            const propertyName = ensureCSharpIdentifier(this.emitter.getProgram(), property, property.name);
-            const [typeName, typeDefault, nullable] = this.#findPropertyType(property);
+            let propertyName = ensureCSharpIdentifier(this.emitter.getProgram(), property, property.name);
+            const { typeReference: typeName, defaultValue: typeDefault, nullableType: nullable, } = this.#findPropertyType(property);
             const doc = getDoc(this.emitter.getProgram(), property);
-            const attributes = getModelAttributes(this.emitter.getProgram(), property, propertyName);
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            const defaultValue = property.default
-                ? // eslint-disable-next-line @typescript-eslint/no-deprecated
-                    code `${this.emitter.emitType(property.default)}`
-                : typeDefault;
+            const attributes = new Map(getModelAttributes(this.emitter.getProgram(), property, propertyName).map((a) => [
+                a.type.name,
+                a,
+            ]));
+            const modelName = this.emitter.getContext()["name"];
+            if (modelName === propertyName ||
+                (this.isDuplicateExceptionName(propertyName) &&
+                    property.model &&
+                    isErrorModel(this.emitter.getProgram(), property.model))) {
+                propertyName = `${propertyName}Prop`;
+                const attr = getEncodedNameAttribute(this.emitter.getProgram(), property, propertyName);
+                if (!attributes.has(attr.type.name))
+                    attributes.set(attr.type.name, attr);
+            }
+            const defaultValue = this.#opHelpers.getDefaultValue(this.emitter.getProgram(), property.type, property.defaultValue) ?? typeDefault;
+            const attributeList = [...attributes.values()];
             return this.emitter.result
-                .rawCode(code `${doc ? `${formatComment(doc)}\n` : ""}${`${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}${attributes?.length > 0 ? "\n" : ""}`}public ${this.#isInheritedProperty(property) ? "new " : ""}${typeName}${isValueType(this.emitter.getProgram(), property.type) && (property.optional || nullable)
+                .rawCode(code `${doc ? `${formatComment(doc)}\n` : ""}${`${attributeList.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}${attributeList?.length > 0 ? "\n" : ""}`}public ${this.#isInheritedProperty(property) ? "new " : ""}${typeName}${isValueType(this.emitter.getProgram(), property.type) && (property.optional || nullable)
                 ? "?"
                 : ""} ${propertyName} { get; ${typeDefault ? "}" : "set; }"}${defaultValue ? ` = ${defaultValue};\n` : "\n"}
     `);
         }
         #findPropertyType(property) {
-            return this.#getTypeInfoForTsType(property.type);
+            return this.#opHelpers.getTypeInfo(this.emitter.getProgram(), property.type, property);
         }
         #isMultipartRequest(operation) {
             const body = operation.parameters.body;
@@ -298,118 +523,6 @@ export async function $onEmit(context) {
             }
             return false;
         }
-        #getTypeInfoForUnion(union) {
-            const propResult = this.#getNonNullableTsType(union);
-            if (propResult === undefined) {
-                return [
-                    code `${emitter.emitTypeReference(union)}`,
-                    undefined,
-                    [...union.variants.values()].filter((v) => isNullType(v.type)).length > 0,
-                ];
-            }
-            const [typeName, typeDefault, _] = this.#getTypeInfoForTsType(propResult.type);
-            return [typeName, typeDefault, propResult.nullable];
-        }
-        #getTypeInfoForTsType(tsType) {
-            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(emitter.getProgram(), {
-                    code: "invalid-interpolation",
-                    target: span,
-                    format: {},
-                });
-                return "";
-            }
-            switch (tsType.kind) {
-                case "String":
-                    return [code `string`, `"${tsType.value}"`, false];
-                case "StringTemplate":
-                    const template = tsType;
-                    if (template.stringValue !== undefined)
-                        return [code `string`, `"${template.stringValue}"`, false];
-                    const spanResults = [];
-                    for (const span of template.spans) {
-                        spanResults.push(extractStringValue(span, span));
-                    }
-                    return [code `string`, `"${spanResults.join("")}"`, false];
-                case "Boolean":
-                    return [code `bool`, `${tsType.value === true ? true : false}`, false];
-                case "Number":
-                    const [type, value] = this.#findNumericType(tsType);
-                    return [code `${type}`, `${value}`, false];
-                case "Tuple":
-                    const defaults = [];
-                    const [csharpType, isObject] = this.#coalesceTypes(tsType.values);
-                    if (isObject)
-                        return ["object[]", undefined, false];
-                    for (const value of tsType.values) {
-                        const [_, itemDefault] = this.#getTypeInfoForTsType(value);
-                        defaults.push(itemDefault);
-                    }
-                    return [
-                        code `${csharpType.getTypeReference()}[]`,
-                        `[${defaults.join(", ")}]`,
-                        csharpType.isNullable,
-                    ];
-                case "Object":
-                    return [code `object`, undefined, false];
-                case "Model":
-                    if (this.#isRecord(tsType)) {
-                        return [code `JsonObject`, undefined, false];
-                    }
-                    return [code `${emitter.emitTypeReference(tsType)}`, undefined, false];
-                case "ModelProperty":
-                    return this.#getTypeInfoForTsType(tsType.type);
-                case "Enum":
-                    return [code `${emitter.emitTypeReference(tsType)}`, undefined, false];
-                case "EnumMember":
-                    if (typeof tsType.value === "number") {
-                        const stringValue = tsType.value.toString();
-                        if (stringValue.includes(".") || stringValue.includes("e"))
-                            return ["double", stringValue, false];
-                        return ["int", stringValue, false];
-                    }
-                    if (typeof tsType.value === "string") {
-                        return ["string", tsType.value, false];
-                    }
-                    return [code `object`, undefined, false];
-                case "Union":
-                    return this.#getTypeInfoForUnion(tsType);
-                case "UnionVariant":
-                    return this.#getTypeInfoForTsType(tsType.type);
-                default:
-                    return [code `${emitter.emitTypeReference(tsType)}`, undefined, false];
-            }
-        }
-        #findNumericType(type) {
-            const stringValue = type.valueAsString;
-            if (stringValue.includes(".") || stringValue.includes("e"))
-                return ["double", stringValue];
-            return ["int", stringValue];
-        }
         modelPropertyReference(property) {
             return code `${this.emitter.emitTypeReference(property.type)}`;
         }
@@ -423,10 +536,7 @@ export async function $onEmit(context) {
             const doc = getDoc(this.emitter.getProgram(), iface);
             const attributes = getModelAttributes(this.emitter.getProgram(), iface, ifaceName);
             this.#metadateMap.set(iface, new CSharpType({ name: ifaceName, namespace: namespace }));
-            const decl = this.emitter.result.declaration(ifaceName, code `${this.#generatedFileHeaderWithNullable}
-
-      ${this.#emitUsings()}
-
+            const decl = this.emitter.result.declaration(ifaceName, code `
       namespace ${namespace} {
 
       ${doc ? `${formatComment(doc)}\n` : ""}${`${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}${attributes?.length > 0 ? "\n" : ""}`}public interface ${ifaceName} {
@@ -438,80 +548,66 @@ export async function $onEmit(context) {
         interfaceDeclarationContext(iface, name) {
             // set up interfaces file for declaration
             const ifaceName = `I${ensureCSharpIdentifier(this.emitter.getProgram(), iface, name, NameCasingType.Class)}`;
-            const sourceFile = this.emitter.createSourceFile(`operations/${ifaceName}.cs`);
+            const sourceFile = this.emitter.createSourceFile(`generated/operations/${ifaceName}.cs`);
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Interface;
-            const ifaceNamespace = this.#getOrSetBaseNamespace(iface);
-            const modelNamespace = `${ifaceNamespace}.Models`;
-            const context = this.#createModelContext(ifaceNamespace, sourceFile, ifaceName);
-            context.file.imports.set("System", ["System"]);
-            context.file.imports.set("System.Net", ["System.Net"]);
-            context.file.imports.set("System.Text.Json", ["System.Text.Json"]);
-            context.file.imports.set("System.Text.Json.Serialization", [
-                "System.Text.Json.Serialization",
-            ]);
-            context.file.imports.set("System.Threading.Tasks", ["System.Threading.Tasks"]);
-            context.file.imports.set("Microsoft.AspNetCore.Mvc", ["Microsoft.AspNetCore.Mvc"]);
+            sourceFile.meta["nullable"] = true;
+            const ifaceNamespace = this.#getOrAddNamespace(iface.namespace);
+            sourceFile.imports.set("System", ["System"]);
+            sourceFile.imports.set("System.Net", ["System.Net"]);
+            sourceFile.imports.set("System.Text.Json", ["System.Text.Json"]);
+            sourceFile.imports.set("System.Text.Json.Serialization", ["System.Text.Json.Serialization"]);
+            sourceFile.imports.set("System.Threading.Tasks", ["System.Threading.Tasks"]);
+            sourceFile.imports.set("Microsoft.AspNetCore.Mvc", ["Microsoft.AspNetCore.Mvc"]);
             if (this.#hasMultipartOperation(iface)) {
-                context.file.imports.set("Microsoft.AspNetCore.WebUtilities", [
+                sourceFile.imports.set("Microsoft.AspNetCore.WebUtilities", [
                     "Microsoft.AspNetCore.WebUtilities",
                 ]);
             }
-            context.file.imports.set(modelNamespace, [modelNamespace]);
-            return context;
+            return this.#createModelContext(ifaceNamespace, sourceFile, ifaceName);
         }
         interfaceDeclarationOperations(iface) {
             // add in operations
             const builder = new StringBuilder();
-            const metadata = new HttpMetadata();
             const context = this.emitter.getContext();
             const name = `${ensureCSharpIdentifier(this.emitter.getProgram(), iface, iface.name, NameCasingType.Class)}`;
-            const ifaceNamespace = this.#getOrSetBaseNamespace(iface);
-            const namespace = `${ifaceNamespace}`;
+            const ifaceNamespace = this.#getOrAddNamespace(iface.namespace);
+            const namespace = ifaceNamespace;
             const mock = {
                 className: name,
                 interfaceName: `I${name}`,
                 methods: [],
                 namespace: namespace,
-                usings: [`${ifaceNamespace}.Models`],
+                usings: [],
             };
             for (const [name, operation] of iface.operations) {
+                if (isTemplateDeclaration(operation))
+                    continue;
                 const doc = getDoc(this.emitter.getProgram(), operation);
                 const returnTypes = [];
                 const [httpOp, _] = getHttpOperation(this.emitter.getProgram(), operation);
                 for (const response of httpOp.responses.filter((r) => !isErrorModel(this.emitter.getProgram(), r.type))) {
-                    returnTypes.push(metadata.resolveLogicalResponseType(this.emitter.getProgram(), response));
+                    const [_, responseType] = this.#resolveOperationResponse(response, httpOp.operation);
+                    returnTypes.push(responseType);
                 }
-                const returnInfo = coalesceTypes(this.emitter.getProgram(), returnTypes, context.namespace);
+                const returnInfo = coalesceTypes(this.emitter.getProgram(), returnTypes, namespace);
                 const returnType = returnInfo?.type || UnknownType;
                 const opName = ensureCSharpIdentifier(this.emitter.getProgram(), operation, name, NameCasingType.Method);
-                let opDecl;
-                let opImpl;
-                if (this.#isMultipartRequest(httpOp)) {
-                    opImpl = {
-                        methodName: `${opName}Async`,
-                        methodParams: `${this.#emitInterfaceOperationParameters(operation, "MultipartReader reader")}`,
-                        returnType: `${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`}`,
-                        instantiatedReturnType: returnType.name === "void"
-                            ? undefined
-                            : `${returnType.getTypeReference(context.scope)}`,
-                    };
-                    opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${opImpl.returnType} ${opImpl.methodName}( ${opImpl.methodParams});`);
-                }
-                else {
-                    opImpl = {
-                        methodName: `${opName}Async`,
-                        methodParams: `${this.#emitInterfaceOperationParameters(operation)}`,
-                        returnType: `${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`}`,
-                        instantiatedReturnType: returnType.name === "void"
-                            ? undefined
-                            : `${returnType.getTypeReference(context.scope)}`,
-                    };
-                    opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${opImpl.returnType} ${opImpl.methodName}( ${opImpl.methodParams});`);
-                }
+                const parameters = this.#opHelpers.getParameters(this.emitter.getProgram(), httpOp);
+                const opImpl = {
+                    methodName: `${opName}Async`,
+                    methodParams: `${getBusinessLogicDeclParameters(parameters)}`,
+                    returnType: returnType,
+                    returnTypeName: `${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`}`,
+                    instantiatedReturnType: returnType.name === "void"
+                        ? undefined
+                        : `${returnType.getTypeReference(context.scope)}`,
+                };
+                const opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${opImpl.returnTypeName} ${opImpl.methodName}( ${opImpl.methodParams});`);
                 mock.methods.push(opImpl);
                 builder.push(code `${opDecl.value}\n`);
                 this.emitter.emitInterfaceOperation(operation);
             }
+            mock.usings.push(...getImports(context.scope));
             this.#mockRegistrations.set(mock.interfaceName, mock);
             return builder.reduce();
         }
@@ -529,9 +625,8 @@ export async function $onEmit(context) {
             const doc = getDoc(this.emitter.getProgram(), operation);
             const [httpOperation, _] = getHttpOperation(this.emitter.getProgram(), operation);
             const multipart = this.#isMultipartRequest(httpOperation);
-            const declParams = !multipart
-                ? this.#emitHttpOperationParameters(httpOperation)
-                : this.#emitHttpOperationParameters(httpOperation, true);
+            const parameters = this.#opHelpers.getParameters(this.emitter.getProgram(), httpOperation);
+            const declParams = getHttpDeclParameters(parameters);
             if (multipart) {
                 const context = this.emitter.getContext();
                 context.file.imports.set("Microsoft.AspNetCore.WebUtilities", [
@@ -551,7 +646,7 @@ export async function $onEmit(context) {
                     isValueType: false,
                 });
             const hasResponseValue = response.name !== "void";
-            const resultString = `${status === 204 ? "NoContent" : "Ok"}`;
+            const returnStatement = getControllerReturnStatement(status, hasResponseValue);
             if (!this.#isMultipartRequest(httpOperation)) {
                 return this.emitter.result.declaration(operation.name, code `
         ${doc ? `${formatComment(doc)}` : ""}
@@ -561,10 +656,10 @@ export async function $onEmit(context) {
         public virtual async Task<IActionResult> ${operationName}(${declParams})
         {
           ${hasResponseValue
-                    ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
-          return ${resultString}(result);`
-                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
-          return ${resultString}();`}
+                    ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
+          ${returnStatement}`
+                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
+          ${returnStatement}`}
         }`);
             }
             else {
@@ -585,10 +680,10 @@ export async function $onEmit(context) {
 
           var reader = new MultipartReader(boundary, Request.Body);
           ${hasResponseValue
-                    ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation, "reader")});
-          return ${resultString}(result);`
-                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation, "reader")});
-          return ${resultString}();`}
+                    ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
+          ${returnStatement}`
+                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
+          ${returnStatement}`}
         }`);
             }
         }
@@ -603,7 +698,8 @@ export async function $onEmit(context) {
             const operationName = ensureCSharpIdentifier(this.emitter.getProgram(), operation, name, NameCasingType.Method);
             const doc = getDoc(this.emitter.getProgram(), operation);
             const [httpOperation, _] = getHttpOperation(this.emitter.getProgram(), operation);
-            const declParams = this.#emitHttpOperationParameters(httpOperation);
+            const parameters = this.#opHelpers.getParameters(this.emitter.getProgram(), httpOperation);
+            const declParams = getHttpDeclParameters(parameters);
             const responseInfo = this.#getOperationResponse(httpOperation);
             const status = responseInfo?.statusCode ?? 200;
             const response = responseInfo?.resultType ??
@@ -614,7 +710,7 @@ export async function $onEmit(context) {
                     isValueType: false,
                 });
             const hasResponseValue = response.name !== "void";
-            const resultString = `${status === 204 ? "NoContent" : "Ok"}`;
+            const returnStatement = getControllerReturnStatement(status, hasResponseValue);
             return this.emitter.result.declaration(operation.name, code `
         ${doc ? `${formatComment(doc)}` : ""}
         [${getOperationVerbDecorator(httpOperation)}]
@@ -623,10 +719,10 @@ export async function $onEmit(context) {
         public virtual async Task<IActionResult> ${operationName}(${declParams})
         {
           ${hasResponseValue
-                ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
-          return ${resultString}(result);`
-                : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
-          return ${resultString}();`}
+                ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
+          ${returnStatement}`
+                : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
+          ${returnStatement}`}
         }`);
         }
         operationReturnType(operation, returnType) {
@@ -636,6 +732,28 @@ export async function $onEmit(context) {
         stringTemplate(stringTemplate) {
             return this.emitter.result.rawCode(stringTemplate.stringValue || "");
         }
+        #resolveOperationResponse(response, operation) {
+            function getName(sourceType, part) {
+                return ensureCSharpIdentifier(emitter.getProgram(), sourceType, part, NameCasingType.Class);
+            }
+            let responseType = new HttpMetadata().resolveLogicalResponseType(this.emitter.getProgram(), response);
+            if (responseType.kind === "Model" && !responseType.name) {
+                const modelName = `${getName(responseType, operation.interface.name)}${getName(responseType, operation.name)}Response}`;
+                const returnedType = this.emitter
+                    .getProgram()
+                    .checker.cloneType(responseType, { name: modelName });
+                responseType = returnedType;
+            }
+            // TemplateParameter types cannot be emitted (they are unresolved template placeholders).
+            // Template operations are filtered in interfaceDeclarationOperations, but this guard
+            // prevents crashes if a TemplateParameter response type is encountered via other paths.
+            if (responseType.kind !== "TemplateParameter") {
+                this.emitter.emitType(responseType);
+            }
+            const context = this.emitter.getContext();
+            const result = getCSharpType(this.emitter.getProgram(), responseType, context.namespace);
+            return [result?.type || UnknownType, responseType];
+        }
         #getOperationResponse(operation) {
             const validResponses = operation.responses.filter((r) => !isErrorModel(this.emitter.getProgram(), r.type) &&
                 getCSharpStatusCode(r.statusCodes) !== undefined);
@@ -656,106 +774,36 @@ export async function $onEmit(context) {
             };
         }
         #emitOperationResponses(operation) {
-            const builder = new StringBuilder();
-            let i = 0;
-            const validResponses = operation.responses.filter((r) => !isErrorModel(this.emitter.getProgram(), r.type) &&
-                getCSharpStatusCode(r.statusCodes) !== undefined);
-            for (const response of validResponses) {
-                i++;
-                builder.push(code `${this.#emitOperationResponseDecorator(response)}`);
-                if (i < validResponses.length) {
-                    builder.pushLiteralSegment("\n");
-                }
+            function isValid(program, response) {
+                return (!isErrorModel(program, response.type) &&
+                    getCSharpStatusCode(response.statusCodes) !== undefined);
             }
+            const builder = new StringBuilder();
             for (const response of operation.responses) {
-                if (!isEmptyResponseModel(this.emitter.getProgram(), response.type))
-                    this.emitter.emitType(response.type);
+                const [responseType, _] = this.#resolveOperationResponse(response, operation.operation);
+                if (isValid(this.emitter.getProgram(), response)) {
+                    builder.push(code `${builder.segments.length > 0 ? "\n" : ""}${this.#emitOperationResponseDecorator(response, responseType)}`);
+                }
             }
             return builder.reduce();
         }
-        #emitOperationResponseDecorator(response) {
-            const responseType = new HttpMetadata().resolveLogicalResponseType(this.emitter.getProgram(), response);
-            return this.emitter.result.rawCode(code `[ProducesResponseType((int)${getCSharpStatusCode(response.statusCodes)}, Type = typeof(${this.#emitResponseType(responseType)}))]`);
+        #emitOperationResponseDecorator(response, result) {
+            return this.emitter.result.rawCode(code `[ProducesResponseType((int)${getCSharpStatusCode(response.statusCodes)}, Type = typeof(${this.#emitResponseType(result)}))]`);
         }
         #emitResponseType(type) {
             const context = this.emitter.getContext();
-            const result = getCSharpType(this.emitter.getProgram(), type, context.namespace);
-            const resultType = result?.type || UnknownType;
-            return resultType.getTypeReference(context.scope);
-        }
-        #emitInterfaceOperationParameters(operation, bodyParam) {
-            const signature = new StringBuilder();
-            const requiredParams = [];
-            const optionalParams = [];
-            let totalParams = 0;
-            if (bodyParam !== undefined)
-                totalParams++;
-            const validParams = [...operation.parameters.properties.entries()].filter(([_, p]) => isValidParameter(this.emitter.getProgram(), p));
-            for (const [_, parameter] of validParams) {
-                if (!isContentTypeHeader(this.emitter.getProgram(), parameter) &&
-                    (bodyParam === undefined || isHttpMetadata(this.emitter.getProgram(), parameter))) {
-                    if (parameter.optional || parameter.defaultValue)
-                        optionalParams.push(parameter);
-                    else
-                        requiredParams.push(parameter);
-                    totalParams++;
-                }
-            }
-            let i = 1;
-            for (const requiredParam of requiredParams) {
-                const [paramType, _, __] = this.#findPropertyType(requiredParam);
-                signature.push(code `${paramType} ${ensureCSharpIdentifier(this.emitter.getProgram(), requiredParam, requiredParam.name, NameCasingType.Parameter)}${i++ < totalParams ? ", " : ""}`);
-            }
-            if (bodyParam) {
-                signature.push(bodyParam);
-                if (i++ < totalParams)
-                    signature.push(", ");
-            }
-            for (const optionalParam of optionalParams) {
-                const [paramType, _, __] = this.#findPropertyType(optionalParam);
-                signature.push(code `${paramType}? ${ensureCSharpIdentifier(this.emitter.getProgram(), optionalParam, optionalParam.name, NameCasingType.Parameter)}${i++ < totalParams ? ", " : ""}`);
-            }
-            return signature.reduce();
-        }
-        #emitHttpOperationParameters(operation, bodyParameter) {
-            const signature = new StringBuilder();
-            const bodyParam = operation.parameters.body;
-            let i = 0;
-            //const pathParameters = operation.parameters.parameters.filter((p) => p.type === "path");
-            const validParams = operation.parameters.parameters.filter((p) => isValidParameter(this.emitter.getProgram(), 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) {
-                signature.push(code `${this.#emitOperationSignatureParameter(operation, parameter)}${++i < requiredParams.length ? ", " : ""}`);
-            }
-            if (requiredParams.length > 0 &&
-                (optionalParams.length > 0 || (bodyParameter === undefined && bodyParam !== undefined))) {
-                signature.push(code `, `);
-            }
-            if (bodyParameter === undefined) {
-                if (bodyParam !== undefined) {
-                    signature.push(code `${this.emitter.emitTypeReference(this.#metaInfo.getEffectivePayloadType(bodyParam.type, Visibility.Create || Visibility.Update))} body${requiredParams.length > 0 && optionalParams.length > 0 ? ", " : ""}`);
-                }
-            }
-            i = 0;
-            for (const parameter of optionalParams) {
-                signature.push(code `${this.#emitOperationSignatureParameter(operation, parameter)}${++i < optionalParams.length ? ", " : ""}`);
-            }
-            return signature.reduce();
+            return type.getTypeReference(context.scope);
         }
         unionDeclaration(union, name) {
-            const baseType = this.#coalesceUnionTypes(union);
-            if (baseType.isBuiltIn && baseType.name === "string") {
+            const baseType = coalesceUnionTypes(this.emitter.getProgram(), union);
+            if (isStringEnumType(this.emitter.getProgram(), union)) {
                 const program = this.emitter.getProgram();
                 const unionName = ensureCSharpIdentifier(program, union, name);
                 const namespace = this.emitter.getContext().namespace;
                 const doc = getDoc(this.emitter.getProgram(), union);
                 const attributes = getModelAttributes(program, union, unionName);
                 this.#metadateMap.set(union, new CSharpType({ name: unionName, namespace: namespace }));
-                return this.emitter.result.declaration(unionName, code `${this.#generatedFileHeader}
-        
-        ${this.#emitUsings()}
-        
+                return this.emitter.result.declaration(unionName, code `
         namespace ${namespace}
         {
 
@@ -763,24 +811,19 @@ export async function $onEmit(context) {
             ${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}
             public enum ${unionName}
             {
-              ${this.emitter.emitUnionVariants(union)};
+              ${this.emitter.emitUnionVariants(union)}
             }
         } `);
             }
-            return this.emitter.result.rawCode(code `${baseType.getTypeReference()}`);
+            return this.emitter.result.rawCode(code `${baseType.getTypeReference(this.emitter.getContext().scope)}`);
         }
         unionDeclarationContext(union) {
-            const baseType = this.#coalesceUnionTypes(union);
-            if (baseType.isBuiltIn && baseType.name === "string") {
+            if (isStringEnumType(this.emitter.getProgram(), union)) {
                 const unionName = ensureCSharpIdentifier(this.emitter.getProgram(), union, union.name || "Union");
-                const unionFile = this.emitter.createSourceFile(`models/${unionName}.cs`);
+                const unionFile = this.emitter.createSourceFile(`generated/models/${unionName}.cs`);
                 unionFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
-                const unionNamespace = `${this.#getOrSetBaseNamespace(union)}.Models`;
-                return {
-                    namespace: unionNamespace,
-                    file: unionFile,
-                    scope: unionFile.globalScope,
-                };
+                const unionNamespace = this.#getOrAddNamespace(union.namespace);
+                return this.#createEnumContext(unionNamespace, unionFile, unionName);
             }
             else {
                 return this.emitter.getContext();
@@ -801,7 +844,9 @@ export async function $onEmit(context) {
                     const nameHint = name || variant.type.value;
                     const memberName = ensureCSharpIdentifier(this.emitter.getProgram(), variant, nameHint);
                     this.#metadateMap.set(variant, { name: memberName });
-                    result.push(code `${ensureCSharpIdentifier(this.emitter.getProgram(), variant, nameHint)} = "${variant.type.value}"`);
+                    result.push(code `
+            [JsonStringEnumMemberName("${variant.type.value}")]
+            ${ensureCSharpIdentifier(this.emitter.getProgram(), variant, nameHint, NameCasingType.Property)}`);
                     if (i < union.variants.size)
                         result.pushLiteralSegment(", ");
                 }
@@ -811,132 +856,59 @@ export async function $onEmit(context) {
         unionVariantContext(union) {
             return super.unionVariantContext(union);
         }
-        #emitOperationSignatureParameter(operation, httpParam) {
-            const name = httpParam.param.name;
-            const parameter = httpParam.param;
-            const emittedName = ensureCSharpIdentifier(this.emitter.getProgram(), parameter, name, NameCasingType.Parameter);
-            let [emittedType, emittedDefault, _] = this.#findPropertyType(parameter);
-            if (emittedType.toString().endsWith("[]"))
-                emittedDefault = undefined;
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            const defaultValue = parameter.default
-                ? // eslint-disable-next-line @typescript-eslint/no-deprecated
-                    code `${this.emitter.emitType(parameter.default)}`
-                : emittedDefault;
-            return this.emitter.result.rawCode(code `${httpParam.type !== "path" ? this.#emitParameterAttribute(httpParam) : ""}${emittedType} ${emittedName}${defaultValue === undefined ? "" : ` = ${defaultValue}`}`);
-        }
-        #getBodyParameters(operation) {
-            const bodyParam = operation.parameters.body;
-            if (bodyParam === undefined)
-                return undefined;
-            if (bodyParam.property !== undefined)
-                return [bodyParam.property];
-            if (bodyParam.type.kind !== "Model" || bodyParam.type.properties.size < 1)
-                return undefined;
-            return [...bodyParam.type.properties.values()];
-        }
-        #emitOperationCallParameters(operation, bodyParameter = "body") {
-            const signature = new StringBuilder();
-            let i = 0;
-            const bodyParameters = this.#getBodyParameters(operation);
-            //const pathParameters = operation.parameters.parameters.filter((p) => p.type === "path");
-            const valid = operation.parameters.parameters.filter((p) => isValidParameter(this.emitter.getProgram(), p.param));
-            const required = valid.filter((p) => p.type === "path" || (!p.param.optional && p.param.defaultValue === undefined));
-            const optional = valid.filter((p) => p.type !== "path" && (p.param.optional || p.param.defaultValue !== undefined));
-            for (const parameter of required) {
-                const contentType = isContentTypeHeader(this.emitter.getProgram(), parameter.param);
-                i++;
-                if (!isNeverType(parameter.param.type) &&
-                    !isNullType(parameter.param.type) &&
-                    !isVoidType(parameter.param.type) &&
-                    !contentType) {
-                    signature.push(code `${this.#emitOperationCallParameter(operation, parameter)}${i < valid.length || bodyParameters !== undefined ? ", " : ""}`);
-                }
-            }
-            if (bodyParameters !== undefined) {
-                if (bodyParameters.length === 1) {
-                    signature.push(code `${bodyParameter}`);
-                }
-                else {
-                    let j = 0;
-                    for (const parameter of bodyParameters) {
-                        j++;
-                        const propertyName = ensureCSharpIdentifier(this.emitter.getProgram(), parameter, parameter.name, NameCasingType.Property);
-                        signature.push(code `${bodyParameter}?.${propertyName}${j < bodyParameters.length || i < valid.length ? ", " : ""}`);
-                    }
-                }
-            }
-            for (const parameter of optional) {
-                const contentType = isContentTypeHeader(this.emitter.getProgram(), parameter.param);
-                i++;
-                if (!isNeverType(parameter.param.type) &&
-                    !isNullType(parameter.param.type) &&
-                    !isVoidType(parameter.param.type) &&
-                    !contentType) {
-                    signature.push(code `${this.#emitOperationCallParameter(operation, parameter)}${i < valid.length ? ", " : ""}`);
-                }
-            }
-            return signature.reduce();
-        }
-        #emitOperationCallParameter(operation, httpParam) {
-            const name = httpParam.param.name;
-            const parameter = httpParam.param;
-            const emittedName = ensureCSharpIdentifier(this.emitter.getProgram(), parameter, name, NameCasingType.Parameter);
-            return this.emitter.result.rawCode(code `${emittedName}`);
-        }
-        #emitParameterAttribute(parameter) {
-            switch (parameter.type) {
-                case "header":
-                    return code `[FromHeader(Name="${parameter.name}")] `;
-                case "query":
-                    return code `[FromQuery(Name="${parameter.name}")] `;
-                default:
-                    return "";
-            }
-        }
         #createModelContext(namespace, file, name) {
+            file.imports.set("System", ["System"]);
+            file.imports.set("System.Text.Json", ["System.Text.Json"]);
+            file.imports.set("System.Text.Json.Serialization", ["System.Text.Json.Serialization"]);
+            file.imports.set("TypeSpec.Helpers.JsonConverters", ["TypeSpec.Helpers.JsonConverters"]);
+            file.imports.set("TypeSpec.Helpers", ["TypeSpec.Helpers"]);
+            file.meta[this.#nsKey] = namespace;
             const context = {
                 namespace: namespace,
                 name: name,
                 file: file,
                 scope: file.globalScope,
             };
-            context.file.imports.set("System", ["System"]);
-            context.file.imports.set("System.Text.Json", ["System.Text.Json"]);
-            context.file.imports.set("System.Text.Json.Serialization", [
-                "System.Text.Json.Serialization",
-            ]);
             return context;
         }
+        #createEnumContext(namespace, file, name) {
+            file.imports.set("System.Text.Json", ["System.Text.Json"]);
+            file.imports.set("System.Text.Json.Serialization", ["System.Text.Json.Serialization"]);
+            file.meta[this.#nsKey] = namespace;
+            return {
+                namespace: namespace,
+                name: name,
+                file: file,
+                scope: file.globalScope,
+            };
+        }
         #createOrGetResourceContext(name, operation, resource) {
-            let context = controllers.get(name);
+            name = ensureCSharpIdentifier(this.emitter.getProgram(), operation, name, NameCasingType.Class);
+            const namespace = this.#getOrAddNamespace(operation.namespace);
+            let context = controllers.get(`${namespace}.${name}`);
             if (context !== undefined)
                 return context;
-            const sourceFile = this.emitter.createSourceFile(`controllers/${name}Controller.cs`);
-            const namespace = this.#getOrSetBaseNamespace(operation);
-            const modelNamespace = `${namespace}.Models`;
+            const sourceFile = this.emitter.createSourceFile(`generated/controllers/${name}Controller.cs`);
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Controller;
             sourceFile.meta["resourceName"] = name;
             sourceFile.meta["resource"] = `${name}Controller`;
             sourceFile.meta["namespace"] = namespace;
+            sourceFile.imports.set("System", ["System"]);
+            sourceFile.imports.set("System.Net", ["System.Net"]);
+            sourceFile.imports.set("System.Threading.Tasks", ["System.Threading.Tasks"]);
+            sourceFile.imports.set("System.Text.Json", ["System.Text.Json"]);
+            sourceFile.imports.set("System.Text.Json.Serialization", ["System.Text.Json.Serialization"]);
+            sourceFile.imports.set("Microsoft.AspNetCore.Mvc", ["Microsoft.AspNetCore.Mvc"]);
+            sourceFile.imports.set(namespace, [namespace]);
+            sourceFile.meta[this.#nsKey] = namespace;
             context = {
-                namespace: sourceFile.meta["namespace"],
+                namespace: namespace,
                 file: sourceFile,
                 resourceName: name,
                 scope: sourceFile.globalScope,
                 resourceType: resource,
             };
-            context.file.imports.set("System", ["System"]);
-            context.file.imports.set("System.Net", ["System.Net"]);
-            context.file.imports.set("System.Threading.Tasks", ["System.Threading.Tasks"]);
-            context.file.imports.set("System.Text.Json", ["System.Text.Json"]);
-            context.file.imports.set("System.Text.Json.Serialization", [
-                "System.Text.Json.Serialization",
-            ]);
-            context.file.imports.set("Microsoft.AspNetCore.Mvc", ["Microsoft.AspNetCore.Mvc"]);
-            context.file.imports.set(modelNamespace, [modelNamespace]);
-            context.file.imports.set(namespace, [namespace]);
-            controllers.set(name, context);
+            controllers.set(`${namespace}.${name}`, context);
             return context;
         }
         // eslint-disable-next-line no-unused-private-class-members
@@ -946,8 +918,8 @@ export async function $onEmit(context) {
                 : "TypeSpec";
         }
         reference(targetDeclaration, pathUp, pathDown, commonScope) {
-            //if (targetDeclaration.name) return targetDeclaration.name;
-            return super.reference(targetDeclaration, pathUp, pathDown, commonScope);
+            const resolved = resolveReferenceFromScopes(targetDeclaration, pathDown, pathUp);
+            return resolved ?? super.reference(targetDeclaration, pathUp, pathDown, commonScope);
         }
         scalarInstantiation(scalar, name) {
             const scalarType = getCSharpTypeForScalar(this.emitter.getProgram(), scalar);
@@ -958,21 +930,8 @@ export async function $onEmit(context) {
             return scalarType.getTypeReference(this.emitter.getContext().scope);
         }
         sourceFile(sourceFile) {
-            for (const libFile of this.#libraryFiles) {
-                if (sourceFile === libFile.source)
-                    return libFile.emitted;
-            }
-            if (this.#emitMocks === "all") {
-                for (const helper of this.#mockHelpers) {
-                    if (sourceFile === helper.source)
-                        return helper.emitted;
-                }
-            }
-            if (this.#mockFiles.length > 0) {
-                for (const mock of this.#mockFiles) {
-                    if (sourceFile === mock.source)
-                        return mock.emitted;
-                }
+            if (sourceFile.meta.emitted) {
+                return sourceFile.meta.emitted;
             }
             const emittedSourceFile = {
                 path: sourceFile.path,
@@ -990,15 +949,26 @@ export async function $onEmit(context) {
         }
         #emitCodeContents(file) {
             const contents = new StringBuilder();
+            contents.pushLiteralSegment(`${file.meta["nullable"] ? this.#generatedFileHeaderWithNullable : this.#generatedFileHeader}
+        
+        ${this.#emitUsings(file)}
+        `);
             for (const decl of file.globalScope.declarations) {
                 contents.push(decl.value);
             }
+            for (const child of file.globalScope.childScopes) {
+                if (child.declarations) {
+                    for (const decl of child.declarations) {
+                        contents.push(decl.value);
+                    }
+                }
+            }
             return contents.segments.join("\n") + "\n";
         }
         #emitControllerContents(file) {
             const namespace = file.meta.namespace;
             const contents = new StringBuilder();
-            contents.push(`${this.#generatedFileHeader}\n\n`);
+            contents.push(`${this.#generatedFileHeaderWithNullable}\n\n`);
             contents.push(code `${this.#emitUsings(file)}\n`);
             contents.push("\n");
             contents.push(`namespace ${namespace}.Controllers\n`);
@@ -1063,92 +1033,18 @@ export async function $onEmit(context) {
                 return params.reduce();
             return "";
         }
-        #coalesceUnionTypes(union) {
-            const [result, _] = this.#coalesceTypes([...union.variants.values()].flatMap((v) => v.type));
-            return result;
-        }
-        #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;
-        }
-        #coalesceTypes(types) {
-            const defaultValue = [
-                new CSharpType({
-                    name: "object",
-                    namespace: "System",
-                    isValueType: false,
-                }),
-                true,
-            ];
-            let current = undefined;
-            let nullable = false;
-            for (const type of types) {
-                let candidate = undefined;
-                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 = this.#coalesceUnionTypes(type);
-                        break;
-                    case "Scalar":
-                        candidate = getCSharpTypeForScalar(this.emitter.getProgram(), 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)
-                current.isNullable = true;
-            return current === undefined ? defaultValue : [current, false];
-        }
-        writeOutput(sourceFiles) {
-            for (const source of this.#libraryFiles) {
-                sourceFiles.push(source.source);
-            }
-            if (this.#emitMocks === "all") {
-                for (const helper of this.#mockHelpers) {
-                    sourceFiles.push(helper.source);
-                }
+        async writeOutput(sourceFiles) {
+            sourceFiles.push(...getSerializationSourceFiles(this.emitter).flatMap((l) => l.source));
+            sourceFiles.push(...getProjectDocs(this.emitter, this.#useSwagger, this.#mockRegistrations).flatMap((l) => l.source));
+            if (this.#emitMocks === "mocks-and-project-files" || this.#emitMocks === "mocks-only") {
                 if (this.#mockRegistrations.size > 0) {
-                    const mocks = getBusinessLogicImplementations(this.emitter, this.#mockRegistrations);
-                    this.#mockFiles.push(...mocks);
+                    const mocks = getBusinessLogicImplementations(this.emitter, this.#mockRegistrations, this.#useSwagger, this.#openapiPath);
                     sourceFiles.push(...mocks.flatMap((l) => l.source));
                 }
             }
+            async function shouldWrite(source, exists) {
+                return (!source.meta.conditional || options.overwrite === true || !(await exists(source.path)));
+            }
             const emittedSourceFiles = [];
             for (const source of sourceFiles) {
                 switch (this.#emitterOutputType) {
@@ -1159,51 +1055,22 @@ export async function $onEmit(context) {
                                     // do nothing
                                     break;
                                 default:
-                                    emittedSourceFiles.push(source);
+                                    if (await shouldWrite(source, this.#fileExists)) {
+                                        emittedSourceFiles.push(source);
+                                    }
                                     break;
                             }
                         }
                         break;
                     default:
-                        emittedSourceFiles.push(source);
+                        if (await shouldWrite(source, this.#fileExists)) {
+                            emittedSourceFiles.push(source);
+                        }
                         break;
                 }
             }
             return super.writeOutput(emittedSourceFiles);
         }
-        #getOrSetBaseNamespace(type) {
-            if (this.#baseNamespace === undefined) {
-                if (type.namespace !== undefined) {
-                    this.#baseNamespace = `${type.namespace
-                        ? ensureCSharpIdentifier(this.emitter.getProgram(), type.namespace, getNamespaceFullName(type.namespace))
-                        : "TypeSpec"}.Service`;
-                }
-                else {
-                    this.#baseNamespace = "TypeSpec.Service";
-                }
-            }
-            return this.#baseNamespace;
-        }
-    }
-    function isEmptyResponseModel(program, model) {
-        if (model.kind !== "Model")
-            return false;
-        return model.properties.size === 1 && isStatusCode(program, [...model.properties.values()][0]);
-    }
-    function isContentTypeHeader(program, parameter) {
-        return (isHeader(program, parameter) &&
-            (parameter.name === "contentType" ||
-                getHeaderFieldName(program, parameter) === "Content-type"));
-    }
-    function isValidParameter(program, parameter) {
-        return (!isContentTypeHeader(program, parameter) &&
-            (parameter.type.kind !== "Intrinsic" || parameter.type.name !== "never"));
-    }
-    /** Determine whether the given parameter is http metadata */
-    function isHttpMetadata(program, property) {
-        return (isPathParam(program, property) ||
-            isHeader(program, property) ||
-            isQueryParam(program, property));
     }
     function processNameSpace(program, target, service) {
         if (!service)
@@ -1234,7 +1101,6 @@ export async function $onEmit(context) {
                     }
                 }
                 const iface = program.checker.createAndFinishType({
-                    node: undefined,
                     sourceInterfaces: [],
                     decorators: [],
                     operations: createRekeyableMap(nsOps),
@@ -1268,17 +1134,60 @@ export async function $onEmit(context) {
         }
     }
     const emitter = createAssetEmitter(context.program, CSharpCodeEmitter, context);
-    const ns = context.program.checker.getGlobalNamespaceType();
+    const ns = context.program.getGlobalNamespaceType();
     const options = emitter.getOptions();
     processNameSpace(context.program, ns);
     if (!doNotEmit) {
-        await ensureCleanDirectory(context.program, options.emitterOutputDir);
+        const outputDir = options.emitterOutputDir;
+        const generatedDir = path.join(outputDir, "generated");
+        await ensureCleanDirectory(context.program, generatedDir);
+        function normalizeSlashes(path) {
+            return path.replaceAll("\\", "/");
+        }
+        async function getOpenApiPath() {
+            if (options["openapi-path"])
+                return options["openapi-path"];
+            const openApiSettings = await getOpenApiConfig(context.program);
+            const projectDir = resolvePath(context.program.projectRoot, outputDir);
+            if (openApiSettings.outputDir) {
+                const openApiPath = resolvePath(openApiSettings.outputDir, openApiSettings.fileName || "openapi.yaml");
+                return normalizeSlashes(path.relative(projectDir, openApiPath));
+            }
+            if (openApiSettings.emitted) {
+                const baseDir = context.program.compilerOptions.outputDir ||
+                    resolvePath(context.program.projectRoot, "tsp-output");
+                const openApiPath = resolvePath(baseDir, "@typespec", "openapi3", openApiSettings.fileName || "openapi.yaml");
+                return normalizeSlashes(path.relative(projectDir, openApiPath));
+            }
+            return "";
+        }
+        const openApiPath = await getOpenApiPath();
+        const UseSwaggerUI = openApiPath !== "" && options["use-swaggerui"] === true;
+        let httpPort;
+        let httpsPort;
+        if (options["emit-mocks"] !== "none") {
+            getScaffoldingHelpers(emitter, UseSwaggerUI, openApiPath, true);
+        }
+        if (options["emit-mocks"] === "mocks-and-project-files") {
+            httpPort = options["http-port"] || (await getFreePort(5000, 5999));
+            httpsPort = options["https-port"] || (await getFreePort(7000, 7999));
+            getProjectHelpers(emitter, options["project-name"] || "ServiceProject", options["use-swaggerui"] || false, httpPort, httpsPort);
+        }
         await emitter.writeOutput();
+        const projectDir = normalizeSlashes(path.relative(process.cwd(), resolvePath(outputDir)));
+        function trace(message) {
+            context.program.trace("http-server-csharp", `hscs-msg: ${message}`);
+        }
+        trace(`Your project was successfully created at "${projectDir}"`);
+        trace(`You can build and start the project using 'dotnet run --project "${projectDir}"'`);
+        if (options["use-swaggerui"] === true && httpsPort) {
+            trace(`You can browse the swagger UI to test your service using 'start https://localhost:${httpsPort}/swagger/' `);
+        }
         if (options["skip-format"] === undefined || options["skip-format"] === false) {
             await execFile("dotnet", [
                 "format",
                 "whitespace",
-                emitter.getOptions().emitterOutputDir,
+                outputDir,
                 "--include-generated",
                 "--folder",
             ]);