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

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

@@ -2,15 +2,15 @@
  *  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 { CodegenError } from './errors.js';
+import * as go from "../../codemodel/index.js";
+import * as naming from "../../naming/naming.js";
+import { CodegenError } from "./errors.js";
 // variable to be used to determine comment length when calling comment from @azure-tools
 export const commentLength = 120;
-export const plainDateFormat = 'time.DateOnly';
-export const RFC3339Format = 'time.RFC3339Nano';
-export const RFC1123Format = 'time.RFC1123';
-export const plainTimeFormat = 'time.TimeOnly';
+export const plainDateFormat = "time.DateOnly";
+export const RFC3339Format = "time.RFC3339Nano";
+export const RFC1123Format = "time.RFC1123";
+export const plainTimeFormat = "time.TimeOnly";
 // matches both current format (DO NOT EDIT on same line as Code generated)
 // and legacy autorest format (DO NOT EDIT on a separate line)
 export const doNotEditRegex = /^\/\/ Code generated .*( DO NOT EDIT\.$|[\s\S]*?^\/\/ DO NOT EDIT\.$)/m;
@@ -34,19 +34,19 @@ export function setCustomHeaderText(headerText) {
  * @returns the source file preamble
  */
 export function contentPreamble(pkg, doNotEdit = true) {
-    const headerText = comment(overrideHeaderText ?? defaultHeaderText, '// ');
+    const headerText = comment(overrideHeaderText ?? defaultHeaderText, "// ");
     let text = headerText;
     if (doNotEdit) {
         // ensure tools recognize the file as generated according to
         // https://pkg.go.dev/cmd/go#hdr-Generate_Go_files_by_processing_source
-        text = text.replace(/^\/\/ Code generated .*\.$/m, '$& DO NOT EDIT.');
+        text = text.replace(/^\/\/ Code generated .*\.$/m, "$& DO NOT EDIT.");
         if (!text.match(doNotEditRegex)) {
-            text += '\n// Code generated by @autorest/go. DO NOT EDIT.';
+            text += "\n// Code generated by @autorest/go. DO NOT EDIT.";
         }
     }
     else {
         // remove the blurb about the changes being lost
-        text = text.replace(/^\/\/ Changes may cause incorrect behavior and will be lost if the code is regenerated\.$/m, '');
+        text = text.replace(/^\/\/ Changes may cause incorrect behavior and will be lost if the code is regenerated\.$/m, "");
     }
     text += `\n\npackage ${go.getPackageName(pkg)}\n\n`;
     return text;
@@ -66,15 +66,15 @@ export function formatParameterTypeName(scope, param) {
     let typeName;
     let required;
     switch (param.kind) {
-        case 'armClientOptions':
+        case "armClientOptions":
             typeName = go.getTypeDeclaration(param, scope);
             required = false;
             break;
-        case 'clientOptions':
+        case "clientOptions":
             typeName = go.getTypeDeclaration(param, scope);
             required = false;
             break;
-        case 'paramGroup':
+        case "paramGroup":
             typeName = go.getTypeDeclaration(param, scope);
             required = param.required;
             break;
@@ -86,10 +86,10 @@ export function formatParameterTypeName(scope, param) {
 }
 // sorts parameters by their required state, ordering required before optional
 export function sortParametersByRequired(a, b) {
-    let aRequired = false;
-    let bRequired = false;
+    let aRequired;
+    let bRequired;
     switch (a.kind) {
-        case 'paramGroup':
+        case "paramGroup":
             aRequired = a.required;
             break;
         default:
@@ -97,7 +97,7 @@ export function sortParametersByRequired(a, b) {
             break;
     }
     switch (b.kind) {
-        case 'paramGroup':
+        case "paramGroup":
             bRequired = b.required;
             break;
         default:
@@ -123,9 +123,9 @@ export function sortParametersByRequired(a, b) {
 export function sortClientParameters(params, type) {
     // ARM will never have uriParams but it will likely have a scalar path
     // param for the subscription ID, so we sort by that instead.
-    const sortBy = type === 'azure-arm' ? 'pathScalarParam' : 'uriParam';
+    const sortBy = type === "azure-arm" ? "pathScalarParam" : "uriParam";
     params.sort((a, b) => {
-        if (a.kind === sortBy || (a.kind === 'credentialParam' && b.kind !== sortBy)) {
+        if (a.kind === sortBy || (a.kind === "credentialParam" && b.kind !== sortBy)) {
             // sortBy always comes first, followed by credential (if applicable)
             return -1;
         }
@@ -138,17 +138,19 @@ export function sortClientParameters(params, type) {
 export function getCreateRequestParametersSig(method) {
     const methodParams = getMethodParameters(method);
     const params = new Array();
-    params.push('ctx context.Context');
+    params.push("ctx context.Context");
     for (const methodParam of methodParams) {
         let paramName = methodParam.name;
         // when creating the method sig for fooCreateRequest, if the options type is empty
         // or only contains the ResumeToken param use _ for the param name to quiet the linter
-        if (methodParam.kind === 'paramGroup' && (methodParam.params.length === 0 || (methodParam.params.length === 1 && methodParam.params[0].kind === 'resumeTokenParam'))) {
-            paramName = '_';
+        if (methodParam.kind === "paramGroup" &&
+            (methodParam.params.length === 0 ||
+                (methodParam.params.length === 1 && methodParam.params[0].kind === "resumeTokenParam"))) {
+            paramName = "_";
         }
         params.push(`${paramName} ${formatParameterTypeName(method.receiver.type.pkg, methodParam)}`);
     }
-    return params.join(', ');
+    return params.join(", ");
 }
 /**
  * returns the parameter names for an operation (excludes the param types).
@@ -162,7 +164,7 @@ export function getCreateRequestParameters(method, optionsParam) {
     // NOTE: keep in sync with getCreateRequestParametersSig
     const methodParams = getMethodParameters(method);
     const params = new Array();
-    params.push('ctx');
+    params.push("ctx");
     for (let i = 0; i < methodParams.length; ++i) {
         const methodParam = methodParams[i];
         // the options param is always the last one
@@ -173,7 +175,7 @@ export function getCreateRequestParameters(method, optionsParam) {
             params.push(methodParam.name);
         }
     }
-    return params.join(', ');
+    return params.join(", ");
 }
 // returns the complete collection of method parameters
 export function getMethodParameters(method, paramsFilter) {
@@ -184,7 +186,7 @@ export function getMethodParameters(method, paramsFilter) {
         methodParams = paramsFilter(methodParams);
     }
     for (const param of methodParams) {
-        if (param.location === 'client') {
+        if (param.location === "client") {
             // client params are passed via the receiver
             // must check before param group as client params can be grouped
             continue;
@@ -195,7 +197,7 @@ export function getMethodParameters(method, paramsFilter) {
                 paramGroups.push(param.group);
             }
         }
-        else if (param.type.kind === 'literal') {
+        else if (param.type.kind === "literal") {
             // don't generate a parameter for a constant
             // NOTE: this check must come last as non-required optional constants
             // in header/query params get dumped into the optional params group
@@ -218,7 +220,7 @@ export function getMethodParameters(method, paramsFilter) {
         return 1;
     });
     // add the optional param group last if it's not already in the list.
-    if (method.kind !== 'nextPageMethod') {
+    if (method.kind !== "nextPageMethod") {
         if (!paramGroups.find((gp) => gp.groupName === method.optionalParamsGroup.groupName)) {
             paramGroups.push(method.optionalParamsGroup);
         }
@@ -240,36 +242,38 @@ export function getParamName(param) {
     if (param.group) {
         paramName = `${naming.uncapitalize(param.group.name)}.${naming.capitalize(paramName)}`;
     }
-    if (param.location === 'client') {
+    if (param.location === "client") {
         paramName = `client.${paramName}`;
     }
     // client parameters with default values aren't emitted as pointer-to-type
-    if (!go.isRequiredParameter(param.style) && !(param.location === 'client' && go.isClientSideDefault(param.style)) && !param.byValue) {
+    if (!go.isRequiredParameter(param.style) &&
+        !(param.location === "client" && go.isClientSideDefault(param.style)) &&
+        !param.byValue) {
         paramName = `*${paramName}`;
     }
     return paramName;
 }
 // converts the Go code model encoding type to the type name in the standard library
 export function formatBytesEncoding(enc) {
-    if (enc === 'URL') {
-        return 'RawURL';
+    if (enc === "URL") {
+        return "RawURL";
     }
-    return 'Std';
+    return "Std";
 }
 export function formatParamValue(param, imports, indent) {
-    let paramName = getParamName(param);
+    const paramName = getParamName(param);
     switch (param.kind) {
-        case 'formBodyCollectionParam':
-        case 'headerCollectionParam':
-        case 'pathCollectionParam':
-        case 'queryCollectionParam': {
-            if (param.collectionFormat === 'multi') {
-                throw new CodegenError('InternalError', 'multi collection format should have been previously handled');
+        case "formBodyCollectionParam":
+        case "headerCollectionParam":
+        case "pathCollectionParam":
+        case "queryCollectionParam": {
+            if (param.collectionFormat === "multi") {
+                throw new CodegenError("InternalError", "multi collection format should have been previously handled");
             }
             const separator = getDelimiterForCollectionFormat(param.collectionFormat);
             const emitConvertOver = function (paramName, format) {
                 const encodedVar = `encoded${naming.capitalize(paramName)}`;
-                let content = 'strings.Join(func() []string {\n';
+                let content = "strings.Join(func() []string {\n";
                 content += `${indent.push().get()}${encodedVar} := make([]string, len(${paramName}))\n`;
                 content += `${indent.get()}for i := 0; i < len(${paramName}); i++ {\n`;
                 content += `${indent.push().get()}${encodedVar}[i] = ${format}\n`;
@@ -279,20 +283,20 @@ export function formatParamValue(param, imports, indent) {
                 return content;
             };
             switch (param.type.elementType.kind) {
-                case 'encodedBytes':
-                    imports.add('encoding/base64');
-                    imports.add('strings');
+                case "encodedBytes":
+                    imports.add("encoding/base64");
+                    imports.add("strings");
                     return emitConvertOver(param.name, `base64.${formatBytesEncoding(param.type.elementType.encoding)}Encoding.EncodeToString(${param.name}[i])`);
-                case 'string':
-                    imports.add('strings');
+                case "string":
+                    imports.add("strings");
                     return `strings.Join(${paramName}, "${separator}")`;
-                case 'time':
-                    imports.add('strings');
-                    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                case "time":
+                    imports.add("strings");
+                    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
                     return emitConvertOver(param.name, `datetime.${param.type.elementType.format}(${param.name}[i]).String()`);
                 default:
-                    imports.add('fmt');
-                    imports.add('strings');
+                    imports.add("fmt");
+                    imports.add("strings");
                     return `strings.Join(strings.Fields(strings.Trim(fmt.Sprint(${paramName}), "[]")), "${separator}")`;
             }
         }
@@ -301,69 +305,69 @@ export function formatParamValue(param, imports, indent) {
 }
 export function getDelimiterForCollectionFormat(cf) {
     switch (cf) {
-        case 'csv':
-            return ',';
-        case 'pipes':
-            return '|';
-        case 'ssv':
-            return ' ';
-        case 'tsv':
-            return '\\t';
+        case "csv":
+            return ",";
+        case "pipes":
+            return "|";
+        case "ssv":
+            return " ";
+        case "tsv":
+            return "\\t";
         default:
-            throw new CodegenError('InternalError', `unhandled CollectionFormat ${cf}`);
+            throw new CodegenError("InternalError", `unhandled CollectionFormat ${cf}`);
     }
 }
-export function formatValue(paramName, type, imports, defef) {
+export function formatValue(paramName, type, imports, deref) {
     // callers don't have enough context to know if paramName needs to be
-    // deferenced so we track that here when specified. note that not all
+    // dereferenced so we track that here when specified. note that not all
     // cases will require paramName to be dereferenced.
-    let star = '';
-    if (defef === true) {
-        star = '*';
+    let star = "";
+    if (deref === true) {
+        star = "*";
     }
     switch (type.kind) {
-        case 'constant':
-            if (type.type === 'string') {
+        case "constant":
+            if (type.type === "string") {
                 return `string(${star}${paramName})`;
             }
-            imports.add('fmt');
+            imports.add("fmt");
             return `fmt.Sprintf("%v", ${star}${paramName})`;
-        case 'encodedBytes':
+        case "encodedBytes":
             // a base-64 encoded value in string format
-            imports.add('encoding/base64');
+            imports.add("encoding/base64");
             return `base64.${formatBytesEncoding(type.encoding)}Encoding.EncodeToString(${paramName})`;
-        case 'etag':
+        case "etag":
             return `string(${star}${paramName})`;
-        case 'literal':
+        case "literal":
             // cannot use formatLiteralValue() since all values are treated as strings
             switch (type.type.kind) {
-                case 'constantDef':
+                case "constantDef":
                     return type.type.name;
                 default:
                     return `"${type.literal}"`;
             }
-        case 'scalar':
+        case "scalar":
             switch (type.type) {
-                case 'bool':
-                    imports.add('strconv');
+                case "bool":
+                    imports.add("strconv");
                     return `strconv.FormatBool(${star}${paramName})`;
-                case 'float32':
-                    imports.add('strconv');
+                case "float32":
+                    imports.add("strconv");
                     return `strconv.FormatFloat(float64(${star}${paramName}), 'f', -1, 32)`;
-                case 'float64':
-                    imports.add('strconv');
+                case "float64":
+                    imports.add("strconv");
                     return `strconv.FormatFloat(${star}${paramName}, 'f', -1, 64)`;
-                case 'int32':
-                    imports.add('strconv');
+                case "int32":
+                    imports.add("strconv");
                     return `strconv.FormatInt(int64(${star}${paramName}), 10)`;
-                case 'int64':
-                    imports.add('strconv');
+                case "int64":
+                    imports.add("strconv");
                     return `strconv.FormatInt(${star}${paramName}, 10)`;
                 default:
-                    throw new CodegenError('InternalError', `unhandled scalar type ${type.type}`);
+                    throw new CodegenError("InternalError", `unhandled scalar type ${type.type}`);
             }
-        case 'time':
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+        case "time":
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
             return `datetime.${type.format}(${star}${paramName}).String()`;
         default:
             return `${star}${paramName}`;
@@ -374,53 +378,53 @@ export function formatValue(paramName, type, imports, defef) {
 // it could also be a constant.
 export function formatLiteralValue(value, withCast) {
     switch (value.type.kind) {
-        case 'constant':
-            if (value.literal?.kind === 'constantValue') {
+        case "constant":
+            if (value.literal?.kind === "constantValue") {
                 return value.literal.name;
             }
             // extensible enum with a value that's not one of the pre-defined ones.
             // emit it as a cast to the enum type, e.g. NetworkAPIVersion("2026-04-15-preview").
-            if (value.type.type === 'string') {
+            if (value.type.type === "string") {
                 return `${value.type.name}("${value.literal}")`;
             }
             return `${value.type.name}(${value.literal})`;
-        case 'constantDef':
+        case "constantDef":
             return value.type.name;
-        case 'encodedBytes':
+        case "encodedBytes":
             return value.literal;
-        case 'scalar':
+        case "scalar":
             if (!withCast) {
                 return `${value.literal}`;
             }
             switch (value.type.type) {
-                case 'float32':
+                case "float32":
                     return `float32(${value.literal})`;
-                case 'float64':
+                case "float64":
                     return `float64(${value.literal})`;
-                case 'int32':
+                case "int32":
                     return `int32(${value.literal})`;
-                case 'int64':
+                case "int64":
                     return `int64(${value.literal})`;
                 default:
                     return value.literal;
             }
-        case 'string':
+        case "string":
             if (value.literal[0] === '"') {
                 // string is already quoted
                 return value.literal;
             }
             return `"${value.literal}"`;
-        case 'time':
+        case "time":
             return `"${value.literal}"`;
     }
 }
 // returns true if at least one of the responses has a schema
 export function hasSchemaResponse(method) {
     switch (method.returns.result?.kind) {
-        case 'anyResult':
-        case 'modelResult':
-        case 'monomorphicResult':
-        case 'polymorphicResult':
+        case "anyResult":
+        case "modelResult":
+        case "monomorphicResult":
+        case "polymorphicResult":
             return true;
         default:
             return false;
@@ -430,17 +434,17 @@ export function hasSchemaResponse(method) {
 export function getResultFieldName(method) {
     const result = method.returns.result;
     if (!result) {
-        throw new CodegenError('InternalError', `missing result for method ${method.name}`);
+        throw new CodegenError("InternalError", `missing result for method ${method.name}`);
     }
     switch (result.kind) {
-        case 'anyResult':
-        case 'binaryResult':
-        case 'headAsBooleanResult':
-        case 'monomorphicResult':
+        case "anyResult":
+        case "binaryResult":
+        case "headAsBooleanResult":
+        case "monomorphicResult":
             return result.fieldName;
-        case 'modelResult':
+        case "modelResult":
             return result.modelType.name;
-        case 'polymorphicResult':
+        case "polymorphicResult":
             return result.interface.name;
     }
 }
@@ -449,139 +453,139 @@ export function formatStatusCodes(statusCodes) {
     for (const rawCode of statusCodes) {
         asHTTPStatus.push(formatStatusCode(rawCode));
     }
-    return asHTTPStatus.join(', ');
+    return asHTTPStatus.join(", ");
 }
 export function formatStatusCode(statusCode) {
     switch (statusCode) {
         // 1xx
         case 100:
-            return 'http.StatusContinue';
+            return "http.StatusContinue";
         case 101:
-            return 'http.StatusSwitchingProtocols';
+            return "http.StatusSwitchingProtocols";
         case 102:
-            return 'http.StatusProcessing';
+            return "http.StatusProcessing";
         case 103:
-            return 'http.StatusEarlyHints';
+            return "http.StatusEarlyHints";
         // 2xx
         case 200:
-            return 'http.StatusOK';
+            return "http.StatusOK";
         case 201:
-            return 'http.StatusCreated';
+            return "http.StatusCreated";
         case 202:
-            return 'http.StatusAccepted';
+            return "http.StatusAccepted";
         case 203:
-            return 'http.StatusNonAuthoritativeInfo';
+            return "http.StatusNonAuthoritativeInfo";
         case 204:
-            return 'http.StatusNoContent';
+            return "http.StatusNoContent";
         case 205:
-            return 'http.StatusResetContent';
+            return "http.StatusResetContent";
         case 206:
-            return 'http.StatusPartialContent';
+            return "http.StatusPartialContent";
         case 207:
-            return 'http.StatusMultiStatus';
+            return "http.StatusMultiStatus";
         case 208:
-            return 'http.StatusAlreadyReported';
+            return "http.StatusAlreadyReported";
         case 226:
-            return 'http.StatusIMUsed';
+            return "http.StatusIMUsed";
         // 3xx
         case 300:
-            return 'http.StatusMultipleChoices';
+            return "http.StatusMultipleChoices";
         case 301:
-            return 'http.StatusMovedPermanently';
+            return "http.StatusMovedPermanently";
         case 302:
-            return 'http.StatusFound';
+            return "http.StatusFound";
         case 303:
-            return 'http.StatusSeeOther';
+            return "http.StatusSeeOther";
         case 304:
-            return 'http.StatusNotModified';
+            return "http.StatusNotModified";
         case 305:
-            return 'http.StatusUseProxy';
+            return "http.StatusUseProxy";
         case 307:
-            return 'http.StatusTemporaryRedirect';
+            return "http.StatusTemporaryRedirect";
         // 4xx
         case 400:
-            return 'http.StatusBadRequest';
+            return "http.StatusBadRequest";
         case 401:
-            return 'http.StatusUnauthorized';
+            return "http.StatusUnauthorized";
         case 402:
-            return 'http.StatusPaymentRequired';
+            return "http.StatusPaymentRequired";
         case 403:
-            return 'http.StatusForbidden';
+            return "http.StatusForbidden";
         case 404:
-            return 'http.StatusNotFound';
+            return "http.StatusNotFound";
         case 405:
-            return 'http.StatusMethodNotAllowed';
+            return "http.StatusMethodNotAllowed";
         case 406:
-            return 'http.StatusNotAcceptable';
+            return "http.StatusNotAcceptable";
         case 407:
-            return 'http.StatusProxyAuthRequired';
+            return "http.StatusProxyAuthRequired";
         case 408:
-            return 'http.StatusRequestTimeout';
+            return "http.StatusRequestTimeout";
         case 409:
-            return 'http.StatusConflict';
+            return "http.StatusConflict";
         case 410:
-            return 'http.StatusGone';
+            return "http.StatusGone";
         case 411:
-            return 'http.StatusLengthRequired';
+            return "http.StatusLengthRequired";
         case 412:
-            return 'http.StatusPreconditionFailed';
+            return "http.StatusPreconditionFailed";
         case 413:
-            return 'http.StatusRequestEntityTooLarge';
+            return "http.StatusRequestEntityTooLarge";
         case 414:
-            return 'http.StatusRequestURITooLong';
+            return "http.StatusRequestURITooLong";
         case 415:
-            return 'http.StatusUnsupportedMediaType';
+            return "http.StatusUnsupportedMediaType";
         case 416:
-            return 'http.StatusRequestedRangeNotSatisfiable';
+            return "http.StatusRequestedRangeNotSatisfiable";
         case 417:
-            return 'http.StatusExpectationFailed';
+            return "http.StatusExpectationFailed";
         case 418:
-            return 'http.StatusTeapot';
+            return "http.StatusTeapot";
         case 421:
-            return 'http.StatusMisdirectedRequest';
+            return "http.StatusMisdirectedRequest";
         case 422:
-            return 'http.StatusUnprocessableEntity';
+            return "http.StatusUnprocessableEntity";
         case 423:
-            return 'http.StatusLocked';
+            return "http.StatusLocked";
         case 424:
-            return 'http.StatusFailedDependency';
+            return "http.StatusFailedDependency";
         case 425:
-            return 'http.StatusTooEarly';
+            return "http.StatusTooEarly";
         case 426:
-            return 'http.StatusUpgradeRequired';
+            return "http.StatusUpgradeRequired";
         case 428:
-            return 'http.StatusPreconditionRequired';
+            return "http.StatusPreconditionRequired";
         case 429:
-            return 'http.StatusTooManyRequests';
+            return "http.StatusTooManyRequests";
         case 431:
-            return 'http.StatusRequestHeaderFieldsTooLarge';
+            return "http.StatusRequestHeaderFieldsTooLarge";
         case 451:
-            return 'http.StatusUnavailableForLegalReasons';
+            return "http.StatusUnavailableForLegalReasons";
         // 5xx
         case 500:
-            return 'http.StatusInternalServerError';
+            return "http.StatusInternalServerError";
         case 501:
-            return 'http.StatusNotImplemented';
+            return "http.StatusNotImplemented";
         case 502:
-            return 'http.StatusBadGateway';
+            return "http.StatusBadGateway";
         case 503:
-            return 'http.StatusServiceUnavailable';
+            return "http.StatusServiceUnavailable";
         case 504:
-            return 'http.StatusGatewayTimeout ';
+            return "http.StatusGatewayTimeout ";
         case 505:
-            return 'http.StatusHTTPVersionNotSupported';
+            return "http.StatusHTTPVersionNotSupported";
         case 506:
-            return 'http.StatusVariantAlsoNegotiates';
+            return "http.StatusVariantAlsoNegotiates";
         case 507:
-            return 'http.StatusInsufficientStorage';
+            return "http.StatusInsufficientStorage";
         case 508:
-            return 'http.StatusLoopDetected';
+            return "http.StatusLoopDetected";
         case 510:
-            return 'http.StatusNotExtended';
+            return "http.StatusNotExtended";
         case 511:
-            return 'http.StatusNetworkAuthenticationRequired';
+            return "http.StatusNetworkAuthenticationRequired";
         default:
-            throw new CodegenError('InternalError', `unhandled status code ${statusCode}`);
+            throw new CodegenError("InternalError", `unhandled status code ${statusCode}`);
     }
 }
 export function formatCommentAsBulletItem(prefix, docs) {
@@ -589,24 +593,24 @@ export function formatCommentAsBulletItem(prefix, docs) {
     //
     // some comment first line
     // and it finishes here.
-    let description = formatDocCommentWithPrefix(prefix, docs);
+    const description = formatDocCommentWithPrefix(prefix, docs);
     if (description.length === 0) {
-        return '';
+        return "";
     }
     // transform the above to look like this:
     //
     //   - some comment first line
     //     and it finishes here.
-    const chunks = description.split('\n');
+    const chunks = description.split("\n");
     for (let i = 0; i < chunks.length; ++i) {
         if (i === 0) {
-            chunks[i] = chunks[i].replace('// ', '//   - ');
+            chunks[i] = chunks[i].replace("// ", "//   - ");
         }
         else {
-            chunks[i] = chunks[i].replace('// ', '//     ');
+            chunks[i] = chunks[i].replace("// ", "//     ");
         }
     }
-    return chunks.join('\n');
+    return chunks.join("\n");
 }
 // conditionally returns a doc comment on an entity that requires a prefix.
 // e.g.:
@@ -615,22 +619,22 @@ export function formatCommentAsBulletItem(prefix, docs) {
 // {docs.description}
 export function formatDocCommentWithPrefix(prefix, docs) {
     if (!docs.summary && !docs.description) {
-        return '';
+        return "";
     }
-    let docComment = '';
+    let docComment = "";
     if (docs.summary) {
-        docComment = `${comment(`${prefix} - ${docs.summary}`, '//', undefined, commentLength)}\n`;
+        docComment = `${comment(`${prefix} - ${docs.summary}`, "//", undefined, commentLength)}\n`;
     }
     if (docs.description) {
         let description = docs.description;
         if (docs.summary) {
-            docComment += '//\n';
+            docComment += "//\n";
         }
         else {
             // only apply the prefix to the description if there was no summary
             description = `${prefix} - ${description}`;
         }
-        docComment += `${comment(`${description}`, '//', undefined, commentLength)}\n`;
+        docComment += `${comment(`${description}`, "//", undefined, commentLength)}\n`;
     }
     return docComment;
 }
@@ -640,41 +644,41 @@ export function formatDocCommentWithPrefix(prefix, docs) {
 // {docs.description}
 export function formatDocComment(docs) {
     if (!docs.summary && !docs.description) {
-        return '';
+        return "";
     }
-    let docComment = '';
+    let docComment = "";
     if (docs.summary) {
-        docComment = `${comment(docs.summary, '//', undefined, commentLength)}\n`;
+        docComment = `${comment(docs.summary, "//", undefined, commentLength)}\n`;
     }
     if (docs.description) {
         if (docs.summary) {
-            docComment += '//\n';
+            docComment += "//\n";
         }
-        docComment += `${comment(docs.description, '//', undefined, commentLength)}\n`;
+        docComment += `${comment(docs.description, "//", undefined, commentLength)}\n`;
     }
     return docComment;
 }
 export function getBitSizeForNumber(intSize) {
     switch (intSize) {
-        case 'int8':
-            return '8';
-        case 'int16':
-            return '16';
-        case 'int32':
-        case 'float32':
-            return '32';
-        case 'int64':
-        case 'float64':
-            return '64';
+        case "int8":
+            return "8";
+        case "int16":
+            return "16";
+        case "int32":
+        case "float32":
+            return "32";
+        case "int64":
+        case "float64":
+            return "64";
     }
 }
 // returns the underlying map/slice element/value type
 // if item isn't a map or slice, item is returned
 export function recursiveUnwrapMapSlice(item) {
     switch (item.kind) {
-        case 'map':
+        case "map":
             return recursiveUnwrapMapSlice(item.valueType);
-        case 'slice':
+        case "slice":
             return recursiveUnwrapMapSlice(item.elementType);
         default:
             return item;
@@ -687,7 +691,7 @@ export function recursiveUnwrapMapSlice(item) {
  * @returns a * or the empty string
  */
 export function star(byValue) {
-    return byValue ? '' : '*';
+    return byValue ? "" : "*";
 }
 /**
  * returns the zero-value expression for the specific parameter
@@ -700,14 +704,14 @@ export function zeroValue(param) {
     // them optional, the azcore.ClientOptions.APIVersion field isn't pointer-to-type.
     if (go.isRequiredParameter(param.style) || go.isAPIVersionParameter(param)) {
         switch (param.type.kind) {
-            case 'string':
+            case "string":
                 return `""`;
             default:
-                throw new CodegenError('InternalError', `unhandled zero-value kind ${param.type.kind}`);
+                throw new CodegenError("InternalError", `unhandled zero-value kind ${param.type.kind}`);
         }
     }
     // optional params are pointer-to-type
-    return 'nil';
+    return "nil";
 }
 // used by getSerDeFormat to cache results
 const serDeFormatCache = new Map();
@@ -720,20 +724,20 @@ export function getSerDeFormat(model, pkg) {
     }
     // for model-only builds we assume the format to be JSON
     if (pkg.clients.length === 0) {
-        return 'JSON';
+        return "JSON";
     }
     // recursively walks the fields in model, updating serDeFormatCache with the model name and specified format
     const recursiveWalkModelFields = function (type, serDeFormat) {
         type = recursiveUnwrapMapSlice(type);
         switch (type.kind) {
-            case 'interface':
+            case "interface":
                 recursiveWalkModelFields(type.rootType, serDeFormat);
                 for (const possibleType of type.possibleTypes) {
                     recursiveWalkModelFields(possibleType, serDeFormat);
                 }
                 break;
-            case 'model':
-            case 'polymorphicModel':
+            case "model":
+            case "polymorphicModel":
                 if (serDeFormatCache.has(type.name)) {
                     // we've already processed this type, don't do it again
                     return;
@@ -750,29 +754,30 @@ export function getSerDeFormat(model, pkg) {
     for (const client of pkg.clients) {
         for (const method of client.methods) {
             for (const param of method.parameters) {
-                if (param.kind !== 'bodyParam' || (param.bodyFormat !== 'JSON' && param.bodyFormat !== 'XML')) {
+                if (param.kind !== "bodyParam" ||
+                    (param.bodyFormat !== "JSON" && param.bodyFormat !== "XML")) {
                     continue;
                 }
                 recursiveWalkModelFields(param.type, param.bodyFormat);
             }
             const resultType = method.returns.result;
             switch (resultType?.kind) {
-                case 'anyResult':
-                    if (resultType.format === 'JSON' || resultType.format === 'XML') {
+                case "anyResult":
+                    if (resultType.format === "JSON" || resultType.format === "XML") {
                         for (const type of Object.values(resultType.httpStatusCodeType)) {
                             recursiveWalkModelFields(type, resultType.format);
                         }
                     }
                     break;
-                case 'modelResult':
+                case "modelResult":
                     recursiveWalkModelFields(resultType.modelType, resultType.format);
                     break;
-                case 'monomorphicResult':
-                    if (resultType.format === 'JSON' || resultType.format === 'XML') {
+                case "monomorphicResult":
+                    if (resultType.format === "JSON" || resultType.format === "XML") {
                         recursiveWalkModelFields(resultType.monomorphicType, resultType.format);
                     }
                     break;
-                case 'polymorphicResult':
+                case "polymorphicResult":
                     recursiveWalkModelFields(resultType.interface, resultType.format);
                     break;
             }
@@ -786,7 +791,7 @@ export function getSerDeFormat(model, pkg) {
         //
         // while the former is possible, the latter has the potential to be real.
         // regardless of the cause, we will just assume the format to be JSON.
-        serDeFormat = 'JSON';
+        serDeFormat = "JSON";
     }
     return serDeFormat;
 }
@@ -794,7 +799,7 @@ export function getSerDeFormat(model, pkg) {
 export function getAllClientParameters(pkg, target) {
     const allClientParams = new Array();
     for (const client of pkg.clients) {
-        if (client.instance?.kind === 'constructable') {
+        if (client.instance?.kind === "constructable") {
             for (const ctor of client.instance.constructors) {
                 for (const ctorParam of ctor.parameters) {
                     if (go.isAPIVersionParameter(ctorParam)) {
@@ -815,12 +820,12 @@ export function getCommonClientParameters(pkg, target) {
     const paramCount = new Map();
     let numClients = 0; // track client count since we might skip some
     for (const client of pkg.clients) {
-        // special cases: some ARM clients always don't contain any parameters (OperationsClient will be depracated in the future)
-        if (target === 'azure-arm' && client.name.match(/^OperationsClient$/)) {
+        // special cases: some ARM clients always don't contain any parameters (OperationsClient will be deprecated in the future)
+        if (target === "azure-arm" && client.name.match(/^OperationsClient$/)) {
             continue;
         }
         ++numClients;
-        if (client.instance?.kind === 'constructable') {
+        if (client.instance?.kind === "constructable") {
             for (const ctor of client.instance.constructors) {
                 for (const ctorParam of ctor.parameters) {
                     if (go.isAPIVersionParameter(ctorParam)) {
@@ -863,30 +868,30 @@ export function getMethodParamGroups(method) {
     const unencodedQueryParams = new Array();
     for (const param of method.parameters) {
         switch (param.kind) {
-            case 'bodyParam':
+            case "bodyParam":
                 bodyParam = param;
                 break;
-            case 'formBodyCollectionParam':
-            case 'formBodyScalarParam':
+            case "formBodyCollectionParam":
+            case "formBodyScalarParam":
                 formBodyParams.push(param);
                 break;
-            case 'headerCollectionParam':
-            case 'headerMapParam':
-            case 'headerScalarParam':
+            case "headerCollectionParam":
+            case "headerMapParam":
+            case "headerScalarParam":
                 headerParams.push(param);
                 break;
-            case 'multipartFormBodyParam':
+            case "multipartFormBodyParam":
                 multipartBodyParams.push(param);
                 break;
-            case 'partialBodyParam':
+            case "partialBodyParam":
                 partialBodyParams.push(param);
                 break;
-            case 'pathCollectionParam':
-            case 'pathScalarParam':
+            case "pathCollectionParam":
+            case "pathScalarParam":
                 pathParams.push(param);
                 break;
-            case 'queryCollectionParam':
-            case 'queryScalarParam':
+            case "queryCollectionParam":
+            case "queryScalarParam":
                 if (param.isEncoded) {
                     encodedQueryParams.push(param);
                 }
@@ -925,9 +930,9 @@ export class Indentation {
      * @returns a string with the current indentation level
      */
     get() {
-        let indent = '';
+        let indent = "";
         for (let i = 0; i < this.level; ++i) {
-            indent += '\t';
+            indent += "\t";
         }
         return indent;
     }
@@ -948,7 +953,7 @@ export class Indentation {
     pop() {
         --this.level;
         if (this.level < 0) {
-            throw new CodegenError('InternalError', 'indentation stack underflow');
+            throw new CodegenError("InternalError", "indentation stack underflow");
         }
         return this;
     }
@@ -966,7 +971,7 @@ export function buildIfBlock(indent, ifBlock, elseBlock) {
     body += ifBlock.body(indent.push());
     body += `${indent.pop().get()}}`;
     if (elseBlock) {
-        body += ' else {\n';
+        body += " else {\n";
         body += elseBlock.body(indent.push());
         body += `${indent.pop().get()}}`;
     }
@@ -982,7 +987,7 @@ export function buildIfBlock(indent, ifBlock, elseBlock) {
  */
 export function buildErrCheck(indent, errVar, returns) {
     let body = `if ${errVar} != nil {\n`;
-    body += `${indent.push().get()}return ${returns ? `${returns}, ` : ''}${errVar}\n`;
+    body += `${indent.push().get()}return ${returns ? `${returns}, ` : ""}${errVar}\n`;
     body += `${indent.pop().get()}}`;
     return body;
 }
@@ -994,7 +999,7 @@ export function buildErrCheck(indent, errVar, returns) {
  * @param scope
  */
 export function splitScope(scope) {
-    const scopeSplit = scope.lastIndexOf('/');
+    const scopeSplit = scope.lastIndexOf("/");
     return {
         audience: scope.substring(0, scopeSplit),
         scope: scope.substring(scopeSplit),
@@ -1026,41 +1031,60 @@ export function clientHasNoExportedMethods(client) {
  * @returns the complete path to the next link
  */
 export function buildNextLinkPath(strategy) {
-    return strategy.nextLinkPath.map((segment) => segment.name).join('.');
+    return strategy.nextLinkPath.map((segment) => segment.name).join(".");
 }
 // the following was copied from @azure-tools/codegen as it's being deprecated
 const ones = [
-    '',
-    'one',
-    'two',
-    'three',
-    'four',
-    'five',
-    'six',
-    'seven',
-    'eight',
-    'nine',
-    'ten',
-    'eleven',
-    'twelve',
-    'thirteen',
-    'fourteen',
-    'fifteen',
-    'sixteen',
-    'seventeen',
-    'eighteen',
-    'nineteen',
+    "",
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten",
+    "eleven",
+    "twelve",
+    "thirteen",
+    "fourteen",
+    "fifteen",
+    "sixteen",
+    "seventeen",
+    "eighteen",
+    "nineteen",
+];
+const tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];
+const magvalues = [
+    10 ** 3,
+    10 ** 6,
+    10 ** 9,
+    10 ** 12,
+    10 ** 15,
+    10 ** 18,
+    10 ** 21,
+    10 ** 24,
+    10 ** 27,
+];
+const magnitude = [
+    "thousand",
+    "million",
+    "billion",
+    "trillion",
+    "quadrillion",
+    "quintillion",
+    "septillion",
+    "octillion",
 ];
-const tens = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];
-const magvalues = [10 ** 3, 10 ** 6, 10 ** 9, 10 ** 12, 10 ** 15, 10 ** 18, 10 ** 21, 10 ** 24, 10 ** 27];
-const magnitude = ['thousand', 'million', 'billion', 'trillion', 'quadrillion', 'quintillion', 'septillion', 'octillion'];
 function* convert(num) {
     if (!num) {
-        yield 'zero';
+        yield "zero";
         return;
     }
     if (num > 1e30) {
-        yield 'lots';
+        yield "lots";
         return;
     }
     if (num > 999) {
@@ -1075,7 +1099,7 @@ function* convert(num) {
     }
     if (num > 99) {
         yield ones[Math.floor(num / 100)];
-        yield 'hundred';
+        yield "hundred";
         num %= 100;
     }
     if (num > 19) {
@@ -1091,9 +1115,9 @@ function deconstruct(identifier) {
         return identifier.flatMap(deconstruct);
     }
     return `${identifier}`
-        .replace(/([a-z]+)([A-Z])/g, '$1 $2')
-        .replace(/(\d+)([a-z|A-Z]+)/g, '$1 $2')
-        .replace(/\b([A-Z]+)([A-Z])([a-z])/, '$1 $2$3')
+        .replace(/([a-z]+)([A-Z])/g, "$1 $2")
+        .replace(/(\d+)([a-z|A-Z]+)/g, "$1 $2")
+        .replace(/\b([A-Z]+)([A-Z])([a-z])/, "$1 $2$3")
         .split(/[\W|_]+/)
         .map((each) => each.toLowerCase());
 }
@@ -1104,12 +1128,12 @@ function fixLeadingNumber(identifier) {
     return identifier;
 }
 export function camelCase(identifier) {
-    if (typeof identifier === 'string') {
+    if (typeof identifier === "string") {
         return camelCase(fixLeadingNumber(deconstruct(identifier)));
     }
     switch (identifier.length) {
         case 0:
-            return '';
+            return "";
         case 1:
             return naming.uncapitalize(identifier[0]);
     }
@@ -1117,32 +1141,32 @@ export function camelCase(identifier) {
 }
 export function pascalCase(identifier) {
     return identifier === undefined
-        ? ''
-        : typeof identifier === 'string'
+        ? ""
+        : typeof identifier === "string"
             ? pascalCase(fixLeadingNumber(deconstruct(identifier)))
-            : identifier.map((each) => naming.capitalize(each)).join('');
+            : identifier.map((each) => naming.capitalize(each)).join("");
 }
 function indent(content, factor = 1) {
-    const i = '\t'.repeat(factor);
-    content = i + content.trim().replace(/\r\n/g, '\n');
+    const i = "\t".repeat(factor);
+    content = i + content.trim().replace(/\r\n/g, "\n");
     return content.split(/\n/g).join(`\n${i}`);
 }
-const lineCommentPrefix = '//';
+const lineCommentPrefix = "//";
 export function comment(content, prefix = lineCommentPrefix, factor = 0, maxLength = 120) {
     const result = new Array();
-    let line = '';
+    let line = "";
     prefix = indent(prefix, factor);
     content = content.trim();
     if (content) {
-        for (const word of content.replace(/\n+/g, ' » ').split(/\s+/g)) {
-            if (word === '»') {
+        for (const word of content.replace(/\n+/g, " » ").split(/\s+/g)) {
+            if (word === "»") {
                 result.push(line);
                 line = prefix;
                 continue;
             }
             if (maxLength < line.length) {
                 result.push(line);
-                line = '';
+                line = "";
             }
             if (!line) {
                 line = prefix;
@@ -1152,9 +1176,9 @@ export function comment(content, prefix = lineCommentPrefix, factor = 0, maxLeng
         if (line) {
             result.push(line);
         }
-        return result.join('\n');
+        return result.join("\n");
     }
-    return '';
+    return "";
 }
 // end ports from @azure-tools/codegen
 //# sourceMappingURL=helpers.js.map