@azure-tools/typespec-rust 0.36.0 → 0.37.0

package/dist/src/tcgcadapter/adapter.js

@@ -2,15 +2,15 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
-// cspell: ignore addl requiredness responseheader subclients lropaging
+// cspell: ignore addl clientgenerator requiredness resourcemanager responseheader subclients lropaging
 import * as tsp from '@typespec/compiler';
+import * as http from '@typespec/http';
 import * as helpers from './helpers.js';
 import * as naming from './naming.js';
 import * as utils from '../utils/utils.js';
 import * as tcgc from '@azure-tools/typespec-client-generator-core';
 import * as rust from '../codemodel/index.js';
 import { FinalStateValue } from "@azure-tools/typespec-azure-core";
-import { NoTarget } from "@typespec/compiler";
 /**
  * AdapterError is thrown when the emitter fails to convert part of the tcgc code
  * model to the emitter code model. this could be due to the emitter not supporting
@@ -58,11 +58,32 @@ export class Adapter {
         return new Adapter(ctx, context.options);
     }
     constructor(ctx, options) {
+        this.rootNamespace = '';
         this.types = new Map();
         this.clientMethodParams = new Map();
         this.fieldsMap = new Map();
         this.ctx = ctx;
         this.options = options;
+        // this and adjacent code was taken from
+        // https://github.com/microsoft/typespec/blob/c0f464728f60fe3672204dd7f2907ea4c047dfcb/packages/http-client-python/emitter/src/utils.ts#L274
+        if (this.ctx.sdkPackage.clients.length > 0) {
+            this.rootNamespace = this.ctx.sdkPackage.clients[0].namespace;
+        }
+        else if (this.ctx.sdkPackage.models.length > 0) {
+            const result = this.ctx.sdkPackage.models
+                .map((model) => model.namespace)
+                .filter((namespace) => !isLibNamespace(namespace));
+            if (result.length > 0) {
+                result.sort();
+                this.rootNamespace = result[0];
+            }
+        }
+        else if (this.ctx.sdkPackage.namespaces.length > 0) {
+            this.rootNamespace = this.ctx.sdkPackage.namespaces[0].fullName;
+        }
+        if (this.rootNamespace === '') {
+            throw new AdapterError('UnsupportedTsp', 'unable to determine root namespace');
+        }
         let serviceType = 'data-plane';
         if (this.ctx.arm === true) {
             serviceType = 'azure-arm';
@@ -70,17 +91,9 @@ export class Adapter {
         this.crate = new rust.Crate(this.options['crate-name'], this.options['crate-version'], serviceType);
     }
     /** performs all the steps to convert tcgc to a crate */
-    tcgcToCrate(context) {
-        this.adaptTypes(context);
+    tcgcToCrate() {
+        this.adaptTypes();
         this.adaptClients();
-        // marker models don't require serde so exclude them from the check
-        if (this.crate.enums.length > 0 || this.crate.models.some(e => e.kind === 'model')) {
-            this.crate.addDependency(new rust.CrateDependency('serde'));
-        }
-        if (this.crate.clients.length > 0 || this.crate.enums.length > 0 || this.crate.models.length > 0 || this.crate.unions.length > 0) {
-            this.crate.addDependency(new rust.CrateDependency('azure_core'));
-        }
-        this.crate.sortContent();
         return this.crate;
     }
     /** converts tcgc docs to formatted rust.Docs */
@@ -96,21 +109,78 @@ export class Adapter {
             description: doc,
         };
     }
+    /**
+     * adapts the specified namespace to a hierarchy of Rust modules
+     *
+     * @param namespace the namespace for which to return the package
+     * @returns the leaf module in the namespace
+     */
+    adaptNamespace(namespace) {
+        // some example namespaces
+        //   foo
+        //   foo.bar
+        //   foo.bar.baz
+        //
+        // if the namespace is empty or it's not under the root namespace or the
+        // root's parent namespace then it belongs to a core library, so redirect
+        // its content to the root namespace.
+        // when the root's parent IS a known library namespace (e.g. Azure.ResourceManager),
+        // sibling namespaces (like CommonTypes) also get redirected to root since they
+        // contain library types, not service types.
+        const nsLower = namespace.toLowerCase();
+        const rootLower = this.rootNamespace.toLowerCase();
+        const rootParentLower = rootLower.includes('.')
+            ? rootLower.substring(0, rootLower.lastIndexOf('.'))
+            : '';
+        const isUnderRoot = nsLower === rootLower || nsLower.startsWith(rootLower + '.');
+        const isParent = rootParentLower !== '' && nsLower === rootParentLower;
+        const isSiblingOfRoot = rootParentLower !== '' && !isUnderRoot && nsLower.startsWith(rootParentLower + '.');
+        const isParentLibrary = LIB_NAMESPACE.includes(rootParentLower);
+        if (namespace === '' || isParent || (!isUnderRoot && (!isSiblingOfRoot || isParentLibrary))) {
+            namespace = this.rootNamespace;
+        }
+        // trim off the root namespace. if the result is the empty
+        // string it means the contents goes into the crate's root.
+        // also handle sibling namespaces: if the root namespace is Foo.Bar
+        // and we encounter Foo.Baz, treat Baz as a child module by trimming
+        // the shared parent (Foo) prefix.
+        if (namespace.toLowerCase().startsWith(this.rootNamespace.toLowerCase())) {
+            namespace = namespace.substring(this.rootNamespace.length + 1);
+        }
+        else {
+            const rootParent = this.rootNamespace.includes('.')
+                ? this.rootNamespace.substring(0, this.rootNamespace.lastIndexOf('.'))
+                : '';
+            if (rootParent !== '' && namespace.toLowerCase().startsWith(rootParent.toLowerCase() + '.')) {
+                namespace = namespace.substring(rootParent.length + 1);
+            }
+        }
+        const namespaces = namespace.split('.').filter(Boolean);
+        let cur = this.crate;
+        for (const namespace of namespaces) {
+            const modName = utils.snakeCaseName(namespace);
+            let subMod = cur.subModules.find((each) => each.name === modName);
+            if (!subMod) {
+                subMod = new rust.SubModule(modName, cur);
+                cur.subModules.push(subMod);
+            }
+            cur = subMod;
+        }
+        return cur;
+    }
     /** converts all tcgc types to their Rust type equivalent */
