@azure-tools/typespec-rust 0.20.0 → 0.22.0

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

@@ -1 +1 @@
-{"version":3,"file":"cargotoml.d.ts","sourceRoot":"","sources":["../../../src/codegen/cargotoml.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAE9C;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,MAAM,CAgBvD"}
+{"version":3,"file":"cargotoml.d.ts","sourceRoot":"","sources":["../../../src/codegen/cargotoml.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAE9C;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,MAAM,CAkBvD"}

package/dist/src/codegen/cargotoml.js

@@ -14,7 +14,9 @@ export function emitCargoToml(crate) {
     content += 'edition.workspace = true\n';
     content += 'license.workspace = true\n';
     content += 'repository.workspace = true\n';
-    content += 'rust-version.workspace = true\n';
+    content += 'rust-version.workspace = true\n\n';
+    content += '[features]\n';
+    content += 'default = ["azure_core/default"]\n';
     if (crate.dependencies.length > 0) {
         content += '\n[dependencies]\n';
         for (const dependency of crate.dependencies) {

package/dist/src/codegen/cargotoml.js.map

@@ -1 +1 @@
-{"version":3,"file":"cargotoml.js","sourceRoot":"","sources":["../../../src/codegen/cargotoml.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAI/F;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAiB;IAC7C,IAAI,OAAO,GAAG,sBAAsB,KAAK,CAAC,IAAI,iBAAiB,KAAK,CAAC,OAAO,KAAK,CAAC;IAClF,OAAO,IAAI,4BAA4B,CAAC;IACxC,OAAO,IAAI,4BAA4B,CAAC;IACxC,OAAO,IAAI,4BAA4B,CAAC;IACxC,OAAO,IAAI,+BAA+B,CAAC;IAC3C,OAAO,IAAI,iCAAiC,CAAC;IAC7C,IAAI,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClC,OAAO,IAAI,oBAAoB,CAAC;QAChC,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YAC5C,qEAAqE;YACrE,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,iBAAiB,UAAU,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YACpI,OAAO,IAAI,GAAG,UAAU,CAAC,IAAI,wBAAwB,QAAQ,MAAM,CAAC;QACtE,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}
+{"version":3,"file":"cargotoml.js","sourceRoot":"","sources":["../../../src/codegen/cargotoml.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAI/F;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAiB;IAC7C,IAAI,OAAO,GAAG,sBAAsB,KAAK,CAAC,IAAI,iBAAiB,KAAK,CAAC,OAAO,KAAK,CAAC;IAClF,OAAO,IAAI,4BAA4B,CAAC;IACxC,OAAO,IAAI,4BAA4B,CAAC;IACxC,OAAO,IAAI,4BAA4B,CAAC;IACxC,OAAO,IAAI,+BAA+B,CAAC;IAC3C,OAAO,IAAI,mCAAmC,CAAC;IAC/C,OAAO,IAAI,cAAc,CAAC;IAC1B,OAAO,IAAI,oCAAoC,CAAC;IAChD,IAAI,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClC,OAAO,IAAI,oBAAoB,CAAC;QAChC,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YAC5C,qEAAqE;YACrE,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,iBAAiB,UAAU,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YACpI,OAAO,IAAI,GAAG,UAAU,CAAC,IAAI,wBAAwB,QAAQ,MAAM,CAAC;QACtE,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../src/codegen/clients.ts"],"names":[],"mappings":"AAUA,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,CAiQxE"}
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../src/codegen/clients.ts"],"names":[],"mappings":"AAWA,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,CAuQxE"}

package/dist/src/codegen/clients.js

@@ -5,6 +5,7 @@
 // cspell: ignore conv
 import * as codegen from '@azure-tools/codegen';
 import { values } from '@azure-tools/linq';
+import { emitHeaderTraitDocExample } from './docTests.js';
 import { CodegenError } from './errors.js';
 import * as helpers from './helpers.js';
 import queryString from 'query-string';
@@ -76,23 +77,22 @@ export function emitClients(crate) {
                 if (paramsDocs) {
                     body += paramsDocs;
                 }
-                body += `${indent.get()}#[tracing::new("${crate.name}")]\n`;
+                body += `${indent.get()}#[tracing::new("${client.languageIndependentName}")]\n`;
                 body += `${indent.get()}pub fn ${constructor.name}(${getConstructorParamsSig(constructor.params, client.constructable.options, use)}) -> Result<Self> {\n`;
                 body += `${indent.get()}let options = options.unwrap_or_default();\n`;
                 // by convention, the endpoint param is always the first ctor param
                 const endpointParamName = constructor.params[0].name;
-                body += `${indent.push().get()}let mut ${endpointParamName} = Url::parse(${endpointParamName})?;\n`;
+                body += `${indent.push().get()}let ${client.constructable.endpoint ? 'mut ' : ''}${endpointParamName} = Url::parse(${endpointParamName})?;\n`;
                 body += `${indent.get()}${helpers.buildIfBlock(indent, {
                     condition: `!${endpointParamName}.scheme().starts_with("http")`,
                     body: (indent) => `${indent.get()}return Err(azure_core::Error::message(azure_core::error::ErrorKind::Other, format!("{${endpointParamName}} must use http(s)")));\n`,
                 })}`;
-                body += `${indent.get()}${endpointParamName}.set_query(None);\n`;
                 // construct the supplemental path and join it to the endpoint
                 if (client.constructable.endpoint) {
                     const supplementalEndpoint = client.constructable.endpoint;
                     body += `${indent.get()}let mut host = String::from("${supplementalEndpoint.path}");\n`;
                     for (const param of supplementalEndpoint.parameters) {
-                        body += `${indent.get()}host = host.replace("{${param.segment}}", ${getClientEndpointParamValue(param)});\n`;
+                        body += `${indent.get()}host = host.replace("{${param.segment}}", ${getClientSupplementalEndpointParamValue(param)});\n`;
                     }
                     body += `${indent.push().get()}${endpointParamName} = ${endpointParamName}.join(&host)?;\n`;
                 }
@@ -108,15 +108,11 @@ export function emitClients(crate) {
                 // exclude endpoint params as they aren't propagated to clients (they're consumed when creating the complete endpoint)
                 const sortedParams = values([...constructor.params]
                     .sort((a, b) => { return helpers.sortAscending(a.name, b.name); }))
-                    .where((each) => each.kind !== 'clientEndpoint').toArray();
+                    .where((each) => each.kind !== 'clientSupplementalEndpoint' && each.kind !== 'clientCredential').toArray();
                 for (const param of sortedParams) {
                     if (param.optional) {
                         continue;
                     }
-                    else if (isCredential(param.type)) {
-                        // credential params aren't persisted on the client so skip them
-                        continue;
-                    }
                     if (!client.fields.find((v) => { return v.name === param.name; })) {
                         throw new CodegenError('InternalError', `didn't find field in client ${client.name} for param ${param.name}`);
                     }
@@ -142,7 +138,7 @@ export function emitClients(crate) {
                 body += `${indent.get()}option_env!("CARGO_PKG_VERSION"),\n`;
                 body += `${indent.get()}options.client_options,\n`;
                 body += `${indent.get()}Vec::default(),\n`;
-                body += `${indent.get()}${authPolicy ? 'vec![auth_policy]' : 'Vec::default()'},\n`;
+                body += `${indent.get()}${authPolicy ? 'vec![auth_policy]' : 'Vec::default()'}, None,\n`;
                 body += `${indent.pop().get()}),\n`; // end Pipeline::new
                 body += `${indent.pop().get()}})\n`; // end Ok
                 body += `${indent.pop().get()}}\n`; // end constructor
@@ -183,6 +179,12 @@ export function emitClients(crate) {
                         return getPageableMethodBody(indentation, use, client, method);
                     };
                     break;
+                case 'lro':
+                    isPublicApi = true;
+                    methodBody = (indentation) => {
+                        return getLroMethodBody(indentation, use, client, method);
+                    };
+                    break;
                 case 'clientaccessor':
                     isSubclientNew = true;
                     methodBody = (indentation) => {
@@ -195,6 +197,10 @@ export function emitClients(crate) {
             if (paramsDocs) {
                 body += paramsDocs;
             }
+            // client accessors will never have response headers
+            if (method.kind !== 'clientaccessor' && method.responseHeaders) {
+                body += getHeaderTraitDocComment(indent, crate, method);
+            }
             if (isPublicApi) {
                 body += `${indent.get()}#[tracing::function("${method.languageIndependentName}")]\n`;
             }
@@ -275,7 +281,7 @@ function getMethodOptions(crate) {
                 }
             }
             body += '}\n\n'; // end options
-            if (method.kind === 'pageable') {
+            if (method.kind === 'pageable' || method.kind === 'lro') {
                 body += `impl ${helpers.getTypeDeclaration(method.options.type, true)} {\n`;
                 body += `${indent.get()}pub fn into_owned(self) -> ${method.options.type.name}<'static> {\n`;
                 body += `${indent.push().get()}${method.options.type.name} {\n`;
@@ -316,7 +322,7 @@ function getMethodOptions(crate) {
  */
 function getParamsBlockDocComment(indent, callable) {
     const formatParamBullet = function (paramName) {
-        return `* \`${paramName}\` - `;
+        return `* ${helpers.wrapInBackTicks(paramName)} - `;
     };
     let paramsContent = '';
     for (const param of callable.params) {
@@ -412,6 +418,36 @@ function getMethodParamsSig(method, use) {
     }
     return paramsSig.join(', ');
 }
+/**
+ * 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 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) {
+    if (!method.responseHeaders) {
+        return '';
+    }
+    const traitName = method.responseHeaders.name;
+    let headerDocs = `${indent.get()}///\n`;
+    headerDocs += `${indent.get()}/// ## Response Headers\n`;
+    headerDocs += `${indent.get()}///\n`;
+    headerDocs += `${indent.get()}/// The returned [${helpers.wrapInBackTicks('Response')}](azure_core::http::Response) 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 += `${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()}///\n`;
+    headerDocs += `${indent.get()}/// [${helpers.wrapInBackTicks(traitName)}]: crate::generated::models::${traitName}\n`;
+    return headerDocs;
+}
 /**
  * returns the auth policy instantiation code if the ctor contains a credential param.
  * the policy will be a local var named auth_policy.
@@ -593,7 +629,7 @@ function getMethodParamGroup(method) {
  * @returns
  */
 function getParamValueHelper(indent, param, inClosure, setter) {
-    if (param.optional) {
+    if (param.optional && param.type.kind !== 'literal') {
         // optional params are in the unwrapped options local var
         const op = indent.get() + helpers.buildIfBlock(indent, {
             condition: `let Some(${param.name}) = ${inClosure ? '&' : ''}options.${param.name}`,
@@ -622,7 +658,10 @@ function constructUrl(indent, use, method, paramGroups, urlVarName = 'url') {
     }
     /** returns & if the param needs to be borrowed (which is the majority of cases), else the empty string */
     const borrowOrNot = function (param) {
-        if (param.type.kind !== 'ref' || param.type.type.kind === 'encodedBytes' || param.type.type.kind === 'slice') {
+        // for string-based enums we call .as_ref() which elides the need to borrow.
+        // for numeric-based enums the borrow will be necessary.
+        // TODO: https://github.com/Azure/typespec-rust/issues/25
+        if (param.type.kind !== 'enum' && (param.type.kind !== 'ref' || param.type.type.kind === 'encodedBytes' || param.type.type.kind === 'slice')) {
             return '&';
         }
         return '';
@@ -645,7 +684,7 @@ function constructUrl(indent, use, method, paramGroups, urlVarName = 'url') {
             body += `${indent.get()}let mut path = String::from(${path});\n`;
             for (const pathParam of paramGroups.path) {
                 let wrapSortedVec = (s) => s;
-                let paramExpression = `${borrowOrNot(pathParam)}${getHeaderPathQueryParamValue(use, pathParam, true)}`;
+                let paramExpression = getHeaderPathQueryParamValue(use, pathParam, true);
                 if (pathParam.kind === 'pathHashMap') {
                     wrapSortedVec = (s) => `${indent.get()}{`
                         + `${indent.push().get()}let mut ${pathParam.name}_vec = ${pathParam.name}.iter().collect::<Vec<_>>();\n`
@@ -706,9 +745,22 @@ function constructUrl(indent, use, method, paramGroups, urlVarName = 'url') {
                         case 'matrix':
                             paramExpression = `&format!(";${pathParam.name}={${paramExpression}}")`;
                             break;
+                        default:
+                            paramExpression = `${borrowOrNot(pathParam)}${paramExpression}`;
                     }
                 }
-                body += wrapSortedVec(`${indent.get()}path = path.replace("{${pathParam.segment}}", ${paramExpression});\n`);
+                if (pathParam.optional) {
+                    body += `${indent.get()}path = ${helpers.buildMatch(indent, `options.${pathParam.name}`, [{
+                            pattern: `Some(${pathParam.name})`,
+                            body: (indent) => wrapSortedVec(`${indent.get()}path.replace("{${pathParam.segment}}", ${paramExpression})\n`),
+                        }, {
+                            pattern: `None`,
+                            body: (indent) => `${indent.get()}path.replace("{${pathParam.segment}}", "")\n`,
+                        }])};\n`;
+                }
+                else {
+                    body += wrapSortedVec(`${indent.get()}path = path.replace("{${pathParam.segment}}", ${paramExpression});\n`);
+                }
             }
             path = '&path';
             body += `${indent.get()}${urlVarName} = ${urlVarName}.join(${path})?;\n`;
@@ -774,27 +826,19 @@ function constructUrl(indent, use, method, paramGroups, urlVarName = 'url') {
     return body;
 }
 /**
- * emits the code for building the HTTP request.
- * assumes that there's a local var 'url' which is the Url.
- * creates a mutable local 'request' which is the Request instance.
+ * emits the code for setting HTTP headers in a request.
  *
  * @param indent the indentation helper currently in scope
  * @param use the use statement builder currently in scope
  * @param method the method for which we're building the body
  * @param paramGroups the param groups for the provided method
  * @param inClosure indicates if the request is being constructed within a closure (e.g. pageable methods)
- * @returns the request construction code
+ * @returns the code which sets HTTP headers for the request
  */
-function constructRequest(indent, use, method, paramGroups, inClosure) {
+function applyHeaderParams(indent, use, method, paramGroups, inClosure) {
     var _a, _b, _c;
-    let body = `${indent.get()}let mut request = Request::new(url, Method::${codegen.capitalize(method.httpMethod)});\n`;
-    let optionalContentTypeParam;
+    let body = '';
     for (const headerParam of paramGroups.header) {
-        // if the content-type header is optional, we need to emit it inside the "if let Some(body)" clause below.
-        if (headerParam.kind === 'headerScalar' && headerParam.optional && headerParam.header.toLowerCase() === 'content-type') {
-            optionalContentTypeParam = headerParam;
-            continue;
-        }
         if (method.kind === 'pageable' && ((_a = method.strategy) === null || _a === void 0 ? void 0 : _a.kind) === 'continuationToken' && ((_b = method.strategy) === null || _b === void 0 ? void 0 : _b.requestToken.kind) === 'headerScalar' && ((_c = method.strategy) === null || _c === void 0 ? void 0 : _c.requestToken) === headerParam) {
             // we have some special handling for the header continuation token.
             // if we have a token value, i.e. from the next page, then use that value.
@@ -805,6 +849,12 @@ function constructRequest(indent, use, method, paramGroups, inClosure) {
             });
             continue;
         }
+        if (isOptionalContentTypeHeader(headerParam)) {
+            // when the body is optional, the Content-Type header
+            // will be set IFF the optional body param is not None.
+            // this logic happens elsewhere so we skip it here.
+            continue;
+        }
         body += getParamValueHelper(indent, headerParam, inClosure, () => {
             if (headerParam.kind === 'headerHashMap') {
                 let setter = `for (k, v) in &${headerParam.name} {\n`;
@@ -818,6 +868,36 @@ function constructRequest(indent, use, method, paramGroups, inClosure) {
             return `${indent.get()}request.insert_header("${headerParam.header.toLowerCase()}", ${borrow}${getHeaderPathQueryParamValue(use, headerParam, !inClosure)});\n`;
         });
     }
+    return body;
+}
+/** type guard to determine if headerParam is an optional Content-Type header */
+function isOptionalContentTypeHeader(headerParam) {
+    return headerParam.kind === 'headerScalar' && headerParam.optional && headerParam.header.toLowerCase() === 'content-type';
+}
+/**
+ * emits the code for building the HTTP request.
+ * assumes that there's a local var 'url' which is the Url.
+ * creates a mutable local 'request' which is the Request instance.
+ *
+ * @param indent the indentation helper currently in scope
+ * @param use the use statement builder currently in scope
+ * @param method the method for which we're building the body
+ * @param paramGroups the param groups for the provided method
+ * @param inClosure indicates if the request is being constructed within a closure (e.g. pageable methods)
+ * @param cloneUrl indicates if url should be cloned when it is passed to initialize request
+ * @param forceMut indicates whether request should get declared as 'mut' regardless of whether there are any headers to set
+ * @returns the request construction code
+ */
+function constructRequest(indent, use, method, paramGroups, inClosure, cloneUrl = false, forceMut = true) {
+    let body = `${indent.get()}let ${(forceMut || paramGroups.header.length > 0) ? 'mut ' : ''}request = Request::new(url${cloneUrl ? '.clone()' : ''}, Method::${codegen.capitalize(method.httpMethod)});\n`;
+    body += applyHeaderParams(indent, use, method, paramGroups, inClosure);
+    let optionalContentTypeParam;
+    for (const headerParam of paramGroups.header) {
+        // if the content-type header is optional, we need to emit it inside the "if let Some(body)" clause below.
+        if (isOptionalContentTypeHeader(headerParam)) {
+            optionalContentTypeParam = headerParam;
+        }
+    }
     const bodyParam = paramGroups.body;
     if (bodyParam) {
         body += getParamValueHelper(indent, bodyParam, inClosure, () => {
@@ -860,24 +940,15 @@ function constructRequest(indent, use, method, paramGroups, inClosure) {
     return body;
 }
 /**
- * Return an error if a local RawResponse variable "rsp" has a non-success status code.
+ * Return an error if a local BufResponse variable "rsp" has a non-success status code.
  * @param use the use statement builder currently in scope
  * @param indent the indentation helper currently in scope
  * @returns code to return an error if the status code of "rsp" doesn't indicate success
  */
 function errIfNotSuccessResponse(use, indent) {
-    use.add('azure_core', 'Error', 'Result');
-    use.add('azure_core::error', 'ErrorKind', 'HttpError');
-    return helpers.buildIfBlock(indent, {
-        condition: '!rsp.status().is_success()',
-        body: (indent) => {
-            let body = `${indent.get()}let status = rsp.status();\n`;
-            body += `${indent.get()}let http_error = HttpError::new(rsp).await;\n`;
-            body += `${indent.get()}let error_kind = ErrorKind::http_response(status, http_error.error_code().map(std::borrow::ToOwned::to_owned));\n`;
-            body += `${indent.get()}return Err(Error::new(error_kind, http_error));\n`;
-            return body;
-        },
-    });
+    use.add('azure_core::http', 'check_success');
+    const body = `${indent.get()}let rsp = check_success(rsp).await?;\n`;
+    return body;
 }
 /**
  * Returns 'mut ' if the Url local var needs to be mutable, else the empty string.
@@ -891,6 +962,58 @@ function urlVarNeedsMut(paramGroups, method) {
     }
     return '';
 }
+/**
+ * emits "if path_param is empty then error" checks for string method path parameters
+ *
+ * @param indent the indentation helper currently in scope
+ * @param params the path params to enumerate, can be empty
+ * @returns the empty path param checks or the empty string if there are no checks
+ */
+function checkEmptyRequiredPathParams(indent, params) {
+    let checks = '';
+    for (const param of params) {
+        if (param.optional || param.location === 'client') {
+            continue;
+        }
+        checks += emitEmptyPathParamCheck(indent, param);
+    }
+    return checks;
+}
+/**
+ * emits the "if path_param is empty then error" check.
+ * this is only applicable when the path param's type can
+ * be empty (e.g. a string). for types that can't be empty
+ * the empty string is returned.
+ *
+ * @param indent the indentation helper currently in scope
+ * @param param the path param for which to emit the check
+ * @returns the check or the empty string
+ */
+function emitEmptyPathParamCheck(indent, param) {
+    let toString = '';
+    const paramType = param.type.kind === 'ref' ? param.type.type : param.type;
+    switch (paramType.kind) {
+        case 'String':
+        case 'str':
+            // need to check these for zero length
+            break;
+        case 'enum':
+            if (!paramType.extensible) {
+                // fixed enums will always have a value
+                return '';
+            }
+            // need to get the underlying string value
+            toString = '.as_ref()';
+            break;
+        default:
+            // no length to check so bail
+            return '';
+    }
+    return helpers.buildIfBlock(indent, {
+        condition: `${param.name}${toString}.is_empty()`,
+        body: (indent) => `${indent.get()}return Err(azure_core::Error::message(azure_core::error::ErrorKind::Other, "parameter ${param.name} cannot be empty"));`,
+    });
+}
 /**
  * constructs the body for an async client method
  *
@@ -901,17 +1024,18 @@ function urlVarNeedsMut(paramGroups, method) {
  * @returns the contents of the method body
  */
 function getAsyncMethodBody(indent, use, client, method) {
-    use.add('azure_core::http', 'Context', 'Method', 'Request');
+    use.add('azure_core::http', 'Method', 'Request');
     const paramGroups = getMethodParamGroup(method);
-    let body = 'let options = options.unwrap_or_default();\n';
-    body += `${indent.get()}let ctx = Context::with_context(&options.method_options.context);\n`;
+    let body = checkEmptyRequiredPathParams(indent, paramGroups.path);
+    body += 'let options = options.unwrap_or_default();\n';
+    body += `${indent.get()}let ctx = options.method_options.context.to_borrowed();\n`;
     body += `${indent.get()}let ${urlVarNeedsMut(paramGroups, method)}url = self.${getEndpointFieldName(client)}.clone();\n`;
     body += constructUrl(indent, use, method, paramGroups);
     body += constructRequest(indent, use, method, paramGroups, false);
     body += `${indent.get()}let rsp = self.pipeline.send(&ctx, &mut request).await?;\n`;
     body += errIfNotSuccessResponse(use, indent);
     let rspInto = 'rsp.into()';
-    if (method.returns.type.kind === 'rawResponse') {
+    if (method.returns.type.kind === 'bufResponse') {
         rspInto = 'rsp';
     }
     body += `${indent.get()}Ok(${rspInto})\n`;
@@ -931,13 +1055,15 @@ function getPageableMethodBody(indent, use, client, method) {
         throw new CodegenError('InternalError', 'paged method with no strategy NYI');
     }
     const bodyFormat = helpers.convertResponseFormat(method.returns.type.type.format);
-    use.add('azure_core::http', 'Method', 'PagerResult', 'PagerState', 'Request', 'Url');
+    use.add('azure_core::http', 'Method', 'Request', 'Url');
+    use.add('azure_core::http::pager', 'PagerResult', 'PagerState');
     use.add('azure_core', bodyFormat, 'Result');
     use.addForType(method.returns.type);
     use.addForType(helpers.unwrapType(method.returns.type));
     const paramGroups = getMethodParamGroup(method);
     const urlVar = 'first_url';
-    let body = 'let options = options.unwrap_or_default().into_owned();\n';
+    let body = checkEmptyRequiredPathParams(indent, paramGroups.path);
+    body += 'let options = options.unwrap_or_default().into_owned();\n';
     body += `${indent.get()}let pipeline = self.pipeline.clone();\n`;
     body += `${indent.get()}let ${urlVarNeedsMut(paramGroups, method)}${urlVar} = self.${getEndpointFieldName(client)}.clone();\n`;
     body += constructUrl(indent, use, method, paramGroups, urlVar);
@@ -1001,38 +1127,33 @@ function getPageableMethodBody(indent, use, client, method) {
             break;
         }
     }
-    let rspType;
-    let rspInto;
+    // Pipeline::send() returns a BufResponse, so no reason to declare the type if not something else.
+    let rspType = '';
+    let rspInto = '';
     if (method.strategy.kind === 'continuationToken' && method.strategy.responseToken.kind === 'responseHeaderScalar') {
         // the continuation token comes from a response header. therefore,
         // we need a Response<T> so we have access to the header trait.
         use.addForType(method.returns.type.type);
-        rspType = helpers.getTypeDeclaration(method.returns.type.type);
+        const rspTypeDecl = helpers.getTypeDeclaration(method.returns.type.type);
+        rspType = `: ${rspTypeDecl}`;
         rspInto = '.into()';
     }
-    else {
-        // continuation token comes from the response body.
-        // we'll deconstruct the raw response and parse it later.
-        use.add('azure_core', 'http::RawResponse');
-        rspType = 'RawResponse';
-        rspInto = '';
-    }
     body += constructRequest(indent, use, method, paramGroups, true);
     body += `${indent.get()}let ctx = options.method_options.context.clone();\n`;
     body += `${indent.get()}let pipeline = pipeline.clone();\n`;
     body += `${indent.get()}async move {\n`;
-    body += `${indent.push().get()}let rsp: ${rspType} = pipeline.send(&ctx, &mut request).await?${rspInto};\n`;
-    if (rspType === 'RawResponse') {
+    body += `${indent.push().get()}let rsp${rspType} = pipeline.send(&ctx, &mut request).await?${rspInto};\n`;
+    if (rspType === '') {
         body += errIfNotSuccessResponse(use, indent);
     }
     // check if we need to extract the next link field from the response model
     if (method.strategy.kind === 'nextLink' || method.strategy.responseToken.kind === 'modelField') {
-        use.add('azure_core', 'http::RawResponse');
+        use.add('azure_core', 'http::BufResponse');
         body += `${indent.get()}let (status, headers, body) = rsp.deconstruct();\n`;
         body += `${indent.get()}let bytes = body.collect().await?;\n`;
         const deserialize = bodyFormat === 'json' ? 'json::from_json' : 'xml::read_xml';
         body += `${indent.get()}let res: ${helpers.getTypeDeclaration(helpers.unwrapType(method.returns.type))} = ${deserialize}(&bytes)?;\n`;
-        body += `${indent.get()}let rsp = RawResponse::from_bytes(status, headers, bytes).into();\n`;
+        body += `${indent.get()}let rsp = BufResponse::from_bytes(status, headers, bytes).into();\n`;
     }
     let srcNextPage;
     let nextPageValue;
@@ -1081,13 +1202,100 @@ function getPageableMethodBody(indent, use, client, method) {
     body += `${indent.pop().get()}}))`; // end Ok/Pager::from_callback
     return body;
 }
+/**
+ * constructs the body for an LRO client method
+ *
+ * @param indent the indentation helper currently in scope
+ * @param use the use statement builder currently in scope
+ * @param client the client to which the method belongs
+ * @param method the method for the body to build
+ * @returns the contents of the method body
+ */
+function getLroMethodBody(indent, use, client, method) {
+    const bodyFormat = helpers.convertResponseFormat(method.returns.type.type.format);
+    use.add('azure_core::http', 'Method', 'BufResponse', 'Request', 'Url');
+    use.add('azure_core::http::headers', 'RETRY_AFTER', 'X_MS_RETRY_AFTER_MS', 'RETRY_AFTER_MS');
+    use.add('azure_core::http::poller', 'get_retry_after', 'PollerResult', 'PollerState', 'PollerStatus', 'StatusMonitor as _');
+    use.addForType(method.returns.type);
+    use.addForType(helpers.unwrapType(method.returns.type));
+    const paramGroups = getMethodParamGroup(method);
+    const urlVar = 'url';
+    let body = 'let options = options.unwrap_or_default().into_owned();\n';
+    body += `${indent.get()}let pipeline = self.pipeline.clone();\n`;
+    body += `${indent.get()}let ${urlVarNeedsMut(paramGroups, method)}${urlVar} = self.${getEndpointFieldName(client)}.clone();\n`;
+    body += `${constructUrl(indent, use, method, paramGroups, urlVar)}\n\n`;
+    if (paramGroups.apiVersion) {
+        body += `${indent.get()}let ${paramGroups.apiVersion.name} = ${getHeaderPathQueryParamValue(use, paramGroups.apiVersion, true)}.clone();\n\n`;
+    }
+    body += `${indent.get()}Ok(${method.returns.type.name}::from_callback(\n`;
+    body += `${indent.push().get()}move |next_link: PollerState<Url>| {\n`;
+    body += `${indent.push().get()}let (mut request, next_link) = ${helpers.buildMatch(indent, 'next_link', [{
+            pattern: `PollerState::More(next_link)`,
+            body: (indent) => {
+                let body = '';
+                if (paramGroups.apiVersion) {
+                    body += `${indent.get()}let qp = next_link.query_pairs().filter(|(name, _)| name.ne("api-version"));\n`;
+                }
+                body += `${indent.get()}let mut next_link = next_link.clone();\n`;
+                if (paramGroups.apiVersion) {
+                    body += `${indent.get()}next_link.query_pairs_mut().clear().extend_pairs(qp).append_pair("api-version", &${paramGroups.apiVersion.name});\n\n`;
+                }
+                body += `${indent.get()}let ${paramGroups.header.length > 0 ? 'mut ' : ''}request = Request::new(next_link.clone(), Method::Get);`;
+                body += `\n${applyHeaderParams(indent, use, method, paramGroups, true)}\n\n`;
+                body += `${indent.get()}(request, next_link)\n`;
+                return body;
+            },
+        }, {
+            pattern: 'PollerState::Initial',
+            body: (indent) => {
+                let body = `${constructRequest(indent, use, method, paramGroups, true, true, false)}\n`;
+                body += `${indent.get()}(request, url.clone())\n`;
+                return body;
+            },
+        }])};\n\n`;
+    body += `${indent.get()}let ctx = options.method_options.context.clone();\n`;
+    body += `${indent.get()}let pipeline = pipeline.clone();\n`;
+    body += `${indent.get()}async move {\n`;
+    body += `${indent.push().get()}let rsp = pipeline.send(&ctx, &mut request).await?;\n`;
+    body += `${indent.get()}let (status, headers, body) = rsp.deconstruct();\n`;
+    body += `${indent.get()}let retry_after = get_retry_after(&headers, &[X_MS_RETRY_AFTER_MS, RETRY_AFTER_MS, RETRY_AFTER], &options.poller_options);\n`;
+    body += `${indent.get()}let bytes = body.collect().await?;\n`;
+    let deserialize = '';
+    if (bodyFormat === 'json') {
+        use.add('azure_core', 'json');
+        deserialize = 'json::from_json';
+    }
+    else {
+        deserialize = 'xml::read_xml';
+    }
+    body += `${indent.get()}let res: ${helpers.getTypeDeclaration(helpers.unwrapType(method.returns.type))} = ${deserialize}(&bytes)?;\n`;
+    body += `${indent.get()}let rsp = BufResponse::from_bytes(status, headers, bytes).into();\n`;
+    body += `${indent.get()}Ok(${helpers.buildMatch(indent, 'res.status()', [{
+            pattern: `PollerStatus::InProgress`,
+            body: (indent) => {
+                return `${indent.get()}response: rsp, retry_after, next: next_link\n`;
+            },
+            returns: 'PollerResult::InProgress'
+        }, {
+            pattern: '_',
+            body: (indent) => {
+                return `${indent.get()}response: rsp`;
+            },
+            returns: 'PollerResult::Done'
+        }])})\n`;
+    body += `${indent.pop().get()}}\n`; // end async move
+    body += `${indent.pop().get()}},\n`; // end move
+    body += `${indent.get()}None,\n`;
+    body += `${indent.pop().get()}))`; // end Ok/Poller::from_callback
+    return body;
+}
 /**
  * contains the code to use when populating a client endpoint parameter value
  * from a parameter of that type.
  * @param param the param for which to get the value
  * @returns the code to use for the param's value
  */
-function getClientEndpointParamValue(param) {
+function getClientSupplementalEndpointParamValue(param) {
     let paramName = param.name;
     if (param.optional) {
         paramName = 'options.' + paramName;
@@ -1179,8 +1387,8 @@ function getHeaderPathQueryParamValue(use, param, fromSelf) {
             return encodeBytes(paramType, paramName);
         case 'enum':
         case 'scalar':
-            if (paramType.kind === 'enum' && param.kind === 'queryScalar') {
-                // append_pair wants a reference to the string
+            if (paramType.kind === 'enum' && (param.kind === 'pathScalar' || param.kind === 'queryScalar')) {
+                // append_pair and path.replace() want a reference to the string
                 // TODO: https://github.com/Azure/typespec-rust/issues/25
                 return `${paramName}.as_ref()`;
             }
@@ -1231,9 +1439,4 @@ function nonCopyableType(type) {
 function isClientMethodOptions(type) {
     return type.kind === 'external' && type.name === 'ClientMethodOptions';
 }
-/** returns true if the type is a credential */
-function isCredential(type) {
-    const unwrappedType = helpers.unwrapType(type);
-    return unwrappedType.kind === 'tokenCredential';
-}
 //# sourceMappingURL=clients.js.map