@azure-tools/typespec-rust 0.22.0 → 0.23.1

package/dist/src/codegen/clients.js

@@ -85,7 +85,7 @@ export function emitClients(crate) {
                 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`,
                 })}`;
                 // construct the supplemental path and join it to the endpoint
                 if (client.constructable.endpoint) {
@@ -282,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();
@@ -414,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(', ');
 }
@@ -843,10 +845,20 @@ 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)) {
@@ -939,17 +951,6 @@ function constructRequest(indent, use, method, paramGroups, inClosure, cloneUrl
     }
     return body;
 }
-/**
- * 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::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.
  * @param paramGroups the param groups associated with the Url being constructed.
@@ -1011,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"));`,
     });
 }
 /**
@@ -1032,8 +1033,7 @@ 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 === 'bufResponse') {
         rspInto = 'rsp';
@@ -1051,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`;
@@ -1070,67 +1066,77 @@ 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;
+            }
         }
     }
+    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.kind === 'continuationToken' && method.strategy.responseToken.kind === 'responseHeaderScalar') {
+    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);
@@ -1138,66 +1144,85 @@ function getPageableMethodBody(indent, use, client, method) {
         rspType = `: ${rspTypeDecl}`;
         rspInto = '.into()';
     }
-    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 === '') {
-        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::BufResponse');
+    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 = 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,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`;
-                }
-                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`;
+                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 ${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 = 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`;
@@ -1439,4 +1463,20 @@ function nonCopyableType(type) {
 function isClientMethodOptions(type) {
     return type.kind === 'external' && type.name === 'ClientMethodOptions';
 }
+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