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

package/dist/{codegen.go/src → src/codegen}/fake/servers.js

@@ -2,13 +2,13 @@
  *  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 '../core/helpers.js';
-import { ImportManager } from '../core/imports.js';
-import { fixUpMethodName } from '../core/operations.js';
-import { generateServerInternal, RequiredHelpers } from './internal.js';
-import { CodegenError } from '../core/errors.js';
+import * as go from "../../codemodel/index.js";
+import * as naming from "../../naming/naming.js";
+import { CodegenError } from "../core/errors.js";
+import * as helpers from "../core/helpers.js";
+import { ImportManager } from "../core/imports.js";
+import { fixUpMethodName } from "../core/operations.js";
+import { generateServerInternal, RequiredHelpers } from "./internal.js";
 // contains the generated content for all servers and the required helpers
 export class ServerContent {
     servers;
@@ -31,7 +31,7 @@ export class OperationGroupContent {
 const requiredHelpers = new RequiredHelpers();
 export function getServerName(client) {
     // for the fake server, we use the suffix Server instead of Client
-    return naming.capitalize(client.name.replace(/[C|c]lient$/, 'Server'));
+    return naming.capitalize(client.name.replace(/[C|c]lient$/, "Server"));
 }
 /**
  * Generates the contents for the *_server.go files.
@@ -50,10 +50,10 @@ export function generateServers(pkg, target) {
         // the list of packages to import
         const imports = new ImportManager(pkg);
         // add standard imports
-        imports.add('errors');
-        imports.add('fmt');
-        imports.add('net/http');
-        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+        imports.add("errors");
+        imports.add("fmt");
+        imports.add("net/http");
+        imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
         const serverName = getServerName(client);
         let content;
         content = `// ${serverName} is a fake server for instances of the ${go.getTypeDeclaration(client, pkg)} type.\n`;
@@ -83,25 +83,25 @@ export function generateServers(pkg, target) {
             }
             let serverResponse;
             switch (method.kind) {
-                case 'lroMethod':
-                case 'lroPageableMethod':
+                case "lroMethod":
+                case "lroPageableMethod":
                     let respType = go.getTypeDeclaration(method.returns, pkg);
-                    if (method.kind === 'lroPageableMethod') {
+                    if (method.kind === "lroPageableMethod") {
                         respType = `azfake.PagerResponder[${respType}]`;
                     }
                     serverResponse = `resp azfake.PollerResponder[${respType}], errResp azfake.ErrorResponder`;
                     break;
-                case 'method':
+                case "method":
                     serverResponse = `resp azfake.Responder[${go.getTypeDeclaration(method.returns, pkg)}], errResp azfake.ErrorResponder`;
                     break;
-                case 'pageableMethod':
+                case "pageableMethod":
                     serverResponse = `resp azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                     break;
             }
             const operationName = fixUpMethodName(method);
             content += `${indent.get()}// ${operationName} is the fake for method ${client.name}.${operationName}\n`;
             const successCodes = new Array();
-            if (method.returns.result?.kind === 'anyResult') {
+            if (method.returns.result?.kind === "anyResult") {
                 for (const httpStatus of getMethodStatusCodes(method)) {
                     const result = method.returns.result.httpStatusCodeType[httpStatus];
                     if (!result) {
@@ -120,26 +120,27 @@ export function generateServers(pkg, target) {
                 for (const statusCode of getMethodStatusCodes(method)) {
                     successCodes.push(`${helpers.formatStatusCode(statusCode)}`);
                 }
-                content += `${indent.get()}// HTTP status codes to indicate success: ${successCodes.join(', ')}\n`;
+                content += `${indent.get()}// HTTP status codes to indicate success: ${successCodes.join(", ")}\n`;
             }
             content += `${indent.get()}${operationName} func(${getAPIParametersSig(pkg, method, imports)}) (${serverResponse})\n\n`;
             finalMethods.push(method);
             switch (method.kind) {
-                case 'lroMethod':
-                case 'lroPageableMethod':
+                case "lroMethod":
+                case "lroPageableMethod":
                     ++countLROs;
                     break;
-                case 'pageableMethod':
+                case "pageableMethod":
                     ++countPagers;
                     break;
             }
         }
-        content += '}\n\n';
+        content += "}\n\n";
         ///////////////////////////////////////////////////////////////////////////
         const serverTransport = `${serverName}Transport`;
         content += `// New${serverTransport} creates a new instance of ${serverTransport} with the provided implementation.\n`;
         content += `// The returned ${serverTransport} instance is connected to an instance of ${go.getTypeDeclaration(client, pkg)} via the\n`;
-        content += "// azcore.ClientOptions.Transporter field in the client's constructor parameters.\n";
+        content +=
+            "// azcore.ClientOptions.Transporter field in the client's constructor parameters.\n";
         content += `func New${serverTransport}(srv *${serverName}) *${serverTransport} {\n`;
         if (countLROs === 0 && countPagers === 0) {
             content += `${indent.get()}return &${serverTransport}{srv: srv}\n}\n\n`;
@@ -151,15 +152,15 @@ export function generateServers(pkg, target) {
             for (const method of finalMethods) {
                 let respType = go.getTypeDeclaration(method.returns, pkg);
                 switch (method.kind) {
-                    case 'lroMethod':
-                    case 'lroPageableMethod':
-                        if (method.kind === 'lroPageableMethod') {
+                    case "lroMethod":
+                    case "lroPageableMethod":
+                        if (method.kind === "lroPageableMethod") {
                             respType = `azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                         }
                         requiredHelpers.tracker = true;
                         content += `${indent.get()}${naming.uncapitalize(fixUpMethodName(method))}: newTracker[azfake.PollerResponder[${respType}]](),\n`;
                         break;
-                    case 'pageableMethod':
+                    case "pageableMethod":
                         requiredHelpers.tracker = true;
                         content += `${indent.get()}${naming.uncapitalize(fixUpMethodName(method))}: newTracker[azfake.PagerResponder[${respType}]](),\n`;
                         break;
@@ -175,7 +176,7 @@ export function generateServers(pkg, target) {
         // add server transports for client accessors
         if (finalSubClients.length > 0) {
             requiredHelpers.initServer = true;
-            imports.add('sync');
+            imports.add("sync");
             content += `${indent.get()}trMu sync.Mutex\n`;
             for (const subClient of finalSubClients) {
                 const serverName = getServerName(subClient);
@@ -186,21 +187,21 @@ export function generateServers(pkg, target) {
             // create state machines for any pager/poller operations
             let respType = go.getTypeDeclaration(method.returns, pkg);
             switch (method.kind) {
-                case 'lroMethod':
-                case 'lroPageableMethod':
-                    if (method.kind === 'lroPageableMethod') {
+                case "lroMethod":
+                case "lroPageableMethod":
+                    if (method.kind === "lroPageableMethod") {
                         respType = `azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                     }
                     requiredHelpers.tracker = true;
                     content += `${indent.get()}${naming.uncapitalize(fixUpMethodName(method))} *tracker[azfake.PollerResponder[${respType}]]\n`;
                     break;
-                case 'pageableMethod':
+                case "pageableMethod":
                     requiredHelpers.tracker = true;
                     content += `${indent.get()}${naming.uncapitalize(fixUpMethodName(method))} *tracker[azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]]\n`;
                     break;
             }
         }
-        content += '}\n\n';
+        content += "}\n\n";
         content += generateServerTransportDo(serverTransport, client, finalSubClients, finalMethods, indent);
         content += generateServerTransportClientDispatch(serverTransport, finalSubClients, imports, indent);
         content += generateServerTransportMethodDispatch(serverTransport, client, finalMethods, indent);
@@ -216,7 +217,7 @@ export function generateServers(pkg, target) {
         text += content;
         operations.push(new OperationGroupContent(serverName, text));
     }
-    if (target === 'azure-arm' && pkg.parent.clients.length > 0) {
+    if (target === "azure-arm" && pkg.parent.clients.length > 0) {
         // ARM server factory uses the initServer func
         requiredHelpers.initServer = true;
     }
@@ -226,8 +227,8 @@ function getTransportInterceptorVarName(client) {
     return `${helpers.camelCase(getServerName(client))}TransportInterceptor`;
 }
 // method names for fakes dispatching
-const dispatchMethodFake = 'dispatchToMethodFake';
-const dispatchToClientFake = 'dispatchToClientFake';
+const dispatchMethodFake = "dispatchToMethodFake";
+const dispatchToClientFake = "dispatchToClientFake";
 function generateServerTransportDo(serverTransport, client, finalSubClients, finalMethods, indent) {
     const receiverName = serverTransport[0].toLowerCase();
     let content = `// Do implements the policy.Transporter interface for ${serverTransport}.\n`;
@@ -252,12 +253,12 @@ function generateServerTransportDo(serverTransport, client, finalSubClients, fin
     else {
         content += `${indent.get()}return ${receiverName}.${dispatchMethodFake}(req, method)\n`;
     }
-    content += '}\n\n'; // end Do
+    content += "}\n\n"; // end Do
     return content;
 }
 function generateServerTransportClientDispatch(serverTransport, subClients, imports, indent) {
     if (subClients.length === 0) {
-        return '';
+        return "";
     }
     /** gathers all children, not just immediate children, in breadth first order */
     const getAllSubClientsForCase = function (client) {
@@ -290,7 +291,7 @@ function generateServerTransportClientDispatch(serverTransport, subClients, impo
         return result;
     };
     const receiverName = serverTransport[0].toLowerCase();
-    imports.add('strings');
+    imports.add("strings");
     let content = `func (${receiverName} *${serverTransport}) ${dispatchToClientFake}(req *http.Request, client string) (*http.Response, error) {\n`;
     content += `${indent.get()}var resp *http.Response\n${indent.get()}var err error\n\n`;
     content += `${indent.get()}switch client {\n`;
@@ -299,7 +300,7 @@ function generateServerTransportClientDispatch(serverTransport, subClients, impo
         const subClientsForCase = getAllSubClientsForCase(subClient);
         const allClientNamesForCase = new Array(`"${subClient.name}"`);
         allClientNamesForCase.push(...subClientsForCase.map((each) => `"${each.name}"`));
-        content += `${indent.get()}case ${allClientNamesForCase.join(', ')}:\n`;
+        content += `${indent.get()}case ${allClientNamesForCase.join(", ")}:\n`;
         const serverName = getServerName(subClient);
         indent.push();
         content += `${indent.get()}initServer(&${receiverName}.trMu, &${receiverName}.tr${serverName}, func() *${serverName}Transport {\n`;
@@ -316,7 +317,7 @@ function generateServerTransportClientDispatch(serverTransport, subClients, impo
 }
 function generateServerTransportMethodDispatch(serverTransport, client, finalMethods, indent) {
     if (finalMethods.length === 0) {
-        return '';
+        return "";
     }
     const receiverName = serverTransport[0].toLowerCase();
     let content = `func (${receiverName} *${serverTransport}) ${dispatchMethodFake}(req *http.Request, method string) (*http.Response, error) {\n`;
@@ -363,66 +364,66 @@ function generateServerTransportMethodDispatch(serverTransport, client, finalMet
  */
 function generateServerTransportMethods(pkg, serverTransport, finalMethods, imports, indent) {
     if (finalMethods.length === 0) {
-        return '';
+        return "";
     }
     imports.addForPkg(pkg.parent);
-    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
-    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server');
-    imports.add('slices');
+    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/fake", "azfake");
+    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server");
+    imports.add("slices");
     const receiverName = serverTransport[0].toLowerCase();
-    let content = '';
+    let content = "";
     for (const method of finalMethods) {
         content += `func (${receiverName} *${serverTransport}) dispatch${fixUpMethodName(method)}(req *http.Request) (*http.Response, error) {\n`;
         content += `${indent.get()}if ${receiverName}.srv.${fixUpMethodName(method)} == nil {\n`;
         content += `${indent.push().get()}return nil, &nonRetriableError{errors.New("fake for method ${fixUpMethodName(method)} not implemented")}\n`;
         content += `${indent.pop().get()}}\n`;
         switch (method.kind) {
-            case 'lroMethod':
-            case 'lroPageableMethod':
+            case "lroMethod":
+            case "lroPageableMethod":
                 // must check LRO before pager as you can have paged LROs
                 content += dispatchForLROBody(pkg, receiverName, method, imports, indent);
                 break;
-            case 'method': {
+            case "method": {
                 content += dispatchForOperationBody(pkg, receiverName, method, imports, indent);
                 content += `${indent.get()}respContent := server.GetResponseContent(respr)\n`;
                 const formattedStatusCodes = helpers.formatStatusCodes(method.httpStatusCodes);
                 content += `${indent.get()}if !slices.Contains([]int{${formattedStatusCodes}}, respContent.HTTPStatus) {\n`;
                 content += `${indent.push().get()}return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are ${formattedStatusCodes}", respContent.HTTPStatus)}\n`;
                 content += `${indent.pop().get()}}\n`;
-                if (!method.returns.result || method.returns.result.kind === 'headAsBooleanResult') {
+                if (!method.returns.result || method.returns.result.kind === "headAsBooleanResult") {
                     content += `${indent.get()}resp, err := server.NewResponse(respContent, req, nil)\n`;
                 }
-                else if (method.returns.result.kind === 'anyResult') {
+                else if (method.returns.result.kind === "anyResult") {
                     content += `${indent.get()}resp, err := server.MarshalResponseAs${method.returns.result.format}(respContent, server.GetResponse(respr).${getResultFieldName(method.returns.result)}, req)\n`;
                 }
-                else if (method.returns.result.kind === 'binaryResult') {
+                else if (method.returns.result.kind === "binaryResult") {
                     content += `${indent.get()}resp, err := server.NewResponse(respContent, req, &server.ResponseOptions{\n`;
                     indent.push();
                     content += `${indent.get()}Body: server.GetResponse(respr).${getResultFieldName(method.returns.result)},\n`;
                     content += `${indent.get()}ContentType: req.Header.Get("Content-Type"),\n`;
                     content += `${indent.pop().get()}})\n`;
                 }
-                else if (method.returns.result.kind === 'monomorphicResult') {
-                    if (method.returns.result.monomorphicType.kind === 'encodedBytes') {
+                else if (method.returns.result.kind === "monomorphicResult") {
+                    if (method.returns.result.monomorphicType.kind === "encodedBytes") {
                         const encoding = method.returns.result.monomorphicType.encoding;
                         content += `${indent.get()}resp, err := server.MarshalResponseAsByteArray(respContent, server.GetResponse(respr).${getResultFieldName(method.returns.result)}, runtime.Base64${encoding}Format, req)\n`;
                     }
-                    else if (method.returns.result.monomorphicType.kind === 'rawJSON') {
-                        imports.add('bytes');
-                        imports.add('io');
+                    else if (method.returns.result.monomorphicType.kind === "rawJSON") {
+                        imports.add("bytes");
+                        imports.add("io");
                         content += `${indent.get()}resp, err := server.NewResponse(respContent, req, &server.ResponseOptions{\n`;
                         indent.push();
                         content += `${indent.get()}Body: io.NopCloser(bytes.NewReader(server.GetResponse(respr).RawJSON)),\n`;
                         content += `${indent.get()}ContentType: "application/json",\n`;
                         content += `${indent.pop().get()}})\n`;
                     }
-                    else if (method.returns.result.format === 'Text') {
+                    else if (method.returns.result.format === "Text") {
                         let contentToMarshal;
                         const respField = getResultFieldName(method.returns.result);
                         const getResponseField = `server.GetResponse(respr).${respField}`;
                         switch (method.returns.result.monomorphicType.kind) {
-                            case 'scalar': {
-                                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
+                            case "scalar": {
+                                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
                                 // create a local var that will hold the string-formatted scalar
                                 contentToMarshal = `formatted${respField}`;
                                 content += `${indent.get()}var ${contentToMarshal} *string\n`;
@@ -435,28 +436,30 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
                                 })}\n`;
                                 break;
                             }
-                            case 'string':
+                            case "string":
                                 contentToMarshal = getResponseField;
                                 break;
                             default:
-                                throw new CodegenError('UnsupportedTsp', `unsupported text return kind ${method.returns.result.monomorphicType.kind} for method ${method.receiver.type.name}.${method.name}`);
+                                throw new CodegenError("UnsupportedTsp", `unsupported text return kind ${method.returns.result.monomorphicType.kind} for method ${method.receiver.type.name}.${method.name}`);
                         }
                         content += `${indent.get()}resp, err := server.MarshalResponseAsText(respContent, ${contentToMarshal}, req)\n`;
                     }
                     else {
                         let respField = `.${getResultFieldName(method.returns.result)}`;
-                        if (method.returns.result.format === 'XML' && method.returns.result.monomorphicType.kind === 'slice') {
-                            respField = '';
+                        if (method.returns.result.format === "XML" &&
+                            method.returns.result.monomorphicType.kind === "slice") {
+                            respField = "";
                         }
                         let responseField = `server.GetResponse(respr)${respField}`;
-                        if (method.returns.result.monomorphicType.kind === 'time') {
-                            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                        if (method.returns.result.monomorphicType.kind === "time") {
+                            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
                             responseField = `(*datetime.${method.returns.result.monomorphicType.format})(${responseField})`;
                         }
                         content += `${indent.get()}resp, err := server.MarshalResponseAs${method.returns.result.format}(respContent, ${responseField}, req)\n`;
                     }
                 }
-                else if (method.returns.result.kind === 'modelResult' || method.returns.result.kind === 'polymorphicResult') {
+                else if (method.returns.result.kind === "modelResult" ||
+                    method.returns.result.kind === "polymorphicResult") {
                     const respField = `.${getResultFieldName(method.returns.result)}`;
                     const responseField = `server.GetResponse(respr)${respField}`;
                     content += `${indent.get()}resp, err := server.MarshalResponseAs${method.returns.result.format}(respContent, ${responseField}, req)\n`;
@@ -466,7 +469,7 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
                 content += `${indent.pop().get()}}\n`;
                 // propagate any header response values into the *http.Response
                 for (const header of method.returns.headers) {
-                    if (header.kind === 'headerMapResponse') {
+                    if (header.kind === "headerMapResponse") {
                         content += `${indent.get()}for k, v := range server.GetResponse(respr).${header.fieldName} {\n`;
                         content += `${indent.push().get()}if v != nil {\n`;
                         content += `${indent.push().get()}resp.Header.Set("${header.headerName}"+k, *v)\n`;
@@ -475,20 +478,20 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
                     }
                     else {
                         content += `${indent.get()}if val := server.GetResponse(respr).${header.fieldName}; val != nil {\n`;
-                        content += `${indent.push().get()}resp.Header.Set("${header.headerName}", ${helpers.formatValue('val', header.type, imports, true)})\n`;
+                        content += `${indent.push().get()}resp.Header.Set("${header.headerName}", ${helpers.formatValue("val", header.type, imports, true)})\n`;
                         content += `${indent.pop().get()}}\n`;
                     }
                 }
                 content += `${indent.get()}return resp, nil\n`;
                 break;
             }
-            case 'pageableMethod':
+            case "pageableMethod":
                 content += dispatchForPagerBody(pkg, receiverName, method, imports, indent);
                 break;
             default:
                 method;
         }
-        content += '}\n\n';
+        content += "}\n\n";
     }
     return content;
 }
@@ -506,9 +509,9 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
 function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
     const methodParamGroups = helpers.getMethodParamGroups(method);
     const numPathParams = methodParamGroups.pathParams.filter((each) => !go.isLiteralParameter(each.style)).length;
-    let content = '';
+    let content = "";
     if (numPathParams > 0) {
-        imports.add('regexp');
+        imports.add("regexp");
         content += `${indent.get()}const regexStr = \`${createPathParamsRegex(method, methodParamGroups.pathParams)}\`\n`;
         content += `${indent.get()}regex := regexp.MustCompile(regexStr)\n`;
         content += `${indent.get()}matches := regex.FindStringSubmatch(req.URL.EscapedPath())\n`;
@@ -518,7 +521,7 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
         content += `${indent.push().get()}return nil, fmt.Errorf("failed to parse path %s", req.URL.Path)\n${indent.pop().get()}}\n`;
     }
     const allQueryParams = methodParamGroups.encodedQueryParams.concat(methodParamGroups.unencodedQueryParams);
-    if (allQueryParams.find((each) => each.location === 'method' && !go.isLiteralParameter(each.style))) {
+    if (allQueryParams.find((each) => each.location === "method" && !go.isLiteralParameter(each.style))) {
         content += `${indent.get()}qp := req.URL.Query()\n`;
     }
     // note that these are mutually exclusive
@@ -528,32 +531,32 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
     const partialBodyParams = methodParamGroups.partialBodyParams;
     if (bodyParam) {
         switch (bodyParam.bodyFormat) {
-            case 'JSON':
-            case 'XML':
+            case "JSON":
+            case "XML":
                 if (bodyParam && !go.isLiteralParameter(bodyParam.style)) {
-                    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
+                    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/fake", "azfake");
                     switch (bodyParam.type.kind) {
-                        case 'encodedBytes':
+                        case "encodedBytes":
                             content += `${indent.get()}body, err := server.UnmarshalRequestAsByteArray(req, runtime.Base64${bodyParam.type.encoding}Format)\n`;
                             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
                             break;
-                        case 'interface':
+                        case "interface":
                             requiredHelpers.readRequestBody = true;
                             content += `${indent.get()}raw, err := readRequestBody(req)\n`;
                             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
                             content += `${indent.get()}body, err := unmarshal${bodyParam.type.name}(raw)\n`;
                             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
                             break;
-                        case 'rawJSON':
-                            imports.add('io');
+                        case "rawJSON":
+                            imports.add("io");
                             content += `${indent.get()}body, err := io.ReadAll(req.Body)\n`;
                             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
                             content += `${indent.get()}req.Body.Close()\n`;
                             break;
                         default: {
                             let bodyTypeName = go.getTypeDeclaration(bodyParam.type, pkg);
-                            if (bodyParam.type.kind === 'time') {
-                                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                            if (bodyParam.type.kind === "time") {
+                                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
                                 bodyTypeName = `datetime.${bodyParam.type.format}`;
                             }
                             content += `${indent.get()}body, err := server.UnmarshalRequestAs${bodyParam.bodyFormat}[${bodyTypeName}](req)\n`;
@@ -562,9 +565,9 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
                     }
                 }
                 break;
-            case 'Text':
+            case "Text":
                 if (bodyParam && !go.isLiteralParameter(bodyParam.style)) {
-                    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
+                    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/fake", "azfake");
                     content += `${indent.get()}body, err := server.UnmarshalRequestAsText(req)\n`;
                     content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
                 }
@@ -573,9 +576,9 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
         // nothing to do for binary media type
     }
     else if (multipartBodyParams.length > 0) {
-        imports.add('io');
-        imports.add('mime');
-        imports.add('mime/multipart');
+        imports.add("io");
+        imports.add("mime");
+        imports.add("mime/multipart");
         content += `${indent.get()}_, params, err := mime.ParseMediaType(req.Header.Get("Content-Type"))\n`;
         content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
         content += `${indent.get()}reader := multipart.NewReader(req.Body, params["boundary"])\n`;
@@ -594,39 +597,39 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
         // i.e. the result from the parsing doesn't require further conversion (e.g. casting)
         // otherwise the parsed value is in a local var named parsed.
         const parsePrimitiveType = function (typeName, boolTarget) {
-            let parseErr = 'parseErr';
+            let parseErr = "parseErr";
             const parseResults = `parsed, ${parseErr}`;
-            let parsingCode = '';
-            imports.add('strconv');
+            let parsingCode;
+            imports.add("strconv");
             switch (typeName) {
-                case 'bool':
+                case "bool":
                     if (boolTarget) {
                         // we reuse the err var declared earlier when calling reader.NextPart()
                         parsingCode = `${indent.get()}${boolTarget}, err = strconv.ParseBool(string(content))\n`;
-                        parseErr = 'err';
+                        parseErr = "err";
                     }
                     else {
                         parsingCode = `${indent.get()}${parseResults} := strconv.ParseBool(string(content))\n`;
                     }
                     break;
-                case 'float32':
-                case 'float64':
+                case "float32":
+                case "float64":
                     parsingCode = `${indent.get()}${parseResults} := strconv.ParseFloat(string(content), ${helpers.getBitSizeForNumber(typeName)})\n`;
                     break;
-                case 'int8':
-                case 'int16':
-                case 'int32':
-                case 'int64':
+                case "int8":
+                case "int16":
+                case "int32":
+                case "int64":
                     parsingCode = `${indent.get()}${parseResults} := strconv.ParseInt(string(content), 10, ${helpers.getBitSizeForNumber(typeName)})\n`;
                     break;
                 default:
-                    throw new CodegenError('InternalError', `unhandled multipart parameter primitive type ${typeName}`);
+                    throw new CodegenError("InternalError", `unhandled multipart parameter primitive type ${typeName}`);
             }
             parsingCode += `${indent.get()}if ${parseErr} != nil {\n${indent.push().get()}return nil, ${parseErr}\n${indent.pop().get()}}\n`;
             return parsingCode;
         };
         const isModelType = function (type) {
-            return type.kind === 'model' || type.kind === 'polymorphicModel';
+            return type.kind === "model" || type.kind === "polymorphicModel";
         };
         const emitCase = function (caseValue, paramVar, type, destIsByValue) {
             let caseContent = `${indent.get()}case "${caseValue}":\n`;
@@ -635,61 +638,61 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
             caseContent += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
             let assignedValue;
             if (isModelType(helpers.recursiveUnwrapMapSlice(type))) {
-                imports.add('encoding/json');
+                imports.add("encoding/json");
                 caseContent += `${indent.get()}if err = json.Unmarshal(content, &${paramVar}); err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
             }
-            else if (type.kind === 'readSeekCloser') {
-                imports.add('bytes');
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
-                assignedValue = 'streaming.NopCloser(bytes.NewReader(content))';
+            else if (type.kind === "readSeekCloser") {
+                imports.add("bytes");
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming");
+                assignedValue = "streaming.NopCloser(bytes.NewReader(content))";
             }
-            else if (type.kind === 'constant') {
+            else if (type.kind === "constant") {
                 let from;
                 switch (type.type) {
-                    case 'bool':
-                    case 'float32':
-                    case 'float64':
-                    case 'int32':
-                    case 'int64':
+                    case "bool":
+                    case "float32":
+                    case "float64":
+                    case "int32":
+                    case "int64":
                         caseContent += parsePrimitiveType(type.type);
-                        from = 'parsed';
+                        from = "parsed";
                         break;
-                    case 'string':
-                        from = 'content';
+                    case "string":
+                        from = "content";
                         break;
                 }
                 assignedValue = `${go.getTypeDeclaration(type, pkg)}(${from})`;
             }
-            else if (type.kind === 'scalar') {
+            else if (type.kind === "scalar") {
                 switch (type.type) {
-                    case 'bool':
-                        imports.add('strconv');
+                    case "bool":
+                        imports.add("strconv");
                         // ParseBool happens in place, so no need to set assignedValue
                         caseContent += parsePrimitiveType(type.type, paramVar);
                         break;
-                    case 'float32':
-                    case 'float64':
-                    case 'int8':
-                    case 'int16':
-                    case 'int32':
-                    case 'int64':
+                    case "float32":
+                    case "float64":
+                    case "int8":
+                    case "int16":
+                    case "int32":
+                    case "int64":
                         caseContent += parsePrimitiveType(type.type);
                         assignedValue = `${type.type}(parsed)`;
                         break;
                     default:
-                        throw new CodegenError('InternalError', `unhandled multipart parameter primitive type ${type.type}`);
+                        throw new CodegenError("InternalError", `unhandled multipart parameter primitive type ${type.type}`);
                 }
             }
-            else if (type.kind === 'string') {
-                assignedValue = 'string(content)';
+            else if (type.kind === "string") {
+                assignedValue = "string(content)";
             }
-            else if (helpers.recursiveUnwrapMapSlice(type).kind === 'multipartContent') {
-                imports.add('bytes');
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
-                const bodyContent = 'streaming.NopCloser(bytes.NewReader(content))';
+            else if (helpers.recursiveUnwrapMapSlice(type).kind === "multipartContent") {
+                imports.add("bytes");
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming");
+                const bodyContent = "streaming.NopCloser(bytes.NewReader(content))";
                 const contentType = 'part.Header.Get("Content-Type")';
-                const filename = 'part.FileName()';
-                if (type.kind === 'slice') {
+                const filename = "part.FileName()";
+                if (type.kind === "slice") {
                     caseContent += `${indent.get()}${paramVar} = append(${paramVar}, streaming.MultipartContent{\n`;
                     indent.push();
                     caseContent += `${indent.get()}Body: ${bodyContent},\n`;
@@ -703,27 +706,27 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
                     caseContent += `${indent.get()}${paramVar}.Filename = ${filename}\n`;
                 }
             }
-            else if (type.kind === 'slice') {
-                if (type.elementType.kind === 'readSeekCloser') {
-                    imports.add('bytes');
-                    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
+            else if (type.kind === "slice") {
+                if (type.elementType.kind === "readSeekCloser") {
+                    imports.add("bytes");
+                    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming");
                     assignedValue = `append(${paramVar}, streaming.NopCloser(bytes.NewReader(content)))`;
                 }
                 else {
-                    throw new CodegenError('InternalError', `uhandled multipart parameter array element kind ${type.elementType.kind}`);
+                    throw new CodegenError("InternalError", `unhandled multipart parameter array element kind ${type.elementType.kind}`);
                 }
             }
-            else if (type.kind === 'encodedBytes') {
-                imports.add('encoding/base64');
+            else if (type.kind === "encodedBytes") {
+                imports.add("encoding/base64");
                 caseContent += `${indent.get()}${paramVar}, err = base64.${type.encoding}Encoding.DecodeString(string(content))\n`;
                 caseContent += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
             }
             else {
-                throw new CodegenError('InternalError', `uhandled multipart parameter kind ${type.kind}`);
+                throw new CodegenError("InternalError", `unhandled multipart parameter kind ${type.kind}`);
             }
             if (assignedValue) {
                 if (!destIsByValue) {
-                    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
+                    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
                     assignedValue = `to.Ptr(${assignedValue})`;
                 }
                 caseContent += `${indent.get()}${paramVar} = ${assignedValue}\n`;
@@ -759,14 +762,14 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
             content += `${indent.get()}case "${param.formDataName}":\n`;
             let assignedValue;
             switch (param.type.kind) {
-                case 'constant':
+                case "constant":
                     assignedValue = `${go.getTypeDeclaration(param.type, pkg)}(req.FormValue(key))`;
                     break;
-                case 'string':
-                    assignedValue = 'req.FormValue(key)';
+                case "string":
+                    assignedValue = "req.FormValue(key)";
                     break;
                 default:
-                    throw new CodegenError('InternalError', `uhandled form parameter kind ${param.type.kind}`);
+                    throw new CodegenError("InternalError", `unhandled form parameter kind ${param.type.kind}`);
             }
             content += `${indent.push().get()}${param.name} = ${assignedValue}\n`;
             indent.pop();
@@ -792,7 +795,7 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
         result.params.set(partialBodyParam.name, `${helpers.star(partialBodyParam.byValue)}body.${naming.capitalize(partialBodyParam.name)}`);
     }
     const apiCall = `:= ${receiverName}.srv.${fixUpMethodName(method)}(${populateApiParams(pkg, method, result.params, imports)})`;
-    if (method.kind === 'pageableMethod') {
+    if (method.kind === "pageableMethod") {
         content += `resp ${apiCall}\n`;
         return content;
     }
@@ -805,10 +808,10 @@ function getMethodStatusCodes(method) {
     // NOTE: don't modify the original array!
     const statusCodes = Array.from(method.httpStatusCodes);
     switch (method.kind) {
-        case 'lroMethod':
-        case 'lroPageableMethod':
+        case "lroMethod":
+        case "lroPageableMethod":
             if (!statusCodes.includes(200)) {
-                // pollers always include 200 as an acceptible status code so we emulate that here
+                // pollers always include 200 as an acceptable status code so we emulate that here
                 statusCodes.unshift(200);
             }
             if (!method.returns.result && !statusCodes.includes(204)) {
@@ -876,8 +879,8 @@ function dispatchForPagerBody(pkg, receiverName, method, imports, indent) {
     indent.push();
     content += `${indent.get()}${localVarName} = &resp\n`;
     content += `${indent.get()}${operationStateMachine}.add(req, ${localVarName})\n`;
-    if (method.strategy?.kind === 'nextLink') {
-        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
+    if (method.strategy?.kind === "nextLink") {
+        imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
         content += `${indent.get()}server.PagerResponderInjectNextLinks(${localVarName}, req, func(page *${go.getTypeDeclaration(method.returns, pkg)}, createLink func() string) {\n`;
         content += `${indent.push().get()}page.${helpers.buildNextLinkPath(method.strategy)} = to.Ptr(createLink())\n`;
         content += `${indent.pop().get()}})\n`;
@@ -902,7 +905,7 @@ function dispatchForPagerBody(pkg, receiverName, method, imports, indent) {
 }
 function sanitizeRegexpCaptureGroupName(name) {
     // dash '-' characters are not allowed so replace them with '_'
-    return name.replace('-', '_');
+    return name.replace("-", "_");
 }
 function createPathParamsRegex(method, pathParams) {
     // "/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePath}/{resourceType}/{resourceName}"
@@ -912,12 +915,12 @@ function createPathParamsRegex(method, pathParams) {
     // escape any characters in the path that could be interpreted as regex tokens
     // per RFC3986, these are the pchars that also double as regex tokens
     // . $ * + ()
-    urlPath = urlPath.replace(/([.$*+()])/g, '\\$1');
+    urlPath = urlPath.replace(/([.$*+()])/g, "\\$1");
     for (const param of pathParams) {
         const toReplace = `{${param.pathSegment}}`;
         let replaceWith = `(?P<${sanitizeRegexpCaptureGroupName(param.pathSegment)}>[!#&$-;=?-\\[\\]_a-zA-Z0-9~%@]+)`;
-        if (param.style === 'optional' || param.style === 'flag') {
-            replaceWith += '?';
+        if (param.style === "optional" || param.style === "flag") {
+            replaceWith += "?";
         }
         urlPath = urlPath.replace(toReplace, replaceWith);
     }
@@ -933,7 +936,7 @@ function createPathParamsRegex(method, pathParams) {
  * @returns the parsing code and the params that contain the parsed values
  */
 function parseHeaderPathQueryParams(pkg, method, imports, indent) {
-    let content = '';
+    let content = "";
     const paramValues = new Map();
     const createLocalVariableName = function (param, suffix) {
         const paramName = `${naming.uncapitalize(param.name)}${suffix}`;
@@ -941,16 +944,16 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
         return paramName;
     };
     const emitNumericConversion = function (src, type) {
-        imports.add('strconv');
-        let precision = '32';
-        if (type === 'float64' || type === 'int64') {
-            precision = '64';
+        imports.add("strconv");
+        let precision = "32";
+        if (type === "float64" || type === "int64") {
+            precision = "64";
         }
-        let parseType = 'Int';
-        let base = '10, ';
-        if (type === 'float32' || type === 'float64') {
-            parseType = 'Float';
-            base = '';
+        let parseType = "Int";
+        let base = "10, ";
+        if (type === "float32" || type === "float64") {
+            parseType = "Float";
+            base = "";
         }
         return `strconv.Parse${parseType}(${src}, ${base}${precision})`;
     };
@@ -958,11 +961,11 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
     // we track the params separately as it might be a subset of ParameterGroup.params
     const paramGroups = new Map();
     for (const param of consolidateHostParams(method.parameters)) {
-        if (param.location === 'client' || go.isLiteralParameter(param.style)) {
+        if (param.location === "client" || go.isLiteralParameter(param.style)) {
             // client params and parameter literals aren't passed to APIs
             continue;
         }
-        if (param.kind === 'resumeTokenParam') {
+        if (param.kind === "resumeTokenParam") {
             // skip the ResumeToken param as we don't send that back to the caller
             continue;
         }
@@ -977,11 +980,11 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
             params.push(param);
         }
         switch (param.kind) {
-            case 'bodyParam':
-            case 'formBodyCollectionParam':
-            case 'formBodyScalarParam':
-            case 'multipartFormBodyParam':
-            case 'partialBodyParam':
+            case "bodyParam":
+            case "formBodyCollectionParam":
+            case "formBodyScalarParam":
+            case "multipartFormBodyParam":
+            case "partialBodyParam":
                 // body params will be unmarshalled, no need for parsing.
                 continue;
         }
@@ -993,23 +996,27 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
         let paramValue = getRawParamValue(param);
         // path params are escaped, so we need to unescape them first.
         if (go.isPathParameter(param)) {
-            imports.add('net/url');
-            let paramVar = createLocalVariableName(param, 'Unescaped');
-            if (go.isRequiredParameter(param.style) && param.type.kind === 'constant' && param.type.type === 'string') {
+            imports.add("net/url");
+            let paramVar = createLocalVariableName(param, "Unescaped");
+            if (go.isRequiredParameter(param.style) &&
+                param.type.kind === "constant" &&
+                param.type.type === "string") {
                 // for string-based enums, we perform the conversion as part of unescaping
                 requiredHelpers.parseWithCast = true;
-                paramVar = createLocalVariableName(param, 'Param');
+                paramVar = createLocalVariableName(param, "Param");
                 content += `${indent.get()}${paramVar}, err := parseWithCast(${paramValue}, func (v string) (${go.getTypeDeclaration(param.type, pkg)}, error) {\n`;
                 content += `${indent.push().get()}p, unescapeErr := url.PathUnescape(v)\n`;
                 content += `${indent.get()}if unescapeErr != nil {\n${indent.push().get()}return "", unescapeErr\n${indent.pop().get()}}\n`;
                 content += `${indent.get()}return ${go.getTypeDeclaration(param.type, pkg)}(p), nil\n${indent.pop().get()}})\n`;
             }
             else {
-                if (go.isRequiredParameter(param.style) && (param.type.kind === 'string' || (param.type.kind === 'slice' && param.type.elementType.kind === 'string'))) {
+                if (go.isRequiredParameter(param.style) &&
+                    (param.type.kind === "string" ||
+                        (param.type.kind === "slice" && param.type.elementType.kind === "string"))) {
                     // by convention, if the value is in its "final form" (i.e. no parsing required)
                     // then its var is to have the "Param" suffix. the only case is string, everything
                     // else requires some amount of parsing/conversion.
-                    paramVar = createLocalVariableName(param, 'Param');
+                    paramVar = createLocalVariableName(param, "Param");
                 }
                 content += `${indent.get()}${paramVar}, err := url.PathUnescape(${paramValue})\n`;
             }
@@ -1017,30 +1024,32 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
             paramValue = paramVar;
         }
         // parse params as required
-        if (param.kind === 'headerCollectionParam' || param.kind === 'pathCollectionParam' || param.kind === 'queryCollectionParam') {
+        if (param.kind === "headerCollectionParam" ||
+            param.kind === "pathCollectionParam" ||
+            param.kind === "queryCollectionParam") {
             // any element type other than string will require some form of conversion/parsing
-            if (param.type.elementType.kind !== 'string') {
-                if (param.collectionFormat !== 'multi') {
+            if (param.type.elementType.kind !== "string") {
+                if (param.collectionFormat !== "multi") {
                     requiredHelpers.splitHelper = true;
-                    const elementsParam = createLocalVariableName(param, 'Elements');
+                    const elementsParam = createLocalVariableName(param, "Elements");
                     content += `${indent.get()}${elementsParam} := splitHelper(${paramValue}, "${helpers.getDelimiterForCollectionFormat(param.collectionFormat)}")\n`;
                     paramValue = elementsParam;
                 }
-                const paramVar = createLocalVariableName(param, 'Param');
+                const paramVar = createLocalVariableName(param, "Param");
                 let elementFormat;
                 switch (param.type.elementType.kind) {
-                    case 'constant':
-                    case 'scalar':
+                    case "constant":
+                    case "scalar":
                         elementFormat = param.type.elementType.type;
                         break;
-                    case 'encodedBytes':
+                    case "encodedBytes":
                         elementFormat = param.type.elementType.encoding;
                         break;
-                    case 'time':
+                    case "time":
                         elementFormat = param.type.elementType.format;
                         break;
                     default:
-                        throw new CodegenError('InternalError', `unhandled element kind ${param.type.elementType.kind}`);
+                        throw new CodegenError("InternalError", `unhandled element kind ${param.type.elementType.kind}`);
                 }
                 const toType = go.getTypeDeclaration(param.type.elementType, pkg);
                 content += `${indent.get()}${paramVar} := make([]${toType}, len(${paramValue}))\n`;
@@ -1048,76 +1057,82 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                 indent.push();
                 let fromVar;
                 // TODO: consolidate with non-collection parsing code
-                if (elementFormat === 'bool') {
-                    imports.add('strconv');
-                    fromVar = 'parsedBool';
+                if (elementFormat === "bool") {
+                    imports.add("strconv");
+                    fromVar = "parsedBool";
                     content += `${indent.get()}${fromVar}, parseErr := strconv.ParseBool(${paramValue}[i])\n`;
                     content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return nil, parseErr\n${indent.pop().get()}}\n`;
                 }
-                else if (elementFormat === 'float32' || elementFormat === 'float64' || elementFormat === 'int32' || elementFormat === 'int64') {
+                else if (elementFormat === "float32" ||
+                    elementFormat === "float64" ||
+                    elementFormat === "int32" ||
+                    elementFormat === "int64") {
                     fromVar = `parsed${naming.capitalize(elementFormat)}`;
                     content += `${indent.get()}${fromVar}, parseErr := ${emitNumericConversion(`${paramValue}[i]`, elementFormat)}\n`;
                     content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return nil, parseErr\n${indent.pop().get()}}\n`;
                 }
-                else if (elementFormat === 'string') {
+                else if (elementFormat === "string") {
                     // we're casting an enum string value to its const type
                     // TODO: what about enums that aren't strings?
                     fromVar = `${paramValue}[i]`;
                 }
-                else if (elementFormat === 'Std' || elementFormat === 'URL') {
-                    imports.add('encoding/base64');
+                else if (elementFormat === "Std" || elementFormat === "URL") {
+                    imports.add("encoding/base64");
                     fromVar = `parsed${naming.capitalize(elementFormat)}`;
                     content += `${indent.get()}${fromVar}, parseErr := base64.${elementFormat}Encoding.DecodeString(${paramValue}[i])\n`;
                     content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return nil, parseErr\n${indent.pop().get()}}\n`;
                 }
-                else if (elementFormat === 'RFC1123' || elementFormat === 'RFC3339' || elementFormat === 'RFC7231' || elementFormat === 'Unix') {
-                    imports.add('time');
+                else if (elementFormat === "RFC1123" ||
+                    elementFormat === "RFC3339" ||
+                    elementFormat === "RFC7231" ||
+                    elementFormat === "Unix") {
+                    imports.add("time");
                     fromVar = `parsed${naming.capitalize(elementFormat)}`;
-                    if (elementFormat === 'Unix') {
-                        imports.add('strconv');
+                    if (elementFormat === "Unix") {
+                        imports.add("strconv");
                         content += `${indent.get()}p, parseErr := strconv.ParseInt(${paramValue}[i], 10, 64)\n`;
                         content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return nil, parseErr\n${indent.pop().get()}}\n`;
                         content += `${indent.get()}${fromVar} := time.Unix(p, 0).UTC()\n`;
                     }
                     else {
-                        let format = 'time.RFC3339Nano';
-                        if (elementFormat === 'RFC1123' || elementFormat === 'RFC7231') {
-                            format = 'time.RFC1123';
+                        let format = "time.RFC3339Nano";
+                        if (elementFormat === "RFC1123" || elementFormat === "RFC7231") {
+                            format = "time.RFC1123";
                         }
                         content += `${indent.get()}${fromVar}, parseErr := time.Parse(${format}, ${paramValue}[i])\n`;
                         content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return nil, parseErr\n${indent.pop().get()}}\n`;
                     }
                 }
                 else {
-                    throw new CodegenError('InternalError', `unhandled element format ${elementFormat}`);
+                    throw new CodegenError("InternalError", `unhandled element format ${elementFormat}`);
                 }
                 // TODO: remove cast in some cases
                 content += `${indent.get()}${paramVar}[i] = ${toType}(${fromVar})\n${indent.pop().get()}}\n`;
             }
-            else if (!go.isRequiredParameter(param.style) && param.collectionFormat !== 'multi') {
+            else if (!go.isRequiredParameter(param.style) && param.collectionFormat !== "multi") {
                 // for slices of strings that are required, the call to splitHelper(...) is inlined into
                 // the invocation of the fake e.g. srv.FakeFunc(splitHelper...). but if it's optional, we
                 // need to create a local first which will later be copied into the optional param group.
                 requiredHelpers.splitHelper = true;
-                content += `${indent.get()}${createLocalVariableName(param, 'Param')} := splitHelper(${paramValue}, "${helpers.getDelimiterForCollectionFormat(param.collectionFormat)}")\n`;
+                content += `${indent.get()}${createLocalVariableName(param, "Param")} := splitHelper(${paramValue}, "${helpers.getDelimiterForCollectionFormat(param.collectionFormat)}")\n`;
             }
         }
-        else if (param.type.kind === 'scalar' && param.type.type === 'bool') {
-            imports.add('strconv');
+        else if (param.type.kind === "scalar" && param.type.type === "bool") {
+            imports.add("strconv");
             let from = `strconv.ParseBool(${paramValue})`;
             if (!go.isRequiredParameter(param.style)) {
                 requiredHelpers.parseOptional = true;
                 from = `parseOptional(${paramValue}, strconv.ParseBool)`;
             }
-            content += `${indent.get()}${createLocalVariableName(param, 'Param')}, err := ${from}\n`;
+            content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${from}\n`;
             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
         }
-        else if (param.type.kind === 'encodedBytes') {
-            imports.add('encoding/base64');
-            content += `${indent.get()}${createLocalVariableName(param, 'Param')}, err := base64.${param.type.encoding}Encoding.DecodeString(${paramValue})\n`;
+        else if (param.type.kind === "encodedBytes") {
+            imports.add("encoding/base64");
+            content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := base64.${param.type.encoding}Encoding.DecodeString(${paramValue})\n`;
             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
         }
-        else if (param.type.kind === 'time') {
+        else if (param.type.kind === "time") {
             const formatMap = {
                 PlainDate: helpers.plainDateFormat,
                 PlainTime: helpers.plainTimeFormat,
@@ -1125,7 +1140,7 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                 RFC3339: helpers.RFC3339Format,
                 RFC7231: helpers.RFC1123Format,
             };
-            imports.add('time');
+            imports.add("time");
             if (param.type.format in formatMap) {
                 const format = formatMap[param.type.format];
                 let from = `time.Parse(${format}, ${paramValue})`;
@@ -1133,56 +1148,62 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                     requiredHelpers.parseOptional = true;
                     from = `parseOptional(${paramValue}, func(v string) (time.Time, error) { return time.Parse(${format}, v) })`;
                 }
-                content += `${indent.get()}${createLocalVariableName(param, 'Param')}, err := ${from}\n`;
+                content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${from}\n`;
                 content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
             }
             else {
-                imports.add('strconv');
+                imports.add("strconv");
                 let parser;
                 if (!go.isRequiredParameter(param.style)) {
                     requiredHelpers.parseOptional = true;
-                    parser = 'parseOptional';
+                    parser = "parseOptional";
                 }
                 else {
                     requiredHelpers.parseWithCast = true;
-                    parser = 'parseWithCast';
+                    parser = "parseWithCast";
                 }
-                content += `${indent.get()}${createLocalVariableName(param, 'Param')}, err := ${parser}(${paramValue}, func (v string) (time.Time, error) {\n`;
+                content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${parser}(${paramValue}, func (v string) (time.Time, error) {\n`;
                 content += `${indent.push().get()}p, parseErr := strconv.ParseInt(v, 10, 64)\n`;
                 content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return time.Time{}, parseErr\n${indent.pop().get()}}\n`;
                 content += `${indent.get()}return time.Unix(p, 0).UTC(), nil\n${indent.pop().get()}})\n`;
                 content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
             }
         }
-        else if (param.type.kind === 'scalar' && (param.type.type === 'float32' || param.type.type === 'float64' || param.type.type === 'int32' || param.type.type === 'int64')) {
+        else if (param.type.kind === "scalar" &&
+            (param.type.type === "float32" ||
+                param.type.type === "float64" ||
+                param.type.type === "int32" ||
+                param.type.type === "int64")) {
             let parser;
             if (!go.isRequiredParameter(param.style)) {
                 requiredHelpers.parseOptional = true;
-                parser = 'parseOptional';
+                parser = "parseOptional";
             }
             else {
                 requiredHelpers.parseWithCast = true;
-                parser = 'parseWithCast';
+                parser = "parseWithCast";
             }
-            if (param.type.type === 'float32' || param.type.type === 'int32' || !go.isRequiredParameter(param.style)) {
-                content += `${indent.get()}${createLocalVariableName(param, 'Param')}, err := ${parser}(${paramValue}, func(v string) (${param.type.type}, error) {\n`;
-                content += `${indent.push().get()}p, parseErr := ${emitNumericConversion('v', param.type.type)}\n`;
+            if (param.type.type === "float32" ||
+                param.type.type === "int32" ||
+                !go.isRequiredParameter(param.style)) {
+                content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${parser}(${paramValue}, func(v string) (${param.type.type}, error) {\n`;
+                content += `${indent.push().get()}p, parseErr := ${emitNumericConversion("v", param.type.type)}\n`;
                 content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return 0, parseErr\n${indent.pop().get()}}\n`;
-                let result = 'p';
-                if (param.type.type === 'float32' || param.type.type === 'int32') {
+                let result = "p";
+                if (param.type.type === "float32" || param.type.type === "int32") {
                     result = `${param.type.type}(${result})`;
                 }
                 content += `${indent.get()}return ${result}, nil\n${indent.pop().get()}})\n`;
             }
             else {
-                content += `${indent.get()}${createLocalVariableName(param, 'Param')}, err := ${emitNumericConversion(paramValue, param.type.type)}\n`;
+                content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${emitNumericConversion(paramValue, param.type.type)}\n`;
             }
             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
         }
-        else if (param.kind === 'headerMapParam') {
-            imports.add('strings');
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
-            const localVar = createLocalVariableName(param, 'Param');
+        else if (param.kind === "headerMapParam") {
+            imports.add("strings");
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
+            const localVar = createLocalVariableName(param, "Param");
             content += `${indent.get()}var ${localVar} map[string]*string\n`;
             content += `${indent.get()}for hh := range ${paramValue} {\n`;
             const headerPrefix = param.headerName;
@@ -1192,30 +1213,30 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
             content += `${indent.get()}${localVar}[hh[len("${headerPrefix}"):]] = to.Ptr(getHeaderValue(req.Header, hh))\n`;
             content += `${indent.pop().get()}}\n${indent.pop().get()}}\n`;
         }
-        else if (param.type.kind === 'constant' && param.type.type !== 'string') {
+        else if (param.type.kind === "constant" && param.type.type !== "string") {
             let parseHelper;
             if (!go.isRequiredParameter(param.style)) {
                 requiredHelpers.parseOptional = true;
-                parseHelper = 'parseOptional';
+                parseHelper = "parseOptional";
             }
             else {
                 requiredHelpers.parseWithCast = true;
-                parseHelper = 'parseWithCast';
+                parseHelper = "parseWithCast";
             }
             let parse;
             let zeroValue;
-            if (param.type.type === 'bool') {
-                imports.add('strconv');
-                parse = 'strconv.ParseBool(v)';
-                zeroValue = 'false';
+            if (param.type.type === "bool") {
+                imports.add("strconv");
+                parse = "strconv.ParseBool(v)";
+                zeroValue = "false";
             }
             else {
                 // emitNumericConversion adds the necessary import of strconv
-                parse = emitNumericConversion('v', param.type.type);
-                zeroValue = '0';
+                parse = emitNumericConversion("v", param.type.type);
+                zeroValue = "0";
             }
             const toConstType = go.getTypeDeclaration(param.type, pkg);
-            content += `${indent.get()}${createLocalVariableName(param, 'Param')}, err := ${parseHelper}(${paramValue}, func(v string) (${toConstType}, error) {\n`;
+            content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${parseHelper}(${paramValue}, func(v string) (${toConstType}, error) {\n`;
             content += `${indent.push().get()}p, parseErr := ${parse}\n`;
             content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return ${zeroValue}, parseErr\n${indent.pop().get()}}\n`;
             content += `${indent.get()}return ${toConstType}(p), nil\n${indent.pop().get()}})\n`;
@@ -1224,11 +1245,11 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
         else if (!go.isRequiredParameter(param.style)) {
             // we check this last as it's a superset of the previous conditions
             requiredHelpers.getOptional = true;
-            if (param.type.kind === 'constant' || param.type.kind === 'etag') {
+            if (param.type.kind === "constant" || param.type.kind === "etag") {
                 imports.addForType(param.type);
                 paramValue = `${go.getTypeDeclaration(param.type, pkg)}(${paramValue})`;
             }
-            content += `${indent.get()}${createLocalVariableName(param, 'Param')} := getOptional(${paramValue})\n`;
+            content += `${indent.get()}${createLocalVariableName(param, "Param")} := getOptional(${paramValue})\n`;
         }
     }
     // create the param groups and populate their values
@@ -1252,21 +1273,21 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
             if (params) {
                 for (const param of params) {
                     // check array before body in case the body is just an array
-                    if (param.type.kind === 'slice') {
+                    if (param.type.kind === "slice") {
                         paramNilCheck.push(`len(${getFinalParamValue(pkg, param, paramValues)}) > 0`);
                     }
-                    else if (param.kind === 'bodyParam') {
-                        if (param.bodyFormat === 'binary') {
-                            imports.add('io');
-                            paramNilCheck.push('req.Body != nil');
+                    else if (param.kind === "bodyParam") {
+                        if (param.bodyFormat === "binary") {
+                            imports.add("io");
+                            paramNilCheck.push("req.Body != nil");
                         }
                         else {
-                            imports.add('reflect');
-                            paramNilCheck.push('!reflect.ValueOf(body).IsZero()');
+                            imports.add("reflect");
+                            paramNilCheck.push("!reflect.ValueOf(body).IsZero()");
                         }
                     }
-                    else if (go.isFormBodyParameter(param) || param.kind === 'multipartFormBodyParam') {
-                        imports.add('reflect');
+                    else if (go.isFormBodyParameter(param) || param.kind === "multipartFormBodyParam") {
+                        imports.add("reflect");
                         paramNilCheck.push(`!reflect.ValueOf(${param.name}).IsZero()`);
                     }
                     else {
@@ -1274,14 +1295,18 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                     }
                 }
             }
-            content += `${indent.get()}if ${paramNilCheck.join(' || ')} {\n`;
+            content += `${indent.get()}if ${paramNilCheck.join(" || ")} {\n`;
             content += `${indent.push().get()}${naming.uncapitalize(paramGroup.name)} = &${go.getTypeDeclaration(paramGroup, pkg)}{\n`;
             if (params) {
                 indent.push();
                 for (const param of params) {
-                    let byRef = '&';
-                    if (param.byValue || (!go.isRequiredParameter(param.style) && param.kind !== 'bodyParam' && !go.isFormBodyParameter(param) && param.kind !== 'multipartFormBodyParam')) {
-                        byRef = '';
+                    let byRef = "&";
+                    if (param.byValue ||
+                        (!go.isRequiredParameter(param.style) &&
+                            param.kind !== "bodyParam" &&
+                            !go.isFormBodyParameter(param) &&
+                            param.kind !== "multipartFormBodyParam")) {
+                        byRef = "";
                     }
                     content += `${indent.get()}${naming.capitalize(param.name)}: ${byRef}${getFinalParamValue(pkg, param, paramValues)},\n`;
                 }
@@ -1311,18 +1336,18 @@ function populateApiParams(pkg, method, paramValues, imports) {
     const params = new Array();
     // for non-paged APIs, first param is always the context. use the one
     // from the HTTP request. be careful to properly handle paged LROs
-    if (method.kind !== 'pageableMethod') {
-        params.push('req.Context()');
+    if (method.kind !== "pageableMethod") {
+        params.push("req.Context()");
     }
     // now create the API call sig
     for (const param of helpers.getMethodParameters(method, consolidateHostParams)) {
-        if (param.kind === 'paramGroup') {
+        if (param.kind === "paramGroup") {
             if (param.groupName === method.optionalParamsGroup.groupName) {
                 // this is the optional params type. in some cases we just pass nil
-                const countParams = param.params.filter((each) => each.kind !== 'resumeTokenParam').length;
+                const countParams = param.params.filter((each) => each.kind !== "resumeTokenParam").length;
                 if (countParams === 0) {
                     // if the options param is empty or only contains the resume token param just pass nil
-                    params.push('nil');
+                    params.push("nil");
                     continue;
                 }
             }
@@ -1334,47 +1359,47 @@ function populateApiParams(pkg, method, paramValues, imports) {
         imports.addForType(param.type);
         params.push(getFinalParamValue(pkg, param, paramValues));
     }
-    return params.join(', ');
+    return params.join(", ");
 }
 // getRawParamValue returns the "raw" value for the specified parameter.
 // depending on the type, the value might require parsing before it can be passed to the fake.
 function getRawParamValue(param) {
     switch (param.kind) {
-        case 'bodyParam':
-            if (param.bodyFormat === 'binary') {
-                return 'req.Body.(io.ReadSeekCloser)';
+        case "bodyParam":
+            if (param.bodyFormat === "binary") {
+                return "req.Body.(io.ReadSeekCloser)";
             }
             // JSON/XML/text bodies have been deserialized into a local named body
-            return 'body';
-        case 'formBodyCollectionParam':
-        case 'formBodyScalarParam':
-        case 'multipartFormBodyParam':
-        case 'partialBodyParam':
+            return "body";
+        case "formBodyCollectionParam":
+        case "formBodyScalarParam":
+        case "multipartFormBodyParam":
+        case "partialBodyParam":
             // multipart form data values have been read and assigned
             // to local params with the same name.
             return param.name;
-        case 'headerCollectionParam':
-        case 'headerScalarParam':
+        case "headerCollectionParam":
+        case "headerScalarParam":
             // use req
             requiredHelpers.getHeaderValue = true;
             return `getHeaderValue(req.Header, "${param.headerName}")`;
-        case 'headerMapParam':
-            return 'req.Header';
-        case 'pathCollectionParam':
-        case 'pathScalarParam':
+        case "headerMapParam":
+            return "req.Header";
+        case "pathCollectionParam":
+        case "pathScalarParam":
             // path params are in the matches slice
             return `matches[regex.SubexpIndex("${sanitizeRegexpCaptureGroupName(param.pathSegment)}")]`;
-        case 'queryCollectionParam':
-        case 'queryScalarParam':
+        case "queryCollectionParam":
+        case "queryScalarParam":
             // use qp
-            if (param.kind === 'queryCollectionParam' && param.collectionFormat === 'multi') {
+            if (param.kind === "queryCollectionParam" && param.collectionFormat === "multi") {
                 return `qp["${param.queryParameter}"]`;
             }
             return `qp.Get("${param.queryParameter}")`;
-        case 'uriParam':
-            return 'req.URL.Host';
+        case "uriParam":
+            return "req.URL.Host";
         default:
-            throw new CodegenError('InternalError', `unhandled parameter ${param.name}`);
+            throw new CodegenError("InternalError", `unhandled parameter ${param.name}`);
     }
 }
 /**
@@ -1394,26 +1419,33 @@ function getFinalParamValue(pkg, param, paramValues) {
         paramValue = getRawParamValue(param);
     }
     // there are a few corner-cases that require some fix-ups
-    if ((param.kind === 'bodyParam' || go.isFormBodyParameter(param) || param.kind === 'multipartFormBodyParam') && param.type.kind === 'time') {
+    if ((param.kind === "bodyParam" ||
+        go.isFormBodyParameter(param) ||
+        param.kind === "multipartFormBodyParam") &&
+        param.type.kind === "time") {
         // time types in the body have been unmarshalled into our time helpers thus require a cast to time.Time
         return `time.Time(${paramValue})`;
     }
     else if (go.isRequiredParameter(param.style)) {
         // optional params are always in their "final" form
-        if (param.kind === 'headerCollectionParam' || param.kind === 'pathCollectionParam' || param.kind === 'queryCollectionParam') {
+        if (param.kind === "headerCollectionParam" ||
+            param.kind === "pathCollectionParam" ||
+            param.kind === "queryCollectionParam") {
             // for required params that are collections of strings, we split them inline.
             // not necessary for optional params as they're already in slice format.
-            if (param.collectionFormat !== 'multi' && param.type.elementType.kind === 'string') {
+            if (param.collectionFormat !== "multi" && param.type.elementType.kind === "string") {
                 requiredHelpers.splitHelper = true;
                 return `splitHelper(${paramValue}, "${helpers.getDelimiterForCollectionFormat(param.collectionFormat)}")`;
             }
         }
-        else if ((go.isHeaderParameter(param) || go.isQueryParameter(param)) && param.type.kind === 'constant' && param.type.type === 'string') {
+        else if ((go.isHeaderParameter(param) || go.isQueryParameter(param)) &&
+            param.type.kind === "constant" &&
+            param.type.type === "string") {
             // query params from req.URL.Query() are already decoded, so like headers we cast required, string-based enums inline
             return `${go.getTypeDeclaration(param.type, pkg)}(${paramValue})`;
         }
     }
-    else if (param.kind === 'partialBodyParam') {
+    else if (param.kind === "partialBodyParam") {
         // use the value from the unmarshaled, intermediate struct type
         return `body.${naming.capitalize(param.name)}`;
     }
@@ -1425,7 +1457,7 @@ function getFinalParamValue(pkg, param, paramValues) {
 // there's no way to reliably split the host back up into its constituent parameters.
 // so we just pass the full value as a single host parameter.
 function consolidateHostParams(params) {
-    if (!params.find((each) => each.kind === 'uriParam')) {
+    if (!params.find((each) => each.kind === "uriParam")) {
         // no host params
         return params;
     }
@@ -1433,7 +1465,7 @@ function consolidateHostParams(params) {
     const consolidatedParams = new Array();
     let hostParamAdded = false;
     for (const param of params) {
-        if (param.kind !== 'uriParam') {
+        if (param.kind !== "uriParam") {
             consolidatedParams.push(param);
         }
         else if (!hostParamAdded) {
@@ -1454,27 +1486,27 @@ function consolidateHostParams(params) {
 function getAPIParametersSig(pkg, method, imports) {
     const methodParams = helpers.getMethodParameters(method, consolidateHostParams);
     const params = new Array();
-    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) {
         let paramName = naming.uncapitalize(methodParam.name);
-        if (methodParam.kind === 'uriParam') {
-            paramName = 'host';
+        if (methodParam.kind === "uriParam") {
+            paramName = "host";
         }
         params.push(`${paramName} ${helpers.formatParameterTypeName(pkg, methodParam)}`);
     }
-    return params.join(', ');
+    return params.join(", ");
 }
 // copied from generator/helpers.ts but without the XML-specific stuff
 function getResultFieldName(result) {
     switch (result.kind) {
-        case 'anyResult':
+        case "anyResult":
             return result.fieldName;
-        case 'modelResult':
+        case "modelResult":
             return result.modelType.name;
-        case 'polymorphicResult':
+        case "polymorphicResult":
             return result.interface.name;
         default:
             return result.fieldName;