@azure-tools/typespec-go 0.14.3 → 0.15.0-dev.4

package/dist/{codegen.go/src → src/codegen}/core/operations.js

@@ -2,11 +2,11 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import * as go from '../../../codemodel.go/src/index.js';
-import * as naming from '../../../naming.go/src/naming.js';
-import * as helpers from './helpers.js';
-import { ImportManager } from './imports.js';
-import { CodegenError } from './errors.js';
+import * as go from "../../codemodel/index.js";
+import * as naming from "../../naming/naming.js";
+import { CodegenError } from "./errors.js";
+import * as helpers from "./helpers.js";
+import { ImportManager } from "./imports.js";
 // represents the generated content for an operation group
 export class OperationGroupContent {
     name;
@@ -30,22 +30,24 @@ export function generateOperations(pkg, target, options) {
     if (pkg.clients.length === 0) {
         return operations;
     }
-    const azureARM = target === 'azure-arm';
+    const azureARM = target === "azure-arm";
     for (const client of pkg.clients) {
         // the list of packages to import
         const imports = new ImportManager(pkg);
         if (client.methods.length > 0) {
             // add standard imports for clients with methods.
             // clients that are purely hierarchical (i.e. having no APIs) won't need them.
-            imports.add('net/http');
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/policy');
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+            imports.add("net/http");
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/policy");
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
         }
-        imports.add(azureARM ? 'github.com/Azure/azure-sdk-for-go/sdk/azcore/arm' : 'github.com/Azure/azure-sdk-for-go/sdk/azcore');
+        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);
         clientText += "// Don't use this type directly, use ";
-        if (client.instance?.kind === 'constructable' && client.instance.constructors.length === 1) {
+        if (client.instance?.kind === "constructable" && client.instance.constructors.length === 1) {
             clientText += `${client.instance.constructors[0].name}() instead.\n`;
         }
         else if (client.parent) {
@@ -58,12 +60,12 @@ export function generateOperations(pkg, target, options) {
                 }
             }
             if (!accessorMethod) {
-                throw new CodegenError('InternalError', `didn't find accessor method for client ${client.name} on parent client ${client.parent.name}`);
+                throw new CodegenError("InternalError", `didn't find accessor method for client ${client.name} on parent client ${client.parent.name}`);
             }
             clientText += `[${client.parent.name}.${accessorMethod}] instead.\n`;
         }
         else {
-            clientText += 'a constructor function instead.\n';
+            clientText += "a constructor function instead.\n";
         }
         if (client.apiVersions.length > 0) {
             clientText += `//\n// Generated from API version`;
@@ -71,7 +73,7 @@ export function generateOperations(pkg, target, options) {
                 clientText += `s ${client.apiVersions
                     .map((v) => v.literal.literal)
                     .sort()
-                    .join(', ')}\n`;
+                    .join(", ")}\n`;
             }
             else {
                 clientText += ` ${client.apiVersions[0].literal.literal}\n`;
@@ -79,12 +81,12 @@ export function generateOperations(pkg, target, options) {
         }
         const indent = new helpers.Indentation();
         clientText += `type ${client.name} struct {\n`;
-        clientText += `${indent.get()}internal *${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) {
             // for client params, only optional and flag types are passed by pointer
-            return param.style === 'flag' || param.style === 'optional';
+            return param.style === "flag" || param.style === "optional";
         };
         // now emit any client params (non parameterized host params case)
         if (client.parameters.length > 0) {
@@ -95,7 +97,7 @@ export function generateOperations(pkg, target, options) {
                 }
                 if (clientParam.group) {
                     if (!addedGroups.has(clientParam.group.groupName)) {
-                        clientText += `${indent.get()}${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;
@@ -113,17 +115,17 @@ export function generateOperations(pkg, target, options) {
             }
         }
         // end of client definition
-        clientText += '}\n\n';
+        clientText += "}\n\n";
         clientText += generateConstructors(client, target, imports, indent);
         // generate client accessors and operations
-        let opText = '';
+        let opText = "";
         for (const clientAccessor of client.clientAccessors) {
             imports.addForType(clientAccessor.returns);
             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 += `${indent.get()}return &${subClientDecl}{\n`;
-            const initFields = new Array('internal: client.internal');
+            const initFields = new Array("internal: client.internal");
             // propagate all client params
             for (const param of clientAccessor.parameters) {
                 // by convention, the client accessor params have the
@@ -159,11 +161,14 @@ export function generateOperations(pkg, target, options) {
             }
             opText += generateOperation(method, options, imports, indent);
             opText += createProtocolRequest(azureARM, method, imports, indent);
-            if (method.kind !== 'lroMethod') {
+            if (method.kind !== "lroMethod") {
                 // LRO responses are handled elsewhere, with the exception of pageable LROs
                 opText += createProtocolResponse(method, imports, indent);
             }
-            if (go.isPageableMethod(method) && method.strategy?.kind === 'nextLink' && method.strategy.method && !nextPageMethods.includes(method.strategy.method)) {
+            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.strategy.method);
             }
@@ -189,12 +194,12 @@ export function generateOperations(pkg, target, options) {
  * @returns the client constructor code or the empty string
  */
 function generateConstructors(client, type, imports, indent) {
-    if (client.instance?.kind !== 'constructable') {
-        return '';
+    if (client.instance?.kind !== "constructable") {
+        return "";
     }
     const clientOptions = client.instance.options;
-    let ctorText = '';
-    if (clientOptions.kind === 'clientOptions') {
+    let ctorText = "";
+    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${indent.get()}azcore.ClientOptions\n`;
@@ -206,13 +211,13 @@ function generateConstructors(client, type, imports, indent) {
             ctorText += helpers.formatDocCommentWithPrefix(naming.ensureNameCase(param.name), param.docs);
             if (go.isClientSideDefault(param.style)) {
                 if (!param.docs.description && !param.docs.summary) {
-                    ctorText += '\n';
+                    ctorText += "\n";
                 }
-                ctorText += `${indent.get()}${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 += `${indent.get()}${naming.ensureNameCase(param.name)} *${go.getTypeDeclaration(param.type, client.pkg)}\n`;
         }
-        ctorText += '}\n\n';
+        ctorText += "}\n\n";
     }
     for (const constructor of client.instance.constructors) {
         const ctorParams = new Array();
@@ -242,28 +247,28 @@ function generateConstructors(client, type, imports, indent) {
             }
         }
         const emitProlog = function (optionsTypeName, tokenAuth, plOpts) {
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
             let bodyText = `${indent.get()}if options == nil {\n`;
             bodyText += `${indent.push().get()}options = &${optionsTypeName}{}\n`;
             bodyText += `${indent.pop().get()}}\n`;
-            let apiVersionConfig = '';
+            let apiVersionConfig = "";
             // check if there's an api version parameter
             let apiVersionParam;
             for (const param of consolidatedCtorParams) {
                 switch (param.kind) {
-                    case 'headerScalarParam':
-                    case 'pathScalarParam':
-                    case 'queryScalarParam':
-                    case 'uriParam':
+                    case "headerScalarParam":
+                    case "pathScalarParam":
+                    case "queryScalarParam":
+                    case "uriParam":
                         if (param.isApiVersion) {
                             apiVersionParam = param;
                         }
                 }
             }
             if (tokenAuth) {
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud');
-                imports.add('fmt');
-                imports.add('reflect');
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud");
+                imports.add("fmt");
+                imports.add("reflect");
                 bodyText += `${indent.get()}if reflect.ValueOf(options.Cloud).IsZero() {\n`;
                 bodyText += `${indent.push().get()}options.Cloud = cloud.AzurePublic\n`;
                 bodyText += `${indent.pop().get()}}\n`;
@@ -278,17 +283,17 @@ function generateConstructors(client, type, imports, indent) {
                 let location;
                 let name;
                 switch (apiVersionParam.kind) {
-                    case 'headerScalarParam':
-                        location = 'Header';
+                    case "headerScalarParam":
+                        location = "Header";
                         name = apiVersionParam.headerName;
                         break;
-                    case 'pathScalarParam':
-                    case 'uriParam':
-                        location = 'Path';
+                    case "pathScalarParam":
+                    case "uriParam":
+                        location = "Path";
                         // name isn't used for the path case
                         break;
-                    case 'queryScalarParam':
-                        location = 'QueryParam';
+                    case "queryScalarParam":
+                        location = "QueryParam";
                         name = apiVersionParam.queryParameter;
                         break;
                 }
@@ -299,22 +304,22 @@ function generateConstructors(client, type, imports, indent) {
                     indent.pop(); // back to level 2
                 }
                 else {
-                    name = '';
+                    name = "";
                 }
                 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';
+                    apiVersionConfig += "\n";
                 }
             }
-            bodyText += `${indent.get()}cl, 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
         let credentialParam;
         for (const param of constructor.parameters) {
-            if (param.kind === 'credentialParam') {
+            if (param.kind === "credentialParam") {
                 credentialParam = param;
                 break;
             }
@@ -322,12 +327,14 @@ function generateConstructors(client, type, imports, indent) {
         let prolog;
         if (credentialParam) {
             switch (credentialParam.type.kind) {
-                case 'tokenCredential':
-                    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore');
-                    paramDocs.push(helpers.formatCommentAsBulletItem('credential', { summary: 'used to authorize requests. Usually a credential from azidentity.' }));
+                case "tokenCredential":
+                    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore");
+                    paramDocs.push(helpers.formatCommentAsBulletItem("credential", {
+                        summary: "used to authorize requests. Usually a credential from azidentity.",
+                    }));
                     switch (clientOptions.kind) {
-                        case 'clientOptions': {
-                            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/policy');
+                        case "clientOptions": {
+                            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/policy");
                             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()}}`;
@@ -337,9 +344,9 @@ function generateConstructors(client, type, imports, indent) {
                             prolog = emitProlog(go.getTypeDeclaration(clientOptions, client.pkg), true, tokenPolicy);
                             break;
                         }
-                        case 'armClientOptions':
+                        case "armClientOptions":
                             // this is the ARM case
-                            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/arm');
+                            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/arm");
                             prolog = `${indent.get()}cl, err := arm.NewClient(moduleName, moduleVersion, credential, options)\n`;
                             break;
                     }
@@ -351,23 +358,25 @@ function generateConstructors(client, type, imports, indent) {
         }
         // add client options last
         ctorParams.push(`options ${helpers.formatParameterTypeName(client.pkg, clientOptions)}`);
-        paramDocs.push(helpers.formatCommentAsBulletItem('options', { summary: 'Contains optional client configuration. Pass nil to accept the default values.' }));
+        paramDocs.push(helpers.formatCommentAsBulletItem("options", {
+            summary: "Contains optional client configuration. Pass nil to accept the default values.",
+        }));
         ctorText += `// ${constructor.name} creates a new instance of ${client.name} with the specified values.\n`;
         for (const doc of paramDocs) {
             ctorText += doc;
         }
-        ctorText += `func ${constructor.name}(${ctorParams.join(', ')}) (*${client.name}, error) {\n`;
+        ctorText += `func ${constructor.name}(${ctorParams.join(", ")}) (*${client.name}, error) {\n`;
         ctorText += prolog;
         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') {
+        if (clientOptions.kind === "clientOptions") {
             for (const param of clientOptions.parameters) {
                 if (go.isClientSideDefault(param.style)) {
                     let name;
                     if (go.isAPIVersionParameter(param)) {
-                        name = 'APIVersion';
+                        name = "APIVersion";
                     }
                     else {
                         name = naming.ensureNameCase(param.name);
@@ -384,7 +393,7 @@ function generateConstructors(client, type, imports, indent) {
             // the endpoint param is always the first ctor param
             const endpointParam = client.instance.constructors[0].parameters[0];
             if (client.instance.endpoint.supplemental.parameters.length > 0) {
-                imports.add('strings');
+                imports.add("strings");
                 ctorText += `${indent.get()}host := "${client.instance.endpoint.supplemental.path}"\n`;
                 for (const param of client.instance.endpoint.supplemental.parameters) {
                     ctorText += `${indent.get()}host = strings.ReplaceAll(host, "{${param.uriPathSegment}}", ${helpers.formatValue(param.name, param.type, imports)})\n`;
@@ -397,7 +406,7 @@ function generateConstructors(client, type, imports, indent) {
             }
         }
         // construct client literal
-        let clientVar = 'client';
+        let clientVar = "client";
         // ensure clientVar doesn't collide with any params
         for (const param of consolidatedCtorParams) {
             if (param.name === clientVar) {
@@ -421,16 +430,16 @@ function generateConstructors(client, type, imports, indent) {
         indent.pop();
         ctorText += `${indent.get()}}\n`;
         ctorText += `${indent.get()}return ${clientVar}, nil\n`;
-        ctorText += '}\n\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, 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');
+    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 = `${indent.get()}for hh := range resp.Header {\n`;
         text += `${indent.push().get()}if len(hh) > len("${headerPrefix}") && strings.EqualFold(hh[:len("${headerPrefix}")], "${headerPrefix}") {\n`;
@@ -445,52 +454,52 @@ function formatHeaderResponseValue(method, headerResp, respObj, zeroResp, import
     let text = `${indent.get()}if val := resp.Header.Get("${headerResp.headerName}"); val != "" {\n`;
     indent.push();
     let name = naming.uncapitalize(headerResp.fieldName);
-    let byRef = '&';
+    let byRef = "&";
     switch (headerResp.type.kind) {
-        case 'constant':
-        case 'etag':
+        case "constant":
+        case "etag":
             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':
+        case "encodedBytes":
             // a base-64 encoded value in string format
-            imports.add('encoding/base64');
+            imports.add("encoding/base64");
             text += `${indent.get()}${name}, err := base64.${helpers.formatBytesEncoding(headerResp.type.encoding)}Encoding.DecodeString(val)\n`;
-            byRef = '';
+            byRef = "";
             break;
-        case 'literal':
+        case "literal":
             text += `${indent.get()}${respObj}.${headerResp.fieldName} = &val\n`;
             indent.pop();
             text += `${indent.get()}}\n`;
             return text;
-        case 'scalar':
-            text += emitScalarParsing(headerResp.type, 'val', name, imports, indent);
+        case "scalar":
+            text += emitScalarParsing(headerResp.type, "val", name, imports, indent);
             break;
-        case 'string':
+        case "string":
             text += `${indent.get()}${respObj}.${headerResp.fieldName} = &val\n`;
             text += `${indent.pop().get()}}\n`;
             return text;
-        case 'time':
-            imports.add('time');
+        case "time":
+            imports.add("time");
             switch (headerResp.type.format) {
-                case 'RFC1123':
-                case 'RFC3339':
-                case 'RFC7231':
-                    text += `${indent.get()}${name}, err := time.Parse(${headerResp.type.format === 'RFC3339' ? helpers.RFC3339Format : helpers.RFC1123Format}, val)\n`;
+                case "RFC1123":
+                case "RFC3339":
+                case "RFC7231":
+                    text += `${indent.get()}${name}, err := time.Parse(${headerResp.type.format === "RFC3339" ? helpers.RFC3339Format : helpers.RFC1123Format}, val)\n`;
                     break;
-                case 'PlainDate':
+                case "PlainDate":
                     text += `${indent.get()}${name}, err := time.Parse(${helpers.plainDateFormat}, val)\n`;
                     break;
-                case 'PlainTime':
+                case "PlainTime":
                     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');
+                case "Unix":
+                    imports.add("strconv");
+                    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
                     text += `${indent.get()}sec, err := strconv.ParseInt(val, 10, 64)\n`;
-                    name = 'to.Ptr(time.Unix(sec, 0))';
-                    byRef = '';
+                    name = "to.Ptr(time.Unix(sec, 0))";
+                    byRef = "";
                     break;
                 default:
                     headerResp.type.format;
@@ -517,20 +526,22 @@ function formatHeaderResponseValue(method, headerResp, respObj, zeroResp, import
  * @returns the scalar parsing code
  */
 function emitScalarParsing(scalar, src, dst, imports, indent) {
-    imports.add('strconv');
+    imports.add("strconv");
     switch (scalar.type) {
-        case 'bool':
+        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':
+        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':
+        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}`);
+            throw new CodegenError("InternalError", `unhandled scalar type ${scalar.type}`);
     }
 }
 /**
@@ -548,10 +559,10 @@ function emitScalarParsing(scalar, src, dst, imports, indent) {
 function getZeroReturnValue(method, apiType) {
     let returnType = `${method.returns.name}{}`;
     if (go.isLROMethod(method)) {
-        if (apiType === 'lro' || apiType === 'op') {
+        if (apiType === "lro" || apiType === "op") {
             // the api returns a *Poller[T]
             // the operation returns an *http.Response
-            returnType = 'nil';
+            returnType = "nil";
         }
     }
     return returnType;
@@ -566,17 +577,17 @@ function getZeroReturnValue(method, apiType) {
  *   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) {
+function generateNilChecks(segments, varName = "page", omitLastSegment = false) {
     const checks = [];
     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('.');
+        const currentPath = [varName, ...segments.map((segment) => segment.name).slice(0, i + 1)].join(".");
         checks.push(`${currentPath} != nil`);
     }
-    return checks.join(' && ');
+    return checks.join(" && ");
 }
 /**
  * emits code that calls runtime.NewPager
@@ -588,7 +599,7 @@ function generateNilChecks(segments, varName = 'page', omitLastSegment = false)
  * @returns the complete call to runtime.NewPager(...)
  */
 function emitPagerDefinition(method, options, imports, indent) {
-    imports.add('context');
+    imports.add("context");
     let text = `runtime.NewPager(runtime.PagingHandler[${method.returns.name}]{\n`;
     text += `${indent.push().get()}More: func(page ${method.returns.name}) bool {\n`;
     indent.push();
@@ -599,13 +610,13 @@ function emitPagerDefinition(method, options, imports, indent) {
             text += `${indent.get()}return ${nilChecks} && len(*page.${nextLinkPath}) > 0\n`;
         };
         switch (method.strategy.kind) {
-            case 'continuationToken': {
+            case "continuationToken": {
                 switch (method.strategy.responseToken.kind) {
-                    case 'headerScalarResponse':
+                    case "headerScalarResponse":
                         const tokenRespField = method.strategy.responseToken.fieldName;
                         text += `${indent.get()}return page.${tokenRespField} != nil && len(*page.${tokenRespField}) > 0\n`;
                         break;
-                    case 'nextLink':
+                    case "nextLink":
                         moreForNextLinkPath(method.strategy.responseToken);
                         break;
                     default:
@@ -613,7 +624,7 @@ function emitPagerDefinition(method, options, imports, indent) {
                 }
                 break;
             }
-            case 'nextLink': {
+            case "nextLink": {
                 moreForNextLinkPath(method.strategy);
                 break;
             }
@@ -636,33 +647,33 @@ function emitPagerDefinition(method, options, imports, indent) {
     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`,
+            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': {
+            case "continuationToken": {
                 const ms = method.strategy;
-                const optionsCopy = 'nextOpts';
+                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 = '';
+                let nestedNilChecks = "";
                 switch (ms.responseToken.kind) {
-                    case 'headerScalarResponse':
+                    case "headerScalarResponse":
                         respToken = ms.responseToken.fieldName;
                         break;
-                    case 'nextLink':
+                    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)}`;
+                            nestedNilChecks = ` && ${generateNilChecks(ms.responseToken.nextLinkPath, "page", true)}`;
                         }
                         break;
                 }
@@ -670,17 +681,17 @@ function emitPagerDefinition(method, options, imports, 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);
+                text += callCreateRequestWithErrCheck(method, "req", indent, `&${optionsCopy}`);
+                text += callPipelineDoWithErrCheck(method, "req", "resp", indent);
+                text += emitStatusCodeCheckAndResponse("resp", indent);
                 break;
             }
-            case 'nextLink': {
+            case "nextLink": {
                 const nextLinkPath = helpers.buildNextLinkPath(method.strategy);
                 let nextLinkVar;
-                if (method.kind === 'pageableMethod') {
+                if (method.kind === "pageableMethod") {
                     text += `${indent.get()}nextLink := ""\n`;
-                    nextLinkVar = 'nextLink';
+                    nextLinkVar = "nextLink";
                     text += `${indent.get()}if page != nil {\n`;
                     text += `${indent.push().get()}nextLink = *page.${nextLinkPath}\n`;
                     text += `${indent.pop().get()}}\n`;
@@ -693,13 +704,15 @@ function emitPagerDefinition(method, options, imports, indent) {
                 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(',');
+                    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';
+                        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;
@@ -709,17 +722,17 @@ function emitPagerDefinition(method, options, imports, indent) {
                     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.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') {
+                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 += "nil)\n";
                 }
                 text += `${indent.get()}if err != nil {\n`;
                 text += `${indent.push().get()}return ${method.returns.name}{}, err\n`;
@@ -730,9 +743,9 @@ function emitPagerDefinition(method, options, imports, indent) {
     }
     else {
         // this is the singular page case, no fetcher helper required
-        text += callCreateRequestWithErrCheck(method, 'req', indent);
-        text += callPipelineDoWithErrCheck(method, 'req', 'resp', indent);
-        text += emitStatusCodeCheckAndResponse('resp', indent);
+        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) {
@@ -754,8 +767,8 @@ function emitPagerDefinition(method, options, imports, indent) {
 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`;
+    const zeroResp = getZeroReturnValue(method, "op");
+    text += `${indent.get()}${helpers.buildErrCheck(indent, "err", zeroResp)}\n`;
     return text;
 }
 /**
@@ -770,17 +783,17 @@ function callCreateRequestWithErrCheck(method, reqVarName, indent, optionsParam)
  */
 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`;
+    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)) {
+    if (!(method.returns.result?.kind === "headAsBooleanResult") && !go.isPageableMethod(method)) {
         // when head-as-boolean is enabled, no error is returned for 4xx status codes.
         // pager constructors don't return an error
-        return '// If the operation fails it returns an *azcore.ResponseError type.\n';
+        return "// If the operation fails it returns an *azcore.ResponseError type.\n";
     }
-    return '';
+    return "";
 }
 /**
  * returns the receiver definition for a client
@@ -789,16 +802,16 @@ function genRespErrorDoc(method) {
  * @returns the receiver definition
  */
 function getClientReceiverDefinition(receiver) {
-    return `(${receiver.name} ${receiver.byValue ? '' : '*'}${receiver.type.name})`;
+    return `(${receiver.name} ${receiver.byValue ? "" : "*"}${receiver.type.name})`;
 }
 function generateOperation(method, options, imports, indent) {
     const params = getAPIParametersSig(method, imports);
-    const returns = generateReturnsInfo(method, 'op');
+    const returns = generateReturnsInfo(method, "op");
     let methodName = method.name;
-    if (method.kind === 'pageableMethod') {
+    if (method.kind === "pageableMethod") {
         methodName = fixUpMethodName(method);
     }
-    let text = '';
+    let text = "";
     const respErrDoc = genRespErrorDoc(method);
     if (method.docs.summary || method.docs.description) {
         text += helpers.formatDocCommentWithPrefix(methodName, method.docs);
@@ -818,18 +831,18 @@ function generateOperation(method, options, imports, indent) {
             text += helpers.formatCommentAsBulletItem(param.name, param.docs);
         }
     }
-    text += `func ${getClientReceiverDefinition(method.receiver)} ${methodName}(${params}) (${returns.join(', ')}) {\n`;
-    if (method.kind === 'pageableMethod') {
+    text += `func ${getClientReceiverDefinition(method.receiver)} ${methodName}(${params}) (${returns.join(", ")}) {\n`;
+    if (method.kind === "pageableMethod") {
         text += `${indent.get()}return `;
         text += emitPagerDefinition(method, options, imports, indent);
-        text += '}\n\n';
+        text += "}\n\n";
         return text;
     }
     text += `${indent.get()}var err error\n`;
     let operationName = `"${method.receiver.type.name}.${fixUpMethodName(method)}"`;
     if (options.generateFakes && options.injectSpans) {
         text += `${indent.get()}const operationName = ${operationName}\n`;
-        operationName = 'operationName';
+        operationName = "operationName";
     }
     if (options.generateFakes) {
         text += `${indent.get()}ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, ${operationName})\n`;
@@ -838,16 +851,17 @@ function generateOperation(method, options, imports, indent) {
         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 += callCreateRequestWithErrCheck(method, 'req', indent);
-    text += callPipelineDoWithErrCheck(method, 'req', 'httpResp', indent);
+    const zeroResp = getZeroReturnValue(method, "op");
+    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) {
+    if (method.returns.result?.kind === "headAsBooleanResult" &&
+        method.returns.headers.length === 0) {
         text += `${indent.get()}return ${method.returns.name}{${method.returns.result.fieldName}: httpResp.StatusCode >= 200 && httpResp.StatusCode < 300}, nil\n`;
     }
     else {
@@ -859,14 +873,14 @@ function generateOperation(method, options, imports, indent) {
             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') {
+        else if (method.returns.result?.kind === "binaryResult") {
             text += `${indent.get()}return ${method.returns.name}{${method.returns.result.fieldName}: httpResp.Body}, nil\n`;
         }
         else {
             text += `${indent.get()}return ${method.returns.name}{}, nil\n`;
         }
     }
-    text += '}\n\n';
+    text += "}\n\n";
     return text;
 }
 /**
@@ -880,16 +894,16 @@ function generateOperation(method, options, imports, indent) {
  * @returns setter code or the empty string
  */
 function emitMultipartContentTypeSetter(paramName, wireType, indent) {
-    let text = '';
+    let text = "";
     const unwrapped = helpers.recursiveUnwrapMapSlice(wireType);
-    if (unwrapped.kind !== 'multipartContent' || !unwrapped.contentType) {
+    if (unwrapped.kind !== "multipartContent" || !unwrapped.contentType) {
         return text;
     }
     switch (wireType.kind) {
-        case 'multipartContent':
+        case "multipartContent":
             text += `${indent.get()}${paramName}.ContentType = ${unwrapped.contentType.literal}\n`;
             break;
-        case 'slice':
+        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`;
@@ -899,30 +913,30 @@ function emitMultipartContentTypeSetter(paramName, wireType, indent) {
 }
 function createProtocolRequest(azureARM, method, imports, indent) {
     let name = method.name;
-    if (method.kind !== 'nextPageMethod') {
+    if (method.kind !== "nextPageMethod") {
         name = method.naming.requestMethod;
     }
     for (const param of method.parameters) {
-        if (param.location !== 'method' || !go.isRequiredParameter(param.style)) {
+        if (param.location !== "method" || !go.isRequiredParameter(param.style)) {
             continue;
         }
         imports.addForType(param.type);
     }
-    const returns = ['*policy.Request', 'error'];
-    let text = `${helpers.comment(name, '// ')} creates the ${method.name} request.\n`;
-    text += `func ${getClientReceiverDefinition(method.receiver)} ${name}(${helpers.getCreateRequestParametersSig(method)}) (${returns.join(', ')}) {\n`;
+    const returns = ["*policy.Request", "error"];
+    let text = `${helpers.comment(name, "// ")} creates the ${method.name} request.\n`;
+    text += `func ${getClientReceiverDefinition(method.receiver)} ${name}(${helpers.getCreateRequestParametersSig(method)}) (${returns.join(", ")}) {\n`;
     const hostParams = new Array();
     for (const parameter of method.receiver.type.parameters) {
-        if (parameter.kind === 'uriParam') {
+        if (parameter.kind === "uriParam") {
             hostParams.push(parameter);
         }
     }
     let hostParam;
     if (azureARM) {
-        hostParam = 'client.internal.Endpoint()';
+        hostParam = "client.internal.Endpoint()";
     }
-    else if (method.receiver.type.instance?.kind === 'templatedHost') {
-        imports.add('strings');
+    else if (method.receiver.type.instance?.kind === "templatedHost") {
+        imports.add("strings");
         // we have a templated host
         text += `${indent.get()}host := "${method.receiver.type.instance.path}"\n`;
         // get all the host params on the client
@@ -931,18 +945,18 @@ function createProtocolRequest(azureARM, method, imports, indent) {
         }
         // check for any method local host params
         for (const param of method.parameters) {
-            if (param.location === 'method' && param.kind === 'uriParam') {
+            if (param.location === "method" && param.kind === "uriParam") {
                 text += `${indent.get()}host = strings.ReplaceAll(host, "{${param.uriPathSegment}}", ${helpers.formatValue(helpers.getParamName(param), param.type, imports)})\n`;
             }
         }
-        hostParam = 'host';
+        hostParam = "host";
     }
     else if (hostParams.length === 1) {
         // simple parameterized host case
-        hostParam = 'client.' + hostParams[0].name;
+        hostParam = "client." + hostParams[0].name;
     }
     else {
-        throw new CodegenError('InternalError', `no host or endpoint defined for method ${method.receiver.type.name}.${method.name}`);
+        throw new CodegenError("InternalError", `no host or endpoint defined for method ${method.receiver.type.name}.${method.name}`);
     }
     const methodParamGroups = helpers.getMethodParamGroups(method);
     const hasPathParams = methodParamGroups.pathParams.length > 0;
@@ -952,7 +966,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
     // actually reference the path params (i.e. no params with which to replace the tokens).
     // so, if a path contains tokens but there are no path params, skip emitting the path.
     const pathStr = method.httpPath;
-    const pathContainsParms = pathStr.includes('{');
+    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 += `${indent.get()}urlPath := "${method.httpPath}"\n`;
@@ -961,42 +975,42 @@ function createProtocolRequest(azureARM, method, imports, indent) {
     // helper to build nil checks for param groups
     const emitParamGroupCheck = function (param) {
         if (!param.group) {
-            throw new CodegenError('InternalError', `emitParamGroupCheck called for ungrouped parameter ${param.name}`);
+            throw new CodegenError("InternalError", `emitParamGroupCheck called for ungrouped parameter ${param.name}`);
         }
-        let client = '';
-        if (param.location === 'client') {
-            client = 'client.';
+        let client = "";
+        if (param.location === "client") {
+            client = "client.";
         }
         const paramGroupName = naming.uncapitalize(param.group.name);
         let optionalParamGroupCheck = `${client}${paramGroupName} != nil && `;
         if (param.group.required) {
-            optionalParamGroupCheck = '';
+            optionalParamGroupCheck = "";
         }
         return `${indent.get()}if ${optionalParamGroupCheck}${client}${paramGroupName}.${naming.capitalize(param.name)} != nil {\n`;
     };
     if (hasPathParams) {
         // swagger defines path params, emit path and replace tokens
-        imports.add('strings');
+        imports.add("strings");
         // replace path parameters
         for (const pp of methodParamGroups.pathParams) {
             let paramValue;
             let optionalPathSep = false;
-            if (pp.style === 'literal') {
+            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') {
+            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') {
+                if (pp.kind === "pathScalarParam") {
                     const choiceIsString = function (type) {
-                        return type.kind === 'constant' && type.type === 'string';
+                        return type.kind === "constant" && type.type === "string";
                     };
                     // we only need to do this for params that have an underlying type of string
-                    if ((pp.type.kind === 'string' || choiceIsString(pp.type)) && !pp.omitEmptyStringCheck) {
+                    if ((pp.type.kind === "string" || choiceIsString(pp.type)) && !pp.omitEmptyStringCheck) {
                         const paramName = helpers.getParamName(pp);
-                        imports.add('errors');
+                        imports.add("errors");
                         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`;
@@ -1006,11 +1020,11 @@ function createProtocolRequest(azureARM, method, 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') {
+                if (pp.kind === "pathCollectionParam") {
                     const paramName = helpers.getParamName(pp);
                     const joinedParamName = `${paramName}Param`;
                     text += `${indent.get()}${joinedParamName} := ${paramValue}\n`;
-                    imports.add('errors');
+                    imports.add("errors");
                     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`;
@@ -1018,7 +1032,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
                 }
             }
             else if (go.isClientSideDefault(pp.style)) {
-                const defaultValue = naming.uncapitalize(pp.name) + 'Default';
+                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`;
@@ -1038,13 +1052,13 @@ function createProtocolRequest(azureARM, method, imports, indent) {
                 //  - /foo/bar/{optional}
                 //  - /foo/bar{/optional}
                 // for the second case, we need to include a forward slash
-                if (method.httpPath[method.httpPath.indexOf(`{${pp.pathSegment}}`) - 1] !== '/') {
+                if (method.httpPath[method.httpPath.indexOf(`{${pp.pathSegment}}`) - 1] !== "/") {
                     optionalPathSep = true;
                 }
             }
             const emitPathEscape = function () {
                 if (pp.isEncoded) {
-                    imports.add('net/url');
+                    imports.add("net/url");
                     return `url.PathEscape(${paramValue})`;
                 }
                 return paramValue;
@@ -1068,16 +1082,18 @@ function createProtocolRequest(azureARM, method, imports, indent) {
     const encodedParams = methodParamGroups.encodedQueryParams;
     const unencodedParams = methodParamGroups.unencodedQueryParams;
     const emitQueryParam = function (qp, setter) {
-        let qpText = '';
-        if (qp.location === 'method' && go.isClientSideDefault(qp.style)) {
+        let qpText;
+        if (qp.location === "method" && go.isClientSideDefault(qp.style)) {
             qpText = emitClientSideDefault(qp, qp.style, (name, val) => {
                 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))) {
+        else if (go.isRequiredParameter(qp.style) ||
+            go.isLiteralParameter(qp.style) ||
+            (qp.location === "client" && go.isClientSideDefault(qp.style))) {
             qpText = `${indent.get()}${setter}\n`;
         }
-        else if (qp.location === 'client' && !qp.group) {
+        else if (qp.location === "client" && !qp.group) {
             // global optional param
             qpText = `${indent.get()}if client.${qp.name} != nil {\n`;
             qpText += `${indent.push().get()}${setter}\n`;
@@ -1097,27 +1113,27 @@ function createProtocolRequest(azureARM, method, imports, indent) {
             return helpers.sortAscending(a.queryParameter, b.queryParameter);
         })) {
             let setter;
-            if (qp.kind === 'queryCollectionParam' && qp.collectionFormat === 'multi') {
+            if (qp.kind === "queryCollectionParam" && qp.collectionFormat === "multi") {
                 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;
                 switch (arrayQP.elementType.kind) {
-                    case 'constant':
+                    case "constant":
                         switch (arrayQP.elementType.type) {
-                            case 'string':
-                                queryVal = 'string(qv)';
+                            case "string":
+                                queryVal = "string(qv)";
                                 break;
                             default:
-                                imports.add('fmt');
+                                imports.add("fmt");
                                 queryVal = 'fmt.Sprintf("%d", qv)';
                         }
                         break;
-                    case 'string':
-                        queryVal = 'qv';
+                    case "string":
+                        queryVal = "qv";
                         break;
                     default:
-                        imports.add('fmt');
+                        imports.add("fmt");
                         queryVal = 'fmt.Sprintf("%v", qv)';
                 }
                 setter += `${indent.push().get()}reqQP.Add("${qp.queryParameter}", ${queryVal})\n`;
@@ -1133,7 +1149,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
         // thus not applicable for URIs. the correct URI encoding for SP is %20. note that literal '+'
         // characters are encoded by reqQP.Encode() as %2B so there's no risk of replacing them.
         // see https://www.rfc-editor.org/rfc/rfc3986 sections 2.1, 2.2, and 3.4
-        imports.add('strings');
+        imports.add("strings");
         text += `${indent.get()}req.Raw().URL.RawQuery = strings.ReplaceAll(reqQP.Encode(), "+", "%20")\n`;
     }
     // tack on any unencoded params to the end
@@ -1148,7 +1164,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
             return helpers.sortAscending(a.queryParameter, b.queryParameter);
         })) {
             let setter;
-            if (qp.kind === 'queryCollectionParam' && qp.collectionFormat === 'multi') {
+            if (qp.kind === "queryCollectionParam" && qp.collectionFormat === "multi") {
                 setter = `for _, qv := range ${helpers.getParamName(qp)} {\n`;
                 setter += `${indent.push().get()}unencodedParams = append(unencodedParams, "${qp.queryParameter}="+qv)\n`;
                 setter += `${indent.pop().get()}}`;
@@ -1158,16 +1174,16 @@ function createProtocolRequest(azureARM, method, imports, indent) {
             }
             text += emitQueryParam(qp, setter);
         }
-        imports.add('strings');
+        imports.add("strings");
         text += `${indent.get()}req.Raw().URL.RawQuery = strings.Join(unencodedParams, "&")\n`;
     }
-    if (method.kind !== 'nextPageMethod' && method.returns.result?.kind === 'binaryResult') {
+    if (method.kind !== "nextPageMethod" && method.returns.result?.kind === "binaryResult") {
         // skip auto-body downloading for binary stream responses
         text += `${indent.get()}runtime.SkipBodyDownload(req)\n`;
     }
     // add specific request headers
     const emitHeaderSet = function (headerParam) {
-        if (headerParam.kind === 'headerMapParam') {
+        if (headerParam.kind === "headerMapParam") {
             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`;
@@ -1175,7 +1191,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
             headerText += `${indent.pop().get()}}\n`;
             return headerText;
         }
-        else if (headerParam.location === 'method' && go.isClientSideDefault(headerParam.style)) {
+        else if (headerParam.location === "method" && go.isClientSideDefault(headerParam.style)) {
             return emitClientSideDefault(headerParam, headerParam.style, (name, val) => {
                 return `${indent.get()}req.Raw().Header[${name}] = []string{${val}}`;
             }, imports, indent);
@@ -1190,34 +1206,36 @@ function createProtocolRequest(azureARM, method, imports, indent) {
     })) {
         if (param.headerName.match(/^content-type$/i)) {
             // canonicalize content-type as req.SetBody checks for it via its canonicalized name :(
-            param.headerName = 'Content-Type';
+            param.headerName = "Content-Type";
             // there's a corner case where we have a content-type param with no body
             // param. for this case we still need to set the header inline.
             const bodyParam = methodParamGroups.bodyParam;
-            if (bodyParam?.bodyFormat === 'binary' || bodyParam?.bodyFormat === 'Text') {
+            if (bodyParam?.bodyFormat === "binary" || bodyParam?.bodyFormat === "Text") {
                 // if the content-type is from a param, then the param will be passed
                 // explicitly to runtime.SetBody() so don't emit code to set it inline.
                 // NOTE: only binary/text payloads call runtime.SetBody().
                 if (go.isClientSideDefault(param.style)) {
-                    text += emitClientSideDefault(param, param.style, () => '', imports, indent);
+                    text += emitClientSideDefault(param, param.style, () => "", imports, indent);
                     continue;
                 }
-                else if (param.style === 'required') {
+                else if (param.style === "required") {
                     continue;
                 }
             }
         }
-        if (param.headerName === 'Content-Type' && param.style === 'literal') {
+        if (param.headerName === "Content-Type" && param.style === "literal") {
             // the content-type header will be set as part of emitSetBodyWithErrCheck
             // 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, indent);
         }
-        else if (go.isRequiredParameter(param.style) || go.isLiteralParameter(param.style) || go.isClientSideDefault(param.style)) {
+        else if (go.isRequiredParameter(param.style) ||
+            go.isLiteralParameter(param.style) ||
+            go.isClientSideDefault(param.style)) {
             text += emitHeaderSet(param);
         }
-        else if (param.location === 'client' && !param.group) {
+        else if (param.location === "client" && !param.group) {
             // global optional param
             text += `${indent.get()}if client.${param.name} != nil {\n`;
             indent.push();
@@ -1239,7 +1257,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
     const multipartBodyParams = methodParamGroups.multipartBodyParams;
     const partialBodyParams = methodParamGroups.partialBodyParams;
     const emitSetBodyWithErrCheck = function (setBodyParam, contentType) {
-        let content = '';
+        let content = "";
         if (contentType) {
             content += `${indent.get()}req.Raw().Header["Content-Type"] = []string{${contentType}}\n`;
         }
@@ -1252,36 +1270,36 @@ function createProtocolRequest(azureARM, method, imports, indent) {
         /** returns the source value for the content type */
         const getContentTypeValue = function (src) {
             switch (src.kind) {
-                case 'literal':
+                case "literal":
                     return helpers.formatLiteralValue(src, false);
-                case 'parameterRef': {
+                case "parameterRef": {
                     // find the param
                     for (const param of method.parameters) {
-                        if (param.kind === 'headerScalarParam' && param.name === src.name) {
+                        if (param.kind === "headerScalarParam" && param.name === src.name) {
                             if (go.isClientSideDefault(param.style)) {
                                 return getClientSideDefaultVarName(param);
                             }
                             let paramName = helpers.getParamName(param);
-                            if (param.type.kind === 'constant') {
+                            if (param.type.kind === "constant") {
                                 paramName = `string(${paramName})`;
                             }
                             return paramName;
                         }
                     }
-                    throw new CodegenError('InternalError', `didn't find parameter reference ${src.name}`);
+                    throw new CodegenError("InternalError", `didn't find parameter reference ${src.name}`);
                 }
             }
         };
-        if (bodyParam.bodyFormat === 'JSON' || bodyParam.bodyFormat === 'XML') {
+        if (bodyParam.bodyFormat === "JSON" || bodyParam.bodyFormat === "XML") {
             // default to the body param name
             let body = helpers.getParamName(bodyParam);
-            if (bodyParam.type.kind === 'literal') {
+            if (bodyParam.type.kind === "literal") {
                 // if the value is constant, embed it directly
                 body = helpers.formatLiteralValue(bodyParam.type, true);
             }
-            else if (bodyParam.bodyFormat === 'XML' && bodyParam.type.kind === 'slice') {
+            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');
+                imports.add("encoding/xml");
                 text += `${indent.get()}type wrapper struct {\n`;
                 indent.push();
                 let tagName;
@@ -1294,49 +1312,49 @@ function createProtocolRequest(azureARM, method, imports, indent) {
                 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) {
+                if (bodyParam.type.elementType.kind === "model" && bodyParam.type.elementType.xml?.name) {
                     tag = bodyParam.type.elementType.xml.name;
                 }
                 text += `${indent.get()}${fieldName} *${go.getTypeDeclaration(bodyParam.type, method.receiver.type.pkg)} \`xml:"${tag}"\`\n`;
                 text += `${indent.pop().get()}}\n`;
-                let addr = '&';
+                let addr = "&";
                 if (!go.isRequiredParameter(bodyParam.style) && !bodyParam.byValue) {
-                    addr = '';
+                    addr = "";
                 }
                 body = `wrapper{${fieldName}: ${addr}${body}}`;
             }
-            else if (bodyParam.type.kind === 'time' && bodyParam.type.format !== 'RFC3339') {
+            else if (bodyParam.type.kind === "time" && bodyParam.type.format !== "RFC3339") {
                 // wrap the body in the internal time type
                 // no need for RFC3339 as the JSON marshaler defaults to that.
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
                 body = `datetime.${bodyParam.type.format}(${body})`;
             }
             else if (isArrayOfDateTimeForMarshalling(bodyParam.type)) {
                 const timeInfo = isArrayOfDateTimeForMarshalling(bodyParam.type);
-                let elementPtr = '*';
+                let elementPtr = "*";
                 if (timeInfo?.elemByVal) {
-                    elementPtr = '';
+                    elementPtr = "";
                 }
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
                 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';
+                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');
+                const timeType = isMapOfDateTime(bodyParam.type);
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
                 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';
+                body = "aux";
             }
             let setBody = `runtime.MarshalAs${getMediaFormat(bodyParam.type, bodyParam.bodyFormat, `req, ${body}`)}`;
-            if (bodyParam.type.kind === 'rawJSON') {
-                imports.add('bytes');
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
+            if (bodyParam.type.kind === "rawJSON") {
+                imports.add("bytes");
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming");
                 setBody = `req.SetBody(streaming.NopCloser(bytes.NewReader(${body})), "application/${bodyParam.bodyFormat.toLowerCase()}")`;
             }
             if (go.isRequiredParameter(bodyParam.style) || go.isLiteralParameter(bodyParam.style)) {
@@ -1353,7 +1371,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
                 text += `${indent.get()}return req, nil\n`;
             }
         }
-        else if (bodyParam.bodyFormat === 'binary') {
+        else if (bodyParam.bodyFormat === "binary") {
             if (go.isRequiredParameter(bodyParam.style)) {
                 text += emitSetBodyWithErrCheck(`req.SetBody(${bodyParam.name}, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
                 text += `${indent.get()}return req, nil\n`;
@@ -1368,9 +1386,9 @@ function createProtocolRequest(azureARM, method, imports, indent) {
                 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');
+        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 += `${indent.get()}body := streaming.NopCloser(strings.NewReader(${bodyParam.name}))\n`;
                 text += emitSetBodyWithErrCheck(`req.SetBody(body, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
@@ -1429,7 +1447,9 @@ function createProtocolRequest(azureARM, method, imports, indent) {
         // 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) {
+        if (multipartBodyParams.length === 1 &&
+            multipartBodyParams[0].type.kind === "model" &&
+            multipartBodyParams[0].type.annotations.multipartFormData) {
             // 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.
@@ -1462,7 +1482,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
     }
     else if (formBodyParams.length > 0) {
         const emitFormData = function (param, setter) {
-            let formDataText = '';
+            let formDataText;
             if (go.isRequiredParameter(param.style)) {
                 formDataText = `${indent.get()}${setter}\n`;
             }
@@ -1473,9 +1493,9 @@ function createProtocolRequest(azureARM, method, imports, indent) {
             }
             return formDataText;
         };
-        imports.add('net/url');
-        imports.add('strings');
-        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
+        imports.add("net/url");
+        imports.add("strings");
+        imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming");
         text += `${indent.get()}formData := url.Values{}\n`;
         // find all the form body params
         for (const param of formBodyParams) {
@@ -1489,7 +1509,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
     else {
         text += `${indent.get()}return req, nil\n`;
     }
-    text += '}\n\n';
+    text += "}\n\n";
     return text;
 }
 /**
@@ -1499,7 +1519,7 @@ function createProtocolRequest(azureARM, method, imports, indent) {
  * @returns the var name
  */
 function getClientSideDefaultVarName(param) {
-    return naming.uncapitalize(param.name) + 'Default';
+    return naming.uncapitalize(param.name) + "Default";
 }
 function emitClientSideDefault(param, csd, setterFormat, imports, indent) {
     const defaultVar = getClientSideDefaultVarName(param);
@@ -1509,12 +1529,12 @@ function emitClientSideDefault(param, csd, setterFormat, imports, indent) {
     text += `${indent.pop().get()}}\n`;
     let serializedName;
     switch (param.kind) {
-        case 'headerCollectionParam':
-        case 'headerScalarParam':
+        case "headerCollectionParam":
+        case "headerScalarParam":
             serializedName = param.headerName;
             break;
-        case 'queryCollectionParam':
-        case 'queryScalarParam':
+        case "queryCollectionParam":
+        case "queryScalarParam":
             serializedName = param.queryParameter;
             break;
     }
@@ -1523,32 +1543,32 @@ function emitClientSideDefault(param, csd, setterFormat, imports, indent) {
     // setterFormat can return the empty string in some cases.
     // if it does, there's no need for an extra new-line char.
     if (setterFormatText.length > 0) {
-        text += '\n';
+        text += "\n";
     }
     return text;
 }
 function getMediaFormat(type, mediaType, param) {
     let marshaller = mediaType;
-    let format = '';
-    if (type.kind === 'encodedBytes') {
-        marshaller = 'ByteArray';
+    let format = "";
+    if (type.kind === "encodedBytes") {
+        marshaller = "ByteArray";
         format = `, runtime.Base64${type.encoding}Format`;
     }
     return `${marshaller}(${param}${format})`;
 }
 function isArrayOfDateTimeForMarshalling(paramType) {
-    if (paramType.kind !== 'slice') {
+    if (paramType.kind !== "slice") {
         return undefined;
     }
-    if (paramType.elementType.kind !== 'time') {
+    if (paramType.elementType.kind !== "time") {
         return undefined;
     }
     switch (paramType.elementType.format) {
-        case 'PlainDate':
-        case 'RFC1123':
-        case 'RFC7231':
-        case 'PlainTime':
-        case 'Unix':
+        case "PlainDate":
+        case "RFC1123":
+        case "RFC7231":
+        case "PlainTime":
+        case "Unix":
             return {
                 format: paramType.elementType.format,
                 elemByVal: paramType.elementTypeByValue,
@@ -1564,11 +1584,11 @@ function needsResponseHandler(method) {
     return helpers.hasSchemaResponse(method) || method.returns.headers.length > 0;
 }
 function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imports, indent) {
-    let unmarshallerText = '';
-    const zeroValue = getZeroReturnValue(method, 'handler');
-    if (type.kind === 'time') {
+    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');
+        imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
         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`;
@@ -1579,11 +1599,11 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imp
     else if (isArrayOfDateTime(type)) {
         // unmarshalling arrays of date/time is a little more involved
         const timeInfo = isArrayOfDateTime(type);
-        let elementPtr = '*';
+        let elementPtr = "*";
         if (timeInfo?.elemByVal) {
-            elementPtr = '';
+            elementPtr = "";
         }
-        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+        imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
         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`;
@@ -1596,8 +1616,8 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imp
         return unmarshallerText;
     }
     else if (isMapOfDateTime(type)) {
-        let timeType = isMapOfDateTime(type);
-        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+        const timeType = isMapOfDateTime(type);
+        imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
         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`;
@@ -1609,8 +1629,8 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imp
         unmarshallerText += `${indent.get()}result.${helpers.getResultFieldName(method)} = cp\n`;
         return unmarshallerText;
     }
-    if (format === 'JSON' || format === 'XML') {
-        if (type.kind === 'rawJSON') {
+    if (format === "JSON" || format === "XML") {
+        if (type.kind === "rawJSON") {
             unmarshallerText += `${indent.get()}body, err := runtime.Payload(resp)\n`;
             unmarshallerText += `${indent.get()}if err != nil {\n`;
             unmarshallerText += `${indent.push().get()}return ${zeroValue}, err\n`;
@@ -1623,43 +1643,43 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imp
             unmarshallerText += `${indent.pop().get()}}\n`;
         }
     }
-    else if (format === 'Text') {
+    else if (format === "Text") {
         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`;
+            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';
+            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}`);
+                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
-        throw new CodegenError('InternalError', `unhandled format ${format} for operation ${method.receiver.type.name}.${method.name}`);
+        throw new CodegenError("InternalError", `unhandled format ${format} for operation ${method.receiver.type.name}.${method.name}`);
     }
     return unmarshallerText;
 }
 function createProtocolResponse(method, imports, indent) {
     if (!needsResponseHandler(method)) {
-        return '';
+        return "";
     }
     const name = method.naming.responseMethod;
-    let text = `${helpers.comment(name, '// ')} handles the ${method.name} response.\n`;
-    text += `func ${getClientReceiverDefinition(method.receiver)} ${name}(resp *http.Response) (${generateReturnsInfo(method, 'handler').join(', ')}) {\n`;
+    let text = `${helpers.comment(name, "// ")} handles the ${method.name} response.\n`;
+    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, 'result', `${method.returns.name}{}`, imports, indent);
+            text += formatHeaderResponseValue(method, header, "result", `${method.returns.name}{}`, imports, indent);
         }
     };
     const result = method.returns.result;
@@ -1670,8 +1690,8 @@ function createProtocolResponse(method, imports, indent) {
     }
     else {
         switch (result.kind) {
-            case 'anyResult':
-                imports.add('fmt');
+            case "anyResult":
+                imports.add("fmt");
                 text += `${indent.get()}result := ${method.returns.name}{}\n`;
                 addHeaders(method.returns.headers);
                 text += `${indent.get()}switch resp.StatusCode {\n`;
@@ -1683,54 +1703,54 @@ function createProtocolResponse(method, imports, indent) {
                         continue;
                     }
                     text += `${indent.get()}var val ${go.getTypeDeclaration(resultType, method.receiver.type.pkg)}\n`;
-                    text += generateResponseUnmarshaller(method, resultType, result.format, 'val', imports, indent);
+                    text += generateResponseUnmarshaller(method, resultType, result.format, "val", imports, indent);
                     text += `${indent.get()}result.Value = val\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.push().get()}return ${getZeroReturnValue(method, "handler")}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)\n`;
                 text += `${indent.pop().get()}}\n`;
                 break;
-            case 'binaryResult':
+            case "binaryResult":
                 text += `${indent.get()}result := ${method.returns.name}{${result.fieldName}: resp.Body}\n`;
                 addHeaders(method.returns.headers);
                 break;
-            case 'headAsBooleanResult':
+            case "headAsBooleanResult":
                 text += `${indent.get()}result := ${method.returns.name}{${result.fieldName}: resp.StatusCode >= 200 && resp.StatusCode < 300}\n`;
                 addHeaders(method.returns.headers);
                 break;
-            case 'modelResult':
+            case "modelResult":
                 text += `${indent.get()}result := ${method.returns.name}{}\n`;
                 addHeaders(method.returns.headers);
                 text += generateResponseUnmarshaller(method, result.modelType, result.format, `result.${helpers.getResultFieldName(method)}`, imports, indent);
                 break;
-            case 'monomorphicResult':
+            case "monomorphicResult":
                 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';
+                if (result.format === "XML" && result.monomorphicType.kind === "slice") {
+                    target = "result";
                 }
                 text += generateResponseUnmarshaller(method, result.monomorphicType, result.format, target, imports, indent);
                 break;
-            case 'polymorphicResult':
+            case "polymorphicResult":
                 text += `${indent.get()}result := ${method.returns.name}{}\n`;
                 addHeaders(method.returns.headers);
-                text += generateResponseUnmarshaller(method, result.interface, result.format, 'result', imports, indent);
+                text += generateResponseUnmarshaller(method, result.interface, result.format, "result", imports, indent);
                 break;
             default:
                 result;
         }
     }
     text += `${indent.get()}return result, nil\n`;
-    text += '}\n\n';
+    text += "}\n\n";
     return text;
 }
 function isArrayOfDateTime(paramType) {
-    if (paramType.kind !== 'slice') {
+    if (paramType.kind !== "slice") {
         return undefined;
     }
-    if (paramType.elementType.kind !== 'time') {
+    if (paramType.elementType.kind !== "time") {
         return undefined;
     }
     return {
@@ -1739,10 +1759,10 @@ function isArrayOfDateTime(paramType) {
     };
 }
 function isMapOfDateTime(paramType) {
-    if (paramType.kind !== 'map') {
+    if (paramType.kind !== "map") {
         return undefined;
     }
-    if (paramType.valueType.kind !== 'time') {
+    if (paramType.valueType.kind !== "time") {
         return undefined;
     }
     return paramType.valueType.format;
@@ -1757,7 +1777,7 @@ function isMapOfDateTime(paramType) {
  */
 function getAPIParametersSig(method, imports) {
     const params = new Array();
-    if (method.kind === 'clientAccessor') {
+    if (method.kind === "clientAccessor") {
         // client accessor params don't have a concept
         // of optionality nor do they contain literals
         for (const param of method.parameters) {
@@ -1767,18 +1787,18 @@ function getAPIParametersSig(method, imports) {
     }
     else {
         const methodParams = helpers.getMethodParameters(method);
-        if (method.kind !== 'pageableMethod') {
-            imports.add('context');
-            params.push('ctx context.Context');
+        if (method.kind !== "pageableMethod") {
+            imports.add("context");
+            params.push("ctx context.Context");
         }
         for (const methodParam of methodParams) {
-            if (methodParam.kind !== 'paramGroup') {
+            if (methodParam.kind !== "paramGroup") {
                 imports.addForType(methodParam.type);
             }
             params.push(`${methodParam.name} ${helpers.formatParameterTypeName(method.receiver.type.pkg, methodParam)}`);
         }
     }
-    return params.join(', ');
+    return params.join(", ");
 }
 // returns the return signature where each entry is the type name
 // e.g. [ '*string', 'error' ]
@@ -1789,60 +1809,60 @@ function getAPIParametersSig(method, imports) {
 function generateReturnsInfo(method, apiType) {
     let returnType = method.returns.name;
     switch (method.kind) {
-        case 'lroMethod':
-        case 'lroPageableMethod':
+        case "lroMethod":
+        case "lroPageableMethod":
             switch (apiType) {
-                case 'api':
-                    if (method.kind === 'lroPageableMethod') {
+                case "api":
+                    if (method.kind === "lroPageableMethod") {
                         returnType = `*runtime.Poller[*runtime.Pager[${returnType}]]`;
                     }
                     else {
                         returnType = `*runtime.Poller[${returnType}]`;
                     }
                     break;
-                case 'handler':
+                case "handler":
                     // we only have a handler for operations that return a schema
-                    if (method.kind !== 'lroPageableMethod') {
-                        throw new CodegenError('InternalError', `handler being generated for non-pageable LRO ${method.name} which is unexpected`);
+                    if (method.kind !== "lroPageableMethod") {
+                        throw new CodegenError("InternalError", `handler being generated for non-pageable LRO ${method.name} which is unexpected`);
                     }
                     break;
-                case 'op':
-                    returnType = '*http.Response';
+                case "op":
+                    returnType = "*http.Response";
                     break;
             }
             break;
-        case 'pageableMethod':
+        case "pageableMethod":
             switch (apiType) {
-                case 'api':
-                case 'op':
+                case "api":
+                case "op":
                     // pager operations don't return an error
                     return [`*runtime.Pager[${returnType}]`];
             }
             break;
     }
-    return [returnType, 'error'];
+    return [returnType, "error"];
 }
 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');
-    let text = '';
+    const returns = generateReturnsInfo(method, "api");
+    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
+    let text = "";
     if (method.docs.summary || method.docs.description) {
         text += helpers.formatDocCommentWithPrefix(fixUpMethodName(method), method.docs);
         text += genRespErrorDoc(method);
     }
-    const zeroResp = getZeroReturnValue(method, 'lro');
+    const zeroResp = getZeroReturnValue(method, "lro");
     const methodParams = helpers.getMethodParameters(method);
     for (const param of methodParams) {
         text += helpers.formatCommentAsBulletItem(param.name, param.docs);
     }
-    text += `func ${getClientReceiverDefinition(method.receiver)} ${fixUpMethodName(method)}(${params}) (${returns.join(', ')}) {\n`;
-    let pollerType = 'nil';
+    text += `func ${getClientReceiverDefinition(method.receiver)} ${fixUpMethodName(method)}(${params}) (${returns.join(", ")}) {\n`;
+    let pollerType = "nil";
     let pollerTypeParam = `[${method.returns.name}]`;
-    if (method.kind === 'lroPageableMethod') {
+    if (method.kind === "lroPageableMethod") {
         // for paged LROs, we construct a pager and pass it to the LRO ctor.
         pollerTypeParam = `[*runtime.Pager${pollerTypeParam}]`;
-        pollerType = '&pager';
+        pollerType = "&pager";
         text += `${indent.get()}pager := `;
         text += emitPagerDefinition(method, options, imports, indent);
     }
@@ -1854,49 +1874,52 @@ function generateLROBeginMethod(method, options, imports, indent) {
     text += `${indent.get()}if err != nil {\n`;
     text += `${indent.push().get()}return ${zeroResp}, err\n`;
     text += `${indent.pop().get()}}\n`;
-    let finalStateVia = '';
+    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
     if (method.finalStateVia) {
         switch (method.finalStateVia) {
-            case 'azure-async-operation':
-                finalStateVia = 'runtime.FinalStateViaAzureAsyncOp';
+            case "azure-async-operation":
+                finalStateVia = "runtime.FinalStateViaAzureAsyncOp";
                 break;
-            case 'location':
-                finalStateVia = 'runtime.FinalStateViaLocation';
+            case "location":
+                finalStateVia = "runtime.FinalStateViaLocation";
                 break;
-            case 'original-uri':
-                finalStateVia = 'runtime.FinalStateViaOriginalURI';
+            case "original-uri":
+                finalStateVia = "runtime.FinalStateViaOriginalURI";
                 break;
-            case 'operation-location':
-                finalStateVia = 'runtime.FinalStateViaOpLocation';
+            case "operation-location":
+                finalStateVia = "runtime.FinalStateViaOpLocation";
                 break;
             default:
-                throw new CodegenError('InternalError', `unhandled final-state-via value ${finalStateVia}`);
+                throw new CodegenError("InternalError", `unhandled final-state-via value ${finalStateVia}`);
         }
     }
     text += `${indent.get()}poller, err := runtime.NewPoller`;
-    if (finalStateVia === '' && pollerType === 'nil' && !options.injectSpans) {
+    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.
         text += pollerTypeParam;
     }
-    text += '(resp, client.internal.Pipeline(), ';
-    if (finalStateVia === '' && pollerType === 'nil' && !options.injectSpans && !method.operationLocationResultPath) {
+    text += "(resp, client.internal.Pipeline(), ";
+    if (finalStateVia === "" &&
+        pollerType === "nil" &&
+        !options.injectSpans &&
+        !method.operationLocationResultPath) {
         // no options
-        text += 'nil)\n';
+        text += "nil)\n";
     }
     else {
         // at least one option
         indent.push();
         text += `&runtime.NewPollerOptions${pollerTypeParam}{\n`;
-        if (finalStateVia !== '') {
+        if (finalStateVia !== "") {
             text += `${indent.get()}FinalStateVia: ${finalStateVia},\n`;
         }
         if (method.operationLocationResultPath) {
             text += `${indent.get()}OperationLocationResultPath: "${method.operationLocationResultPath}",\n`;
         }
-        if (pollerType !== 'nil') {
+        if (pollerType !== "nil") {
             text += `${indent.get()}Response: ${pollerType},\n`;
         }
         if (options.injectSpans) {
@@ -1911,17 +1934,17 @@ function generateLROBeginMethod(method, options, imports, indent) {
     indent.push();
     // creating the poller from resume token branch
     text += `${indent.get()}return runtime.NewPollerFromResumeToken`;
-    if (pollerType === 'nil' && !options.injectSpans) {
+    if (pollerType === "nil" && !options.injectSpans) {
         text += pollerTypeParam;
     }
-    text += '(options.ResumeToken, client.internal.Pipeline(), ';
-    if (pollerType === 'nil' && !options.injectSpans) {
-        text += 'nil)\n';
+    text += "(options.ResumeToken, client.internal.Pipeline(), ";
+    if (pollerType === "nil" && !options.injectSpans) {
+        text += "nil)\n";
     }
     else {
         indent.push();
         text += `&runtime.NewPollerFromResumeTokenOptions${pollerTypeParam}{\n`;
-        if (pollerType !== 'nil') {
+        if (pollerType !== "nil") {
             text += `${indent.get()}Response: ${pollerType},\n`;
         }
         if (options.injectSpans) {
@@ -1932,27 +1955,27 @@ function generateLROBeginMethod(method, options, imports, indent) {
     }
     indent.pop();
     text += `${indent.get()}}\n`;
-    text += '}\n\n';
+    text += "}\n\n";
     return text;
 }
 export function fixUpMethodName(method) {
     switch (method.kind) {
-        case 'lroMethod':
-        case 'lroPageableMethod':
+        case "lroMethod":
+        case "lroPageableMethod":
             return `Begin${method.name}`;
-        case 'pageableMethod': {
-            let N = 'N';
+        case "pageableMethod": {
+            let N = "N";
             let name = method.name;
             if (method.name[0] !== method.name[0].toUpperCase()) {
                 // the method isn't exported; don't export the pager ctor
-                N = 'n';
+                N = "n";
                 // ensure correct casing of the emitted function name e.g.,
                 // "listThings" -> "newListThingsPager"
                 name = name[0].toUpperCase() + name.substring(1);
             }
             return `${N}ew${name}Pager`;
         }
-        case 'method':
+        case "method":
             return method.name;
     }
 }