@azure-tools/typespec-rust 0.36.0 → 0.38.0

package/dist/src/codegen/clients.d.ts

@@ -5,13 +5,13 @@ export interface ClientModules {
     /** the list of client modules */
     modules: Array<helpers.Module>;
     /** the client method options module */
-    options: helpers.Module;
+    options?: helpers.Module;
 }
 /**
  * emits the content for all client files
  *
- * @param crate the crate for which to emit clients
- * @returns client content or undefined if the crate contains no clients
+ * @param module the module for which to emit clients
+ * @returns client content or undefined if the module contains no clients
  */
-export declare function emitClients(crate: rust.Crate): ClientModules | undefined;
+export declare function emitClients(module: rust.ModuleContainer): ClientModules | undefined;
 //# sourceMappingURL=clients.d.ts.map

package/dist/src/codegen/clients.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../src/codegen/clients.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAGxC,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAG9C,yBAAyB;AACzB,MAAM,WAAW,aAAa;IAC5B,iCAAiC;IACjC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/B,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,aAAa,GAAG,SAAS,CA+RxE"}
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../src/codegen/clients.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAGxC,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAG9C,yBAAyB;AACzB,MAAM,WAAW,aAAa;IAC5B,iCAAiC;IACjC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/B,uCAAuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,GAAG,aAAa,GAAG,SAAS,CA+UnF"}

package/dist/src/codegen/clients.js

@@ -13,11 +13,11 @@ import * as utils from '../utils/utils.js';
 /**
  * emits the content for all client files
  *
- * @param crate the crate for which to emit clients
- * @returns client content or undefined if the crate contains no clients
+ * @param module the module for which to emit clients
+ * @returns client content or undefined if the module contains no clients
  */
