@azure-tools/typespec-go 0.10.7 → 0.11.1

package/dist/codegen.go/src/core/operations.js

@@ -43,7 +43,11 @@ export function generateOperations(pkg, target, options) {
         }
         imports.add(azureARM ? 'github.com/Azure/azure-sdk-for-go/sdk/azcore/arm' : 'github.com/Azure/azure-sdk-for-go/sdk/azcore');
         // generate client type
-        let clientText = helpers.formatDocComment(client.docs);
+        let clientText = '';
+        if (client.apiVersion) {
+            clientText += `const ${client.apiVersion.name} ${go.getTypeDeclaration(client.apiVersion, pkg)} = ${helpers.formatLiteralValue(client.apiVersion.literal, false)}\n\n`;
+        }
+        clientText += helpers.formatDocComment(client.docs);
         clientText += "// Don't use this type directly, use ";
         if (client.instance?.kind === 'constructable' && client.instance.constructors.length === 1) {
             clientText += `${client.instance.constructors[0].name}() instead.\n`;
@@ -65,8 +69,12 @@ export function generateOperations(pkg, target, options) {
         else {
             clientText += 'a constructor function instead.\n';
         }
+        if (client.apiVersion) {
+            clientText += `//\n// Generated from API version ${client.apiVersion.literal.literal}\n`;
+        }
+        const indent = new helpers.Indentation();
         clientText += `type ${client.name} struct {\n`;
-        clientText += `\tinternal *${azureARM ? 'arm' : 'azcore'}.Client\n`;
+        clientText += `${indent.get()}internal *${azureARM ? 'arm' : 'azcore'}.Client\n`;
         // check for any optional host params
         const optionalParams = new Array();
         const isParamPointer = function (param) {
@@ -82,12 +90,12 @@ export function generateOperations(pkg, target, options) {
                 }
                 if (clientParam.group) {
                     if (!addedGroups.has(clientParam.group.groupName)) {
-                        clientText += `\t${naming.uncapitalize(clientParam.group.groupName)} ${!isParamPointer(clientParam) ? '' : '*'}${clientParam.group.groupName}\n`;
+                        clientText += `${indent.get()}${naming.uncapitalize(clientParam.group.groupName)} ${!isParamPointer(clientParam) ? '' : '*'}${clientParam.group.groupName}\n`;
                         addedGroups.add(clientParam.group.groupName);
                     }
                     continue;
                 }
-                clientText += `\t${clientParam.name} `;
+                clientText += `${indent.get()}${clientParam.name} `;
                 if (!isParamPointer(clientParam)) {
                     clientText += `${go.getTypeDeclaration(clientParam.type, client.pkg)}\n`;
                 }
@@ -101,7 +109,7 @@ export function generateOperations(pkg, target, options) {
         }
         // end of client definition
         clientText += '}\n\n';
-        clientText += generateConstructors(client, target, imports);
+        clientText += generateConstructors(client, target, imports, indent);
         // generate client accessors and operations
         let opText = '';
         for (const clientAccessor of client.clientAccessors) {
@@ -109,7 +117,7 @@ export function generateOperations(pkg, target, options) {
             const subClientDecl = go.getTypeDeclaration(clientAccessor.returns, pkg);
             opText += helpers.formatDocComment(clientAccessor.docs);
             opText += `func (client *${client.name}) ${clientAccessor.name}(${getAPIParametersSig(clientAccessor, imports)}) *${subClientDecl} {\n`;
-            opText += `\treturn &${subClientDecl}{\n`;
+            opText += `${indent.get()}return &${subClientDecl}{\n`;
             const initFields = new Array('internal: client.internal');
             // propagate all client params
             for (const param of clientAccessor.parameters) {
@@ -129,10 +137,12 @@ export function generateOperations(pkg, target, options) {
                 }
             }
             initFields.sort();
+            indent.push();
             for (const initField of initFields) {
-                opText += `\t\t${initField},\n`;
+                opText += `${indent.get()}${initField},\n`;
             }
-            opText += '\t}\n}\n\n';
+            indent.pop();
+            opText += `${indent.get()}}\n}\n\n`;
         }
         const nextPageMethods = new Array();
         for (const method of client.methods) {
@@ -140,21 +150,21 @@ export function generateOperations(pkg, target, options) {
             // it must be done before the imports are written out
             if (go.isLROMethod(method)) {
                 // generate Begin method
-                opText += generateLROBeginMethod(method, imports, options);
+                opText += generateLROBeginMethod(method, options, imports, indent);
             }
-            opText += generateOperation(method, imports, options);
-            opText += createProtocolRequest(azureARM, method, imports);
+            opText += generateOperation(method, options, imports, indent);
+            opText += createProtocolRequest(azureARM, method, imports, indent);
             if (method.kind !== 'lroMethod') {
                 // LRO responses are handled elsewhere, with the exception of pageable LROs
-                opText += createProtocolResponse(method, imports);
+                opText += createProtocolResponse(method, imports, indent);
             }
-            if ((method.kind === 'lroPageableMethod' || method.kind === 'pageableMethod') && method.nextPageMethod && !nextPageMethods.includes(method.nextPageMethod)) {
+            if (go.isPageableMethod(method) && method.strategy?.kind === 'nextLink' && method.strategy.method && !nextPageMethods.includes(method.strategy.method)) {
                 // track the next page methods to generate as multiple operations can use the same next page operation
-                nextPageMethods.push(method.nextPageMethod);
+                nextPageMethods.push(method.strategy.method);
             }
         }
         for (const method of nextPageMethods) {
-            opText += createProtocolRequest(azureARM, method, imports);
+            opText += createProtocolRequest(azureARM, method, imports, indent);
         }
         // stitch it all together
         let text = helpers.contentPreamble(pkg);
@@ -173,7 +183,7 @@ export function generateOperations(pkg, target, options) {
  * @param imports the import manager currently in scope
  * @returns the client constructor code or the empty string
  */
-function generateConstructors(client, type, imports) {
+function generateConstructors(client, type, imports, indent) {
     if (client.instance?.kind !== 'constructable') {
         return '';
     }
@@ -182,7 +192,7 @@ function generateConstructors(client, type, imports) {
     if (clientOptions.kind === 'clientOptions') {
         // for non-ARM, the options type will always be a parameter group
         ctorText += `// ${clientOptions.name} contains the optional values for creating a [${client.name}].\n`;
-        ctorText += `type ${clientOptions.name} struct {\n\tazcore.ClientOptions\n`;
+        ctorText += `type ${clientOptions.name} struct {\n${indent.get()}azcore.ClientOptions\n`;
         for (const param of clientOptions.parameters) {
             if (go.isAPIVersionParameter(param)) {
                 // we use azcore.ClientOptions.APIVersion
@@ -193,9 +203,9 @@ function generateConstructors(client, type, imports) {
                 if (!param.docs.description && !param.docs.summary) {
                     ctorText += '\n';
                 }
-                ctorText += `\t${helpers.comment(`The default value is ${helpers.formatLiteralValue(param.style.defaultValue, false)}`, '// ')}.\n`;
+                ctorText += `${indent.get()}${helpers.comment(`The default value is ${helpers.formatLiteralValue(param.style.defaultValue, false)}`, '// ')}.\n`;
             }
-            ctorText += `\t${naming.ensureNameCase(param.name)} *${go.getTypeDeclaration(param.type, client.pkg)}\n`;
+            ctorText += `${indent.get()}${naming.ensureNameCase(param.name)} *${go.getTypeDeclaration(param.type, client.pkg)}\n`;
         }
         ctorText += '}\n\n';
     }
@@ -228,7 +238,9 @@ function generateConstructors(client, type, imports) {
         }
         const emitProlog = function (optionsTypeName, tokenAuth, plOpts) {
             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
-            let bodyText = `\tif options == nil {\n\t\toptions = &${optionsTypeName}{}\n\t}\n`;
+            let bodyText = `${indent.get()}if options == nil {\n`;
+            bodyText += `${indent.push().get()}options = &${optionsTypeName}{}\n`;
+            bodyText += `${indent.pop().get()}}\n`;
             let apiVersionConfig = '';
             // check if there's an api version parameter
             let apiVersionParam;
@@ -247,13 +259,15 @@ function generateConstructors(client, type, imports) {
                 imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud');
                 imports.add('fmt');
                 imports.add('reflect');
-                bodyText += '\tif reflect.ValueOf(options.Cloud).IsZero() {\n';
-                bodyText += '\t\toptions.Cloud = cloud.AzurePublic\n\t}\n';
-                bodyText += '\tc, ok := options.Cloud.Services[ServiceName]\n';
-                bodyText += '\tif !ok {\n';
-                bodyText += '\t\treturn nil, fmt.Errorf("provided Cloud field is missing configuration for %s", ServiceName)\n';
-                bodyText += '\t} else if c.Audience == "" {\n';
-                bodyText += '\t\treturn nil, fmt.Errorf("provided Cloud field is missing Audience for %s", ServiceName)\n\t}\n';
+                bodyText += `${indent.get()}if reflect.ValueOf(options.Cloud).IsZero() {\n`;
+                bodyText += `${indent.push().get()}options.Cloud = cloud.AzurePublic\n`;
+                bodyText += `${indent.pop().get()}}\n`;
+                bodyText += `${indent.get()}c, ok := options.Cloud.Services[ServiceName]\n`;
+                bodyText += `${indent.get()}if !ok {\n`;
+                bodyText += `${indent.push().get()}return nil, fmt.Errorf("provided Cloud field is missing configuration for %s", ServiceName)\n`;
+                bodyText += `${indent.pop().get()}} else if c.Audience == "" {\n`;
+                bodyText += `${indent.push().get()}return nil, fmt.Errorf("provided Cloud field is missing Audience for %s", ServiceName)\n`;
+                bodyText += `${indent.pop().get()}}\n`;
             }
             if (apiVersionParam) {
                 let location;
@@ -273,18 +287,23 @@ function generateConstructors(client, type, imports) {
                         name = apiVersionParam.queryParameter;
                         break;
                 }
+                indent.push(); // level 2 for PipelineOptions fields
                 if (name) {
-                    name = `\n\t\t\tName: "${name}",`;
+                    indent.push(); // level 3 for APIVersionOptions fields
+                    name = `\n${indent.get()}Name: "${name}",`;
+                    indent.pop(); // back to level 2
                 }
                 else {
                     name = '';
                 }
-                apiVersionConfig = `\n\t\tAPIVersion: runtime.APIVersionOptions{${name}\n\t\t\tLocation: runtime.APIVersionLocation${location},\n\t\t},`;
+                indent.push(); // level 3 for APIVersionOptions fields
+                apiVersionConfig = `\n${indent.pop().get()}APIVersion: runtime.APIVersionOptions{${name}\n${indent.push().get()}Location: runtime.APIVersionLocation${location},\n${indent.pop().get()}},`;
+                indent.pop(); // back to level 1
                 if (!plOpts) {
                     apiVersionConfig += '\n';
                 }
             }
-            bodyText += `\tcl, err := azcore.NewClient(moduleName, moduleVersion, runtime.PipelineOptions{${apiVersionConfig}${plOpts ?? ''}}, &options.ClientOptions)\n`;
+            bodyText += `${indent.get()}cl, err := azcore.NewClient(moduleName, moduleVersion, runtime.PipelineOptions{${apiVersionConfig}${plOpts ?? ''}}, &options.ClientOptions)\n`;
             return bodyText;
         };
         // check if there's a credential parameter
@@ -304,16 +323,19 @@ function generateConstructors(client, type, imports) {
                     switch (clientOptions.kind) {
                         case 'clientOptions': {
                             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/policy');
-                            const tokenPolicyOpts = '&policy.BearerTokenOptions{\n\t\t\tInsecureAllowCredentialWithHTTP: options.InsecureAllowCredentialWithHTTP,\n\t\t}';
+                            indent.push(); // level 2 for PipelineOptions fields
+                            indent.push(); // level 3 for BearerTokenOptions fields
+                            const tokenPolicyOpts = `&policy.BearerTokenOptions{\n${indent.get()}InsecureAllowCredentialWithHTTP: options.InsecureAllowCredentialWithHTTP,\n${indent.pop().get()}}`;
                             // we assume a single scope. this is enforced when adapting the data from tcgc
-                            const tokenPolicy = `\n\t\tPerCall: []policy.Policy{\n\t\truntime.NewBearerTokenPolicy(credential, []string{c.Audience + "${helpers.splitScope(credentialParam.type.scopes[0]).scope}"}, ${tokenPolicyOpts}),\n\t\t},\n`;
+                            const tokenPolicy = `\n${indent.get()}PerCall: []policy.Policy{\n${indent.get()}runtime.NewBearerTokenPolicy(credential, []string{c.Audience + "${helpers.splitScope(credentialParam.type.scopes[0]).scope}"}, ${tokenPolicyOpts}),\n${indent.get()}},\n`;
+                            indent.pop(); // back to level 1
                             prolog = emitProlog(go.getTypeDeclaration(clientOptions, client.pkg), true, tokenPolicy);
                             break;
                         }
                         case 'armClientOptions':
                             // this is the ARM case
                             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/arm');
-                            prolog = '\tcl, err := arm.NewClient(moduleName, moduleVersion, credential, options)\n';
+                            prolog = `${indent.get()}cl, err := arm.NewClient(moduleName, moduleVersion, credential, options)\n`;
                             break;
                     }
                     break;
@@ -331,9 +353,9 @@ function generateConstructors(client, type, imports) {
         }
         ctorText += `func ${constructor.name}(${ctorParams.join(', ')}) (*${client.name}, error) {\n`;
         ctorText += prolog;
-        ctorText += '\tif err != nil {\n';
-        ctorText += '\t\treturn nil, err\n';
-        ctorText += '\t}\n';
+        ctorText += `${indent.get()}if err != nil {\n`;
+        ctorText += `${indent.push().get()}return nil, err\n`;
+        ctorText += `${indent.pop().get()}}\n`;
         // handle any client-side defaults
         if (clientOptions.kind === 'clientOptions') {
             for (const param of clientOptions.parameters) {
@@ -345,8 +367,10 @@ function generateConstructors(client, type, imports) {
                     else {
                         name = naming.ensureNameCase(param.name);
                     }
-                    ctorText += `\t${param.name} := ${helpers.formatLiteralValue(param.style.defaultValue, false)}\n`;
-                    ctorText += `\tif options.${name} != ${helpers.zeroValue(param)} {\n\t\t${param.name} = ${helpers.star(param.byValue)}options.${name}\n\t}\n`;
+                    ctorText += `${indent.get()}${param.name} := ${helpers.formatLiteralValue(param.style.defaultValue, false)}\n`;
+                    ctorText += `${indent.get()}if options.${name} != ${helpers.zeroValue(param)} {\n`;
+                    ctorText += `${indent.push().get()}${param.name} = ${helpers.star(param.byValue)}options.${name}\n`;
+                    ctorText += `${indent.pop().get()}}\n`;
                 }
             }
         }
@@ -356,15 +380,15 @@ function generateConstructors(client, type, imports) {
             const endpointParam = client.instance.constructors[0].parameters[0];
             if (client.instance.endpoint.supplemental.parameters.length > 0) {
                 imports.add('strings');
-                ctorText += `\thost := "${client.instance.endpoint.supplemental.path}"\n`;
+                ctorText += `${indent.get()}host := "${client.instance.endpoint.supplemental.path}"\n`;
                 for (const param of client.instance.endpoint.supplemental.parameters) {
-                    ctorText += `\thost = strings.ReplaceAll(host, "{${param.uriPathSegment}}", ${helpers.formatValue(param.name, param.type, imports)})\n`;
+                    ctorText += `${indent.get()}host = strings.ReplaceAll(host, "{${param.uriPathSegment}}", ${helpers.formatValue(param.name, param.type, imports)})\n`;
                 }
-                ctorText += `\t${endpointParam.name} = runtime.JoinPaths(${endpointParam.name}, host)\n`;
+                ctorText += `${indent.get()}${endpointParam.name} = runtime.JoinPaths(${endpointParam.name}, host)\n`;
             }
             else {
                 // there are no params for the supplemental host, so just append it
-                ctorText += `\t${endpointParam.name} = runtime.JoinPaths(${endpointParam.name}, "${client.instance.endpoint.supplemental.path}")\n`;
+                ctorText += `${indent.get()}${endpointParam.name} = runtime.JoinPaths(${endpointParam.name}, "${client.instance.endpoint.supplemental.path}")\n`;
             }
         }
         // construct client literal
@@ -376,122 +400,147 @@ function generateConstructors(client, type, imports) {
                 break;
             }
         }
-        ctorText += `\t${clientVar} := &${client.name}{\n`;
+        ctorText += `${indent.get()}${clientVar} := &${client.name}{\n`;
         // NOTE: we don't enumerate consolidatedCtorParams here
         // as any supplemental endpoint params are ephemeral and
         // consumed during client construction.
+        indent.push();
         for (const parameter of client.parameters) {
             if (go.isLiteralParameter(parameter.style)) {
                 continue;
             }
             // each client field will have a matching parameter with the same name
-            ctorText += `\t\t${parameter.name}: ${parameter.name},\n`;
+            ctorText += `${indent.get()}${parameter.name}: ${parameter.name},\n`;
         }
-        ctorText += '\tinternal: cl,\n';
-        ctorText += '\t}\n';
-        ctorText += `\treturn ${clientVar}, nil\n`;
+        ctorText += `${indent.get()}internal: cl,\n`;
+        indent.pop();
+        ctorText += `${indent.get()}}\n`;
+        ctorText += `${indent.get()}return ${clientVar}, nil\n`;
         ctorText += '}\n\n';
     }
     return ctorText;
 }
 // use this to generate the code that will help process values returned in response headers
-function formatHeaderResponseValue(method, headerResp, imports, respObj, zeroResp) {
+function formatHeaderResponseValue(method, headerResp, respObj, zeroResp, imports, indent) {
     // dictionaries are handled slightly different so we do that first
     if (headerResp.kind === 'headerMapResponse') {
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
         imports.add('strings');
         const headerPrefix = headerResp.headerName;
-        let text = '\tfor hh := range resp.Header {\n';
-        text += `\t\tif len(hh) > len("${headerPrefix}") && strings.EqualFold(hh[:len("${headerPrefix}")], "${headerPrefix}") {\n`;
-        text += `\t\t\tif ${respObj}.${headerResp.fieldName} == nil {\n`;
-        text += `\t\t\t\t${respObj}.${headerResp.fieldName} = map[string]*string{}\n`;
-        text += '\t\t\t}\n';
-        text += `\t\t\t${respObj}.${headerResp.fieldName}[hh[len("${headerPrefix}"):]] = to.Ptr(resp.Header.Get(hh))\n`;
-        text += '\t\t}\n';
-        text += '\t}\n';
+        let text = `${indent.get()}for hh := range resp.Header {\n`;
+        text += `${indent.push().get()}if len(hh) > len("${headerPrefix}") && strings.EqualFold(hh[:len("${headerPrefix}")], "${headerPrefix}") {\n`;
+        text += `${indent.push().get()}if ${respObj}.${headerResp.fieldName} == nil {\n`;
+        text += `${indent.push().get()}${respObj}.${headerResp.fieldName} = map[string]*string{}\n`;
+        text += `${indent.pop().get()}}\n`;
+        text += `${indent.get()}${respObj}.${headerResp.fieldName}[hh[len("${headerPrefix}"):]] = to.Ptr(resp.Header.Get(hh))\n`;
+        text += `${indent.pop().get()}}\n`;
+        text += `${indent.pop().get()}}\n`;
         return text;
     }
-    let text = `\tif val := resp.Header.Get("${headerResp.headerName}"); val != "" {\n`;
+    let text = `${indent.get()}if val := resp.Header.Get("${headerResp.headerName}"); val != "" {\n`;
+    indent.push();
     let name = naming.uncapitalize(headerResp.fieldName);
     let byRef = '&';
     switch (headerResp.type.kind) {
         case 'constant':
         case 'etag':
-            text += `\t\t${respObj}.${headerResp.fieldName} = (*${go.getTypeDeclaration(headerResp.type, method.receiver.type.pkg)})(&val)\n`;
-            text += '\t}\n';
+            text += `${indent.get()}${respObj}.${headerResp.fieldName} = (*${go.getTypeDeclaration(headerResp.type, method.receiver.type.pkg)})(&val)\n`;
+            indent.pop();
+            text += `${indent.get()}}\n`;
             return text;
         case 'encodedBytes':
             // a base-64 encoded value in string format
             imports.add('encoding/base64');
-            text += `\t\t${name}, err := base64.${helpers.formatBytesEncoding(headerResp.type.encoding)}Encoding.DecodeString(val)\n`;
+            text += `${indent.get()}${name}, err := base64.${helpers.formatBytesEncoding(headerResp.type.encoding)}Encoding.DecodeString(val)\n`;
             byRef = '';
             break;
         case 'literal':
-            text += `\t\t${respObj}.${headerResp.fieldName} = &val\n`;
-            text += '\t}\n';
+            text += `${indent.get()}${respObj}.${headerResp.fieldName} = &val\n`;
+            indent.pop();
+            text += `${indent.get()}}\n`;
             return text;
         case 'scalar':
-            imports.add('strconv');
-            switch (headerResp.type.type) {
-                case 'bool':
-                    text += `\t\t${name}, err := strconv.ParseBool(val)\n`;
-                    break;
-                case 'float32':
-                    text += `\t\t${name}32, err := strconv.ParseFloat(val, 32)\n`;
-                    text += `\t\t${name} := float32(${name}32)\n`;
-                    break;
-                case 'float64':
-                    text += `\t\t${name}, err := strconv.ParseFloat(val, 64)\n`;
-                    break;
-                case 'int32':
-                    text += `\t\t${name}32, err := strconv.ParseInt(val, 10, 32)\n`;
-                    text += `\t\t${name} := int32(${name}32)\n`;
-                    break;
-                case 'int64':
-                    text += `\t\t${name}, err := strconv.ParseInt(val, 10, 64)\n`;
-                    break;
-                default:
-                    throw new CodegenError('InternalError', `unhandled scalar type ${headerResp.type.type}`);
-            }
+            text += emitScalarParsing(headerResp.type, 'val', name, imports, indent);
             break;
         case 'string':
-            text += `\t\t${respObj}.${headerResp.fieldName} = &val\n`;
-            text += '\t}\n';
+            text += `${indent.get()}${respObj}.${headerResp.fieldName} = &val\n`;
+            text += `${indent.pop().get()}}\n`;
             return text;
         case 'time':
             imports.add('time');
             switch (headerResp.type.format) {
                 case 'RFC1123':
                 case 'RFC3339':
-                    text += `\t\t${name}, err := time.Parse(${headerResp.type.format === 'RFC1123' ? helpers.RFC1123Format : helpers.RFC3339Format}, val)\n`;
+                    text += `${indent.get()}${name}, err := time.Parse(${headerResp.type.format === 'RFC1123' ? helpers.RFC1123Format : helpers.RFC3339Format}, val)\n`;
                     break;
                 case 'PlainDate':
-                    text += `\t\t${name}, err := time.Parse(${helpers.plainDateFormat}, val)\n`;
+                    text += `${indent.get()}${name}, err := time.Parse(${helpers.plainDateFormat}, val)\n`;
                     break;
                 case 'PlainTime':
-                    text += `\t\t${name}, err := time.Parse(${helpers.plainTimeFormat}, val)\n`;
+                    text += `${indent.get()}${name}, err := time.Parse(${helpers.plainTimeFormat}, val)\n`;
                     break;
                 case 'Unix':
                     imports.add('strconv');
                     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
-                    text += '\t\tsec, err := strconv.ParseInt(val, 10, 64)\n';
+                    text += `${indent.get()}sec, err := strconv.ParseInt(val, 10, 64)\n`;
                     name = 'to.Ptr(time.Unix(sec, 0))';
                     byRef = '';
                     break;
             }
     }
     // NOTE: only cases that required parsing will fall through to here
-    text += '\t\tif err != nil {\n';
-    text += `\t\t\treturn ${zeroResp}, err\n`;
-    text += '\t\t}\n';
-    text += `\t\t${respObj}.${headerResp.fieldName} = ${byRef}${name}\n`;
-    text += '\t}\n';
+    text += `${indent.get()}if err != nil {\n`;
+    text += `${indent.push().get()}return ${zeroResp}, err\n`;
+    text += `${indent.pop().get()}}\n`;
+    text += `${indent.get()}${respObj}.${headerResp.fieldName} = ${byRef}${name}\n`;
+    text += `${indent.pop().get()}}\n`;
     return text;
 }
+/**
+ * emits the code for parsing scalar types from a string.
+ * note that the parsing error result is placed into a
+ * local var named "err".
+ *
+ * @param scalar the type of scalar to parse
+ * @param src the source var that contains the scalar in string format
+ * @param dst the destination var that contains the result
+ * @param imports the import manager currently in scope
+ * @param indent the indentation helper currently in scope
+ * @returns the scalar parsing code
+ */
+function emitScalarParsing(scalar, src, dst, imports, indent) {
+    imports.add('strconv');
+    switch (scalar.type) {
+        case 'bool':
+            return `${indent.get()}${dst}, err := strconv.ParseBool(${src})\n`;
+        case 'float32':
+            return `${indent.get()}${dst}32, err := strconv.ParseFloat(${src}, 32)\n` + `${indent.get()}${dst} := float32(${dst}32)\n`;
+        case 'float64':
+            return `${indent.get()}${dst}, err := strconv.ParseFloat(${src}, 64)\n`;
+        case 'int32':
+            return `${indent.get()}${dst}32, err := strconv.ParseInt(${src}, 10, 32)\n` + `${indent.get()}${dst} := int32(${dst}32)\n`;
+        case 'int64':
+            return `${indent.get()}${dst}, err := strconv.ParseInt(${src}, 10, 64)\n`;
+        default:
+            throw new CodegenError('InternalError', `unhandled scalar type ${scalar.type}`);
+    }
+}
+/**
+ * returns the zero value for the specified method.
+ * note that the zero value will be different depending
+ * on which API for the method is being called.
+ *
+ * @param method the method to determine the zero value
+ * @param apiType the method's API that's being invoked
+ *       lro - the exported LRO API
+ *        op - the operation method. for sync methods this is the exported API. for LROs it's the internal method called by Begin*
+ *   handler - the internal response handler method
+ * @returns the zero value
+ */
 function getZeroReturnValue(method, apiType) {
     let returnType = `${method.returns.name}{}`;
     if (go.isLROMethod(method)) {
-        if (apiType === 'api' || apiType === 'op') {
+        if (apiType === 'lro' || apiType === 'op') {
             // the api returns a *Poller[T]
             // the operation returns an *http.Response
             returnType = 'nil';
@@ -499,103 +548,223 @@ function getZeroReturnValue(method, apiType) {
     }
     return returnType;
 }
-// Helper function to generate nil checks for a dotted path
-function generateNilChecks(path, prefix = 'page') {
-    const segments = path.split('.');
+/**
+ * Helper function to generate nil checks for a segmented path
+ * e.g. page.Foo != nil && page.Foo.Bar != nil
+ *
+ * @param segments the field segments
+ * @param varName optional variable name containing the fields
+ * @param omitLastSegment when true, omits the last item in segments.
+ *   note that this can cause the function to return the empty string when segments.length === 1
+ * @returns the sequence of nil checks
+ */
+function generateNilChecks(segments, varName = 'page', omitLastSegment = false) {
     const checks = [];
-    for (let i = 0; i < segments.length; i++) {
-        const currentPath = [prefix, ...segments.slice(0, i + 1)].join('.');
+    let segmentCount = segments.length;
+    if (omitLastSegment) {
+        segmentCount -= 1;
+    }
+    for (let i = 0; i < segmentCount; i++) {
+        const currentPath = [varName, ...segments.map((segment) => segment.name).slice(0, i + 1)].join('.');
         checks.push(`${currentPath} != nil`);
     }
     return checks.join(' && ');
 }
-function emitPagerDefinition(method, imports, options) {
+/**
+ * emits code that calls runtime.NewPager
+ *
+ * @param method the pageable method
+ * @param options emitter options
+ * @param imports the import manager currently in scope
+ * @param indent the indentation helper currently in scope
+ * @returns the complete call to runtime.NewPager(...)
+ */
+function emitPagerDefinition(method, options, imports, indent) {
     imports.add('context');
     let text = `runtime.NewPager(runtime.PagingHandler[${method.returns.name}]{\n`;
-    text += `\t\tMore: func(page ${method.returns.name}) bool {\n`;
-    // there is no advancer for single-page pagers
-    if (method.nextLinkName) {
-        const nilChecks = generateNilChecks(method.nextLinkName);
-        text += `\t\t\treturn ${nilChecks} && len(*page.${method.nextLinkName}) > 0\n`;
-        text += '\t\t},\n';
+    text += `${indent.push().get()}More: func(page ${method.returns.name}) bool {\n`;
+    indent.push();
+    if (method.strategy) {
+        const moreForNextLinkPath = function (strategy) {
+            const nilChecks = generateNilChecks(strategy.nextLinkPath);
+            const nextLinkPath = helpers.buildNextLinkPath(strategy);
+            text += `${indent.get()}return ${nilChecks} && len(*page.${nextLinkPath}) > 0\n`;
+        };
+        switch (method.strategy.kind) {
+            case 'continuationToken': {
+                switch (method.strategy.responseToken.kind) {
+                    case 'headerScalarResponse':
+                        const tokenRespField = method.strategy.responseToken.fieldName;
+                        text += `${indent.get()}return page.${tokenRespField} != nil && len(*page.${tokenRespField}) > 0\n`;
+                        break;
+                    case 'nextLink':
+                        moreForNextLinkPath(method.strategy.responseToken);
+                        break;
+                    default:
+                        method.strategy.responseToken;
+                }
+                break;
+            }
+            case 'nextLink': {
+                moreForNextLinkPath(method.strategy);
+                break;
+            }
+            default:
+                method.strategy;
+        }
     }
     else {
-        text += '\t\t\treturn false\n';
-        text += '\t\t},\n';
+        // there is no advancer for single-page pagers
+        text += `${indent.get()}return false\n`;
     }
-    text += `\t\tFetcher: func(ctx context.Context, page *${method.returns.name}) (${method.returns.name}, error) {\n`;
+    text += `${indent.pop().get()}},\n`; // end More func
+    text += `${indent.get()}Fetcher: func(ctx context.Context, page *${method.returns.name}) (${method.returns.name}, error) {\n`;
+    indent.push();
     const reqParams = helpers.getCreateRequestParameters(method);
     if (options.generateFakes) {
-        text += `\t\tctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "${method.receiver.type.name}.${fixUpMethodName(method)}")\n`;
-    }
-    if (method.nextLinkName) {
-        let nextLinkVar;
-        if (method.kind === 'pageableMethod') {
-            text += '\t\t\tnextLink := ""\n';
-            nextLinkVar = 'nextLink';
-            text += '\t\t\tif page != nil {\n';
-            text += `\t\t\t\tnextLink = *page.${method.nextLinkName}\n\t\t\t}\n`;
-        }
-        else {
-            nextLinkVar = `*page.${method.nextLinkName}`;
-        }
-        text += `\t\t\tresp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), ${nextLinkVar}, func(ctx context.Context) (*policy.Request, error) {\n`;
-        text += `\t\t\t\treturn client.${method.naming.requestMethod}(${reqParams})\n\t\t\t}, `;
-        // nextPageMethod might be absent in some cases, see https://github.com/Azure/autorest/issues/4393
-        if (method.nextPageMethod) {
-            const nextOpParams = helpers.getCreateRequestParametersSig(method.nextPageMethod).split(',');
-            // keep the parameter names from the name/type tuples and find nextLink param
-            for (let i = 0; i < nextOpParams.length; ++i) {
-                const paramName = nextOpParams[i].trim().split(' ')[0];
-                const paramType = nextOpParams[i].trim().split(' ')[1];
-                if (paramName.startsWith('next') && paramType === 'string') {
-                    nextOpParams[i] = 'encodedNextLink';
+        text += `${indent.get()}ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "${method.receiver.type.name}.${fixUpMethodName(method)}")\n`;
+    }
+    /** emits code to check the HTTP status code and conditionally call the response handler */
+    const emitStatusCodeCheckAndResponse = function (respVarName, indent) {
+        let content = `${indent.get()}${helpers.buildIfBlock(indent, {
+            condition: `!runtime.HasStatusCode(${respVarName}, http.StatusOK)`,
+            body: (indent) => `${indent.get()}return ${getZeroReturnValue(method, 'op')}, runtime.NewResponseError(${respVarName})\n`,
+        })}\n`;
+        content += `${indent.get()}return client.${method.naming.responseMethod}(${respVarName})\n`;
+        return content;
+    };
+    if (method.strategy) {
+        switch (method.strategy.kind) {
+            case 'continuationToken': {
+                const ms = method.strategy;
+                const optionsCopy = 'nextOpts';
+                text += `${indent.get()}${optionsCopy} := ${method.optionalParamsGroup.groupName}{}\n`;
+                text += `${indent.get()}${helpers.buildIfBlock(indent, {
+                    condition: `${method.optionalParamsGroup.name} != nil`,
+                    body: (indent) => `${indent.get()}${optionsCopy} = *${method.optionalParamsGroup.name}\n`,
+                })}\n`;
+                let respToken;
+                let nestedNilChecks = '';
+                switch (ms.responseToken.kind) {
+                    case 'headerScalarResponse':
+                        respToken = ms.responseToken.fieldName;
+                        break;
+                    case 'nextLink':
+                        respToken = helpers.buildNextLinkPath(ms.responseToken);
+                        if (ms.responseToken.nextLinkPath.length > 1) {
+                            // we don't need to check the last field for nil as we'll just
+                            // assign it to the corresponding field in the options param
+                            nestedNilChecks = ` && ${generateNilChecks(ms.responseToken.nextLinkPath, 'page', true)}`;
+                        }
+                        break;
+                }
+                text += `${indent.get()}${helpers.buildIfBlock(indent, {
+                    condition: `page != nil${nestedNilChecks}`,
+                    body: (indent) => `${indent.get()}${optionsCopy}.${ms.requestToken.name} = page.${respToken}\n`,
+                })}\n`;
+                text += callCreateRequestWithErrCheck(method, 'req', indent, `&${optionsCopy}`);
+                text += callPipelineDoWithErrCheck(method, 'req', 'resp', indent);
+                text += emitStatusCodeCheckAndResponse('resp', indent);
+                break;
+            }
+            case 'nextLink': {
+                const nextLinkPath = helpers.buildNextLinkPath(method.strategy);
+                let nextLinkVar;
+                if (method.kind === 'pageableMethod') {
+                    text += `${indent.get()}nextLink := ""\n`;
+                    nextLinkVar = 'nextLink';
+                    text += `${indent.get()}if page != nil {\n`;
+                    text += `${indent.push().get()}nextLink = *page.${nextLinkPath}\n`;
+                    text += `${indent.pop().get()}}\n`;
                 }
                 else {
-                    nextOpParams[i] = paramName;
+                    nextLinkVar = `*page.${nextLinkPath}`;
                 }
+                text += `${indent.get()}resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), ${nextLinkVar}, func(ctx context.Context) (*policy.Request, error) {\n`;
+                text += `${indent.push().get()}return client.${method.naming.requestMethod}(${reqParams})\n`;
+                text += `${indent.pop().get()}}, `;
+                // nextPageMethod might be absent in some cases, see https://github.com/Azure/autorest/issues/4393
+                if (method.strategy.method) {
+                    const nextOpParams = helpers.getCreateRequestParametersSig(method.strategy.method).split(',');
+                    // keep the parameter names from the name/type tuples and find nextLink param
+                    for (let i = 0; i < nextOpParams.length; ++i) {
+                        const paramName = nextOpParams[i].trim().split(' ')[0];
+                        const paramType = nextOpParams[i].trim().split(' ')[1];
+                        if (paramName.startsWith('next') && paramType === 'string') {
+                            nextOpParams[i] = 'encodedNextLink';
+                        }
+                        else {
+                            nextOpParams[i] = paramName;
+                        }
+                    }
+                    // add a definition for the nextReq func that uses the nextLinkOperation
+                    indent.push();
+                    text += `&runtime.FetcherForNextLinkOptions{\n`;
+                    text += `${indent.get()}NextReq: func(ctx context.Context, encodedNextLink string) (*policy.Request, error) {\n`;
+                    text += `${indent.push().get()}return client.${method.strategy.method.name}(${nextOpParams.join(', ')})\n`;
+                    text += `${indent.pop().get()}},\n`;
+                    text += `${indent.pop().get()}})\n`;
+                }
+                else if (method.nextLinkVerb !== 'get') {
+                    text += `&runtime.FetcherForNextLinkOptions{\n`;
+                    text += `${indent.push().get()}HTTPVerb: http.Method${naming.capitalize(method.nextLinkVerb)},\n`;
+                    text += `${indent.pop().get()}})\n`;
+                }
+                else {
+                    text += 'nil)\n';
+                }
+                text += `${indent.get()}if err != nil {\n`;
+                text += `${indent.push().get()}return ${method.returns.name}{}, err\n`;
+                text += `${indent.pop().get()}}\n`;
+                text += `${indent.get()}return client.${method.naming.responseMethod}(resp)\n`;
             }
-            // add a definition for the nextReq func that uses the nextLinkOperation
-            text += '&runtime.FetcherForNextLinkOptions{\n\t\t\t\tNextReq: func(ctx context.Context, encodedNextLink string) (*policy.Request, error) {\n';
-            text += `\t\t\t\t\treturn client.${method.nextPageMethod.name}(${nextOpParams.join(', ')})\n\t\t\t\t},\n\t\t\t})\n`;
-        }
-        else if (method.nextLinkVerb !== 'get') {
-            text += `&runtime.FetcherForNextLinkOptions{\n\t\t\t\tHTTPVerb: http.Method${naming.capitalize(method.nextLinkVerb)},\n\t\t\t})\n`;
-        }
-        else {
-            text += 'nil)\n';
         }
-        text += `\t\t\tif err != nil {\n\t\t\t\treturn ${method.returns.name}{}, err\n\t\t\t}\n`;
-        text += `\t\t\treturn client.${method.naming.responseMethod}(resp)\n`;
-        text += '\t\t\t},\n';
     }
     else {
         // this is the singular page case, no fetcher helper required
-        text += `\t\t\treq, err := client.${method.naming.requestMethod}(${reqParams})\n`;
-        text += '\t\t\tif err != nil {\n';
-        text += `\t\t\t\treturn ${method.returns.name}{}, err\n`;
-        text += '\t\t\t}\n';
-        text += '\t\t\tresp, err := client.internal.Pipeline().Do(req)\n';
-        text += '\t\t\tif err != nil {\n';
-        text += `\t\t\t\treturn ${method.returns.name}{}, err\n`;
-        text += '\t\t\t}\n';
-        text += '\t\t\tif !runtime.HasStatusCode(resp, http.StatusOK) {\n';
-        text += `\t\t\t\treturn ${method.returns.name}{}, runtime.NewResponseError(resp)\n`;
-        text += '\t\t\t}\n';
-        text += `\t\t\treturn client.${method.naming.responseMethod}(resp)\n`;
-        text += '\t\t},\n';
+        text += callCreateRequestWithErrCheck(method, 'req', indent);
+        text += callPipelineDoWithErrCheck(method, 'req', 'resp', indent);
+        text += emitStatusCodeCheckAndResponse('resp', indent);
     }
+    text += `${indent.pop().get()}},\n`; // end Fetcher func
     if (options.injectSpans) {
-        text += '\t\tTracer: client.internal.Tracer(),\n';
+        text += `${indent.get()}Tracer: client.internal.Tracer(),\n`;
     }
-    text += '\t})\n';
+    text += `${indent.pop().get()}})\n`; // end runtime.NewPager
     return text;
 }
-function genApiVersionDoc(apiVersions) {
-    if (apiVersions.length === 0) {
-        return '';
-    }
-    return `//\n// Generated from API version ${apiVersions.join(', ')}\n`;
+/**
+ * emits the call to the *CreateRequest method for an SDK method.
+ * if the call returns an error, the error is propagated to the caller.
+ *
+ * @param method the method to call its *CreateRequest method
+ * @param reqVarName the var name of the resultant *policy.Request
+ * @param indent the indentation helper currently in scope
+ * @param optionsParam optional custom param name for the method options param
+ * @returns the call to *CreateRequest with an error check
+ */
+function callCreateRequestWithErrCheck(method, reqVarName, indent, optionsParam) {
+    const reqParams = helpers.getCreateRequestParameters(method, optionsParam);
+    let text = `${indent.get()}${reqVarName}, err := client.${method.naming.requestMethod}(${reqParams})\n`;
+    const zeroResp = getZeroReturnValue(method, 'op');
+    text += `${indent.get()}${helpers.buildErrCheck(indent, 'err', zeroResp)}\n`;
+    return text;
+}
+/**
+ * emits the call to the pipeline's Do() method on the internal client.
+ * if the call returns an error, the error is propagated to the caller.
+ *
+ * @param method the method that's making the call
+ * @param reqVarName the var name of the *policy.Request
+ * @param respVarName the var name of the *http.Response
+ * @param indent the indentation helper currently in scope
+ * @returns the call to Do() with an error check
+ */
+function callPipelineDoWithErrCheck(method, reqVarName, respVarName, indent) {
+    let text = `${indent.get()}${respVarName}, err := client.internal.Pipeline().Do(${reqVarName})\n`;
+    const zeroResp = getZeroReturnValue(method, 'op');
+    text += `${indent.get()}${helpers.buildErrCheck(indent, 'err', zeroResp)}\n`;
+    return text;
 }
 function genRespErrorDoc(method) {
     if (!(method.returns.result?.kind === 'headAsBooleanResult') && !go.isPageableMethod(method)) {
@@ -614,7 +783,7 @@ function genRespErrorDoc(method) {
 function getClientReceiverDefinition(receiver) {
     return `(${receiver.name} ${receiver.byValue ? '' : '*'}${receiver.type.name})`;
 }
-function generateOperation(method, imports, options) {
+function generateOperation(method, options, imports, indent) {
     const params = getAPIParametersSig(method, imports);
     const returns = generateReturnsInfo(method, 'op');
     let methodName = method.name;
@@ -623,18 +792,16 @@ function generateOperation(method, imports, options) {
     }
     let text = '';
     const respErrDoc = genRespErrorDoc(method);
-    const apiVerDoc = genApiVersionDoc(method.apiVersions);
     if (method.docs.summary || method.docs.description) {
         text += helpers.formatDocCommentWithPrefix(methodName, method.docs);
     }
-    else if (respErrDoc.length > 0 || apiVerDoc.length > 0) {
+    else if (respErrDoc.length > 0) {
         // if the method has no doc comment but we're adding other
         // doc comments, add an empty method name comment. this preserves
         // existing behavior and makes the docs look better overall.
         text += `// ${methodName} -\n`;
     }
     text += respErrDoc;
-    text += apiVerDoc;
     if (go.isLROMethod(method)) {
         methodName = method.naming.internalMethod;
     }
@@ -644,63 +811,85 @@ function generateOperation(method, imports, options) {
         }
     }
     text += `func ${getClientReceiverDefinition(method.receiver)} ${methodName}(${params}) (${returns.join(', ')}) {\n`;
-    const reqParams = helpers.getCreateRequestParameters(method);
     if (method.kind === 'pageableMethod') {
-        text += '\treturn ';
-        text += emitPagerDefinition(method, imports, options);
+        text += `${indent.get()}return `;
+        text += emitPagerDefinition(method, options, imports, indent);
         text += '}\n\n';
         return text;
     }
-    text += '\tvar err error\n';
+    text += `${indent.get()}var err error\n`;
     let operationName = `"${method.receiver.type.name}.${fixUpMethodName(method)}"`;
     if (options.generateFakes && options.injectSpans) {
-        text += `\tconst operationName = ${operationName}\n`;
+        text += `${indent.get()}const operationName = ${operationName}\n`;
         operationName = 'operationName';
     }
     if (options.generateFakes) {
-        text += `\tctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, ${operationName})\n`;
+        text += `${indent.get()}ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, ${operationName})\n`;
     }
     if (options.injectSpans) {
-        text += `\tctx, endSpan := runtime.StartSpan(ctx, ${operationName}, client.internal.Tracer(), nil)\n`;
-        text += '\tdefer func() { endSpan(err) }()\n';
+        text += `${indent.get()}ctx, endSpan := runtime.StartSpan(ctx, ${operationName}, client.internal.Tracer(), nil)\n`;
+        text += `${indent.get()}defer func() { endSpan(err) }()\n`;
     }
     const zeroResp = getZeroReturnValue(method, 'op');
-    text += `\treq, err := client.${method.naming.requestMethod}(${reqParams})\n`;
-    text += '\tif err != nil {\n';
-    text += `\t\treturn ${zeroResp}, err\n`;
-    text += '\t}\n';
-    text += '\thttpResp, err := client.internal.Pipeline().Do(req)\n';
-    text += '\tif err != nil {\n';
-    text += `\t\treturn ${zeroResp}, err\n`;
-    text += '\t}\n';
-    text += `\tif !runtime.HasStatusCode(httpResp, ${helpers.formatStatusCodes(method.httpStatusCodes)}) {\n`;
-    text += '\t\terr = runtime.NewResponseError(httpResp)\n';
-    text += `\t\treturn ${zeroResp}, err\n`;
-    text += '\t}\n';
+    text += callCreateRequestWithErrCheck(method, 'req', indent);
+    text += callPipelineDoWithErrCheck(method, 'req', 'httpResp', indent);
+    text += `${indent.get()}if !runtime.HasStatusCode(httpResp, ${helpers.formatStatusCodes(method.httpStatusCodes)}) {\n`;
+    indent.push();
+    text += `${indent.get()}err = runtime.NewResponseError(httpResp)\n`;
+    text += `${indent.get()}return ${zeroResp}, err\n`;
+    text += `${indent.pop().get()}}\n`;
     // HAB with headers response is handled in protocol responder
     if (method.returns.result?.kind === 'headAsBooleanResult' && method.returns.headers.length === 0) {
-        text += `\treturn ${method.returns.name}{${method.returns.result.fieldName}: httpResp.StatusCode >= 200 && httpResp.StatusCode < 300}, nil\n`;
+        text += `${indent.get()}return ${method.returns.name}{${method.returns.result.fieldName}: httpResp.StatusCode >= 200 && httpResp.StatusCode < 300}, nil\n`;
     }
     else {
         if (go.isLROMethod(method)) {
-            text += '\treturn httpResp, nil\n';
+            text += `${indent.get()}return httpResp, nil\n`;
         }
         else if (needsResponseHandler(method)) {
             // also cheating here as at present the only param to the responder is an http.Response
-            text += `\tresp, err := client.${method.naming.responseMethod}(httpResp)\n`;
-            text += '\treturn resp, err\n';
+            text += `${indent.get()}resp, err := client.${method.naming.responseMethod}(httpResp)\n`;
+            text += `${indent.get()}return resp, err\n`;
         }
         else if (method.returns.result?.kind === 'binaryResult') {
-            text += `\treturn ${method.returns.name}{${method.returns.result.fieldName}: httpResp.Body}, nil\n`;
+            text += `${indent.get()}return ${method.returns.name}{${method.returns.result.fieldName}: httpResp.Body}, nil\n`;
         }
         else {
-            text += `\treturn ${method.returns.name}{}, nil\n`;
+            text += `${indent.get()}return ${method.returns.name}{}, nil\n`;
         }
     }
     text += '}\n\n';
     return text;
 }
-function createProtocolRequest(azureARM, method, imports) {
+/**
+ * emits Go code to set ContentType on a MultipartContent variable if it has a fixed content type.
+ * handles both direct MultipartContent and slices of MultipartContent.
+ * returns the empty string if there's nothing to set.
+ *
+ * @param paramName the name of the multipart param
+ * @param wireType the underlying type of the multipart param
+ * @param indent the indentation helper currently in scope
+ * @returns setter code or the empty string
+ */
+function emitMultipartContentTypeSetter(paramName, wireType, indent) {
+    let text = '';
+    const unwrapped = helpers.recursiveUnwrapMapSlice(wireType);
+    if (unwrapped.kind !== 'multipartContent' || !unwrapped.contentType) {
+        return text;
+    }
+    switch (wireType.kind) {
+        case 'multipartContent':
+            text += `${indent.get()}${paramName}.ContentType = ${unwrapped.contentType.literal}\n`;
+            break;
+        case 'slice':
+            text += `${indent.get()}for i := range ${paramName} {\n`;
+            text += `${indent.push().get()}${paramName}[i].ContentType = ${unwrapped.contentType.literal}\n`;
+            text += `${indent.pop().get()}}\n`;
+            break;
+    }
+    return text;
+}
+function createProtocolRequest(azureARM, method, imports, indent) {
     let name = method.name;
     if (method.kind !== 'nextPageMethod') {
         name = method.naming.requestMethod;
@@ -727,15 +916,15 @@ function createProtocolRequest(azureARM, method, imports) {
     else if (method.receiver.type.instance?.kind === 'templatedHost') {
         imports.add('strings');
         // we have a templated host
-        text += `\thost := "${method.receiver.type.instance.path}"\n`;
+        text += `${indent.get()}host := "${method.receiver.type.instance.path}"\n`;
         // get all the host params on the client
         for (const hostParam of hostParams) {
-            text += `\thost = strings.ReplaceAll(host, "{${hostParam.uriPathSegment}}", ${helpers.formatValue(`client.${hostParam.name}`, hostParam.type, imports)})\n`;
+            text += `${indent.get()}host = strings.ReplaceAll(host, "{${hostParam.uriPathSegment}}", ${helpers.formatValue(`client.${hostParam.name}`, hostParam.type, imports)})\n`;
         }
         // check for any method local host params
         for (const param of method.parameters) {
             if (param.location === 'method' && param.kind === 'uriParam') {
-                text += `\thost = strings.ReplaceAll(host, "{${param.uriPathSegment}}", ${helpers.formatValue(helpers.getParamName(param), param.type, imports)})\n`;
+                text += `${indent.get()}host = strings.ReplaceAll(host, "{${param.uriPathSegment}}", ${helpers.formatValue(helpers.getParamName(param), param.type, imports)})\n`;
             }
         }
         hostParam = 'host';
@@ -758,7 +947,7 @@ function createProtocolRequest(azureARM, method, imports) {
     const pathContainsParms = pathStr.includes('{');
     if (hasPathParams || (!pathContainsParms && pathStr.length > 1)) {
         // there are path params, or the path doesn't contain tokens and is not "/" so emit it
-        text += `\turlPath := "${method.httpPath}"\n`;
+        text += `${indent.get()}urlPath := "${method.httpPath}"\n`;
         hostParam = `runtime.JoinPaths(${hostParam}, urlPath)`;
     }
     // helper to build nil checks for param groups
@@ -775,7 +964,7 @@ function createProtocolRequest(azureARM, method, imports) {
         if (param.group.required) {
             optionalParamGroupCheck = '';
         }
-        return `\tif ${optionalParamGroupCheck}${client}${paramGroupName}.${naming.capitalize(param.name)} != nil {\n`;
+        return `${indent.get()}if ${optionalParamGroupCheck}${client}${paramGroupName}.${naming.capitalize(param.name)} != nil {\n`;
     };
     if (hasPathParams) {
         // swagger defines path params, emit path and replace tokens
@@ -784,7 +973,13 @@ function createProtocolRequest(azureARM, method, imports) {
         for (const pp of methodParamGroups.pathParams) {
             let paramValue;
             let optionalPathSep = false;
-            if (pp.style !== 'optional') {
+            if (pp.style === 'literal') {
+                // literals are always scalar types and require no empty checks
+                paramValue = helpers.formatParamValue(pp, imports, indent);
+            }
+            else if (pp.style === 'required' || pp.location === 'client') {
+                // NOTE: we include client params here since they behave
+                // like required params (i.e. not grouped).
                 // emit check to ensure path param isn't an empty string
                 if (pp.kind === 'pathScalarParam') {
                     const choiceIsString = function (type) {
@@ -794,34 +989,43 @@ function createProtocolRequest(azureARM, method, imports) {
                     if ((pp.type.kind === 'string' || choiceIsString(pp.type)) && !pp.omitEmptyStringCheck) {
                         const paramName = helpers.getParamName(pp);
                         imports.add('errors');
-                        text += `\tif ${paramName} == "" {\n`;
-                        text += `\t\treturn nil, errors.New("parameter ${paramName} cannot be empty")\n`;
-                        text += '\t}\n';
+                        text += `${indent.get()}if ${paramName} == "" {\n`;
+                        text += `${indent.push().get()}return nil, errors.New("parameter ${paramName} cannot be empty")\n`;
+                        text += `${indent.pop().get()}}\n`;
                     }
                 }
-                paramValue = helpers.formatParamValue(pp, imports);
+                paramValue = helpers.formatParamValue(pp, imports, indent);
                 // for collection-based path params, we emit the empty check
                 // after calling helpers.formatParamValue as that will have the
                 // var name that contains the slice.
                 if (pp.kind === 'pathCollectionParam') {
                     const paramName = helpers.getParamName(pp);
                     const joinedParamName = `${paramName}Param`;
-                    text += `\t${joinedParamName} := ${paramValue}\n`;
+                    text += `${indent.get()}${joinedParamName} := ${paramValue}\n`;
                     imports.add('errors');
-                    text += `\tif len(${joinedParamName}) == 0 {\n`;
-                    text += `\t\treturn nil, errors.New("parameter ${paramName} cannot be empty")\n`;
-                    text += '\t}\n';
+                    text += `${indent.get()}if len(${joinedParamName}) == 0 {\n`;
+                    text += `${indent.push().get()}return nil, errors.New("parameter ${paramName} cannot be empty")\n`;
+                    text += `${indent.pop().get()}}\n`;
                     paramValue = joinedParamName;
                 }
             }
+            else if (go.isClientSideDefault(pp.style)) {
+                const defaultValue = naming.uncapitalize(pp.name) + 'Default';
+                text += `${indent.get()}${defaultValue} := ${helpers.formatLiteralValue(pp.style.defaultValue, true)}\n`;
+                text += emitParamGroupCheck(pp);
+                text += `${indent.push().get()}${defaultValue} = ${helpers.getParamName(pp)}\n`;
+                text += `${indent.pop().get()}}\n`;
+                paramValue = helpers.formatValue(defaultValue, pp.type, imports);
+            }
             else {
                 // param isn't required, so emit a local var with
                 // the correct default value, then populate it with
                 // the optional value when set.
                 paramValue = `optional${naming.capitalize(pp.name)}`;
-                text += `\t${paramValue} := ""\n`;
+                text += `${indent.get()}${paramValue} := ""\n`;
                 text += emitParamGroupCheck(pp);
-                text += `\t${paramValue} = ${helpers.formatParamValue(pp, imports)}\n\t}\n`;
+                text += `${indent.push().get()}${paramValue} = ${helpers.formatParamValue(pp, imports, indent)}\n`;
+                text += `${indent.pop().get()}}\n`;
                 // there are two cases for optional path params.
                 //  - /foo/bar/{optional}
                 //  - /foo/bar{/optional}
@@ -838,20 +1042,20 @@ function createProtocolRequest(azureARM, method, imports) {
                 return paramValue;
             };
             if (optionalPathSep) {
-                text += `\tif len(${paramValue}) > 0 {\n`;
-                text += `\t\t${paramValue} = "/"+${emitPathEscape()}\n`;
-                text += '\t}\n';
+                text += `${indent.get()}if len(${paramValue}) > 0 {\n`;
+                text += `${indent.push().get()}${paramValue} = "/"+${emitPathEscape()}\n`;
+                text += `${indent.pop().get()}}\n`;
             }
             else {
                 paramValue = emitPathEscape();
             }
-            text += `\turlPath = strings.ReplaceAll(urlPath, "{${pp.pathSegment}}", ${paramValue})\n`;
+            text += `${indent.get()}urlPath = strings.ReplaceAll(urlPath, "{${pp.pathSegment}}", ${paramValue})\n`;
         }
     }
-    text += `\treq, err := runtime.NewRequest(ctx, http.Method${naming.capitalize(method.httpMethod)}, ${hostParam})\n`;
-    text += '\tif err != nil {\n';
-    text += '\t\treturn nil, err\n';
-    text += '\t}\n';
+    text += `${indent.get()}req, err := runtime.NewRequest(ctx, http.Method${naming.capitalize(method.httpMethod)}, ${hostParam})\n`;
+    text += `${indent.get()}if err != nil {\n`;
+    text += `${indent.push().get()}return nil, err\n`;
+    text += `${indent.pop().get()}}\n`;
     // add query parameters
     const encodedParams = methodParamGroups.encodedQueryParams;
     const unencodedParams = methodParamGroups.unencodedQueryParams;
@@ -859,34 +1063,34 @@ function createProtocolRequest(azureARM, method, imports) {
         let qpText = '';
         if (qp.location === 'method' && go.isClientSideDefault(qp.style)) {
             qpText = emitClientSideDefault(qp, qp.style, (name, val) => {
-                return `\treqQP.Set(${name}, ${val})`;
-            }, imports);
+                return `${indent.get()}reqQP.Set(${name}, ${val})`;
+            }, imports, indent);
         }
         else if (go.isRequiredParameter(qp.style) || go.isLiteralParameter(qp.style) || (qp.location === 'client' && go.isClientSideDefault(qp.style))) {
-            qpText = `\t${setter}\n`;
+            qpText = `${indent.get()}${setter}\n`;
         }
         else if (qp.location === 'client' && !qp.group) {
             // global optional param
-            qpText = `\tif client.${qp.name} != nil {\n`;
-            qpText += `\t\t${setter}\n`;
-            qpText += '\t}\n';
+            qpText = `${indent.get()}if client.${qp.name} != nil {\n`;
+            qpText += `${indent.push().get()}${setter}\n`;
+            qpText += `${indent.pop().get()}}\n`;
         }
         else {
             qpText = emitParamGroupCheck(qp);
-            qpText += `\t\t${setter}\n`;
-            qpText += '\t}\n';
+            qpText += `${indent.push().get()}${setter}\n`;
+            qpText += `${indent.pop().get()}}\n`;
         }
         return qpText;
     };
     // emit encoded params first
     if (encodedParams.length > 0) {
-        text += '\treqQP := req.Raw().URL.Query()\n';
+        text += `${indent.get()}reqQP := req.Raw().URL.Query()\n`;
         for (const qp of encodedParams.sort((a, b) => {
             return helpers.sortAscending(a.queryParameter, b.queryParameter);
         })) {
             let setter;
             if (qp.kind === 'queryCollectionParam' && qp.collectionFormat === 'multi') {
-                setter = `\tfor _, qv := range ${helpers.getParamName(qp)} {\n`;
+                setter = `for _, qv := range ${helpers.getParamName(qp)} {\n`;
                 // emit a type conversion for the qv based on the array's element type
                 let queryVal;
                 const arrayQP = qp.type;
@@ -908,63 +1112,63 @@ function createProtocolRequest(azureARM, method, imports) {
                         imports.add('fmt');
                         queryVal = 'fmt.Sprintf("%v", qv)';
                 }
-                setter += `\t\treqQP.Add("${qp.queryParameter}", ${queryVal})\n`;
-                setter += '\t}';
+                setter += `${indent.push().get()}reqQP.Add("${qp.queryParameter}", ${queryVal})\n`;
+                setter += `${indent.pop().get()}}`;
             }
             else {
                 // cannot initialize setter to this value as helpers.formatParamValue() can change imports
-                setter = `reqQP.Set("${qp.queryParameter}", ${helpers.formatParamValue(qp, imports)})`;
+                setter = `reqQP.Set("${qp.queryParameter}", ${helpers.formatParamValue(qp, imports, indent)})`;
             }
             text += emitQueryParam(qp, setter);
         }
-        text += '\treq.Raw().URL.RawQuery = reqQP.Encode()\n';
+        text += `${indent.get()}req.Raw().URL.RawQuery = reqQP.Encode()\n`;
     }
     // tack on any unencoded params to the end
     if (unencodedParams.length > 0) {
         if (encodedParams.length > 0) {
-            text += '\tunencodedParams := []string{req.Raw().URL.RawQuery}\n';
+            text += `${indent.get()}unencodedParams := []string{req.Raw().URL.RawQuery}\n`;
         }
         else {
-            text += '\tunencodedParams := []string{}\n';
+            text += `${indent.get()}unencodedParams := []string{}\n`;
         }
         for (const qp of unencodedParams.sort((a, b) => {
             return helpers.sortAscending(a.queryParameter, b.queryParameter);
         })) {
             let setter;
             if (qp.kind === 'queryCollectionParam' && qp.collectionFormat === 'multi') {
-                setter = `\tfor _, qv := range ${helpers.getParamName(qp)} {\n`;
-                setter += `\t\tunencodedParams = append(unencodedParams, "${qp.queryParameter}="+qv)\n`;
-                setter += '\t}';
+                setter = `for _, qv := range ${helpers.getParamName(qp)} {\n`;
+                setter += `${indent.push().get()}unencodedParams = append(unencodedParams, "${qp.queryParameter}="+qv)\n`;
+                setter += `${indent.pop().get()}}`;
             }
             else {
-                setter = `unencodedParams = append(unencodedParams, "${qp.queryParameter}="+${helpers.formatParamValue(qp, imports)})`;
+                setter = `unencodedParams = append(unencodedParams, "${qp.queryParameter}="+${helpers.formatParamValue(qp, imports, indent)})`;
             }
             text += emitQueryParam(qp, setter);
         }
         imports.add('strings');
-        text += '\treq.Raw().URL.RawQuery = strings.Join(unencodedParams, "&")\n';
+        text += `${indent.get()}req.Raw().URL.RawQuery = strings.Join(unencodedParams, "&")\n`;
     }
     if (method.kind !== 'nextPageMethod' && method.returns.result?.kind === 'binaryResult') {
         // skip auto-body downloading for binary stream responses
-        text += '\truntime.SkipBodyDownload(req)\n';
+        text += `${indent.get()}runtime.SkipBodyDownload(req)\n`;
     }
     // add specific request headers
-    const emitHeaderSet = function (headerParam, prefix) {
+    const emitHeaderSet = function (headerParam) {
         if (headerParam.kind === 'headerMapParam') {
-            let headerText = `${prefix}for k, v := range ${helpers.getParamName(headerParam)} {\n`;
-            headerText += `${prefix}\tif v != nil {\n`;
-            headerText += `${prefix}\t\treq.Raw().Header["${headerParam.headerName}"+k] = []string{*v}\n`;
-            headerText += `${prefix}}\n`;
-            headerText += `${prefix}}\n`;
+            let headerText = `${indent.get()}for k, v := range ${helpers.getParamName(headerParam)} {\n`;
+            headerText += `${indent.push().get()}if v != nil {\n`;
+            headerText += `${indent.push().get()}req.Raw().Header["${headerParam.headerName}"+k] = []string{*v}\n`;
+            headerText += `${indent.pop().get()}}\n`;
+            headerText += `${indent.pop().get()}}\n`;
             return headerText;
         }
         else if (headerParam.location === 'method' && go.isClientSideDefault(headerParam.style)) {
             return emitClientSideDefault(headerParam, headerParam.style, (name, val) => {
-                return `${prefix}req.Raw().Header[${name}] = []string{${val}}`;
-            }, imports);
+                return `${indent.get()}req.Raw().Header[${name}] = []string{${val}}`;
+            }, imports, indent);
         }
         else {
-            return `${prefix}req.Raw().Header["${headerParam.headerName}"] = []string{${helpers.formatParamValue(headerParam, imports)}}\n`;
+            return `${indent.get()}req.Raw().Header["${headerParam.headerName}"] = []string{${helpers.formatParamValue(headerParam, imports, indent)}}\n`;
         }
     };
     let contentType;
@@ -980,21 +1184,25 @@ function createProtocolRequest(azureARM, method, imports) {
             // to handle cases where the body param is optional. we don't want to set
             // the content-type if the body is nil.
             // we do it like this as tsp specifies content-type while swagger does not.
-            contentType = helpers.formatParamValue(param, imports);
+            contentType = helpers.formatParamValue(param, imports, indent);
         }
         else if (go.isRequiredParameter(param.style) || go.isLiteralParameter(param.style) || go.isClientSideDefault(param.style)) {
-            text += emitHeaderSet(param, '\t');
+            text += emitHeaderSet(param);
         }
         else if (param.location === 'client' && !param.group) {
             // global optional param
-            text += `\tif client.${param.name} != nil {\n`;
-            text += emitHeaderSet(param, '\t');
-            text += '\t}\n';
+            text += `${indent.get()}if client.${param.name} != nil {\n`;
+            indent.push();
+            text += emitHeaderSet(param);
+            indent.pop();
+            text += `${indent.get()}}\n`;
         }
         else {
             text += emitParamGroupCheck(param);
-            text += emitHeaderSet(param, '\t\t');
-            text += '\t}\n';
+            indent.push();
+            text += emitHeaderSet(param);
+            indent.pop();
+            text += `${indent.get()}}\n`;
         }
     }
     // note that these are mutually exclusive
@@ -1003,13 +1211,36 @@ function createProtocolRequest(azureARM, method, imports) {
     const multipartBodyParams = methodParamGroups.multipartBodyParams;
     const partialBodyParams = methodParamGroups.partialBodyParams;
     const emitSetBodyWithErrCheck = function (setBodyParam, contentType) {
-        let content = `if err := ${setBodyParam}; err != nil {\n\treturn nil, err\n}\n;`;
+        let content = '';
         if (contentType) {
-            content = `req.Raw().Header["Content-Type"] = []string{${contentType}}\n` + content;
+            content += `${indent.get()}req.Raw().Header["Content-Type"] = []string{${contentType}}\n`;
         }
+        content += `${indent.get()}if err := ${setBodyParam}; err != nil {\n`;
+        content += `${indent.push().get()}return nil, err\n`;
+        content += `${indent.pop().get()}}\n`;
         return content;
     };
     if (bodyParam) {
+        /** returns the source value for the content type */
+        const getContentTypeValue = function (src) {
+            switch (src.kind) {
+                case 'literal':
+                    return helpers.formatLiteralValue(src, false);
+                case 'parameterRef': {
+                    // find the param
+                    for (const param of method.parameters) {
+                        if (param.kind === 'headerScalarParam' && param.name === src.name) {
+                            let paramName = helpers.getParamName(param);
+                            if (param.type.kind === 'constant') {
+                                paramName = `string(${paramName})`;
+                            }
+                            return paramName;
+                        }
+                    }
+                    throw new CodegenError('InternalError', `didn't find parameter reference ${src.name}`);
+                }
+            }
+        };
         if (bodyParam.bodyFormat === 'JSON' || bodyParam.bodyFormat === 'XML') {
             // default to the body param name
             let body = helpers.getParamName(bodyParam);
@@ -1020,7 +1251,8 @@ function createProtocolRequest(azureARM, method, imports) {
             else if (bodyParam.bodyFormat === 'XML' && bodyParam.type.kind === 'slice') {
                 // for XML payloads, create a wrapper type if the payload is an array
                 imports.add('encoding/xml');
-                text += '\ttype wrapper struct {\n';
+                text += `${indent.get()}type wrapper struct {\n`;
+                indent.push();
                 let tagName;
                 if (bodyParam.xml?.wrapper) {
                     tagName = bodyParam.xml.wrapper;
@@ -1028,14 +1260,14 @@ function createProtocolRequest(azureARM, method, imports) {
                 else {
                     tagName = go.getTypeDeclaration(bodyParam.type, method.receiver.type.pkg);
                 }
-                text += `\t\tXMLName xml.Name \`xml:"${tagName}"\`\n`;
+                text += `${indent.get()}XMLName xml.Name \`xml:"${tagName}"\`\n`;
                 const fieldName = naming.capitalize(bodyParam.name);
                 let tag = go.getTypeDeclaration(bodyParam.type.elementType, method.receiver.type.pkg);
                 if (bodyParam.type.elementType.kind === 'model' && bodyParam.type.elementType.xml?.name) {
                     tag = bodyParam.type.elementType.xml.name;
                 }
-                text += `\t\t${fieldName} *${go.getTypeDeclaration(bodyParam.type, method.receiver.type.pkg)} \`xml:"${tag}"\`\n`;
-                text += '\t}\n';
+                text += `${indent.get()}${fieldName} *${go.getTypeDeclaration(bodyParam.type, method.receiver.type.pkg)} \`xml:"${tag}"\`\n`;
+                text += `${indent.pop().get()}}\n`;
                 let addr = '&';
                 if (!go.isRequiredParameter(bodyParam.style) && !bodyParam.byValue) {
                     addr = '';
@@ -1055,19 +1287,19 @@ function createProtocolRequest(azureARM, method, imports) {
                     elementPtr = '';
                 }
                 imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
-                text += `\taux := make([]${elementPtr}datetime.${timeInfo?.format}, len(${body}))\n`;
-                text += `\tfor i := 0; i < len(${body}); i++ {\n`;
-                text += `\t\taux[i] = (${elementPtr}datetime.${timeInfo?.format})(${body}[i])\n`;
-                text += '\t}\n';
+                text += `${indent.get()}aux := make([]${elementPtr}datetime.${timeInfo?.format}, len(${body}))\n`;
+                text += `${indent.get()}for i := 0; i < len(${body}); i++ {\n`;
+                text += `${indent.push().get()}aux[i] = (${elementPtr}datetime.${timeInfo?.format})(${body}[i])\n`;
+                text += `${indent.pop().get()}}\n`;
                 body = 'aux';
             }
             else if (isMapOfDateTime(bodyParam.type)) {
                 let timeType = isMapOfDateTime(bodyParam.type);
                 imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
-                text += `\taux := map[string]*datetime.${timeType}{}\n`;
-                text += `\tfor k, v := range ${body} {\n`;
-                text += `\t\taux[k] = (*datetime.${timeType})(v)\n`;
-                text += '\t}\n';
+                text += `${indent.get()}aux := map[string]*datetime.${timeType}{}\n`;
+                text += `${indent.get()}for k, v := range ${body} {\n`;
+                text += `${indent.push().get()}aux[k] = (*datetime.${timeType})(v)\n`;
+                text += `${indent.pop().get()}}\n`;
                 body = 'aux';
             }
             let setBody = `runtime.MarshalAs${getMediaFormat(bodyParam.type, bodyParam.bodyFormat, `req, ${body}`)}`;
@@ -1077,134 +1309,164 @@ function createProtocolRequest(azureARM, method, imports) {
                 setBody = `req.SetBody(streaming.NopCloser(bytes.NewReader(${body})), "application/${bodyParam.bodyFormat.toLowerCase()}")`;
             }
             if (go.isRequiredParameter(bodyParam.style) || go.isLiteralParameter(bodyParam.style)) {
-                text += `\t${emitSetBodyWithErrCheck(setBody, contentType)}`;
-                text += '\treturn req, nil\n';
+                text += emitSetBodyWithErrCheck(setBody, contentType);
+                text += `${indent.get()}return req, nil\n`;
             }
             else {
                 text += emitParamGroupCheck(bodyParam);
-                text += `\t${emitSetBodyWithErrCheck(setBody, contentType)}`;
-                text += '\t\treturn req, nil\n';
-                text += '\t}\n';
-                text += '\treturn req, nil\n';
+                indent.push();
+                text += emitSetBodyWithErrCheck(setBody, contentType);
+                text += `${indent.get()}return req, nil\n`;
+                indent.pop();
+                text += `${indent.get()}}\n`;
+                text += `${indent.get()}return req, nil\n`;
             }
         }
         else if (bodyParam.bodyFormat === 'binary') {
             if (go.isRequiredParameter(bodyParam.style)) {
-                text += `\t${emitSetBodyWithErrCheck(`req.SetBody(${bodyParam.name}, ${bodyParam.contentType})`, contentType)}`;
-                text += '\treturn req, nil\n';
+                text += emitSetBodyWithErrCheck(`req.SetBody(${bodyParam.name}, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
+                text += `${indent.get()}return req, nil\n`;
             }
             else {
                 text += emitParamGroupCheck(bodyParam);
-                text += `\t${emitSetBodyWithErrCheck(`req.SetBody(${helpers.getParamName(bodyParam)}, ${bodyParam.contentType})`, contentType)}`;
-                text += '\treturn req, nil\n';
-                text += '\t}\n';
-                text += '\treturn req, nil\n';
+                indent.push();
+                text += emitSetBodyWithErrCheck(`req.SetBody(${helpers.getParamName(bodyParam)}, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
+                text += `${indent.get()}return req, nil\n`;
+                indent.pop();
+                text += `${indent.get()}}\n`;
+                text += `${indent.get()}return req, nil\n`;
             }
         }
         else if (bodyParam.bodyFormat === 'Text') {
             imports.add('strings');
             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
             if (go.isRequiredParameter(bodyParam.style)) {
-                text += `\tbody := streaming.NopCloser(strings.NewReader(${bodyParam.name}))\n`;
-                text += `\t${emitSetBodyWithErrCheck(`req.SetBody(body, ${bodyParam.contentType})`, contentType)}`;
-                text += '\treturn req, nil\n';
+                text += `${indent.get()}body := streaming.NopCloser(strings.NewReader(${bodyParam.name}))\n`;
+                text += emitSetBodyWithErrCheck(`req.SetBody(body, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
+                text += `${indent.get()}return req, nil\n`;
             }
             else {
                 text += emitParamGroupCheck(bodyParam);
-                text += `\tbody := streaming.NopCloser(strings.NewReader(${helpers.getParamName(bodyParam)}))\n`;
-                text += `\t${emitSetBodyWithErrCheck(`req.SetBody(body, ${bodyParam.contentType})`, contentType)}`;
-                text += '\treturn req, nil\n';
-                text += '\t}\n';
-                text += '\treturn req, nil\n';
+                indent.push();
+                text += `${indent.get()}body := streaming.NopCloser(strings.NewReader(${helpers.getParamName(bodyParam)}))\n`;
+                text += emitSetBodyWithErrCheck(`req.SetBody(body, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
+                text += `${indent.get()}return req, nil\n`;
+                indent.pop();
+                text += `${indent.get()}}\n`;
+                text += `${indent.get()}return req, nil\n`;
             }
         }
     }
     else if (partialBodyParams.length > 0) {
         // partial body params are discrete params that are all fields within an internal struct.
         // define and instantiate an instance of the wire type, using the values from each param.
-        text += '\tbody := struct {\n';
+        text += `${indent.get()}body := struct {\n`;
+        indent.push();
         for (const partialBodyParam of partialBodyParams) {
-            text += `\t\t${naming.capitalize(partialBodyParam.serializedName)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type, method.receiver.type.pkg)} \`${partialBodyParam.format.toLowerCase()}:"${partialBodyParam.serializedName}"\`\n`;
+            text += `${indent.get()}${naming.capitalize(partialBodyParam.serializedName)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type, method.receiver.type.pkg)} \`${partialBodyParam.format.toLowerCase()}:"${partialBodyParam.serializedName}"\`\n`;
         }
-        text += '\t}{\n';
+        indent.pop();
+        text += `${indent.get()}}{\n`;
+        indent.push();
         // required params are emitted as initializers in the struct literal
         for (const partialBodyParam of partialBodyParams) {
             if (go.isRequiredParameter(partialBodyParam.style)) {
-                text += `\t\t${naming.capitalize(partialBodyParam.serializedName)}: ${naming.uncapitalize(partialBodyParam.name)},\n`;
+                text += `${indent.get()}${naming.capitalize(partialBodyParam.serializedName)}: ${naming.uncapitalize(partialBodyParam.name)},\n`;
             }
         }
-        text += '\t}\n';
+        indent.pop();
+        text += `${indent.get()}}\n`;
         // now populate any optional params from the options type
         for (const partialBodyParam of partialBodyParams) {
             if (!go.isRequiredParameter(partialBodyParam.style)) {
                 text += emitParamGroupCheck(partialBodyParam);
-                text += `\t\tbody.${naming.capitalize(partialBodyParam.serializedName)} = options.${naming.capitalize(partialBodyParam.name)}\n\t}\n`;
+                text += `${indent.push().get()}body.${naming.capitalize(partialBodyParam.serializedName)} = options.${naming.capitalize(partialBodyParam.name)}\n`;
+                text += `${indent.pop().get()}}\n`;
             }
         }
         // TODO: spread params are JSON only https://github.com/Azure/autorest.go/issues/1455
-        text += '\treq.Raw().Header["Content-Type"] = []string{"application/json"}\n';
-        text += '\tif err := runtime.MarshalAsJSON(req, body); err != nil {\n\t\treturn nil, err\n\t}\n';
-        text += '\treturn req, nil\n';
+        text += `${indent.get()}req.Raw().Header["Content-Type"] = []string{"application/json"}\n`;
+        text += `${indent.get()}if err := runtime.MarshalAsJSON(req, body); err != nil {\n`;
+        text += `${indent.push().get()}return nil, err\n`;
+        text += `${indent.pop().get()}}\n`;
+        text += `${indent.get()}return req, nil\n`;
     }
     else if (multipartBodyParams.length > 0) {
+        // emit content type setters for direct MultipartContent params with a fixed content type.
+        // this handles the case where the param itself is a MultipartContent or a slice of them
+        // (i.e. not wrapped in a model struct with toMultipartFormData()).
+        // note that tsp only allows homogeneous content types, which is why it's safe
+        // to unwrap the first param's type and check its contentType field.
+        text += emitMultipartContentTypeSetter(multipartBodyParams[0].name, multipartBodyParams[0].type, indent);
         if (multipartBodyParams.length === 1 && multipartBodyParams[0].type.kind === 'model' && multipartBodyParams[0].type.annotations.multipartFormData) {
-            text += `\tformData, err := ${multipartBodyParams[0].name}.toMultipartFormData()\n`;
-            text += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+            // emit content type setters for model fields that have a fixed content type.
+            // toMultipartFormData() converts the model to map[string]any but doesn't set ContentType,
+            // so we must set it on each MultipartContent field before the conversion.
+            for (const field of multipartBodyParams[0].type.fields) {
+                text += emitMultipartContentTypeSetter(`${multipartBodyParams[0].name}.${field.name}`, field.type, indent);
+            }
+            text += `${indent.get()}formData, err := ${multipartBodyParams[0].name}.toMultipartFormData()\n`;
+            text += `${indent.get()}if err != nil {\n`;
+            text += `${indent.push().get()}return nil, err\n`;
+            text += `${indent.pop().get()}}\n`;
         }
         else {
-            text += '\tformData := map[string]any{}\n';
+            text += `${indent.get()}formData := map[string]any{}\n`;
             for (const param of multipartBodyParams) {
                 const setter = `formData["${param.name}"] = ${helpers.getParamName(param)}`;
                 if (go.isRequiredParameter(param.style)) {
-                    text += `\t${setter}\n`;
+                    text += `${indent.get()}${setter}\n`;
                 }
                 else {
                     text += emitParamGroupCheck(param);
-                    text += `\t${setter}\n\t}\n`;
+                    text += `${indent.push().get()}${setter}\n`;
+                    text += `${indent.pop().get()}}\n`;
                 }
             }
         }
-        text += '\tif err := runtime.SetMultipartFormData(req, formData); err != nil {\n\t\treturn nil, err\n\t}\n';
-        text += '\treturn req, nil\n';
+        text += `${indent.get()}if err := runtime.SetMultipartFormData(req, formData); err != nil {\n`;
+        text += `${indent.push().get()}return nil, err\n`;
+        text += `${indent.pop().get()}}\n`;
+        text += `${indent.get()}return req, nil\n`;
     }
     else if (formBodyParams.length > 0) {
         const emitFormData = function (param, setter) {
             let formDataText = '';
             if (go.isRequiredParameter(param.style)) {
-                formDataText = `\t${setter}\n`;
+                formDataText = `${indent.get()}${setter}\n`;
             }
             else {
                 formDataText = emitParamGroupCheck(param);
-                formDataText += `\t\t${setter}\n`;
-                formDataText += '\t}\n';
+                formDataText += `${indent.push().get()}${setter}\n`;
+                formDataText += `${indent.pop().get()}}\n`;
             }
             return formDataText;
         };
         imports.add('net/url');
         imports.add('strings');
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
-        text += '\tformData := url.Values{}\n';
+        text += `${indent.get()}formData := url.Values{}\n`;
         // find all the form body params
         for (const param of formBodyParams) {
-            const setter = `formData.Set("${param.formDataName}", ${helpers.formatParamValue(param, imports)})`;
+            const setter = `formData.Set("${param.formDataName}", ${helpers.formatParamValue(param, imports, indent)})`;
             text += emitFormData(param, setter);
         }
-        text += '\tbody := streaming.NopCloser(strings.NewReader(formData.Encode()))\n';
-        text += `\t${emitSetBodyWithErrCheck('req.SetBody(body, "application/x-www-form-urlencoded")')}`;
-        text += '\treturn req, nil\n';
+        text += `${indent.get()}body := streaming.NopCloser(strings.NewReader(formData.Encode()))\n`;
+        text += emitSetBodyWithErrCheck('req.SetBody(body, "application/x-www-form-urlencoded")');
+        text += `${indent.get()}return req, nil\n`;
     }
     else {
-        text += '\treturn req, nil\n';
+        text += `${indent.get()}return req, nil\n`;
     }
     text += '}\n\n';
     return text;
 }
-function emitClientSideDefault(param, csd, setterFormat, imports) {
+function emitClientSideDefault(param, csd, setterFormat, imports, indent) {
     const defaultVar = naming.uncapitalize(param.name) + 'Default';
-    let text = `\t${defaultVar} := ${helpers.formatLiteralValue(csd.defaultValue, true)}\n`;
-    text += `\tif options != nil && options.${naming.capitalize(param.name)} != nil {\n`;
-    text += `\t\t${defaultVar} = *options.${naming.capitalize(param.name)}\n`;
-    text += '}\n';
+    let text = `${indent.get()}${defaultVar} := ${helpers.formatLiteralValue(csd.defaultValue, true)}\n`;
+    text += `${indent.get()}if options != nil && options.${naming.capitalize(param.name)} != nil {\n`;
+    text += `${indent.push().get()}${defaultVar} = *options.${naming.capitalize(param.name)}\n`;
+    text += `${indent.pop().get()}}\n`;
     let serializedName;
     switch (param.kind) {
         case 'headerCollectionParam':
@@ -1254,17 +1516,17 @@ function isArrayOfDateTimeForMarshalling(paramType) {
 function needsResponseHandler(method) {
     return helpers.hasSchemaResponse(method) || method.returns.headers.length > 0;
 }
-function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imports) {
+function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imports, indent) {
     let unmarshallerText = '';
     const zeroValue = getZeroReturnValue(method, 'handler');
     if (type.kind === 'time') {
         // use the designated time type for unmarshalling
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
-        unmarshallerText += `\tvar aux *datetime.${type.format}\n`;
-        unmarshallerText += `\tif err := runtime.UnmarshalAs${format}(resp, &aux); err != nil {\n`;
-        unmarshallerText += `\t\treturn ${zeroValue}, err\n`;
-        unmarshallerText += '\t}\n';
-        unmarshallerText += `\tresult.${helpers.getResultFieldName(method)} = (*time.Time)(aux)\n`;
+        unmarshallerText += `${indent.get()}var aux *datetime.${type.format}\n`;
+        unmarshallerText += `${indent.get()}if err := runtime.UnmarshalAs${format}(resp, &aux); err != nil {\n`;
+        unmarshallerText += `${indent.push().get()}return ${zeroValue}, err\n`;
+        unmarshallerText += `${indent.pop().get()}}\n`;
+        unmarshallerText += `${indent.get()}result.${helpers.getResultFieldName(method)} = (*time.Time)(aux)\n`;
         return unmarshallerText;
     }
     else if (isArrayOfDateTime(type)) {
@@ -1275,52 +1537,65 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imp
             elementPtr = '';
         }
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
-        unmarshallerText += `\tvar aux []${elementPtr}datetime.${timeInfo?.format}\n`;
-        unmarshallerText += `\tif err := runtime.UnmarshalAs${format}(resp, &aux); err != nil {\n`;
-        unmarshallerText += `\t\treturn ${zeroValue}, err\n`;
-        unmarshallerText += '\t}\n';
-        unmarshallerText += `\tcp := make([]${elementPtr}time.Time, len(aux))\n`;
-        unmarshallerText += '\tfor i := 0; i < len(aux); i++ {\n';
-        unmarshallerText += `\t\tcp[i] = (${elementPtr}time.Time)(aux[i])\n`;
-        unmarshallerText += '\t}\n';
-        unmarshallerText += `\tresult.${helpers.getResultFieldName(method)} = cp\n`;
+        unmarshallerText += `${indent.get()}var aux []${elementPtr}datetime.${timeInfo?.format}\n`;
+        unmarshallerText += `${indent.get()}if err := runtime.UnmarshalAs${format}(resp, &aux); err != nil {\n`;
+        unmarshallerText += `${indent.push().get()}return ${zeroValue}, err\n`;
+        unmarshallerText += `${indent.pop().get()}}\n`;
+        unmarshallerText += `${indent.get()}cp := make([]${elementPtr}time.Time, len(aux))\n`;
+        unmarshallerText += `${indent.get()}for i := 0; i < len(aux); i++ {\n`;
+        unmarshallerText += `${indent.push().get()}cp[i] = (${elementPtr}time.Time)(aux[i])\n`;
+        unmarshallerText += `${indent.pop().get()}}\n`;
+        unmarshallerText += `${indent.get()}result.${helpers.getResultFieldName(method)} = cp\n`;
         return unmarshallerText;
     }
     else if (isMapOfDateTime(type)) {
         let timeType = isMapOfDateTime(type);
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
-        unmarshallerText += `\taux := map[string]*datetime.${timeType}{}\n`;
-        unmarshallerText += `\tif err := runtime.UnmarshalAs${format}(resp, &aux); err != nil {\n`;
-        unmarshallerText += `\t\treturn ${zeroValue}, err\n`;
-        unmarshallerText += '\t}\n';
-        unmarshallerText += '\tcp := map[string]*time.Time{}\n';
-        unmarshallerText += '\tfor k, v := range aux {\n';
-        unmarshallerText += '\t\tcp[k] = (*time.Time)(v)\n';
-        unmarshallerText += '\t}\n';
-        unmarshallerText += `\tresult.${helpers.getResultFieldName(method)} = cp\n`;
+        unmarshallerText += `${indent.get()}aux := map[string]*datetime.${timeType}{}\n`;
+        unmarshallerText += `${indent.get()}if err := runtime.UnmarshalAs${format}(resp, &aux); err != nil {\n`;
+        unmarshallerText += `${indent.push().get()}return ${zeroValue}, err\n`;
+        unmarshallerText += `${indent.pop().get()}}\n`;
+        unmarshallerText += `${indent.get()}cp := map[string]*time.Time{}\n`;
+        unmarshallerText += `${indent.get()}for k, v := range aux {\n`;
+        unmarshallerText += `${indent.push().get()}cp[k] = (*time.Time)(v)\n`;
+        unmarshallerText += `${indent.pop().get()}}\n`;
+        unmarshallerText += `${indent.get()}result.${helpers.getResultFieldName(method)} = cp\n`;
         return unmarshallerText;
     }
     if (format === 'JSON' || format === 'XML') {
         if (type.kind === 'rawJSON') {
-            unmarshallerText += '\tbody, err := runtime.Payload(resp)\n';
-            unmarshallerText += '\tif err != nil {\n';
-            unmarshallerText += `\t\treturn ${zeroValue}, err\n`;
-            unmarshallerText += '\t}\n';
-            unmarshallerText += `\t${unmarshalTarget} = body\n`;
+            unmarshallerText += `${indent.get()}body, err := runtime.Payload(resp)\n`;
+            unmarshallerText += `${indent.get()}if err != nil {\n`;
+            unmarshallerText += `${indent.push().get()}return ${zeroValue}, err\n`;
+            unmarshallerText += `${indent.pop().get()}}\n`;
+            unmarshallerText += `${indent.get()}${unmarshalTarget} = body\n`;
         }
         else {
-            unmarshallerText += `\tif err := runtime.UnmarshalAs${getMediaFormat(type, format, `resp, &${unmarshalTarget}`)}; err != nil {\n`;
-            unmarshallerText += `\t\treturn ${zeroValue}, err\n`;
-            unmarshallerText += '\t}\n';
+            unmarshallerText += `${indent.get()}if err := runtime.UnmarshalAs${getMediaFormat(type, format, `resp, &${unmarshalTarget}`)}; err != nil {\n`;
+            unmarshallerText += `${indent.push().get()}return ${zeroValue}, err\n`;
+            unmarshallerText += `${indent.pop().get()}}\n`;
         }
     }
     else if (format === 'Text') {
-        unmarshallerText += '\tbody, err := runtime.Payload(resp)\n';
-        unmarshallerText += '\tif err != nil {\n';
-        unmarshallerText += `\t\treturn ${zeroValue}, err\n`;
-        unmarshallerText += '\t}\n';
-        unmarshallerText += '\ttxt := string(body)\n';
-        unmarshallerText += `\t${unmarshalTarget} = &txt\n`;
+        unmarshallerText += `${indent.get()}body, err := runtime.Payload(resp)\n`;
+        unmarshallerText += `${indent.get()}if err != nil {\n`;
+        unmarshallerText += `${indent.push().get()}return ${zeroValue}, err\n`;
+        unmarshallerText += `${indent.pop().get()}}\n`;
+        let resultVar;
+        switch (type.kind) {
+            case 'scalar':
+                resultVar = 'parsedBody';
+                unmarshallerText += emitScalarParsing(type, 'string(body)', resultVar, imports, indent);
+                unmarshallerText += `${indent.get()}${helpers.buildErrCheck(indent, 'err', zeroValue)}\n`;
+                break;
+            case 'string':
+                resultVar = 'txt';
+                unmarshallerText += `${indent.get()}${resultVar} := string(body)\n`;
+                break;
+            default:
+                throw new CodegenError('UnsupportedTsp', `unsupported text return kind ${type.kind} for method ${method.receiver.type.name}.${method.name}`);
+        }
+        unmarshallerText += `${indent.get()}${unmarshalTarget} = &${resultVar}\n`;
     }
     else {
         // the remaining formats should have been handled elsewhere
@@ -1328,7 +1603,7 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imp
     }
     return unmarshallerText;
 }
-function createProtocolResponse(method, imports) {
+function createProtocolResponse(method, imports, indent) {
     if (!needsResponseHandler(method)) {
         return '';
     }
@@ -1337,70 +1612,70 @@ function createProtocolResponse(method, imports) {
     text += `func ${getClientReceiverDefinition(method.receiver)} ${name}(resp *http.Response) (${generateReturnsInfo(method, 'handler').join(', ')}) {\n`;
     const addHeaders = function (headers) {
         for (const header of headers) {
-            text += formatHeaderResponseValue(method, header, imports, 'result', `${method.returns.name}{}`);
+            text += formatHeaderResponseValue(method, header, 'result', `${method.returns.name}{}`, imports, indent);
         }
     };
     const result = method.returns.result;
     if (!result) {
         // only headers
-        text += `\tresult := ${method.returns.name}{}\n`;
+        text += `${indent.get()}result := ${method.returns.name}{}\n`;
         addHeaders(method.returns.headers);
     }
     else {
         switch (result.kind) {
             case 'anyResult':
                 imports.add('fmt');
-                text += `\tresult := ${method.returns.name}{}\n`;
+                text += `${indent.get()}result := ${method.returns.name}{}\n`;
                 addHeaders(method.returns.headers);
-                text += '\tswitch resp.StatusCode {\n';
+                text += `${indent.get()}switch resp.StatusCode {\n`;
                 for (const statusCode of method.httpStatusCodes) {
-                    text += `\tcase ${helpers.formatStatusCodes([statusCode])}:\n`;
+                    text += `${indent.get()}case ${helpers.formatStatusCodes([statusCode])}:\n`;
                     const resultType = result.httpStatusCodeType[statusCode];
                     if (!resultType) {
                         // the operation contains a mix of schemas and non-schema responses
                         continue;
                     }
-                    text += `\tvar val ${go.getTypeDeclaration(resultType, method.receiver.type.pkg)}\n`;
-                    text += generateResponseUnmarshaller(method, resultType, result.format, 'val', imports);
-                    text += '\tresult.Value = val\n';
+                    text += `${indent.get()}var val ${go.getTypeDeclaration(resultType, method.receiver.type.pkg)}\n`;
+                    text += generateResponseUnmarshaller(method, resultType, result.format, 'val', imports, indent);
+                    text += `${indent.get()}result.Value = val\n`;
                 }
-                text += '\tdefault:\n';
-                text += `\t\treturn ${getZeroReturnValue(method, 'handler')}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)\n`;
-                text += '\t}\n';
+                text += `${indent.get()}default:\n`;
+                text += `${indent.push().get()}return ${getZeroReturnValue(method, 'handler')}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)\n`;
+                text += `${indent.pop().get()}}\n`;
                 break;
             case 'binaryResult':
-                text += `\tresult := ${method.returns.name}{${result.fieldName}: resp.Body}\n`;
+                text += `${indent.get()}result := ${method.returns.name}{${result.fieldName}: resp.Body}\n`;
                 addHeaders(method.returns.headers);
                 break;
             case 'headAsBooleanResult':
-                text += `\tresult := ${method.returns.name}{${result.fieldName}: resp.StatusCode >= 200 && resp.StatusCode < 300}\n`;
+                text += `${indent.get()}result := ${method.returns.name}{${result.fieldName}: resp.StatusCode >= 200 && resp.StatusCode < 300}\n`;
                 addHeaders(method.returns.headers);
                 break;
             case 'modelResult':
-                text += `\tresult := ${method.returns.name}{}\n`;
+                text += `${indent.get()}result := ${method.returns.name}{}\n`;
                 addHeaders(method.returns.headers);
-                text += generateResponseUnmarshaller(method, result.modelType, result.format, `result.${helpers.getResultFieldName(method)}`, imports);
+                text += generateResponseUnmarshaller(method, result.modelType, result.format, `result.${helpers.getResultFieldName(method)}`, imports, indent);
                 break;
             case 'monomorphicResult':
-                text += `\tresult := ${method.returns.name}{}\n`;
+                text += `${indent.get()}result := ${method.returns.name}{}\n`;
                 addHeaders(method.returns.headers);
                 let target = `result.${helpers.getResultFieldName(method)}`;
                 // when unmarshalling a wrapped XML array, unmarshal into the response envelope
                 if (result.format === 'XML' && result.monomorphicType.kind === 'slice') {
                     target = 'result';
                 }
-                text += generateResponseUnmarshaller(method, result.monomorphicType, result.format, target, imports);
+                text += generateResponseUnmarshaller(method, result.monomorphicType, result.format, target, imports, indent);
                 break;
             case 'polymorphicResult':
-                text += `\tresult := ${method.returns.name}{}\n`;
+                text += `${indent.get()}result := ${method.returns.name}{}\n`;
                 addHeaders(method.returns.headers);
-                text += generateResponseUnmarshaller(method, result.interface, result.format, 'result', imports);
+                text += generateResponseUnmarshaller(method, result.interface, result.format, 'result', imports, indent);
                 break;
             default:
                 result;
         }
     }
-    text += '\treturn result, nil\n';
+    text += `${indent.get()}return result, nil\n`;
     text += '}\n\n';
     return text;
 }
@@ -1500,7 +1775,7 @@ function generateReturnsInfo(method, apiType) {
     }
     return [returnType, 'error'];
 }
-function generateLROBeginMethod(method, imports, options) {
+function generateLROBeginMethod(method, options, imports, indent) {
     const params = getAPIParametersSig(method, imports);
     const returns = generateReturnsInfo(method, 'api');
     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
@@ -1508,9 +1783,8 @@ function generateLROBeginMethod(method, imports, options) {
     if (method.docs.summary || method.docs.description) {
         text += helpers.formatDocCommentWithPrefix(fixUpMethodName(method), method.docs);
         text += genRespErrorDoc(method);
-        text += genApiVersionDoc(method.apiVersions);
     }
-    const zeroResp = getZeroReturnValue(method, 'api');
+    const zeroResp = getZeroReturnValue(method, 'lro');
     const methodParams = helpers.getMethodParameters(method);
     for (const param of methodParams) {
         text += helpers.formatCommentAsBulletItem(param.name, param.docs);
@@ -1522,16 +1796,17 @@ function generateLROBeginMethod(method, imports, options) {
         // for paged LROs, we construct a pager and pass it to the LRO ctor.
         pollerTypeParam = `[*runtime.Pager${pollerTypeParam}]`;
         pollerType = '&pager';
-        text += '\tpager := ';
-        text += emitPagerDefinition(method, imports, options);
+        text += `${indent.get()}pager := `;
+        text += emitPagerDefinition(method, options, imports, indent);
     }
-    text += '\tif options == nil || options.ResumeToken == "" {\n';
+    text += `${indent.get()}if options == nil || options.ResumeToken == "" {\n`;
+    indent.push();
     // creating the poller from response branch
     const opName = method.naming.internalMethod;
-    text += `\t\tresp, err := client.${opName}(${helpers.getCreateRequestParameters(method)})\n`;
-    text += '\t\tif err != nil {\n';
-    text += `\t\t\treturn ${zeroResp}, err\n`;
-    text += '\t\t}\n';
+    text += `${indent.get()}resp, err := client.${opName}(${helpers.getCreateRequestParameters(method)})\n`;
+    text += `${indent.get()}if err != nil {\n`;
+    text += `${indent.push().get()}return ${zeroResp}, err\n`;
+    text += `${indent.pop().get()}}\n`;
     let finalStateVia = '';
     // LRO operation might have a special configuration set in x-ms-long-running-operation-options
     // which indicates a specific url to perform the final Get operation on
@@ -1553,7 +1828,7 @@ function generateLROBeginMethod(method, imports, options) {
                 throw new CodegenError('InternalError', `unhandled final-state-via value ${finalStateVia}`);
         }
     }
-    text += '\t\tpoller, err := runtime.NewPoller';
+    text += `${indent.get()}poller, err := runtime.NewPoller`;
     if (finalStateVia === '' && pollerType === 'nil' && !options.injectSpans) {
         // the generic type param is redundant when it's also specified in the
         // options struct so we only include it when there's no options.
@@ -1566,25 +1841,29 @@ function generateLROBeginMethod(method, imports, options) {
     }
     else {
         // at least one option
+        indent.push();
         text += `&runtime.NewPollerOptions${pollerTypeParam}{\n`;
         if (finalStateVia !== '') {
-            text += `\t\t\tFinalStateVia: ${finalStateVia},\n`;
+            text += `${indent.get()}FinalStateVia: ${finalStateVia},\n`;
         }
         if (method.operationLocationResultPath) {
-            text += `\t\t\tOperationLocationResultPath: "${method.operationLocationResultPath}",\n`;
+            text += `${indent.get()}OperationLocationResultPath: "${method.operationLocationResultPath}",\n`;
         }
         if (pollerType !== 'nil') {
-            text += `\t\t\tResponse: ${pollerType},\n`;
+            text += `${indent.get()}Response: ${pollerType},\n`;
         }
         if (options.injectSpans) {
-            text += '\t\t\tTracer: client.internal.Tracer(),\n';
+            text += `${indent.get()}Tracer: client.internal.Tracer(),\n`;
         }
-        text += '\t\t})\n';
+        indent.pop();
+        text += `${indent.get()}})\n`;
     }
-    text += '\t\treturn poller, err\n';
-    text += '\t} else {\n';
+    text += `${indent.get()}return poller, err\n`;
+    indent.pop();
+    text += `${indent.get()}} else {\n`;
+    indent.push();
     // creating the poller from resume token branch
-    text += '\t\treturn runtime.NewPollerFromResumeToken';
+    text += `${indent.get()}return runtime.NewPollerFromResumeToken`;
     if (pollerType === 'nil' && !options.injectSpans) {
         text += pollerTypeParam;
     }
@@ -1593,16 +1872,19 @@ function generateLROBeginMethod(method, imports, options) {
         text += 'nil)\n';
     }
     else {
+        indent.push();
         text += `&runtime.NewPollerFromResumeTokenOptions${pollerTypeParam}{\n`;
         if (pollerType !== 'nil') {
-            text += `\t\t\tResponse: ${pollerType},\n`;
+            text += `${indent.get()}Response: ${pollerType},\n`;
         }
         if (options.injectSpans) {
-            text += '\t\t\tTracer: client.internal.Tracer(),\n';
+            text += `${indent.get()}Tracer: client.internal.Tracer(),\n`;
         }
-        text += '\t\t})\n';
+        indent.pop();
+        text += `${indent.get()}})\n`;
     }
-    text += '\t}\n';
+    indent.pop();
+    text += `${indent.get()}}\n`;
     text += '}\n\n';
     return text;
 }