@azure-tools/typespec-rust 0.21.0 → 0.23.0

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

@@ -1 +1 @@
-{"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,CA2QxE"}
+{"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

@@ -82,18 +82,17 @@ export function emitClients(crate) {
                 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) => `${indent.get()}return Err(azure_core::Error::with_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`;
                 }
@@ -109,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}`);
                     }
@@ -287,7 +282,9 @@ function getMethodOptions(crate) {
             }
             body += '}\n\n'; // end options
             if (method.kind === 'pageable' || method.kind === 'lro') {
-                body += `impl ${helpers.getTypeDeclaration(method.options.type, true)} {\n`;
+                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`;
                 indent.push();
@@ -419,7 +416,7 @@ function getMethodParamsSig(method, use) {
                 paramsSig.push(`${param.name}: ${formatParamTypeName(param)}`);
             }
         }
-        paramsSig.push(`options: ${helpers.getTypeDeclaration(method.options, true)}`);
+        paramsSig.push(`options: ${helpers.getTypeDeclaration(method.options, 'anonymous')}`);
     }
     return paramsSig.join(', ');
 }
@@ -848,10 +845,26 @@ function applyHeaderParams(indent, use, method, paramGroups, inClosure) {
             // 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.
             // if not, then check if an optional token value was provided.
+            body += `${indent.get()}let ${headerParam.name} = ` + helpers.buildMatch(indent, headerParam.name, [
+                {
+                    pattern: `PagerState::More(${headerParam.name})`,
+                    body: (indent) => `${indent.get()}&Some(${headerParam.name})\n`,
+                },
+                {
+                    pattern: 'PagerState::Initial',
+                    body: (indent) => `${indent.get()}&options.${headerParam.name}\n`,
+                }
+            ]) + ';\n';
             body += indent.get() + helpers.buildIfBlock(indent, {
-                condition: `let Some(${headerParam.name}) = ${headerParam.name}.or_else(|| options.${headerParam.name}.clone())`,
+                condition: `let Some(${headerParam.name}) = ${headerParam.name}`,
                 body: (indent) => `${indent.get()}request.insert_header("${headerParam.header}", ${headerParam.name});\n`,
-            });
+            }) + '\n';
+            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, () => {
@@ -869,6 +882,10 @@ function applyHeaderParams(indent, use, method, paramGroups, inClosure) {
     }
     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.
@@ -889,7 +906,7 @@ function constructRequest(indent, use, method, paramGroups, inClosure, cloneUrl
     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 (headerParam.kind === 'headerScalar' && headerParam.optional && headerParam.header.toLowerCase() === 'content-type') {
+        if (isOptionalContentTypeHeader(headerParam)) {
             optionalContentTypeParam = headerParam;
         }
     }
@@ -934,27 +951,6 @@ function constructRequest(indent, use, method, paramGroups, inClosure, cloneUrl
     }
     return body;
 }
-/**
- * Return an error if a local RawResponse 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::http::headers', 'ERROR_CODE');
-    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, Some(ERROR_CODE)).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;
-        },
-    });
-}
 /**
  * Returns 'mut ' if the Url local var needs to be mutable, else the empty string.
  * @param paramGroups the param groups associated with the Url being constructed.
@@ -1016,7 +1012,7 @@ function emitEmptyPathParamCheck(indent, param) {
     }
     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"));`,
+        body: (indent) => `${indent.get()}return Err(azure_core::Error::with_message(azure_core::error::ErrorKind::Other, "parameter ${param.name} cannot be empty"));`,
     });
 }
 /**
@@ -1037,10 +1033,9 @@ function getAsyncMethodBody(indent, use, client, method) {
     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);
+    body += `${indent.get()}let rsp = self.pipeline.send(&ctx, &mut request, ${getPipelineSendOptions(indent, use, method)}).await?;\n`;
     let rspInto = 'rsp.into()';
-    if (method.returns.type.kind === 'rawResponse') {
+    if (method.returns.type.kind === 'bufResponse') {
         rspInto = 'rsp';
     }
     body += `${indent.get()}Ok(${rspInto})\n`;
@@ -1056,17 +1051,13 @@ function getAsyncMethodBody(indent, use, client, method) {
  * @returns the contents of the method body
  */
 function getPageableMethodBody(indent, use, client, method) {
-    if (!method.strategy) {
-        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', 'Request', 'Url');
     use.add('azure_core::http::pager', 'PagerResult', 'PagerState');
-    use.add('azure_core', bodyFormat, 'Result');
+    use.add('azure_core', 'Result');
     use.addForType(method.returns.type);
     use.addForType(helpers.unwrapType(method.returns.type));
     const paramGroups = getMethodParamGroup(method);
-    const urlVar = 'first_url';
+    const urlVar = method.strategy ? 'first_url' : 'url';
     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`;
@@ -1075,139 +1066,163 @@ function getPageableMethodBody(indent, use, client, method) {
     if (paramGroups.apiVersion) {
         body += `${indent.get()}let ${paramGroups.apiVersion.name} = ${getHeaderPathQueryParamValue(use, paramGroups.apiVersion, true)}.clone();\n`;
     }
-    switch (method.strategy.kind) {
-        case 'continuationToken': {
-            const reqTokenParam = method.strategy.requestToken.name;
-            body += `${indent.get()}Ok(${method.returns.type.name}::from_callback(move |${reqTokenParam}: PagerState<String>| {\n`;
-            body += `${indent.push().get()}let ${method.strategy.requestToken.kind === 'queryScalar' ? 'mut ' : ''}url = first_url.clone();\n`;
-            if (method.strategy.requestToken.kind === 'queryScalar') {
-                // if the url already contains the token query param,
-                // e.g. we started on some page, then we need to remove
-                // it before appending the token for the next page.
-                const reqTokenValue = method.strategy.requestToken.key;
-                body += `${indent.get()}${helpers.buildIfBlock(indent, {
-                    condition: `let PagerState::More(${reqTokenParam}) = ${reqTokenParam}`,
-                    body: (indent) => {
-                        let body = indent.get() + helpers.buildIfBlock(indent, {
-                            condition: `url.query_pairs().any(|(name, _)| name.eq("${reqTokenValue}"))`,
-                            body: (indent) => {
-                                let body = `${indent.get()}let mut new_url = url.clone();\n`;
-                                body += `${indent.get()}new_url.query_pairs_mut().clear().extend_pairs(url.query_pairs().filter(|(name, _)| name.ne("${reqTokenValue}")));\n`;
-                                body += `${indent.get()}url = new_url;\n`;
-                                return body;
-                            },
-                        });
-                        body += `${indent.get()}url.query_pairs_mut().append_pair("${reqTokenValue}", &${reqTokenParam});\n`;
-                        return body;
-                    }
-                })}`;
+    // passed to constructRequest. we only need to
+    // clone it for the non-continuation case.
+    let cloneUrl = false;
+    if (method.strategy) {
+        switch (method.strategy.kind) {
+            case 'continuationToken': {
+                const reqTokenParam = method.strategy.requestToken.name;
+                body += `${indent.get()}Ok(${method.returns.type.name}::from_callback(move |${reqTokenParam}: PagerState<String>| {\n`;
+                body += `${indent.push().get()}let ${method.strategy.requestToken.kind === 'queryScalar' ? 'mut ' : ''}url = first_url.clone();\n`;
+                if (method.strategy.requestToken.kind === 'queryScalar') {
+                    // if the url already contains the token query param,
+                    // e.g. we started on some page, then we need to remove
+                    // it before appending the token for the next page.
+                    const reqTokenValue = method.strategy.requestToken.key;
+                    body += `${indent.get()}${helpers.buildIfBlock(indent, {
+                        condition: `let PagerState::More(${reqTokenParam}) = ${reqTokenParam}`,
+                        body: (indent) => {
+                            let body = indent.get() + helpers.buildIfBlock(indent, {
+                                condition: `url.query_pairs().any(|(name, _)| name.eq("${reqTokenValue}"))`,
+                                body: (indent) => {
+                                    let body = `${indent.get()}let mut new_url = url.clone();\n`;
+                                    body += `${indent.get()}new_url.query_pairs_mut().clear().extend_pairs(url.query_pairs().filter(|(name, _)| name.ne("${reqTokenValue}")));\n`;
+                                    body += `${indent.get()}url = new_url;\n`;
+                                    return body;
+                                },
+                            }) + '\n';
+                            body += `${indent.get()}url.query_pairs_mut().append_pair("${reqTokenValue}", &${reqTokenParam});\n`;
+                            return body;
+                        }
+                    })}\n`;
+                }
+                break;
             }
-            break;
-        }
-        case 'nextLink': {
-            const nextLinkName = method.strategy.nextLink.name;
-            body += `${indent.get()}Ok(${method.returns.type.name}::from_callback(move |${nextLinkName}: PagerState<Url>| {\n`;
-            body += `${indent.push().get()}let url = ` + helpers.buildMatch(indent, nextLinkName, [{
-                    pattern: `PagerState::More(${nextLinkName})`,
-                    body: (indent) => {
-                        if (paramGroups.apiVersion && paramGroups.apiVersion.kind === 'queryScalar') {
-                            const apiVersionKey = `"${paramGroups.apiVersion.key}"`;
-                            // there are no APIs to set/update an existing query parameter.
-                            // so, we filter the existing query params to remove the api-version
-                            // query param. we then add back the filtered set and then add the
-                            // api-version as specified on the client.
-                            let setApiVerBody = `${indent.get()}let qp = ${nextLinkName}.query_pairs().filter(|(name, _)| name.ne(${apiVersionKey}));\n`;
-                            setApiVerBody += `${indent.get()}let mut ${nextLinkName} = ${nextLinkName}.clone();\n`;
-                            setApiVerBody += `${indent.get()}${nextLinkName}.query_pairs_mut().clear().extend_pairs(qp).append_pair(${apiVersionKey}, &${paramGroups.apiVersion.name});\n`;
-                            setApiVerBody += `${indent.get()}${nextLinkName}\n`;
-                            return setApiVerBody;
+            case 'nextLink': {
+                const nextLinkName = method.strategy.nextLinkPath[method.strategy.nextLinkPath.length - 1].name;
+                body += `${indent.get()}Ok(${method.returns.type.name}::from_callback(move |${nextLinkName}: PagerState<Url>| {\n`;
+                body += `${indent.push().get()}let url = ` + helpers.buildMatch(indent, nextLinkName, [{
+                        pattern: `PagerState::More(${nextLinkName})`,
+                        body: (indent) => {
+                            if (paramGroups.apiVersion && paramGroups.apiVersion.kind === 'queryScalar') {
+                                const apiVersionKey = `"${paramGroups.apiVersion.key}"`;
+                                // there are no APIs to set/update an existing query parameter.
+                                // so, we filter the existing query params to remove the api-version
+                                // query param. we then add back the filtered set and then add the
+                                // api-version as specified on the client.
+                                let setApiVerBody = `${indent.get()}let qp = ${nextLinkName}.query_pairs().filter(|(name, _)| name.ne(${apiVersionKey}));\n`;
+                                setApiVerBody += `${indent.get()}let mut ${nextLinkName} = ${nextLinkName}.clone();\n`;
+                                setApiVerBody += `${indent.get()}${nextLinkName}.query_pairs_mut().clear().extend_pairs(qp).append_pair(${apiVersionKey}, &${paramGroups.apiVersion.name});\n`;
+                                setApiVerBody += `${indent.get()}${nextLinkName}\n`;
+                                return setApiVerBody;
+                            }
+                            return `${indent.get()} ${nextLinkName}\n`;
                         }
-                        return `${indent.get()} ${nextLinkName}\n`;
-                    }
-                }, {
-                    pattern: 'PagerState::Initial',
-                    body: (indent) => `${indent.get()}${urlVar}.clone()\n`
-                }]);
-            body += ';\n';
-            break;
+                    }, {
+                        pattern: 'PagerState::Initial',
+                        body: (indent) => `${indent.get()}${urlVar}.clone()\n`
+                    }]);
+                body += ';\n';
+                break;
+            }
         }
     }
-    let rspType;
-    let rspInto;
-    if (method.strategy.kind === 'continuationToken' && method.strategy.responseToken.kind === 'responseHeaderScalar') {
+    else {
+        // no next link when there's no strategy
+        body += `${indent.get()}Ok(Pager::from_callback(move |_: PagerState<Url>| {\n`;
+        cloneUrl = true;
+    }
+    // Pipeline::send() returns a BufResponse, so no reason to declare the type if not something else.
+    let rspType = '';
+    let rspInto = '';
+    if (method.strategy && 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 += constructRequest(indent, use, method, paramGroups, true, cloneUrl);
     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 += errIfNotSuccessResponse(use, indent);
-    }
+    body += `${indent.push().get()}let rsp${rspType} = pipeline.send(&ctx, &mut request, ${getPipelineSendOptions(indent, use, method)}).await?${rspInto};\n`;
     // 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');
+    if (method.strategy && (method.strategy.kind === 'nextLink' || method.strategy.responseToken.kind === 'nextLink')) {
+        const bodyFormat = helpers.convertResponseFormat(method.returns.type.type.format);
+        use.add('azure_core', bodyFormat, '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;
-    let continuation;
-    switch (method.strategy.kind) {
-        case 'continuationToken':
-            nextPageValue = method.strategy.responseToken.name;
-            continuation = nextPageValue;
-            switch (method.strategy.responseToken.kind) {
-                case 'modelField':
-                    srcNextPage = `res.${nextPageValue}`;
-                    break;
-                case 'responseHeaderScalar':
-                    if (!method.responseHeaders) {
-                        throw new CodegenError('InternalError', `missing response headers trait for method ${method.name}`);
-                    }
-                    use.addForType(method.responseHeaders);
-                    srcNextPage = `rsp.${method.strategy.responseToken.name}()?`;
-                    break;
+    if (method.strategy) {
+        /** provides access to the next link field, handling nested fields as required */
+        const buildNextLinkPath = function (nextLinkPath) {
+            let fullPath = nextLinkPath[0].name;
+            if (nextLinkPath.length > 1) {
+                for (let i = 1; i < nextLinkPath.length; ++i) {
+                    const prev = nextLinkPath[i - 1];
+                    const cur = nextLinkPath[i];
+                    fullPath += `.and_then(|${prev.name}| ${prev.name}.${cur.name})`;
+                }
             }
-            break;
-        case 'nextLink':
-            nextPageValue = method.strategy.nextLink.name;
-            srcNextPage = `res.${nextPageValue}`;
-            continuation = `${nextPageValue}.parse()?`;
-            break;
+            return fullPath;
+        };
+        let srcNextPage;
+        let nextPageValue;
+        let continuation;
+        switch (method.strategy.kind) {
+            case 'continuationToken':
+                switch (method.strategy.responseToken.kind) {
+                    case 'nextLink':
+                        nextPageValue = method.strategy.responseToken.nextLinkPath[method.strategy.responseToken.nextLinkPath.length - 1].name;
+                        srcNextPage = `res.${buildNextLinkPath(method.strategy.responseToken.nextLinkPath)}`;
+                        break;
+                    case 'responseHeaderScalar':
+                        if (!method.responseHeaders) {
+                            throw new CodegenError('InternalError', `missing response headers trait for method ${method.name}`);
+                        }
+                        nextPageValue = method.strategy.responseToken.name;
+                        use.addForType(method.responseHeaders);
+                        srcNextPage = `rsp.${method.strategy.responseToken.name}()?`;
+                        break;
+                }
+                continuation = nextPageValue;
+                break;
+            case 'nextLink': {
+                const lastFieldName = method.strategy.nextLinkPath[method.strategy.nextLinkPath.length - 1].name;
+                nextPageValue = lastFieldName;
+                srcNextPage = `res.${buildNextLinkPath(method.strategy.nextLinkPath)}`;
+                continuation = `${lastFieldName}.parse()?`;
+                break;
+            }
+        }
+        // we need to handle the case where the next page value is the empty string,
+        // so checking strictly for None(theNextLink) is insufficient.
+        // the most common case for this is XML, e.g. an empty tag like <NextLink />
+        body += `${indent.get()}Ok(${helpers.buildMatch(indent, srcNextPage, [{
+                pattern: `Some(${nextPageValue}) if !${nextPageValue}.is_empty()`,
+                body: (indent) => {
+                    return `${indent.get()}response: rsp, continuation: ${continuation}\n`;
+                },
+                returns: 'PagerResult::More',
+            }, {
+                pattern: '_',
+                body: (indent) => {
+                    return `${indent.get()}response: rsp\n`;
+                },
+                returns: 'PagerResult::Done',
+            }])}`;
+        body += ')\n'; // end Ok
+    }
+    else {
+        // non-continuation case, so we don't need to worry about next links, continuation tokens, etc...
+        body += `${indent.get()}Ok(PagerResult::Done { response: rsp.into() })\n`;
     }
-    // we need to handle the case where the next page value is the empty string,
-    // so checking strictly for None(theNextLink) is insufficient.
-    // the most common case for this is XML, e.g. an empty tag like <NextLink />
-    body += `${indent.get()}Ok(${helpers.buildMatch(indent, srcNextPage, [{
-            pattern: `Some(${nextPageValue}) if !${nextPageValue}.is_empty()`,
-            body: (indent) => {
-                return `${indent.get()}response: rsp, continuation: ${continuation}`;
-            },
-            returns: 'PagerResult::More',
-        }, {
-            pattern: '_',
-            body: (indent) => {
-                return `${indent.get()}response: rsp`;
-            },
-            returns: 'PagerResult::Done',
-        }])}`;
-    body += ')\n'; // end Ok
     body += `${indent.pop().get()}}\n`; // end async move
     body += `${indent.pop().get()}}))`; // end Ok/Pager::from_callback
     return body;
@@ -1223,7 +1238,7 @@ function getPageableMethodBody(indent, use, client, method) {
  */
 function getLroMethodBody(indent, use, client, method) {
     const bodyFormat = helpers.convertResponseFormat(method.returns.type.type.format);
-    use.add('azure_core::http', 'Method', 'RawResponse', 'Request', 'Url');
+    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);
@@ -1233,40 +1248,39 @@ function getLroMethodBody(indent, use, client, method) {
     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`;
+    body += constructUrl(indent, use, method, paramGroups, urlVar);
     if (paramGroups.apiVersion) {
-        body += `${indent.get()}let ${paramGroups.apiVersion.name} = ${getHeaderPathQueryParamValue(use, paramGroups.apiVersion, true)}.clone();\n\n`;
+        body += `${indent.get()}let ${paramGroups.apiVersion.name} = ${getHeaderPathQueryParamValue(use, paramGroups.apiVersion, true)}.clone();\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) => {
+                var _a;
                 let body = '';
-                if (paramGroups.apiVersion) {
-                    body += `${indent.get()}let qp = next_link.query_pairs().filter(|(name, _)| name.ne("api-version"));\n`;
+                if (((_a = paramGroups.apiVersion) === null || _a === void 0 ? void 0 : _a.kind) === 'queryScalar') {
+                    body += `${indent.get()}let qp = next_link.query_pairs().filter(|(name, _)| name.ne("${paramGroups.apiVersion.key}"));\n`;
+                    body += `${indent.get()}let mut next_link = next_link.clone();\n`;
+                    body += `${indent.get()}next_link.query_pairs_mut().clear().extend_pairs(qp).append_pair("${paramGroups.apiVersion.key}", &${paramGroups.apiVersion.name});\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()}let ${paramGroups.header.length > 0 ? 'mut ' : ''}request = Request::new(next_link.clone(), Method::Get);\n`;
+                body += applyHeaderParams(indent, use, method, paramGroups, true);
                 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`;
+                let body = constructRequest(indent, use, method, paramGroups, true, true, false);
                 body += `${indent.get()}(request, url.clone())\n`;
                 return body;
             },
-        }])};\n\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: RawResponse = pipeline.send(&ctx, &mut request).await?;\n`;
+    body += `${indent.push().get()}let rsp = pipeline.send(&ctx, &mut request, ${getPipelineSendOptions(indent, use, method)}).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`;
@@ -1279,7 +1293,7 @@ function getLroMethodBody(indent, use, client, method) {
         deserialize = '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`;
     body += `${indent.get()}Ok(${helpers.buildMatch(indent, 'res.status()', [{
             pattern: `PollerStatus::InProgress`,
             body: (indent) => {
@@ -1305,7 +1319,7 @@ function getLroMethodBody(indent, use, client, method) {
  * @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;
@@ -1449,9 +1463,20 @@ 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';
+function getPipelineSendOptions(indent, use, method) {
+    let options = '';
+    if (method.statusCodes.length != 0) {
+        use.add("azure_core::http", "PipelineSendOptions");
+        use.add("azure_core::error", "CheckSuccessOptions");
+        options += `Some(PipelineSendOptions {\n`;
+        indent.push();
+        options += `${indent.get()}check_success: CheckSuccessOptions{ success_codes: &[${method.statusCodes.join(', ')}]},\n`;
+        options += `${indent.get()}..Default::default()\n`;
+        options += `${indent.pop().get()}})`;
+        return options;
+    }
+    else {
+        return 'None';
+    }
 }
 //# sourceMappingURL=clients.js.map