-export function emitClients(crate) {
-    if (crate.clients.length === 0) {
+export function emitClients(module) {
+    if (module.clients.length === 0) {
         return undefined;
     }
     // returns true if the client options type needs to explicitly implement Default
@@ -34,8 +34,8 @@ export function emitClients(crate) {
     };
     const clientModules = new Array();
     // emit the clients, one file per client
-    for (const client of crate.clients) {
-        const use = new Use('clients');
+    for (const client of module.clients) {
+        const use = new Use(module, 'clients');
         const indent = new helpers.indentation();
         let body = helpers.formatDocComment(client.docs);
         use.add('azure_core', 'tracing');
@@ -163,6 +163,7 @@ export function emitClients(crate) {
         body += `${indent.get()}pub fn endpoint(&self) -> &Url {\n`;
         body += `${indent.push().get()}&self.${client.endpoint.name}\n`;
         body += `${indent.pop().get()}}\n\n`;
+        const crate = helpers.getCrate(module);
         for (let i = 0; i < client.methods.length; ++i) {
             const method = client.methods[i];
             const returnType = helpers.getTypeDeclaration(method.returns);
@@ -231,6 +232,42 @@ export function emitClients(crate) {
             }
         }
         body += '}\n\n'; // end client impl
+        // Emit pub(crate) const declarations for fields with default value constants.
+        //
+        // These constants are ALWAYS emitted, even when the options type is suppressed.
+        // In SDK crates with suppressed options, SDK authors need these constants to
+        // reference TypeSpec-defined default values (e.g., api-version) in their
+        // hand-authored Default impl. Suppressing them would force hardcoding.
+        //
+        // Visibility design:
+        // - Non-suppressed: constant is referenced by the generated Default impl, so
+        //   it's alive and no dead_code suppression is needed.
+        // - Suppressed: the generated options type doesn't exist — SDK authors provide
+        //   their own. The constant is a convenience they SHOULD use, but may not.
+        //   #[allow(dead_code)] is appropriate here (parallels std library patterns).
+        if (client.constructable) {
+            const isSuppressed = client.constructable.suppressed === 'yes';
+            for (const field of client.constructable.options.type.fields) {
+                if (field.defaultValueConstant) {
+                    if (isSuppressed) {
+                        // Plain text doc comment — the options type doesn't exist when suppressed,
+                        // so intra-doc links would be broken.
+                        body += `/// Default value for \`${client.constructable.options.type.name}::${field.name}\`.\n`;
+                        body += `///\n`;
+                        body += `/// This constant is available for SDK authors to use in hand-authored code.\n`;
+                        body += `/// When the options type is suppressed (via \`@access(Access.internal)\`), the\n`;
+                        body += `/// SDK author provides a custom options type and should reference this constant\n`;
+                        body += `/// in their \`Default\` implementation rather than hardcoding the value.\n`;
+                        body += `#[allow(dead_code)]\n`;
+                    }
+                    else {
+                        // Intra-doc link — the options type exists and the link resolves.
+                        body += `/// Default value for [\`${client.constructable.options.type.name}::${field.name}\`].\n`;
+                    }
+                    body += `pub(crate) const ${field.defaultValueConstant.name}: &str = "${field.defaultValueConstant.value}";\n\n`;
+                }
+            }
+        }
         // only implement Default when there's more than one field.
         // for the single-case field we just derive Default.
         if (client.constructable && clientOptionsImplDefault(client.constructable)) {
@@ -256,7 +293,16 @@ export function emitClients(crate) {
         // add using for method_options as required
         for (const method of client.methods) {
             if (method.kind !== 'clientaccessor') {
-                use.add('crate::generated::models', method.options.type.name);
+                // client method options types are always in the same module as their client method
+                use.add(`${utils.buildImportPath(client.module, client.module)}::models`, method.options.type.type.name);
+                // add imports for parameter group types
+                const seenGroups = new Set();
+                for (const param of method.params) {
+                    if (param.group && !seenGroups.has(param.group.type.name)) {
+                        seenGroups.add(param.group.type.name);
+                        use.add(`${utils.buildImportPath(client.module, client.module)}::models`, param.group.type.name);
+                    }
+                }
             }
         }
         let content = helpers.contentPreamble();
@@ -271,64 +317,102 @@ export function emitClients(crate) {
     }
     return {
         modules: clientModules,
-        options: getMethodOptions(crate),
+        options: getMethodOptions(module),
     };
 }
-function getMethodOptions(crate) {
-    const use = new Use('modelsOther');
+function getMethodOptions(module) {
+    const use = new Use(module, 'modelsOther');
     const indent = new helpers.indentation();
     const visTracker = new helpers.VisibilityTracker();
-    let body = '';
-    for (const client of crate.clients) {
-        for (let i = 0; i < client.methods.length; ++i) {
-            const method = client.methods[i];
+    // collect all struct blocks so they can be sorted by name
+    const structBlocks = [];
+    for (const client of module.clients) {
+        for (const method of client.methods) {
             if (method.kind === 'clientaccessor') {
                 continue;
             }
-            body += helpers.formatDocComment(method.options.type.docs);
+            // method options struct
+            let block = '';
+            const optionsStruct = method.options.type.type;
+            block += helpers.formatDocComment(optionsStruct.docs);
             use.add('azure_core::fmt', 'SafeDebug');
-            body += '#[derive(Clone, Default, SafeDebug)]\n';
-            body += `${helpers.emitVisibility(method.options.type.visibility)}struct ${helpers.getTypeDeclaration(method.options.type)} {\n`;
-            visTracker.update(method.options.type.visibility);
-            for (let i = 0; i < method.options.type.fields.length; ++i) {
-                const field = method.options.type.fields[i];
+            block += '#[derive(Clone, Default, SafeDebug)]\n';
+            block += `${helpers.emitVisibility(optionsStruct.visibility)}struct ${helpers.getTypeDeclaration(optionsStruct)} {\n`;
+            visTracker.update(optionsStruct.visibility);
+            for (let i = 0; i < optionsStruct.fields.length; ++i) {
+                const field = optionsStruct.fields[i];
                 use.addForType(field.type);
                 const fieldDocs = helpers.formatDocComment(field.docs);
                 if (fieldDocs.length > 0) {
-                    body += `${indent.get()}${fieldDocs}`;
+                    block += `${indent.get()}${fieldDocs}`;
                 }
-                body += `${indent.get()}${helpers.emitVisibility(method.visibility)}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
-                if (i + 1 < method.options.type.fields.length) {
-                    body += '\n';
+                block += `${indent.get()}${helpers.emitVisibility(method.visibility)}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
+                if (i + 1 < optionsStruct.fields.length) {
+                    block += '\n';
                 }
             }
-            body += '}\n\n'; // end options
+            block += '}\n';
             if (method.kind === 'pageable' || method.kind === 'lro') {
-                body += `impl ${helpers.getTypeDeclaration(method.options.type, 'anonymous')} {\n`;
-                const wrappedTypeName = helpers.wrapInBackTicks(helpers.getTypeDeclaration(method.options.type, 'omit'));
-                body += `${indent.get()}/// Transforms this [${wrappedTypeName}] into a new ${wrappedTypeName} that owns the underlying data, cloning it if necessary.\n`;
-                body += `${indent.get()}pub fn into_owned(self) -> ${method.options.type.name}<'static> {\n`;
-                body += `${indent.push().get()}${method.options.type.name} {\n`;
+                block += '\n';
+                block += `impl ${helpers.getTypeDeclaration(optionsStruct, 'anonymous')} {\n`;
+                const wrappedTypeName = helpers.wrapInBackTicks(helpers.getTypeDeclaration(optionsStruct, 'omit'));
+                block += `${indent.get()}/// Transforms this [${wrappedTypeName}] into a new ${wrappedTypeName} that owns the underlying data, cloning it if necessary.\n`;
+                block += `${indent.get()}pub fn into_owned(self) -> ${optionsStruct.name}<'static> {\n`;
+                block += `${indent.push().get()}${optionsStruct.name} {\n`;
                 indent.push();
-                for (const field of method.options.type.fields) {
+                for (const field of optionsStruct.fields) {
                     if (field.type.kind === 'clientMethodOptions' || field.type.kind === 'pagerOptions' || field.type.kind === 'pollerOptions') {
-                        body += `${indent.get()}${field.name}: ${field.type.name} {\n`;
-                        body += `${indent.push().get()}context: self.${field.name}.context.into_owned(),\n`;
-                        body += `${indent.get()}..self.${field.name}\n`;
-                        body += `${indent.pop().get()}},\n`;
+                        block += `${indent.get()}${field.name}: ${field.type.name} {\n`;
+                        block += `${indent.push().get()}context: self.${field.name}.context.into_owned(),\n`;
+                        block += `${indent.get()}..self.${field.name}\n`;
+                        block += `${indent.pop().get()}},\n`;
                         continue;
                     }
-                    body += `${indent.get()}${field.name}: self.${field.name},\n`;
+                    block += `${indent.get()}${field.name}: self.${field.name},\n`;
                 }
-                body += `${indent.pop().get()}}\n`;
-                body += `${indent.pop().get()}}\n`;
-                body += '}\n';
+                block += `${indent.pop().get()}}\n`;
+                block += `${indent.pop().get()}}\n`;
+                block += '}\n';
             }
-            if (i + 1 < client.methods.length) {
-                body += '\n';
+            structBlocks.push({ name: optionsStruct.name, body: block });
+            // parameter group structs
+            const seenGroups = new Set();
+            for (const param of method.params) {
+                if (param.group) {
+                    seenGroups.add(param.group);
+                }
+            }
+            for (const group of seenGroups) {
+                const groupParams = method.params.filter(p => p.group === group);
+                let groupBlock = '';
+                groupBlock += helpers.formatDocComment(group.type.docs);
+                use.add('azure_core::fmt', 'SafeDebug');
+                groupBlock += '#[derive(Clone, SafeDebug)]\n';
+                groupBlock += `${helpers.emitVisibility(group.type.visibility)}struct ${group.type.name}${group.type.lifetime ? `<${group.type.lifetime.name}>` : ''} {\n`;
+                visTracker.update(group.type.visibility);
+                for (let i = 0; i < groupParams.length; i++) {
+                    const field = groupParams[i];
+                    use.addForType(field.type);
+                    const fieldDocs = helpers.formatDocComment(field.docs);
+                    if (fieldDocs.length > 0) {
+                        if (i > 0) {
+                            groupBlock += '\n';
+                        }
+                        groupBlock += `${indent.get()}${fieldDocs}`;
+                    }
+                    groupBlock += `${indent.get()}${helpers.emitVisibility(group.type.visibility)}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
+                }
+                groupBlock += '}\n';
+                structBlocks.push({ name: group.type.name, body: groupBlock });
             }
         }
     }
+    structBlocks.sort((a, b) => helpers.sortAscending(a.name, b.name));
+    const body = structBlocks.map((b) => b.body).join('\n');
+    if (body === '') {
+        // client is top-level only, no methods just accessors
+        return undefined;
+    }
     let content = helpers.contentPreamble();
     content += use.text();
     content += body;
@@ -351,7 +435,17 @@ function getParamsBlockDocComment(indent, callable) {
         return `* ${helpers.wrapInBackTicks(paramName)} - `;
     };
     let paramsContent = '';
+    const documentedGroups = new Set();
     for (const param of callable.params) {
+        if ('group' in param && param.group) {
+            // required parameter group appears as a single param in the method sig
+            const group = param.group;
+            if (!documentedGroups.has(group.name)) {
+                documentedGroups.add(group.name);
+                paramsContent += helpers.formatDocComment(group.docs, false, formatParamBullet(group.name), indent);
+            }
+            continue;
+        }
         let optional = false;
         if ('optional' in param) {
             optional = param.optional;
@@ -426,7 +520,17 @@ function getMethodParamsCountAndSig(method, use) {
         }
     }
     else {
+        const emittedGroups = new Set();
         for (const param of method.params) {
+            if (param.group) {
+                if (!emittedGroups.has(param.group.name)) {
+                    emittedGroups.add(param.group.name);
+                    // required parameter group appears as a single struct parameter in the method signature
+                    paramsSig.push(`${param.group.name}: ${helpers.getTypeDeclaration(param.group.type, 'anonymous')}`);
+                    ++count;
+                }
+                continue;
+            }
             const paramType = helpers.unwrapType(param.type);
             if (paramType.kind === 'literal') {
                 // literal params are embedded directly in the code (e.g. accept header param)
@@ -444,7 +548,7 @@ function getMethodParamsCountAndSig(method, use) {
                 ++count;
             }
         }
-        paramsSig.push(`options: ${helpers.getTypeDeclaration(method.options, 'anonymous')}`);
+        paramsSig.push(`${method.options.name}: ${helpers.getTypeDeclaration(method.options.type, 'anonymous')}`);
         ++count;
     }
     return { count: count, sig: paramsSig.join(', ') };
@@ -453,11 +557,11 @@ function getMethodParamsCountAndSig(method, use) {
  * returns documentation for header trait access if the method has response headers.
  *
  * @param indent the current indentation level
- * @param crate the crate to which method belongs
+ * @param module the module to which method belongs
  * @param method the method for which to generate header trait documentation
  * @returns the header trait documentation or empty string if not applicable
  */
-function getHeaderTraitDocComment(indent, crate, method) {
+function getHeaderTraitDocComment(indent, module, method) {
     if (!method.responseHeaders) {
         return '';
     }
@@ -479,15 +583,15 @@ function getHeaderTraitDocComment(indent, crate, method) {
     headerDocs += `${indent.get()}/// The returned [${helpers.wrapInBackTicks(returnType)}](azure_core::http::${returnType}) implements the [${helpers.wrapInBackTicks(traitName)}] trait, which provides\n`;
     headerDocs += `${indent.get()}/// access to response headers. For example:\n`;
     headerDocs += `${indent.get()}///\n`;
-    headerDocs += emitHeaderTraitDocExample(crate.name, method.responseHeaders, indent);
+    headerDocs += emitHeaderTraitDocExample(method.responseHeaders, indent);
     headerDocs += `${indent.get()}///\n`;
     headerDocs += `${indent.get()}/// ### Available headers\n`;
     // List all available headers
     for (const header of method.responseHeaders.headers) {
-        headerDocs += `${indent.get()}/// * [${helpers.wrapInBackTicks(header.name)}()](crate::generated::models::${traitName}::${header.name}) - ${header.header}\n`;
+        headerDocs += `${indent.get()}/// * [${helpers.wrapInBackTicks(header.name)}()](${utils.buildImportPath(module, module)}::models::${traitName}::${header.name}) - ${header.header}\n`;
     }
     headerDocs += `${indent.get()}///\n`;
-    headerDocs += `${indent.get()}/// [${helpers.wrapInBackTicks(traitName)}]: crate::generated::models::${traitName}\n`;
+    headerDocs += `${indent.get()}/// [${helpers.wrapInBackTicks(traitName)}]: ${utils.buildImportPath(module, module)}::models::${traitName}\n`;
     return headerDocs;
 }
 /**
@@ -565,6 +669,17 @@ function getClientAccessorMethodBody(indent, client, clientAccessor) {
         if (clientAccessor.returns.fields.find((e) => e.name === field.name)) {
             initFields.push(`${field.name}: self.${field.name}${nonCopyableType(field.type) ? '.clone()' : ''}`);
         }
+        else {
+            // by convention the fields propagated from parent to child have the same name.
+            // there is an edge-case though for multi-client where the parent client contains
+            // multiple api-version params, one per child client. in this case, the param
+            // names include the client name as a prefix to disambiguate them. we check for
+            // that case here.
+            const disambiguatedField = clientAccessor.returns.fields.find((e) => utils.deduplicateClientFieldName(clientAccessor.returns, e.name) === field.name);
+            if (disambiguatedField) {
+                initFields.push(`${disambiguatedField.name}: self.${field.name}${nonCopyableType(field.type) ? '.clone()' : ''}`);
+            }
+        }
     }
     // sort the fields as the fields in the client are also sorted
     initFields.sort();
@@ -683,8 +798,8 @@ function constructUrl(indent, use, method, paramGroups, urlVarName) {
         throw new CodegenError('InternalError', 'too many HTTP path chunks');
     }
     let body = '';
-    // if path is just "/" no need to set it again, we're already there
-    if (pathChunks[0] !== '/') {
+    // if path is just "/" or empty, no need to set it again, we're already there
+    if (pathChunks[0] !== '/' && pathChunks[0] !== '') {
         use.add('azure_core::http', 'UrlExt');
         let path = `"${pathChunks[0]}"`;
         if (paramGroups.path.length === 0) {
@@ -704,50 +819,49 @@ function constructUrl(indent, use, method, paramGroups, urlVarName) {
                 let wrapSortedVec = (s) => s;
                 let paramExpression;
                 if (pathParam.kind === 'pathHashMap') {
-                    wrapSortedVec = (s) => `${indent.get()}{`
-                        + `${indent.push().get()}let mut ${pathParam.name}_vec = ${pathParam.name}.iter().collect::<Vec<_>>();\n`
-                        + `${indent.get()}${pathParam.name}_vec.sort_by_key(|p| p.0);\n`
-                        + `${s}`
-                        + `${indent.pop().get()}}`;
+                    const pathParamRef = qualifiedParamName(pathParam);
+                    wrapSortedVec = (s) => `${indent.get()}let mut ${pathParam.name} = ${pathParamRef}.iter().collect::<Vec<_>>();\n`
+                        + `${indent.get()}${pathParam.name}.sort_by_key(|p| p.0);\n${s}`;
                     const kEqualsV = '"{k}={v}"';
                     const kCommaV = '"{k},{v}"';
-                    paramExpression = `&${pathParam.name}_vec.iter().map(|(k,v)| `
+                    paramExpression = `&${pathParam.name}.iter().map(|(k,v)| `
                         + (pathParam.explode
                             ? `format!(${kEqualsV})).collect::<Vec<_>>().join(",")`
                             : `format!(${kCommaV})).collect::<Vec<_>>().join(",")`);
                     switch (pathParam.style) {
                         case 'path':
-                            paramExpression = `&format!("/{}", ${pathParam.name}_vec.iter().map(|(k,v)| `
+                            paramExpression = `&format!("/{}", ${pathParam.name}.iter().map(|(k,v)| `
                                 + (pathParam.explode
                                     ? `format!(${kEqualsV})).collect::<Vec<_>>().join("/"))`
                                     : `format!(${kCommaV})).collect::<Vec<_>>().join(","))`);
                             break;
                         case 'label':
-                            paramExpression = `&format!(".{}", ${pathParam.name}_vec.iter().map(|(k,v)| `
+                            paramExpression = `&format!(".{}", ${pathParam.name}.iter().map(|(k,v)| `
                                 + (pathParam.explode
                                     ? `format!(${kEqualsV})).collect::<Vec<_>>().join("."))`
                                     : `format!(${kCommaV})).collect::<Vec<_>>().join(","))`);
                             break;
                         case 'matrix':
                             paramExpression = pathParam.explode
-                                ? (`&format!(";{}", ${pathParam.name}_vec.into_iter().map(|(k,v)| `
+                                ? (`&format!(";{}", ${pathParam.name}.into_iter().map(|(k,v)| `
                                     + `format!(${kEqualsV})).collect::<Vec<_>>().join(";"))`)
-                                : (`&format!(";${pathParam.name}={}", ${pathParam.name}_vec.into_iter().map(|(k,v)| `
+                                : (`&format!(";${pathParam.name}={}", ${pathParam.name}.into_iter().map(|(k,v)| `
                                     + `format!(${kCommaV})).collect::<Vec<_>>().join(","))`);
                             break;
                     }
                 }
                 else if (pathParam.kind === 'pathCollection') {
-                    paramExpression = `&${pathParam.name}.join(",")`;
+                    const pathParamRef = qualifiedParamName(pathParam);
+                    paramExpression = `&${pathParamRef}.join(",")`;
                     switch (pathParam.style) {
                         case 'path':
-                            paramExpression = `&format!("/{}", ${pathParam.name}.join("${pathParam.explode ? '/' : ','}"))`;
+                            paramExpression = `&format!("/{}", ${pathParamRef}.join("${pathParam.explode ? '/' : ','}"))`;
                             break;
                         case 'label':
-                            paramExpression = `&format!(".{}", ${pathParam.name}.join("${pathParam.explode ? '.' : ','}"))`;
+                            paramExpression = `&format!(".{}", ${pathParamRef}.join("${pathParam.explode ? '.' : ','}"))`;
                             break;
                         case 'matrix':
-                            paramExpression = `&format!(";${pathParam.name}={}", ${pathParam.name}.join(`
+                            paramExpression = `&format!(";${pathParam.name}={}", ${pathParamRef}.join(`
                                 + `"${pathParam.explode ? `;${pathParam.name}=` : ','}"))`;
                             break;
                     }
@@ -822,8 +936,9 @@ function constructUrl(indent, use, method, paramGroups, urlVarName) {
     for (const queryParam of paramGroups.query) {
         if (queryParam.kind === 'queryCollection' && queryParam.format === 'multi') {
             body += getParamValueHelper(indent, queryParam, () => {
+                const queryParamRef = qualifiedParamName(queryParam);
                 const valueVar = queryParam.name[0];
-                let text = `${indent.get()}for ${valueVar} in ${queryParam.name}.iter() {\n`;
+                let text = `${indent.get()}for ${valueVar} in ${queryParamRef}.iter() {\n`;
                 // if queryParam is a &[&str] then we'll need to deref the iterator
                 const deref = utils.asTypeOf(queryParam.type, 'str', 'ref', 'slice', 'ref') ? '*' : '';
                 text += `${indent.push().get()}query_builder.append_pair("${queryParam.key}", ${deref}${getHeaderPathQueryParamValue(use, queryParam, !queryParam.optional, false, valueVar)});\n`;
@@ -833,19 +948,14 @@ function constructUrl(indent, use, method, paramGroups, urlVarName) {
         }
         else if (queryParam.kind === 'queryHashMap') {
             body += getParamValueHelper(indent, queryParam, () => {
-                let text = `${indent.get()}{\n`;
-                text += `${indent.push().get()}let mut ${queryParam.name}_vec = ${queryParam.name}.iter().collect::<Vec<_>>();\n`;
-                text += `${indent.get()}${queryParam.name}_vec.sort_by_key(|p| p.0);\n`;
-                if (queryParam.explode) {
-                    text += `${indent.get()}for (k, v) in ${queryParam.name}_vec.iter() {\n`;
-                    text += `${indent.push().get()}query_builder.append_pair(*k, v.to_string());\n`;
-                    text += `${indent.pop().get()}}\n`;
-                }
-                else {
-                    text += `${indent.get()}query_builder.set_pair("${queryParam.key}", ${queryParam.name}_vec.iter().map(|(k, v)| format!("{k},{v}")).collect::<Vec<String>>().join(","));\n`;
-                }
-                text += `${indent.pop().get()}}\n`;
-                return text;
+                const queryParamRef = qualifiedParamName(queryParam);
+                return (queryParam.explode)
+                    ? `${indent.get()}for (k, v) in ${queryParamRef}.iter() {\n`
+                        + `${indent.push().get()}query_builder.append_pair(k.as_str(), v.to_string());\n`
+                        + `${indent.pop().get()}}\n`
+                    : `${indent.get()}let mut ${queryParam.name} = ${queryParamRef}.iter().collect::<Vec<_>>();\n`
+                        + `${indent.get()}${queryParam.name}.sort_by_key(|p| p.0);\n`
+                        + `${indent.get()}query_builder.set_pair("${queryParam.key}", ${queryParam.name}.iter().map(|(k, v)| format!("{k},{v}")).collect::<Vec<String>>().join(","));\n`;
             });
         }
         else {
@@ -903,7 +1013,8 @@ function applyHeaderParams(indent, use, method, paramGroups, inClosure, requestV
         }
         body += getParamValueHelper(indent, headerParam, () => {
             if (headerParam.kind === 'headerHashMap') {
-                let setter = `for (k, v) in ${headerParam.name} {\n`;
+                const headerParamRef = qualifiedParamName(headerParam);
+                let setter = `for (k, v) in ${headerParamRef} {\n`;
                 setter += `${indent.push().get()}${requestVarName}.insert_header(format!("${headerParam.header}-{k}"), v);\n`;
                 setter += `${indent.pop().get()}}\n`;
                 return setter;
@@ -961,15 +1072,15 @@ function constructRequest(indent, use, method, paramGroups, inClosure, urlVarNam
         const requestContentType = paramGroups.partialBody[0].type;
         use.addForType(requestContentType);
         if (inClosure) {
-            body += `${indent.get()}let body: Result<${helpers.getTypeDeclaration(requestContentType)}> = ${requestContentType.content.type.name} {\n`;
+            body += `${indent.get()}let body: Result<${helpers.getTypeDeclaration(requestContentType)}> = ${requestContentType.content.name} {\n`;
         }
         else {
-            body += `${indent.get()}let body: ${helpers.getTypeDeclaration(requestContentType)} = ${requestContentType.content.type.name} {\n`;
+            body += `${indent.get()}let body: ${helpers.getTypeDeclaration(requestContentType)} = ${requestContentType.content.name} {\n`;
         }
         indent.push();
         for (const partialBodyParam of paramGroups.partialBody) {
-            if (partialBodyParam.type.content.type !== requestContentType.content.type) {
-                throw new CodegenError('InternalError', `spread param ${partialBodyParam.name} has conflicting model type ${partialBodyParam.type.content.type.name}, expected model type ${requestContentType.content.type.name}`);
+            if (partialBodyParam.type.content !== requestContentType.content) {
+                throw new CodegenError('InternalError', `spread param ${partialBodyParam.name} has conflicting model type ${partialBodyParam.type.content.name}, expected model type ${requestContentType.content.name}`);
             }
             if (partialBodyParam.optional) {
                 body += `${indent.get()}${partialBodyParam.name}: options.${partialBodyParam.name}${inClosure ? '.clone()' : ''},\n`;
@@ -979,7 +1090,7 @@ function constructRequest(indent, use, method, paramGroups, inClosure, urlVarNam
             if (inClosure) {
                 initializer = initializer + '.clone()';
             }
-            if (requestContentType.content.type.visibility === 'pub') {
+            if (requestContentType.content.visibility === 'pub') {
                 // spread param maps to a non-internal model, so it must be wrapped in Some()
                 initializer = `Some(${initializer})`;
             }
@@ -1062,8 +1173,9 @@ function emitEmptyPathParamCheck(indent, param) {
             // no length to check so bail
             return '';
     }
+    const paramRef = qualifiedParamName(param);
     return helpers.buildIfBlock(indent, {
-        condition: `${param.name}${toString}.is_empty()`,
+        condition: `${paramRef}${toString}.is_empty()`,
         body: (indent) => `${indent.get()}return Err(azure_core::Error::with_message(azure_core::error::ErrorKind::Other, "parameter ${param.name} cannot be empty"));\n`,
     });
 }
@@ -1647,6 +1759,9 @@ function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow, overrid
     else if (overrideParamName) {
         paramName = overrideParamName;
     }
+    else if (param.group) {
+        paramName = qualifiedParamName(param);
+    }
     const encodeBytes = function (type, param) {
         const encoding = helpers.getBytesEncodingMethod(type.encoding, 'encode', use);
         if (param) {
@@ -1675,6 +1790,7 @@ function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow, overrid
     // contains the result from calculating if the
     // param requires borrowing.
     let mustBorrow = !helpers.isQueryParameter(param);
+    const isGrouped = !!param.group;
     const paramType = helpers.unwrapType(param.type);
     // we want multi to hit the else case so the necessary conversions etc can happen
     if ((param.kind === 'headerCollection' || param.kind === 'queryCollection') && param.format !== 'multi') {
@@ -1701,8 +1817,8 @@ function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow, overrid
         switch (paramType.kind) {
             case 'String':
                 paramValue = paramName;
-                // if the param is on the client, then we must borrow
-                mustBorrow = param.location === 'client' && fromSelf;
+                // if the param is on the client or in a group struct, then we must borrow
+                mustBorrow = isGrouped || (param.location === 'client' && fromSelf);
                 break;
             case 'str':
                 paramValue = paramName;
@@ -1746,8 +1862,8 @@ function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow, overrid
         case 'headerHashMap':
         case 'headerScalar':
             // for non-copyable params (e.g. String), we need to borrow them if they're on the
-            // client or we're in a closure and the param is required (header params are always owned)
-            mustBorrow = nonCopyableType(param.type) && (param.location === 'client' || (!fromSelf && !param.optional));
+            // client, in a group struct, or we're in a closure and the param is required (header params are always owned)
+            mustBorrow = nonCopyableType(param.type) && (isGrouped || param.location === 'client' || (!fromSelf && !param.optional));
             break;
     }
     return `${mustBorrow && !neverBorrow ? '&' : ''}${paramValue}`;
@@ -1823,4 +1939,8 @@ function isEnumString(type) {
     const unwrapped = helpers.unwrapType(type);
     return unwrapped.kind === 'enum' && unwrapped.type === 'String';
 }
+/** returns the qualified name for a param, prefixing with the group name when the param belongs to a parameter group */
+function qualifiedParamName(param) {
+    return param.group ? `${param.group.name}.${param.name}` : param.name;
+}
 //# sourceMappingURL=clients.js.map