-    adaptTypes(context) {
+    adaptTypes() {
+        let needsCoreAndSerde = false;
         for (const sdkUnion of this.ctx.sdkPackage.unions.filter(u => u.kind === 'union')) {
             if (!sdkUnion.discriminatedOptions) {
-                // When https://github.com/microsoft/typespec/issues/9749 is fixed, we can return to throwing an exception here.
-                context.program.reportDiagnostic({
-                    code: 'UnsupportedTsp',
-                    severity: 'warning',
-                    message: `Non-discriminated unions ('${sdkUnion.name}') are not supported. No type will be generated.`,
-                    target: NoTarget,
-                });
+                // getNonDiscriminatedUnion() self-registers the type into the module and caches it
+                this.getNonDiscriminatedUnion(sdkUnion);
+                needsCoreAndSerde = true;
                 continue;
             }
             const rustUnion = this.getDiscriminatedUnion(sdkUnion);
-            this.crate.unions.push(rustUnion);
+            this.adaptNamespace(sdkUnion.namespace).unions.push(rustUnion);
+            needsCoreAndSerde = true;
         }
         for (const sdkEnum of this.ctx.sdkPackage.enums) {
             if ((sdkEnum.usage & tcgc.UsageFlags.ApiVersionEnum) === tcgc.UsageFlags.ApiVersionEnum) {
@@ -123,17 +193,49 @@ export class Adapter {
             }
             else {
                 const rustEnum = this.getEnum(sdkEnum);
-                this.crate.enums.push(rustEnum);
-            }
+                this.adaptNamespace(sdkEnum.namespace).enums.push(rustEnum);
+                needsCoreAndSerde = true;
+            }
+        }
+        let terminalErrorModelNames = new Set();
+        if (this.options['emit-error-traits']) {
+            // Typespec would flag any model that is used in the error model with the Exception flag,
+            // even if that model is not directly used in any method, but is used as one of the terminal error type fields.
+            // We need to find these terminal error models, and ignore all others, because when we need to implement TryFrom trait,
+            // there is no need to implement it for every Exception model - we just need it for the terminal ones.
+            const getTerminalErrorModelNames = function (clients, visitedClientNames = new Set()) {
+                var _a;
+                const terminalErrorModelNames = new Set();
+                for (const client of clients) {
+                    if (visitedClientNames.has(client.name)) {
+                        continue;
+                    }
+                    visitedClientNames.add(client.name);
+                    for (const errorModelName of client.methods.flatMap(mt => mt.operation.exceptions).filter(e => { var _a; return ((_a = e.type) === null || _a === void 0 ? void 0 : _a.kind) === 'model'; }).map(md => md.type.name)) {
+                        terminalErrorModelNames.add(errorModelName);
+                    }
+                    for (const errorModelName of getTerminalErrorModelNames((_a = client.children) !== null && _a !== void 0 ? _a : [], visitedClientNames).values()) {
+                        terminalErrorModelNames.add(errorModelName);
+                    }
+                }
+                return terminalErrorModelNames;
+            };
+            terminalErrorModelNames = getTerminalErrorModelNames(this.ctx.sdkPackage.clients);
         }
         const processedTypes = new Set();
         for (const model of this.ctx.sdkPackage.models) {
-            if ((model.usage & tcgc.UsageFlags.Input) === 0 && (model.usage & tcgc.UsageFlags.Output) === 0 && (model.usage & tcgc.UsageFlags.Spread) === 0) {
+            if ((model.usage & (tcgc.UsageFlags.Input | tcgc.UsageFlags.Output | tcgc.UsageFlags.Spread | tcgc.UsageFlags.Exception)) === 0) {
                 // skip types without input and output usage. this will include core
                 // types unless they're explicitly referenced (e.g. a model property).
                 // we keep the models for spread params as we internally use them.
+                // We also emit exception (error) types.
+                continue;
+            }
+            // Skip the default Azure core error models.
+            if (tcgc.isAzureCoreModel(model)) {
                 continue;
             }
+            needsCoreAndSerde = true;
             // TODO: workaround for https://github.com/Azure/typespec-azure/issues/3614
             if (processedTypes.has(model.name)) {
                 continue;
@@ -144,7 +246,7 @@ export class Adapter {
             // END workaround
             if (model.discriminatedSubtypes) {
                 const rustUnion = this.getDiscriminatedUnion(model);
-                this.crate.unions.push(rustUnion);
+                this.adaptNamespace(model.namespace).unions.push(rustUnion);
                 // we don't want to add the base type to the array
                 // of models to emit as we hijack its name to be used
                 // for the associated tagged enum type.
@@ -155,9 +257,16 @@ export class Adapter {
             }
             else {
                 const rustModel = this.getModel(model);
-                this.crate.models.push(rustModel);
+                if (terminalErrorModelNames.has(model.name)) {
+                    rustModel.flags |= rust.ModelFlags.Error;
+                }
+                this.adaptNamespace(model.namespace).models.push(rustModel);
             }
         }
+        if (needsCoreAndSerde) {
+            this.crate.addDependency(new rust.CrateDependency('azure_core'));
+            this.crate.addDependency(new rust.CrateDependency('serde'));
+        }
     }
     /**
      * converts a tcgc enum to a Rust enum
@@ -195,7 +304,7 @@ export class Adapter {
             default:
                 throw new AdapterError('UnsupportedTsp', `unsupported enum underlying type ${sdkEnum.valueType.kind}`, (_a = sdkEnum.__raw) === null || _a === void 0 ? void 0 : _a.node);
         }
-        rustEnum = new rust.Enum(enumName, adaptAccessFlags(sdkEnum.access), !sdkEnum.isFixed, enumType);
+        rustEnum = new rust.Enum(enumName, adaptAccessFlags(sdkEnum.access), !sdkEnum.isFixed, enumType, this.adaptNamespace(sdkEnum.namespace));
         rustEnum.docs = this.adaptDocs(sdkEnum.summary, sdkEnum.doc);
         this.types.set(enumName, rustEnum);
         // the first pass is to detect any enum values that coalesce into duplicate entries
@@ -306,11 +415,10 @@ export class Adapter {
         }
         // include error and LRO polling types as output types
         if ((model.usage & tcgc.UsageFlags.Output) === tcgc.UsageFlags.Output ||
-            (model.usage & tcgc.UsageFlags.Exception) === tcgc.UsageFlags.Exception ||
             (model.usage & tcgc.UsageFlags.LroPolling) === tcgc.UsageFlags.LroPolling) {
             modelFlags |= rust.ModelFlags.Output;
         }
-        rustModel = new rust.Model(modelName, model.access === 'internal' ? 'pubCrate' : 'pub', modelFlags);
+        rustModel = new rust.Model(modelName, model.access === 'internal' ? 'pubCrate' : 'pub', modelFlags, this.adaptNamespace(model.namespace));
         rustModel.docs = this.adaptDocs(model.summary, model.doc);
         rustModel.xmlName = getXMLName(model.decorators);
         this.types.set(modelName, rustModel);
@@ -413,7 +521,7 @@ export class Adapter {
                 if (!discriminatorProperty) {
                     throw new AdapterError('InternalError', `failed to find discriminator field for type ${src.name}`, (_c = src.__raw) === null || _c === void 0 ? void 0 : _c.node);
                 }
-                rustUnion = new rust.DiscriminatedUnion(unionName, adaptAccessFlags(src.access), discriminatorProperty.name);
+                rustUnion = new rust.DiscriminatedUnion(unionName, adaptAccessFlags(src.access), discriminatorProperty.name, this.adaptNamespace(src.namespace));
                 if (discriminatorProperty.type.kind === 'enum' && discriminatorProperty.type.isFixed) {
                     // when the DU is a fixed enum, it means we don't fall back to the
                     // base type when the discriminator value is unknown or missing.
@@ -439,7 +547,7 @@ export class Adapter {
                     // at us when accessing src.discriminatedOptions
                     throw new AdapterError('InternalError', 'getDiscriminatedUnion called for non-discriminated union', (_e = src.__raw) === null || _e === void 0 ? void 0 : _e.node);
                 }
-                rustUnion = new rust.DiscriminatedUnion(unionName, adaptAccessFlags(src.access), src.discriminatedOptions.discriminatorPropertyName);
+                rustUnion = new rust.DiscriminatedUnion(unionName, adaptAccessFlags(src.access), src.discriminatedOptions.discriminatorPropertyName, this.adaptNamespace(src.namespace));
                 if (src.discriminatedOptions.envelopePropertyName) {
                     rustUnion.unionKind = new rust.DiscriminatedUnionEnvelope(src.discriminatedOptions.envelopePropertyName);
                 }
@@ -483,6 +591,193 @@ export class Adapter {
         var _a, _b, _c, _d, _e;
         return property.kind === 'property' ? (_d = (_b = (_a = property.serializationOptions.json) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = property.serializationOptions.xml) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : (_e = property.serializationOptions.multipart) === null || _e === void 0 ? void 0 : _e.name : undefined;
     }
+    /**
+     * converts a non-discriminated tcgc union to either a flat merged Rust Enum (union-of-enums)
+     * or a Rust UntaggedUnion (#[serde(untagged)] enum).
+     * self-registers the result in the owning module and caches it.
+     *
+     * @param src the non-discriminated tcgc union
+     * @returns a Rust Enum or UntaggedUnion
+     */
+    getNonDiscriminatedUnion(src) {
+        const unionName = src.name.length > 0
+            ? utils.deconstruct(src.name).map(each => utils.capitalize(each)).join('')
+            : this.synthesizeUnionName(src);
+        const keyName = `non-discriminated-union-${unionName}`;
+        const cached = this.types.get(keyName);
+        if (cached) {
+            return cached;
+        }
+        const result = src.variantTypes.every(v => v.kind === 'enum')
+            ? this.getMergedFlatEnum(unionName, src)
+            : this.buildUntaggedUnion(unionName, src);
+        this.types.set(keyName, result);
+        const mod = this.adaptNamespace(src.namespace);
+        if (result.kind === 'enum') {
+            mod.enums.push(result);
+        }
+        else {
+            mod.unions.push(result);
+        }
+        return result;
+    }
+    /**
+     * synthesizes a union name for anonymous inline unions by concatenating variant type names
+     *
+     * @param src the non-discriminated tcgc union
+     * @returns a PascalCase name for the union
+     */
+    synthesizeUnionName(src) {
+        return src.variantTypes
+            .map(v => {
+            switch (v.kind) {
+                case 'model':
+                case 'enum':
+                    return utils.deconstruct(v.name).map(each => utils.capitalize(each)).join('');
+                case 'string':
+                    return 'String';
+                case 'boolean':
+                    return 'Boolean';
+                case 'int32':
+                    return 'Int32';
+                case 'int64':
+                    return 'Int64';
+                case 'float32':
+                    return 'Float32';
+                case 'float64':
+                    return 'Float64';
+                case 'array':
+                    return 'Array';
+                default:
+                    return 'Value';
+            }
+        })
+            .join('');
+    }
+    /**
+     * builds a flat merged Rust Enum from a union whose every variant is a TSP enum type.
+     * all variant enum values are merged into a single flat enum.
+     *
+     * @param unionName the PascalCase name for the resulting enum
+     * @param src the non-discriminated tcgc union
+     * @returns a flat merged Rust Enum
+     */
+    getMergedFlatEnum(unionName, src) {
+        const rustEnum = new rust.Enum(unionName, adaptAccessFlags(src.access), false, 'String', this.adaptNamespace(src.namespace));
+        rustEnum.docs = this.adaptDocs(src.summary, src.doc);
+        this.types.set(unionName, rustEnum);
+        for (const variant of src.variantTypes) {
+            const sdkEnum = variant;
+            for (const value of sdkEnum.values) {
+                const valueName = naming.fixUpEnumValueName(value);
+                if (!rustEnum.values.some(v => v.name === valueName)) {
+                    const rv = new rust.EnumValue(valueName, rustEnum, value.value);
+                    rv.docs = this.adaptDocs(value.summary, value.doc);
+                    rustEnum.values.push(rv);
+                }
+            }
+        }
+        return rustEnum;
+    }
+    /**
+     * builds an UntaggedUnion (#[serde(untagged)] enum) from a non-discriminated tcgc union
+     * whose variants are not all enum types.
+     *
+     * @param unionName the PascalCase name for the resulting union
+     * @param src the non-discriminated tcgc union
+     * @returns a Rust UntaggedUnion
+     */
+    buildUntaggedUnion(unionName, src) {
+        const mod = this.adaptNamespace(src.namespace);
+        const rustUnion = new rust.UntaggedUnion(unionName, adaptAccessFlags(src.access), mod);
+        rustUnion.docs = this.adaptDocs(src.summary, src.doc);
+        // sort variants for correct serde untagged disambiguation:
+        // bool(0) < int(1) < float(2) < enum(3) < string(4) < array(5) < model(6)
+        const sorted = [...src.variantTypes].sort((a, b) => this.getUntaggedVariantOrder(a) - this.getUntaggedVariantOrder(b));
+        for (const variant of sorted) {
+            const variantName = this.getUntaggedVariantName(variant);
+            const variantType = this.typeToWireType(this.getType(variant));
+            const rv = new rust.UntaggedUnionVariant(variantName, variantType);
+            rustUnion.variants.push(rv);
+        }
+        return rustUnion;
+    }
+    /**
+     * returns the sort order for a variant in a #[serde(untagged)] enum.
+     * more specific types must come before more general ones to ensure correct deserialization.
+     *
+     * @param variant the tcgc type to get the order for
+     * @returns a numeric sort key (lower = earlier)
+     */
+    getUntaggedVariantOrder(variant) {
+        switch (variant.kind) {
+            case 'boolean':
+                return 0;
+            case 'constant':
+                return this.getUntaggedVariantOrder(variant.valueType);
+            case 'int8':
+            case 'int16':
+            case 'int32':
+            case 'int64':
+            case 'safeint':
+                return 1;
+            case 'float':
+            case 'float32':
+            case 'float64':
+                return 2;
+            case 'enum':
+                return 3;
+            case 'string':
+                return 4;
+            case 'array':
+                return 5;
+            case 'model':
+                return 6;
+            default:
+                return 7;
+        }
+    }
+    /**
+     * returns the Rust variant name (PascalCase) for a variant in a #[serde(untagged)] enum.
+     *
+     * @param variant the tcgc type to name
+     * @returns a PascalCase Rust variant name
+     */
+    getUntaggedVariantName(variant) {
+        switch (variant.kind) {
+            case 'model':
+                return utils.deconstruct(variant.name).map(each => utils.capitalize(each)).join('');
+            case 'enum':
+                return utils.deconstruct(variant.name).map(each => utils.capitalize(each)).join('');
+            case 'boolean':
+                return 'Boolean';
+            case 'int8':
+                return 'Int8';
+            case 'int16':
+                return 'Int16';
+            case 'int32':
+                return 'Int32';
+            case 'int64':
+                return 'Int64';
+            case 'safeint':
+                return 'SafeInt';
+            case 'float':
+            case 'float32':
+                return 'Float32';
+            case 'float64':
+                return 'Float64';
+            case 'string':
+                return 'String';
+            case 'constant':
+                return this.getUntaggedVariantName(variant.valueType);
+            case 'array': {
+                const elemName = this.getUntaggedVariantName(variant.valueType);
+                return `${elemName}Array`;
+            }
+            default:
+                return 'Value';
+        }
+    }
     /**
      * converts a tcgc model property to a model field
      *
@@ -495,7 +790,7 @@ export class Adapter {
     getModelField(modelFlags, property, modelVisibility, stack) {
         var _a, _b, _c, _d, _e;
         const fieldNeedsBoxing = function (fieldType) {
-            if (fieldType.kind === 'model' && stack.includes(fieldType)) {
+            if (fieldType.kind === 'model' && (stack.includes(fieldType))) {
                 // if the field's type is a model and it's in the type stack then
                 // box it. this is to avoid infinitely recursive type definitions.
                 return true;
@@ -525,6 +820,17 @@ export class Adapter {
         const serializedName = (_a = this.getSerializedPropertyName(property)) !== null && _a !== void 0 ? _a : property.name;
         const modelField = new rust.ModelField(naming.getEscapedReservedName(utils.snakeCaseName(property.name), 'prop'), serializedName, modelVisibility, fieldType, property.optional);
         modelField.docs = this.adaptDocs(property.summary, property.doc);
+        // append visibility info as a doc comment when visibility is restricted
+        const visibilityStr = formatVisibility(property.visibility);
+        if (visibilityStr) {
+            if (!modelField.docs.description) {
+                modelField.docs.description = '';
+            }
+            else {
+                modelField.docs.description += '\n\n';
+            }
+            modelField.docs.description += `Operational visibility: ${visibilityStr}`;
+        }
         // if this is a literal, add a doc comment explaining its behavior
         const unwrappedType = utils.unwrapOption(fieldType);
         if (unwrappedType.kind === 'enumValue' || unwrappedType.kind === 'literal') {
@@ -600,7 +906,7 @@ export class Adapter {
      * @returns the adapted Rust type
      */
     getType(type, stack) {
-        var _a, _b, _c;
+        var _a, _b;
         if (type.external) {
             return this.getExternalType(type.external);
         }
@@ -682,6 +988,9 @@ export class Adapter {
                 else if (type.discriminatedSubtypes) {
                     return this.getDiscriminatedUnion(type);
                 }
+                else if (tcgc.isAzureCoreModel(type)) {
+                    return this.getExternalType({ kind: 'externalTypeInfo', identity: 'azure_core::error::ErrorDetail' });
+                }
                 return this.getModel(type, stack);
             case 'endpoint':
             case 'plainDate':
@@ -735,12 +1044,12 @@ export class Adapter {
             }
             case 'union': {
                 if (!type.discriminatedOptions) {
-                    throw new AdapterError('UnsupportedTsp', 'non-discriminated unions are not supported', (_b = type.__raw) === null || _b === void 0 ? void 0 : _b.node);
+                    return this.getNonDiscriminatedUnion(type);
                 }
                 return this.getDiscriminatedUnion(type);
             }
             default:
-                throw new AdapterError('UnsupportedTsp', `unhandled tcgc type ${type.kind}`, (_c = type.__raw) === null || _c === void 0 ? void 0 : _c.node);
+                throw new AdapterError('UnsupportedTsp', `unhandled tcgc type ${type.kind}`, (_b = type.__raw) === null || _b === void 0 ? void 0 : _b.node);
         }
     }
     /** returns a Box type */
@@ -808,11 +1117,12 @@ export class Adapter {
         return optionType;
     }
     /** returns the specified type wrapped in a Ref */
-    getRefType(type) {
-        const typeKey = recursiveKeyName('ref', type);
+    getRefType(type, lifetime) {
+        const typeKey = recursiveKeyName(`ref${lifetime ? `-${lifetime.name}` : ''}`, type);
         let refType = this.types.get(typeKey);
         if (!refType) {
             refType = new rust.Ref(type);
+            refType.lifetime = lifetime;
             this.types.set(typeKey, refType);
         }
         return refType;
@@ -961,8 +1271,14 @@ export class Adapter {
     }
     /** converts all tcgc clients and their methods into Rust clients/methods */
     adaptClients() {
+        let needsCore = false;
         for (const client of this.ctx.sdkPackage.clients) {
+            // start with instantiable clients and recursively work down
             this.recursiveAdaptClient(client);
+            needsCore = true;
+        }
+        if (needsCore) {
+            this.crate.addDependency(new rust.CrateDependency('azure_core'));
         }
     }
     /**
@@ -1012,7 +1328,7 @@ export class Adapter {
         if (!clientName.match(/Client$/)) {
             clientName += 'Client';
         }
-        const rustClient = new rust.Client(clientName);
+        const rustClient = new rust.Client(clientName, this.adaptNamespace(client.namespace));
         rustClient.docs = this.adaptDocs(client.summary, client.doc);
         rustClient.parent = parent;
         rustClient.fields.push(new rust.StructField('pipeline', 'pubCrate', new rust.ExternalType(this.crate, 'Pipeline', 'azure_core::http')));
@@ -1217,7 +1533,7 @@ export class Adapter {
         }
         // Set the tracing namespace for tracing based on the client's namespace
         rustClient.languageIndependentName = client.crossLanguageDefinitionId;
-        this.crate.clients.push(rustClient);
+        this.adaptNamespace(client.namespace).clients.push(rustClient);
         return rustClient;
     }
     /**
@@ -1266,7 +1582,9 @@ export class Adapter {
             paramField.docs = this.adaptDocs(param.summary, param.doc);
             constructable.options.type.fields.push(paramField);
             if (param.clientDefaultValue) {
-                paramField.defaultValue = `String::from("${param.clientDefaultValue}")`;
+                const constName = `DEFAULT_${paramName.toUpperCase()}`;
+                paramField.defaultValue = `String::from(${constName})`;
+                paramField.defaultValueConstant = { name: constName, value: param.clientDefaultValue };
             }
         }
         let adaptedParam;
@@ -1319,7 +1637,7 @@ export class Adapter {
      * @param rustClient the client to which the method belongs
      */
     adaptMethod(method, rustClient) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
         let srcMethodName = method.name;
         if (method.kind === 'paging' && !srcMethodName.match(/^list/i)) {
             const chunks = utils.deconstruct(srcMethodName);
@@ -1351,7 +1669,7 @@ export class Adapter {
         const optionsLifetime = new rust.Lifetime('a');
         const methodOptionsStruct = new rust.Struct(`${rustClient.name}${utils.pascalCase(srcMethodName, false)}Options`, pub);
         methodOptionsStruct.lifetime = optionsLifetime;
-        methodOptionsStruct.docs.summary = `Options to be passed to ${this.asDocLink(`${rustClient.name}::${methodName}()`, `crate::generated::clients::${rustClient.name}::${methodName}()`)}`;
+        methodOptionsStruct.docs.summary = `Options to be passed to ${this.asDocLink(`${rustClient.name}::${methodName}()`, `${utils.buildImportPath(rustClient.module, rustClient.module)}::clients::${rustClient.name}::${methodName}()`)}`;
         let clientMethodOptions;
         switch (method.kind) {
             case 'paging':
@@ -1367,7 +1685,7 @@ export class Adapter {
         const methodOptionsField = new rust.StructField('method_options', pub, clientMethodOptions);
         methodOptionsField.docs.summary = 'Allows customization of the method call.';
         methodOptionsStruct.fields.push(methodOptionsField);
-        const methodOptions = new rust.MethodOptions(methodOptionsStruct);
+        const methodOptions = new rust.ParameterGroup('options', new rust.Option(methodOptionsStruct));
         const httpMethod = method.operation.verb;
         let rustMethod;
         switch (method.kind) {
@@ -1418,44 +1736,21 @@ export class Adapter {
         }
         // maps tcgc method header/query params to their Rust method params
         const paramsMap = new Map();
-        for (const param of method.parameters) {
-            // we need to translate from the method param to its underlying operation param.
-            // most params have a one-to-one mapping. however, for spread params, there will
-            // be a many-to-one mapping. i.e. multiple params will map to the same underlying
-            // operation param. each param corresponds to a field within the operation param.
-            const opParam = allOpParams.find((opParam) => {
-                return opParam.methodParameterSegments.map((segment) => segment[segment.length - 1]).some((methodParam) => {
-                    return methodParam.name === param.name;
-                });
-            });
-            if (!opParam) {
-                throw new AdapterError('InternalError', `didn't find operation parameter for method ${method.name} parameter ${param.name}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
-            }
-            if (opParam.kind === 'header' && opParam.serializedName.toLowerCase() === 'x-ms-client-request-id') {
-                // x-ms-client-request-id is automatically inserted into requests via
-                // a pipeline policy. so we don't want to expose this as an actual param.
-                continue;
-            }
-            let adaptedParam;
-            // for spread params there are two cases we need to consider.
-            // if the method param's type doesn't match the op param's type then it's a spread param
-            // - e.g. method param's type is string/int/etc which is a field in the op param's body type
-            // if the method param's type DOES match the op param's type and the op param has multiple corresponding method params, it's a spread param
-            // - e.g. op param is an intersection of multiple model types, and each model type is exposed as a discrete param
-            if (opParam.kind === 'body' && opParam.type.kind === 'model'
-                && (opParam.type.kind !== param.type.kind || opParam.methodParameterSegments.map((segment) => segment[segment.length - 1]).length > 1)) {
-                adaptedParam = this.adaptMethodSpreadParameter(param, this.adaptPayloadFormat(opParam.defaultContentType), opParam.type);
-            }
-            else {
-                adaptedParam = this.adaptMethodParameter(opParam, param);
-            }
+        /** returns true if the op param should be omitted */
+        const skipOpParam = function (opParam) {
+            // x-ms-client-request-id is automatically inserted into requests via
+            // a pipeline policy. so we don't want to expose this as an actual param.
+            return opParam.kind === 'header' && opParam.serializedName.toLowerCase() === 'x-ms-client-request-id';
+        };
+        /** adds adapted params to the method's param list and optional params to method options */
+        const processAdaptedParam = (adaptedParam, methodParam) => {
             switch (adaptedParam.kind) {
                 case 'headerScalar':
                 case 'queryScalar':
-                    paramsMap.set(param, adaptedParam);
+                    paramsMap.set(methodParam, adaptedParam);
                     break;
             }
-            adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
+            adaptedParam.docs = this.adaptDocs(methodParam.summary, methodParam.doc);
             rustMethod.params.push(adaptedParam);
             // we specially handle an optional content-type header to ensure it's omitted
             // from the options bag type. this shows up when the request body is optional.
@@ -1467,9 +1762,9 @@ export class Adapter {
                     // sent in the request. we want the field within the model for this param.
                     // NOTE: if the param is optional then the field is optional, thus it's
                     // already wrapped in an Option<T> type.
-                    const field = adaptedParam.type.content.type.fields.find(f => { return f.name === adaptedParam.name; });
+                    const field = adaptedParam.type.content.fields.find(f => { return f.name === adaptedParam.name; });
                     if (!field) {
-                        throw new AdapterError('InternalError', `didn't find spread param field ${adaptedParam.name} in type ${adaptedParam.type.content.type.name}`);
+                        throw new AdapterError('InternalError', `didn't find spread param field ${adaptedParam.name} in type ${adaptedParam.type.content.name}`);
                     }
                     fieldType = field.type;
                 }
@@ -1478,7 +1773,124 @@ export class Adapter {
                 }
                 const optionsField = new rust.StructField(adaptedParam.name, pub, fieldType);
                 optionsField.docs = adaptedParam.docs;
-                rustMethod.options.type.fields.push(optionsField);
+                rustMethod.options.type.type.fields.push(optionsField);
+            }
+        };
+        for (const param of method.parameters) {
+            // we need to translate from the method param to its underlying operation param.
+            // most params have a one-to-one mapping. however, for spread params, there will
+            // be a many-to-one mapping. i.e. multiple params will map to the same underlying
+            // operation param. each param corresponds to a field within the operation param.
+            // there are three distinct cases
+            //   - one-to-one mapping (header param -> header op param)
+            //   - many-to-one mapping (spread params, multiple params map to one op param)
+            //   - one-to-many mapping (grouped params, one param maps to multiple op params)
+            // two-phase filter: first try strict match on the last segment element (cases 1 and 2).
+            // if no matches, try matching the first segment element (case 3: parameter group from @@override).
+            // this avoids false case-3 matches when a body model has fields extracted as HTTP params
+            // (e.g. @query fields), where segment[0] is the body param name but it's not a parameter group.
+            let opParams = allOpParams.filter((opParam) => {
+                return opParam.methodParameterSegments.some((segment) => segment[segment.length - 1].name === param.name);
+            });
+            if (opParams.length === 0) {
+                opParams = allOpParams.filter((opParam) => {
+                    return opParam.methodParameterSegments.some((segment) => segment[0].name === param.name);
+                });
+            }
+            let adaptedParam;
+            if (opParams.length === 1) {
+                // case 1 or 2
+                const opParam = opParams[0];
+                if (skipOpParam(opParam)) {
+                    continue;
+                }
+                // for spread params there are two cases we need to consider.
+                // if the method param's type doesn't match the op param's type then it's a spread param
+                // - e.g. method param's type is string/int/etc which is a field in the op param's body type
+                // if the method param's type DOES match the op param's type and the op param has multiple corresponding method params, it's a spread param
+                // - e.g. op param is an intersection of multiple model types, and each model type is exposed as a discrete param
+                if (opParam.kind === 'body' && opParam.type.kind === 'model'
+                    && (opParam.type !== param.type || opParam.methodParameterSegments.map((segment) => segment[segment.length - 1]).length > 1)) {
+                    adaptedParam = this.adaptMethodSpreadParameter(param, this.getPayloadFormatType(opParam.type, opParam.defaultContentType), opParam.type);
+                }
+                else {
+                    adaptedParam = this.adaptMethodParameter(opParam, param);
+                }
+                processAdaptedParam(adaptedParam, param);
+            }
+            else if (opParams.length > 1) {
+                // case 3 (param group)
+                // Parameter group handling:
+                //   - required params stay in the named parameter group
+                //   - optional params are moved to the method's options type
+                //   - if no required params remain, the param group evaporates
+                let paramGroup;
+                const groupedParams = new Array();
+                const lifetime = new rust.Lifetime('a');
+                let hasRefs = false;
+                for (const opParam of opParams) {
+                    if (skipOpParam(opParam)) {
+                        continue;
+                    }
+                    // for grouped params, the segment is [groupMethodParam, fieldProp].
+                    // we need the field property to get the correct type for this specific
+                    // operation parameter (the opParam's own type might be the group model type).
+                    const fieldProp = opParam.methodParameterSegments
+                        .flatMap((segment) => segment.length > 1 ? [segment[segment.length - 1]] : [])
+                        .find((prop) => prop.name === opParam.name);
+                    // pass fieldProp as methodParam so adaptMethodParameter uses the field's type.
+                    // cast is safe as we only need .type, .optional, .summary, .doc from it.
+                    const groupedParam = this.adaptMethodParameter(opParam, fieldProp, lifetime);
+                    const fieldOptional = fieldProp ? fieldProp.optional : opParam.optional;
+                    if (!fieldOptional) {
+                        if (!paramGroup) {
+                            if (param.type.kind !== 'model') {
+                                throw new AdapterError('InternalError', `expected model type for parameter group but got ${param.type.kind}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
+                            }
+                            const groupName = utils.capitalize(param.type.name).replace(/\W/g, '');
+                            const paramName = naming.getEscapedReservedName(utils.snakeCaseName(param.name), 'param', reservedParams);
+                            // param group's visibility is tied to its matching method
+                            const groupStruct = new rust.Struct(groupName, rustMethod.visibility);
+                            groupStruct.docs = this.adaptDocs(param.type.summary, param.type.doc);
+                            paramGroup = new rust.ParameterGroup(paramName, groupStruct);
+                            paramGroup.docs = this.adaptDocs(param.summary, param.doc);
+                        }
+                        groupedParam.docs = this.adaptDocs(opParam.summary, opParam.doc);
+                        groupedParams.push(groupedParam);
+                        groupedParam.group = paramGroup;
+                        if (groupedParam.type.kind === 'ref') {
+                            hasRefs = true;
+                        }
+                    }
+                    else {
+                        // optional params within a group are moved to the method's options type
+                        processAdaptedParam(groupedParam, param);
+                    }
+                }
+                if (paramGroup) {
+                    if (hasRefs) {
+                        paramGroup.type.lifetime = lifetime;
+                    }
+                    // push each grouped param individually; they already have .group set
+                    for (const gp of groupedParams) {
+                        rustMethod.params.push(gp);
+                    }
+                    // remove the group's model type from the module's models list.
+                    // the parameter group struct will be emitted by the client codegen
+                    // in method_options.rs. leaving the model in models.rs would create
+                    // a duplicate struct definition with incompatible field types.
+                    if (param.type.kind === 'model') {
+                        const groupModelName = utils.capitalize(param.type.name).replace(/\W/g, '');
+                        const ns = this.adaptNamespace(param.type.namespace);
+                        const idx = ns.models.findIndex(m => m.kind === 'model' && m.name === groupModelName);
+                        if (idx >= 0) {
+                            ns.models.splice(idx, 1);
+                        }
+                    }
+                }
+            }
+            else {
+                throw new AdapterError('InternalError', `didn't find operation parameter for method ${method.name} parameter ${param.name}`, (_g = param.__raw) === null || _g === void 0 ? void 0 : _g.node);
             }
         }
         // client params aren't included in method.parameters so
@@ -1494,6 +1906,7 @@ export class Adapter {
             var _a;
             // fetch the body format from the HTTP responses.
             // they should all have the same type so no need to match responses to type.
+            let responseType;
             let defaultContentType;
             for (const httpResp of method.operation.responses) {
                 if (!httpResp.defaultContentType) {
@@ -1505,11 +1918,12 @@ export class Adapter {
                     throw new AdapterError('InternalError', `method ${method.name} has conflicting content types`, (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node);
                 }
                 defaultContentType = httpResp.defaultContentType;
+                responseType = httpResp.type;
             }
             if (!defaultContentType) {
                 return 'NoFormat';
             }
-            return this.adaptPayloadFormatType(defaultContentType);
+            return this.getPayloadFormatType(responseType, defaultContentType);
         };
         const getStatusCodes = function (httpOp) {
             const statusCodes = new Array();
@@ -1558,25 +1972,26 @@ export class Adapter {
         }
         const responseFormat = getResponseFormat();
         if (method.kind === 'paging') {
-            if (responseFormat === 'NoFormat') {
-                throw new AdapterError('InternalError', `paged method ${method.name} unexpected response format ${responseFormat}`, (_g = method.__raw) === null || _g === void 0 ? void 0 : _g.node);
+            if (responseFormat !== 'JsonFormat' && responseFormat !== 'XmlFormat') {
+                throw new AdapterError('InternalError', `paged method ${method.name} unexpected response format ${responseFormat}`, (_h = method.__raw) === null || _h === void 0 ? void 0 : _h.node);
             }
             // for paged methods, tcgc models method.response.type as an Array<T>.
             // however, we want the synthesized paged response envelope type instead.
             const synthesizedType = method.operation.responses[0].type;
             if (!synthesizedType) {
-                throw new AdapterError('InternalError', `paged method ${method.name} has no synthesized response type`, (_h = method.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} has no synthesized response type`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
             }
             else if (synthesizedType.kind !== 'model') {
-                throw new AdapterError('UnsupportedTsp', `paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
+                throw new AdapterError('UnsupportedTsp', `paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`, (_k = method.__raw) === null || _k === void 0 ? void 0 : _k.node);
             }
             const synthesizedModel = this.getModel(synthesizedType, new Array());
-            if (!this.crate.models.includes(synthesizedModel)) {
-                this.crate.models.push(synthesizedModel);
+            const modelNs = this.adaptNamespace(synthesizedType.namespace);
+            if (!modelNs.models.includes(synthesizedModel)) {
+                modelNs.models.push(synthesizedModel);
             }
             // for the pager response type, remove the Option<T> around the Vec<T> for the page items
             if (!method.pagingMetadata.pageItemsSegments) {
-                throw new AdapterError('InternalError', `paged method ${method.name} has no pageItemsSegments`, (_k = method.__raw) === null || _k === void 0 ? void 0 : _k.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} has no pageItemsSegments`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
             }
             // unwrap all of the segments for the paged response
             let unwrappedCount = 0;
@@ -1587,13 +2002,13 @@ export class Adapter {
                 switch (responseFormat) {
                     case 'JsonFormat':
                         if (segment.kind !== 'property' || !segment.serializationOptions.json) {
-                            throw new AdapterError('InternalError', `paged method ${method.name} is missing JSON serialization data`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
+                            throw new AdapterError('InternalError', `paged method ${method.name} is missing JSON serialization data`, (_m = method.__raw) === null || _m === void 0 ? void 0 : _m.node);
                         }
                         serde = segment.serializationOptions.json.name;
                         break;
                     case 'XmlFormat':
                         if (segment.kind !== 'property' || !segment.serializationOptions.xml) {
-                            throw new AdapterError('InternalError', `paged method ${method.name} is missing XML serialization data`, (_m = method.__raw) === null || _m === void 0 ? void 0 : _m.node);
+                            throw new AdapterError('InternalError', `paged method ${method.name} is missing XML serialization data`, (_o = method.__raw) === null || _o === void 0 ? void 0 : _o.node);
                         }
                         serde = segment.serializationOptions.xml.name;
                         break;
@@ -1619,45 +2034,55 @@ export class Adapter {
                 }
             }
             if (unwrappedCount !== method.pagingMetadata.pageItemsSegments.length) {
-                throw new AdapterError('InternalError', `failed to unwrap paged items for method ${method.name}`, (_o = method.__raw) === null || _o === void 0 ? void 0 : _o.node);
+                throw new AdapterError('InternalError', `failed to unwrap paged items for method ${method.name}`, (_p = method.__raw) === null || _p === void 0 ? void 0 : _p.node);
             }
             this.crate.addDependency(new rust.CrateDependency('async-trait'));
             // default to nextLink. will update it as required when we have that info
             rustMethod.returns = new rust.Result(this.crate, new rust.Pager(this.crate, new rust.Response(this.crate, synthesizedModel, responseFormat), 'nextLink'));
         }
         else if (method.kind === 'lro') {
-            const format = responseFormat === 'NoFormat' ? 'JsonFormat' : responseFormat;
-            const statusType = this.typeToWireType(this.getModel(method.lroMetadata.pollingInfo.responseModel, undefined, `${rustClient.name}${utils.pascalCase(rustMethod.name, false)}OperationStatus`));
-            if (statusType.kind !== 'model') {
-                throw new AdapterError('InternalError', `status type for an LRO method '${method.name}' is not a model`, (_p = method.__raw) === null || _p === void 0 ? void 0 : _p.node);
-            }
-            const pushModels = (model, crate) => {
-                if (crate.models.some(m => m === model)) {
+            const pushModels = (tcgcType, container, rustType = this.getType(tcgcType), ignoreAzureCoreModels = true) => {
+                switch (tcgcType.kind) {
+                    case 'array':
+                        pushModels(tcgcType.valueType, container);
+                        return;
+                    case 'model':
+                        if (ignoreAzureCoreModels && tcgc.isAzureCoreModel(tcgcType)) {
+                            return;
+                        }
+                        break;
+                    default:
+                        return;
+                }
+                if (rustType.kind !== 'model' || container.models.some(m => m === rustType) || rustType.module !== rustClient.module) {
+                    // model already exists or belongs to a different module, do nothing
                     return;
                 }
-                crate.models.push(model);
-                for (const field of model.fields) {
-                    let fieldType = field.type;
-                    fieldType = fieldType.kind === 'option' ? fieldType.type : fieldType;
-                    fieldType = fieldType.kind === 'Vec' ? fieldType.type : fieldType;
-                    if (fieldType.kind === 'model') {
-                        pushModels(fieldType, crate);
-                    }
+                container.models.push(rustType);
+                for (const tcgcField of tcgcType.properties) {
+                    pushModels(tcgcField.type, container);
                 }
             };
-            pushModels(statusType, this.crate);
+            const format = responseFormat === 'JsonFormat' || responseFormat === 'XmlFormat' ? responseFormat : 'JsonFormat';
+            const statusModel = this.getModel(method.lroMetadata.pollingInfo.responseModel, undefined, `${rustClient.name}${utils.pascalCase(rustMethod.name, false)}OperationStatus`);
+            const statusType = this.typeToWireType(statusModel);
+            if (statusType.kind !== 'model') {
+                throw new AdapterError('InternalError', `status type for an LRO method '${method.name}' is not a model`, (_q = method.__raw) === null || _q === void 0 ? void 0 : _q.node);
+            }
+            // the adapted type likely comes from core which means
+            // it will be in the root namespace.  since we emit these
+            // per client.operation, set the correct module
+            statusType.module = rustClient.module;
+            pushModels(method.lroMetadata.pollingInfo.responseModel, rustClient.module, statusModel, false);
             const poller = new rust.Poller(this.crate, new rust.Response(this.crate, statusType, format));
-            if (((_q = method.response.type) === null || _q === void 0 ? void 0 : _q.kind) === "model") {
-                const responseType = this.typeToWireType(this.getModel(method.response.type));
-                if (responseType.kind !== 'model') {
-                    throw new AdapterError('InternalError', `response type for an LRO method '${method.name}' is not a model`, (_r = method.__raw) === null || _r === void 0 ? void 0 : _r.node);
-                }
-                pushModels(responseType, this.crate);
-                poller.resultType = new rust.Response(this.crate, responseType, format);
+            if (method.response.type) {
+                const resultType = this.getType(method.response.type);
+                pushModels(method.response.type, rustClient.module, resultType);
+                poller.resultType = new rust.Response(this.crate, this.typeToWireType(resultType), format);
             }
             rustMethod.returns = new rust.Result(this.crate, poller);
         }
-        else if (method.response.type && !(method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes')) {
+        else if (method.response.type && responseFormat !== 'BinaryFormat') {
             const response = new rust.Response(this.crate, this.typeToWireType(this.getType(method.response.type)), responseFormat);
             rustMethod.returns = new rust.Result(this.crate, response);
         }
@@ -1666,9 +2091,9 @@ export class Adapter {
             // we need to return a marker type
             const markerType = new rust.MarkerType(`${rustClient.name}${utils.pascalCase(method.name, false)}Result`, rustMethod.visibility);
             markerType.docs.summary = `Contains results for ${this.asDocLink(`${rustClient.name}::${methodName}()`, `crate::generated::clients::${rustClient.name}::${methodName}()`)}`;
-            this.crate.models.push(markerType);
+            rustClient.module.models.push(markerType);
             let resultType;
-            if (method.response.type && method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes') {
+            if (responseFormat === 'BinaryFormat') {
                 // method returns a streaming binary response with headers
                 resultType = new rust.AsyncResponse(this.crate, markerType);
             }
@@ -1677,8 +2102,8 @@ export class Adapter {
             }
             rustMethod.returns = new rust.Result(this.crate, resultType);
         }
-        else if (method.response.type && method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes') {
-            // bytes encoding indicates a streaming binary response
+        else if (responseFormat === 'BinaryFormat') {
+            // binary format indicates a streaming binary response
             rustMethod.returns = new rust.Result(this.crate, new rust.AsyncResponse(this.crate, this.getUnitType()));
         }
         else {
@@ -1699,13 +2124,13 @@ export class Adapter {
             // can't do this until the method has been completely adapted
             const pageableMethod = rustMethod;
             pageableMethod.strategy = this.adaptPageableMethodStrategy(method, paramsMap, responseHeadersMap);
-            if (((_s = pageableMethod.strategy) === null || _s === void 0 ? void 0 : _s.kind) === 'nextLink') {
+            if (((_r = pageableMethod.strategy) === null || _r === void 0 ? void 0 : _r.kind) === 'nextLink') {
                 pageableMethod.strategy.reinjectedParams = this.adaptPageableMethodReinjectionParams(method, paramsMap);
             }
-            else if (((_t = pageableMethod.strategy) === null || _t === void 0 ? void 0 : _t.kind) === 'continuationToken') {
+            else if (((_s = pageableMethod.strategy) === null || _s === void 0 ? void 0 : _s.kind) === 'continuationToken') {
                 // set the continuation type to token on the Pager and the PagerOptions field in the method options
                 pageableMethod.returns.type.continuation = 'token';
-                for (const field of pageableMethod.options.type.fields) {
+                for (const field of pageableMethod.options.type.type.fields) {
                     if (field.type.kind === 'pagerOptions') {
                         field.type.continuation = 'token';
                     }
@@ -1812,7 +2237,7 @@ export class Adapter {
         const traitName = `${recursiveTypeName(implFor.kind === 'asyncResponse' ? implFor.type : implFor.content)}Headers`;
         // NOTE: the complete doc text will be emitted at codegen time
         const docs = this.asDocLink(`${client.name}::${method.name}()`, `crate::generated::clients::${client.name}::${method.name}()`);
-        const responseHeadersTrait = new rust.ResponseHeadersTrait(traitName, implFor, docs, method.visibility);
+        const responseHeadersTrait = new rust.ResponseHeadersTrait(traitName, implFor, docs, method.visibility, client.module);
         responseHeadersTrait.headers.push(...responseHeaders);
         return responseHeadersTrait;
     }
@@ -1940,9 +2365,10 @@ export class Adapter {
      *
      * @param opParam the tcgc operation parameter to convert
      * @param methodParam the tcgc method parameter associated with opParam
+     * @param lifetime optional lifetime to stamp on borrowed ref types (used for grouped params that are struct fields)
      * @returns a Rust method parameter
      */
-    adaptMethodParameter(opParam, methodParam) {
+    adaptMethodParameter(opParam, methodParam, lifetime) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         /**
          * used to create keys for this.clientMethodParams
@@ -1976,9 +2402,9 @@ export class Adapter {
         const paramName = naming.getEscapedReservedName(utils.snakeCaseName(getCorrespondingClientParamName(opParam)), 'param', reservedParams);
         const paramOptional = methodParam ? methodParam.optional : opParam.optional;
         let paramType = this.getType(methodParam ? methodParam.type : opParam.type);
-        // for required header/path/query method string params, we might emit them as borrowed types
+        // for required header/path/query method string params, we might emit them as borrowed types.
         if (!paramOptional && paramLoc !== 'client' && (opParam.kind === 'header' || opParam.kind === 'path' || opParam.kind === 'query')) {
-            const borrowedType = this.canBorrowMethodParam(paramType, opParam.kind);
+            const borrowedType = this.canBorrowMethodParam(paramType, opParam.kind, lifetime);
             if (borrowedType) {
                 paramType = borrowedType;
             }
@@ -1987,15 +2413,17 @@ export class Adapter {
         switch (opParam.kind) {
             case 'body': {
                 let requestType;
-                if (opParam.type.kind === 'bytes' && opParam.type.encode === 'bytes') {
-                    // bytes encoding indicates a streaming binary request
+                const requestFormatType = this.getPayloadFormatType(opParam.type, opParam.defaultContentType);
+                if (requestFormatType === 'BinaryFormat') {
+                    // binary format indicates a streaming binary request
                     requestType = new rust.Bytes(this.crate);
                 }
                 else {
-                    requestType = new rust.Payload(this.typeToWireType(paramType), this.adaptPayloadFormat(opParam.defaultContentType));
+                    requestType = this.typeToWireType(paramType);
                 }
-                const requestFormatType = this.adaptPayloadFormatType(opParam.defaultContentType);
-                adaptedParam = new rust.BodyParameter(paramName, paramLoc, paramOptional, new rust.RequestContent(this.crate, requestType, requestFormatType));
+                // binary payloads use NoFormat as the body is sent as raw bytes
+                const wireFormat = requestFormatType === 'BinaryFormat' ? 'NoFormat' : requestFormatType;
+                adaptedParam = new rust.BodyParameter(paramName, paramLoc, paramOptional, new rust.RequestContent(this.crate, requestType, wireFormat));
                 break;
             }
             case 'cookie':
@@ -2115,17 +2543,18 @@ export class Adapter {
      *
      * @param type the param type to be updated
      * @param kind the kind of param
+     * @param lifetime optional lifetime to stamp on Ref types (used for struct fields)
      * @returns the updated param type or undefined
      */
-    canBorrowMethodParam(type, kind) {
+    canBorrowMethodParam(type, kind, lifetime) {
         const recursiveBuildVecStr = (v) => {
             switch (v.kind) {
                 case 'encodedBytes':
-                    return this.getRefType(this.getEncodedBytes(v.encoding, true));
+                    return this.getRefType(this.getEncodedBytes(v.encoding, true), lifetime);
                 case 'hashmap':
                     return this.getHashMap(this.typeToWireType(recursiveBuildVecStr(v.type)));
                 case 'String':
-                    return this.getRefType(this.getStringSlice());
+                    return this.getRefType(this.getStringSlice(), lifetime);
                 case 'Vec':
                     return this.getVec(this.typeToWireType(recursiveBuildVecStr(v.type)));
                 default:
@@ -2142,19 +2571,19 @@ export class Adapter {
             case 'String':
                 // header String params are always owned
                 if (kind !== 'header') {
-                    return this.getRefType(this.getStringSlice());
+                    return this.getRefType(this.getStringSlice(), lifetime);
                 }
                 break;
             case 'Vec': {
                 // if this is an array of string, we ultimately want a slice of &str
                 const unwrapped = recursiveUnwrapVec(type);
                 if (unwrapped.kind === 'String' || unwrapped.kind === 'encodedBytes') {
-                    return this.getRefType(this.getSlice(recursiveBuildVecStr(type.type)));
+                    return this.getRefType(this.getSlice(recursiveBuildVecStr(type.type)), lifetime);
                 }
-                return this.getRefType(this.getSlice(type.type));
+                return this.getRefType(this.getSlice(type.type), lifetime);
             }
             case 'encodedBytes':
-                return this.getRefType(this.getEncodedBytes(type.encoding, true));
+                return this.getRefType(this.getEncodedBytes(type.encoding, true), lifetime);
             case 'decimal':
             case 'Etag':
             case 'hashmap':
@@ -2164,7 +2593,7 @@ export class Adapter {
             case 'Url':
                 // these types all require conversion
                 // to String so we don't need to own them
-                return this.getRefType(type);
+                return this.getRefType(type, lifetime);
         }
         return undefined;
     }
@@ -2196,6 +2625,7 @@ export class Adapter {
             case 'slice':
             case 'str':
             case 'String':
+            case 'untaggedUnion':
             case 'Url':
             case 'Vec':
                 return type;
@@ -2231,46 +2661,41 @@ export class Adapter {
         }
         const paramName = naming.getEscapedReservedName(utils.snakeCaseName(param.name), 'param');
         const paramLoc = 'method';
-        const formatType = utils.getPayloadFormatType(format);
-        const adaptedParam = new rust.PartialBodyParameter(paramName, paramLoc, param.optional, serializedName, this.getType(param.type), new rust.RequestContent(this.crate, new rust.Payload(payloadType, format), formatType));
+        const adaptedParam = new rust.PartialBodyParameter(paramName, paramLoc, param.optional, serializedName, this.getType(param.type), new rust.RequestContent(this.crate, payloadType, format));
         return adaptedParam;
     }
     /**
-     * converts a Content-Type header value into a payload format
+     * determines the payload format type from serializationOptions on the type, falling
+     * back to inspecting the defaultContentType when serializationOptions isn't available.
      *
-     * @param contentType the value of the Content-Type header
-     * @returns a payload format
+     * @param type the SDK type associated with the payload, if available
+     * @param defaultContentType the value of the Accept or Content-Type header
+     * @returns a payload format type
      */
-    adaptPayloadFormat(contentType) {
-        // we only recognize/support JSON and XML content types.
-        if (contentType.match(/json/i)) {
-            return 'json';
-        }
-        else if (contentType.match(/xml/i)) {
-            // XML support is disabled by default
-            this.crate.addDependency(new rust.CrateDependency('azure_core', ['xml']));
-            return 'xml';
-        }
-        else if (contentType.match(/text\/plain/i)) {
-            return 'text';
+    getPayloadFormatType(type, defaultContentType) {
+        if ((type === null || type === void 0 ? void 0 : type.kind) === 'model') {
+            const opts = type.serializationOptions;
+            if (opts.json) {
+                return 'JsonFormat';
+            }
+            else if (opts.xml) {
+                this.crate.addDependency(new rust.CrateDependency('azure_core', ['xml']));
+                return 'XmlFormat';
+            }
+            else if (opts.binary) {
+                return 'BinaryFormat';
+            }
         }
-        else {
-            throw new AdapterError('InternalError', `unexpected contentType ${contentType}`);
+        else if ((type === null || type === void 0 ? void 0 : type.kind) === 'bytes' && type.encode === 'bytes') {
+            // fallback: check if it's a bytes type with bytes encoding (binary stream)
+            return 'BinaryFormat';
         }
-    }
-    /**
-     * converts an accept or content-type header value into a payload format type
-     *
-     * @param contentType the value of the Accept or Content-Type header
-     * @returns a response format
-     */
-    adaptPayloadFormatType(contentType) {
-        // we only recognize/support JSON and XML content types.
-        // anything else is NoFormat
-        if (contentType.match(/json/i)) {
+        // tcgc doesn't yet have serializationOptions on types other
+        // than models.  for those cases, fall back to the header value
+        if (defaultContentType.match(/json/i)) {
             return 'JsonFormat';
         }
-        else if (contentType.match(/xml/i)) {
+        else if (defaultContentType.match(/xml/i)) {
             // XML support is disabled by default
             this.crate.addDependency(new rust.CrateDependency('azure_core', ['xml']));
             return 'XmlFormat';
@@ -2319,15 +2744,14 @@ function recursiveKeyName(root, type) {
         case 'discriminatedUnion':
         case 'model':
         case 'struct':
+        case 'untaggedUnion':
             return `${root}-${type.kind}-${type.name}`;
         case 'literal':
             return `${recursiveKeyName(`${root}-${type.kind}`, type.valueKind)}-${type.value}`;
-        case 'payload':
-            return recursiveKeyName(`${root}-${type.kind}-${type.format}`, type.type);
         case 'ref':
-            return recursiveKeyName(`${root}-${type.kind}`, type.type);
+            return recursiveKeyName(`${root}-${type.kind}${type.lifetime ? `-${type.lifetime.name}` : ''}`, type.type);
         case 'requestContent':
-            return recursiveKeyName(`${root}-${type.kind}`, type.content);
+            return recursiveKeyName(`${root}-${type.kind}-${type.format}`, type.content);
         case 'safeint':
         case 'decimal':
             return `${root}-${type.kind}${type.stringEncoding ? '-string' : ''}`;
@@ -2417,9 +2841,67 @@ function isHttpStatusCodeRange(statusCode) {
 function adaptAccessFlags(access) {
     return access === 'public' ? 'pub' : 'pubCrate';
 }
+/**
+ * converts an array of Visibility flags to a sorted, human-readable string.
+ * returns undefined if visibility is unrestricted (all flags or undefined).
+ *
+ * @param visibility the visibility flags from TCGC
+ * @returns a formatted string like "Read" or "Create, Update", or undefined if unrestricted
+ */
+export function formatVisibility(visibility) {
+    if (!visibility || visibility.length === 0) {
+        return undefined;
+    }
+    // combine all flags into a single bitmask
+    let combined = 0;
+    for (const v of visibility) {
+        combined |= v;
+    }
+    // if all lifecycle flags are set, there's no restriction
+    if ((combined & http.Visibility.All) === http.Visibility.All) {
+        return undefined;
+    }
+    // flags are checked in sorted order: Create, Delete, Query, Read, Update
+    const names = [];
+    if (combined & http.Visibility.Create) {
+        names.push('Create');
+    }
+    if (combined & http.Visibility.Delete) {
+        names.push('Delete');
+    }
+    if (combined & http.Visibility.Query) {
+        names.push('Query');
+    }
+    if (combined & http.Visibility.Read) {
+        names.push('Read');
+    }
+    if (combined & http.Visibility.Update) {
+        names.push('Update');
+    }
+    return names.length > 0 ? names.join(', ') : undefined;
+}
 /** contains reserved param names */
 const reservedParams = new Set([
     // reserved per SDK guidelines
     'options',
 ]);
+/**
+ * possible namespaces from core libraries.
+ * all types from these namespaces will be placed
+ * into the root namespace.
+ * if more core libs show up, add their namespaces here.
+ */
+const LIB_NAMESPACE = [
+    "azure.clientgenerator.core",
+    "azure.core",
+    "azure.resourcemanager",
+    "typespec.http",
+    "typespec.rest",
+    "typespec.versioning",
+];
+/** returns true if the given namespace is a known library namespace or a child of one */
+function isLibNamespace(namespace) {
+    const ns = namespace.toLowerCase();
+    return LIB_NAMESPACE.some((lib) => ns === lib || ns.startsWith(lib + '.'));
+}
 //# sourceMappingURL=adapter.js.map