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

package/dist/{typespec-go/src → src}/tcgcadapter/clients.js

@@ -2,12 +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 tcgc from '@azure-tools/typespec-client-generator-core';
-import { NoTarget } from '@typespec/compiler';
-import * as go from '../../../codemodel.go/src/index.js';
-import { capitalize, createOptionsTypeDescription, createResponseEnvelopeDescription, ensureNameCase, getEscapedReservedName, uncapitalize, } from '../../../naming.go/src/naming.js';
-import { AdapterError } from './errors.js';
-import * as helpers from './helpers.js';
+/* eslint-disable @typescript-eslint/no-deprecated -- uses TCGC APIs marked deprecated (correspondingMethodParams). */
+import * as tcgc from "@azure-tools/typespec-client-generator-core";
+import { NoTarget } from "@typespec/compiler";
+import * as go from "../codemodel/index.js";
+import { capitalize, createOptionsTypeDescription, createResponseEnvelopeDescription, ensureNameCase, getEscapedReservedName, uncapitalize, } from "../naming/naming.js";
+import { AdapterError } from "./errors.js";
+import * as helpers from "./helpers.js";
 /**
  * used to convert tcgc clients and their methods to Go code model types
  */
@@ -30,8 +31,9 @@ export class ClientAdapter {
      * this includes parameter groups/options types and response envelopes.
      */
     adaptClients() {
-        if (this.ta.ctx.emitContext.options['single-client'] && this.ta.ctx.sdkPackage.clients.length > 1) {
-            throw new AdapterError('InvalidArgument', 'single-client cannot be enabled when there are multiple clients');
+        if (this.ta.ctx.emitContext.options["single-client"] &&
+            this.ta.ctx.sdkPackage.clients.length > 1) {
+            throw new AdapterError("InvalidArgument", "single-client cannot be enabled when there are multiple clients");
         }
         for (const sdkClient of this.ta.ctx.sdkPackage.clients) {
             // start with instantiable clients and recursively work down
@@ -47,13 +49,14 @@ export class ClientAdapter {
         }
     }
     recursiveAdaptClient(sdkClient, parent) {
-        if (sdkClient.methods.length === 0 && (sdkClient.children === undefined || sdkClient.children.length === 0)) {
+        if (sdkClient.methods.length === 0 &&
+            (sdkClient.children === undefined || sdkClient.children.length === 0)) {
             // skip generating empty clients
             return undefined;
         }
         let clientName = helpers.getEffectiveName(sdkClient);
         // to keep compat with existing ARM packages, don't use hierarchically named clients
-        if (parent && this.ta.codeModel.type !== 'azure-arm') {
+        if (parent && this.ta.codeModel.type !== "azure-arm") {
             // for hierarchical clients, the child client names are built
             // from the parent client name. this is because tsp allows subclients
             // with the same name. consider the following example.
@@ -104,26 +107,29 @@ export class ClientAdapter {
             AuthTypes[AuthTypes["WithAuth"] = 2] = "WithAuth";
         })(AuthTypes || (AuthTypes = {}));
         let authType = AuthTypes.Default;
-        if (!this.ta.codeModel.options.omitConstructors && this.ta.codeModel.root.kind === 'containingModule') {
+        if (!this.ta.codeModel.options.omitConstructors &&
+            this.ta.codeModel.root.kind === "containingModule") {
             // emit a diagnostic indicating that no ctors will be emitted due to containing-module.
             this.ta.ctx.program.reportDiagnostic({
-                code: 'UnsupportedConfiguration',
-                severity: 'warning',
-                message: 'cannot emit client constructors when containing-module is set',
+                code: "UnsupportedConfiguration",
+                severity: "warning",
+                message: "cannot emit client constructors when containing-module is set",
                 target: sdkClient.__raw.type ?? NoTarget,
             });
         }
-        if ((this.ta.codeModel.options.omitConstructors || this.ta.codeModel.root.kind === 'containingModule') && this.ta.codeModel.options.generateExamples) {
+        if ((this.ta.codeModel.options.omitConstructors ||
+            this.ta.codeModel.root.kind === "containingModule") &&
+            this.ta.codeModel.options.generateExamples) {
             // emit a diagnostic indicating that no ctors will be emitted due to containing-module.
             this.ta.ctx.program.reportDiagnostic({
-                code: 'UnsupportedConfiguration',
-                severity: 'warning',
-                message: 'cannot emit examples when containing-module or omit-constructors is set',
+                code: "UnsupportedConfiguration",
+                severity: "warning",
+                message: "cannot emit examples when containing-module or omit-constructors is set",
                 target: sdkClient.__raw.type ?? NoTarget,
             });
         }
         /**
-         * processes a credendial, potentially adding its supporting client constructor
+         * processes a credential, potentially adding its supporting client constructor
          *
          * @param goClient the Go client for which to add the constructor
          * @param constructable the constructable for the current Go client
@@ -132,16 +138,16 @@ export class ClientAdapter {
          */
         const processCredential = (goClient, constructable, cred) => {
             switch (cred.type) {
-                case 'noAuth':
+                case "noAuth":
                     return AuthTypes.NoAuth;
-                case 'oauth2': {
+                case "oauth2": {
                     constructable.constructors.push(this.createTokenCredentialCtor(goClient, cred));
                     return AuthTypes.WithAuth;
                 }
                 default:
                     this.ta.ctx.program.reportDiagnostic({
-                        code: 'UnsupportedAuthenticationScheme',
-                        severity: 'warning',
+                        code: "UnsupportedAuthenticationScheme",
+                        severity: "warning",
                         message: `unsupported authentication scheme ${cred.type} will be omitted`,
                         target: sdkClient.__raw.type ?? NoTarget,
                     });
@@ -151,7 +157,7 @@ export class ClientAdapter {
                     return AuthTypes.WithAuth;
             }
         };
-        if (this.ta.codeModel.type === 'azure-arm') {
+        if (this.ta.codeModel.type === "azure-arm") {
             // to keep compat with pre-tsp codegen we
             // treat all ARM clients as instantiable.
             sdkClient.clientInitialization.initializedBy |= tcgc.InitializedByFlags.Individually;
@@ -163,20 +169,21 @@ export class ClientAdapter {
             // an existing module. this is because the constructor(s) require
             // the module name and version info, and we can't make any
             // assumptions about the names/location.
-            if (!this.ta.codeModel.options.omitConstructors && this.ta.codeModel.root.kind !== 'containingModule') {
+            if (!this.ta.codeModel.options.omitConstructors &&
+                this.ta.codeModel.root.kind !== "containingModule") {
                 constructable = new go.Constructable(go.newClientOptions(this.ta.getPkg(), this.ta.codeModel.type, clientName));
             }
             for (const param of sdkClient.clientInitialization.parameters) {
                 switch (param.kind) {
-                    case 'credential':
+                    case "credential":
                         if (!constructable) {
                             continue;
                         }
                         switch (param.type.kind) {
-                            case 'credential':
+                            case "credential":
                                 authType |= processCredential(goClient, constructable, param.type.scheme);
                                 break;
-                            case 'union': {
+                            case "union": {
                                 const variantKinds = new Array();
                                 for (const variantType of param.type.variantTypes) {
                                     variantKinds.push(variantType.scheme.type);
@@ -187,25 +194,25 @@ export class ClientAdapter {
                                 }
                                 // no supported credential types were specified
                                 if (authType === AuthTypes.Default) {
-                                    throw new AdapterError('UnsupportedTsp', `credential scheme types ${variantKinds.join()} NYI`, param.__raw?.node);
+                                    throw new AdapterError("UnsupportedTsp", `credential scheme types ${variantKinds.join()} NYI`, param.__raw?.node);
                                 }
                                 continue;
                             }
                         }
                         break;
-                    case 'endpoint': {
-                        if (this.ta.codeModel.type === 'azure-arm') {
+                    case "endpoint": {
+                        if (this.ta.codeModel.type === "azure-arm") {
                             // for ARM, the endpoint is handled via the azcore/arm.Client
                             // so we don't need to adapt it.
                             continue;
                         }
                         let endpointType;
                         switch (param.type.kind) {
-                            case 'endpoint':
+                            case "endpoint":
                                 // single endpoint without any supplemental path
                                 endpointType = param.type;
                                 break;
-                            case 'union':
+                            case "union":
                                 // this is a union of endpoints. the first is the endpoint plus
                                 // the supplemental path. the second is a "raw" endpoint which
                                 // requires the caller to provide the complete endpoint. we only
@@ -233,7 +240,7 @@ export class ClientAdapter {
                                     // there's either a suffix on the endpoint param, more template arguments, or both.
                                     // either way we need to create supplemental info on the constructable.
                                     // strip off the first segment which corresponds to the endpoint param as it's not needed.
-                                    const serverUrl = endpointType.serverUrl.replace(`{${templateArg.serializedName}}/`, '');
+                                    const serverUrl = endpointType.serverUrl.replace(`{${templateArg.serializedName}}/`, "");
                                     constructable.endpoint.supplemental = new go.SupplementalEndpoint(serverUrl);
                                 }
                                 continue;
@@ -245,18 +252,18 @@ export class ClientAdapter {
                                 adaptedParam.isApiVersion = templateArg.isApiVersionParam;
                                 constructable.endpoint?.supplemental?.parameters.push(adaptedParam);
                                 if (!go.isRequiredParameter(adaptedParam.style)) {
-                                    if (constructable.options.kind === 'clientOptions') {
+                                    if (constructable.options.kind === "clientOptions") {
                                         constructable.options.parameters.push(adaptedParam);
                                     }
                                     else {
-                                        throw new AdapterError('UnsupportedTsp', 'optional client parameters for ARM is not supported', templateArg.__raw?.node);
+                                        throw new AdapterError("UnsupportedTsp", "optional client parameters for ARM is not supported", templateArg.__raw?.node);
                                     }
                                 }
                             }
                         }
                         break;
                     }
-                    case 'method':
+                    case "method":
                         // some client params, notably api-version, can be explicitly
                         // defined in the operation signature:
                         // e.g. op withQueryApiVersion(@query("api-version") apiVersion: string)
@@ -288,7 +295,7 @@ export class ClientAdapter {
             // this is a sub-client. it will share the client/host params of the parent.
             // NOTE: we must propagate parent params before a potential recursive call
             // to create a child client that will need to inherit our client params.
-            if (parent.instance?.kind === 'templatedHost') {
+            if (parent.instance?.kind === "templatedHost") {
                 goClient.instance = parent.instance;
             }
             // make a copy of the client params. this is to prevent
@@ -297,14 +304,14 @@ export class ClientAdapter {
             goClient.parameters = new Array(...parent.parameters);
         }
         else {
-            throw new AdapterError('InternalError', `uninstantiable client ${sdkClient.name} has no parent`);
+            throw new AdapterError("InternalError", `uninstantiable client ${sdkClient.name} has no parent`);
         }
         if (sdkClient.children && sdkClient.children.length > 0) {
             for (const child of sdkClient.children) {
                 const subClient = this.recursiveAdaptClient(child, goClient);
                 // for ARM we skip adding client accessors as we use a customized
                 // client factory instead of hierarchical clients.
-                if (subClient && this.ta.codeModel.type !== 'azure-arm') {
+                if (subClient && this.ta.codeModel.type !== "azure-arm") {
                     this.adaptClientAccessor(sdkClient, child, goClient, subClient);
                 }
             }
@@ -312,7 +319,9 @@ export class ClientAdapter {
         for (const sdkMethod of sdkClient.methods) {
             this.adaptMethod(sdkMethod, goClient);
         }
-        if (this.ta.codeModel.type === 'azure-arm' && goClient.clientAccessors.length === 0 && goClient.methods.length === 0) {
+        if (this.ta.codeModel.type === "azure-arm" &&
+            goClient.clientAccessors.length === 0 &&
+            goClient.methods.length === 0) {
             // this is the service client. to keep compat with existing
             // ARM SDKs we skip adding it to the code model in favor of
             // the synthesized client factory.
@@ -331,16 +340,16 @@ export class ClientAdapter {
      */
     createTokenCredentialCtor(goClient, cred) {
         if (cred.flows.length === 0) {
-            throw new AdapterError('InternalError', `no flows defined for credential type ${cred.type}`, cred.model);
+            throw new AdapterError("InternalError", `no flows defined for credential type ${cred.type}`, cred.model);
         }
         else if (cred.flows[0].scopes.length === 0) {
-            throw new AdapterError('InternalError', `no scopes defined for credential type ${cred.type}`, cred.model);
+            throw new AdapterError("InternalError", `no scopes defined for credential type ${cred.type}`, cred.model);
         }
         else if (cred.flows[0].scopes.length > 1) {
-            throw new AdapterError('InternalError', `too many scopes defined for credential type ${cred.type}`, cred.model);
+            throw new AdapterError("InternalError", `too many scopes defined for credential type ${cred.type}`, cred.model);
         }
         const ctor = new go.Constructor(this.ta.getPkg(), `New${goClient.name}`);
-        ctor.parameters.push(new go.ClientCredentialParameter('credential', new go.TokenCredential(cred.flows[0].scopes.map((each) => each.value))));
+        ctor.parameters.push(new go.ClientCredentialParameter("credential", new go.TokenCredential(cred.flows[0].scopes.map((each) => each.value))));
         return ctor;
     }
     /**
@@ -368,7 +377,7 @@ export class ClientAdapter {
             if (existsOnParent) {
                 continue;
             }
-            const adaptedParam = new go.Parameter(getEscapedReservedName(helpers.getEffectiveName(param, true), 'Param'), this.ta.getWireType(param.type, true, true), true);
+            const adaptedParam = new go.Parameter(getEscapedReservedName(helpers.getEffectiveName(param, true), "Param"), this.ta.getWireType(param.type, true, true), true);
             adaptedParam.docs.summary = param.summary;
             adaptedParam.docs.description = param.doc;
             clientAccessor.parameters.push(adaptedParam);
@@ -391,23 +400,23 @@ export class ClientAdapter {
             paramType = this.ta.getWireType(sdkParam.type, true, false);
         }
         if (go.isURIParameterType(paramType)) {
-            const style = forceRequired ? 'required' : this.adaptParameterStyle(sdkParam);
-            if (this.ta.codeModel.type === 'azure-arm' && !go.isRequiredParameter(style)) {
-                throw new AdapterError('UnsupportedTsp', 'optional client parameters for ARM is not supported', sdkParam.__raw?.node);
+            const style = forceRequired ? "required" : this.adaptParameterStyle(sdkParam);
+            if (this.ta.codeModel.type === "azure-arm" && !go.isRequiredParameter(style)) {
+                throw new AdapterError("UnsupportedTsp", "optional client parameters for ARM is not supported", sdkParam.__raw?.node);
             }
-            const uriParam = new go.URIParameter(sdkParam.name, sdkParam.serializedName, paramType, style, helpers.isTypePassedByValue(sdkParam.type) || !sdkParam.optional, 'client');
+            const uriParam = new go.URIParameter(sdkParam.name, sdkParam.serializedName, paramType, style, helpers.isTypePassedByValue(sdkParam.type) || !sdkParam.optional, "client");
             uriParam.docs.summary = sdkParam.summary;
             uriParam.docs.description = sdkParam.doc;
             uriParam.isApiVersion = sdkParam.isApiVersionParam;
             return uriParam;
         }
-        throw new AdapterError('UnsupportedTsp', `unsupported URI parameter type ${paramType.kind}`, sdkParam.__raw?.node);
+        throw new AdapterError("UnsupportedTsp", `unsupported URI parameter type ${paramType.kind}`, sdkParam.__raw?.node);
     }
     adaptMethod(sdkMethod, goClient) {
         const opName = helpers.getEffectiveName(sdkMethod, true);
-        const createReqName = helpers.getEffectiveName(sdkMethod, true, 'CreateRequest');
-        const handleRespName = helpers.getEffectiveName(sdkMethod, true, 'HandleResponse');
-        const naming = new go.MethodNaming(getEscapedReservedName(opName, 'Operation'), createReqName, handleRespName);
+        const createReqName = helpers.getEffectiveName(sdkMethod, true, "CreateRequest");
+        const handleRespName = helpers.getEffectiveName(sdkMethod, true, "HandleResponse");
+        const naming = new go.MethodNaming(getEscapedReservedName(opName, "Operation"), createReqName, handleRespName);
         const getStatusCodes = function (httpOp) {
             const statusCodes = new Array();
             for (const response of httpOp.responses) {
@@ -424,38 +433,38 @@ export class ClientAdapter {
             return statusCodes;
         };
         let methodName = helpers.getEffectiveName(sdkMethod);
-        if (sdkMethod.access === 'internal') {
+        if (sdkMethod.access === "internal") {
             methodName = uncapitalize(methodName);
-            if (sdkMethod.kind === 'basic') {
+            if (sdkMethod.kind === "basic") {
                 // we add internal to the extra list so we don't end up with a method named "internal"
                 // which will collide with an unexported field with the same name. we don't need to
                 // do this for pagers/pollers as those methods get extra naming.
-                methodName = getEscapedReservedName(methodName, 'Method', ['internal']);
+                methodName = getEscapedReservedName(methodName, "Method", ["internal"]);
             }
         }
         const setLROInfo = function (goMethod, sdkMethod) {
-            const lroOptions = helpers.hasDecorator('@useFinalStateVia', sdkMethod.decorators);
+            const lroOptions = helpers.hasDecorator("@useFinalStateVia", sdkMethod.decorators);
             if (lroOptions) {
-                goMethod.finalStateVia = lroOptions['finalState'];
+                goMethod.finalStateVia = lroOptions["finalState"];
             }
             if (sdkMethod.lroMetadata.finalResponse?.resultSegments) {
-                // 'resultSegments' is designed for furture extensibility, currently only has one segment
+                // 'resultSegments' is designed for future extensibility, currently only has one segment
                 goMethod.operationLocationResultPath = sdkMethod.lroMetadata.finalResponse.resultSegments
                     .map((segment) => {
                     return segment.serializationOptions.json?.name;
                 })
-                    .join('.');
+                    .join(".");
             }
         };
         const setPageableInfo = (goMethod, sdkMethod) => {
             return (paramsMap, respHeadersMap) => {
                 if (sdkMethod.pagingMetadata.nextLinkVerb) {
                     switch (sdkMethod.pagingMetadata.nextLinkVerb) {
-                        case 'GET':
+                        case "GET":
                             // we default to GET in the ctor for PageableMethod
                             break;
-                        case 'POST':
-                            goMethod.nextLinkVerb = 'post';
+                        case "POST":
+                            goMethod.nextLinkVerb = "post";
                             break;
                         default:
                             sdkMethod.pagingMetadata.nextLinkVerb;
@@ -468,28 +477,29 @@ export class ClientAdapter {
         let method;
         let applyPageableInfo;
         switch (sdkMethod.kind) {
-            case 'basic':
+            case "basic":
                 method = new go.SyncMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
                 break;
-            case 'paging':
-                if (sdkMethod.pagingMetadata.nextLinkReInjectedParametersSegments !== undefined && sdkMethod.pagingMetadata.nextLinkReInjectedParametersSegments.length > 0) {
-                    throw new AdapterError('UnsupportedTsp', `paging with re-injected parameters is not supported`, sdkMethod.__raw?.node);
+            case "paging":
+                if (sdkMethod.pagingMetadata.nextLinkReInjectedParametersSegments !== undefined &&
+                    sdkMethod.pagingMetadata.nextLinkReInjectedParametersSegments.length > 0) {
+                    throw new AdapterError("UnsupportedTsp", `paging with re-injected parameters is not supported`, sdkMethod.__raw?.node);
                 }
                 method = new go.PageableMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
                 applyPageableInfo = setPageableInfo(method, sdkMethod);
                 break;
-            case 'lro':
+            case "lro":
                 method = new go.LROMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
                 setLROInfo(method, sdkMethod);
                 break;
-            case 'lropaging':
+            case "lropaging":
                 method = new go.LROPageableMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
                 setLROInfo(method, sdkMethod);
                 applyPageableInfo = setPageableInfo(method, sdkMethod);
                 break;
             default:
                 sdkMethod;
-                throw new AdapterError('UnsupportedTsp', 'unreachable');
+                throw new AdapterError("UnsupportedTsp", "unreachable");
         }
         method.docs.summary = sdkMethod.summary;
         method.docs.description = sdkMethod.doc;
@@ -510,58 +520,59 @@ export class ClientAdapter {
             // build the field path for the next link segments
             const nextLinkPath = new Array();
             for (const segment of segments) {
-                if (segment.kind !== 'property') {
-                    throw new AdapterError('InternalError', `unexpected kind ${segment.kind} for next link segment in operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
+                if (segment.kind !== "property") {
+                    throw new AdapterError("InternalError", `unexpected kind ${segment.kind} for next link segment in operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
                 }
                 const nextLinkField = this.ta.fieldsMap.get(segment);
                 if (!nextLinkField) {
                     // the most likely explanation for this is lack of reference equality
-                    throw new AdapterError('InternalError', `missing next link field name ${segment.name} for operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
+                    throw new AdapterError("InternalError", `missing next link field name ${segment.name} for operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
                 }
                 nextLinkPath.push(nextLinkField);
             }
             return nextLinkPath;
         };
         if (sdkMethod.pagingMetadata.nextLinkOperation) {
-            throw new AdapterError('UnsupportedTsp', 'next page operation NYI', sdkMethod.__raw?.node);
+            throw new AdapterError("UnsupportedTsp", "next page operation NYI", sdkMethod.__raw?.node);
         }
         else if (sdkMethod.pagingMetadata.nextLinkSegments) {
             return new go.PageableStrategyNextLink(buildNextLinkPath(sdkMethod.pagingMetadata.nextLinkSegments));
         }
-        else if (sdkMethod.pagingMetadata.continuationTokenParameterSegments && sdkMethod.pagingMetadata.continuationTokenResponseSegments) {
+        else if (sdkMethod.pagingMetadata.continuationTokenParameterSegments &&
+            sdkMethod.pagingMetadata.continuationTokenResponseSegments) {
             const tokenReq = sdkMethod.pagingMetadata.continuationTokenParameterSegments[0];
             const tokenResp = sdkMethod.pagingMetadata.continuationTokenResponseSegments[0];
             // find the continuation token parameter
             let requestToken;
             switch (tokenReq.kind) {
-                case 'method': {
+                case "method": {
                     const tokenParam = paramsMap.get(tokenReq);
                     if (!tokenParam) {
-                        throw new AdapterError('InternalError', `missing continuation token request parameter name ${tokenReq.name} for operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
+                        throw new AdapterError("InternalError", `missing continuation token request parameter name ${tokenReq.name} for operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
                     }
                     requestToken = tokenParam;
                     break;
                 }
                 default:
-                    throw new AdapterError('InternalError', `unhandled continuationTokenParameterSegment kind ${tokenReq.kind}`, tokenReq.__raw?.node);
+                    throw new AdapterError("InternalError", `unhandled continuationTokenParameterSegment kind ${tokenReq.kind}`, tokenReq.__raw?.node);
             }
             // find the continuation token response
             let responseToken;
             switch (tokenResp.kind) {
-                case 'property': {
+                case "property": {
                     responseToken = new go.PageableStrategyNextLink(buildNextLinkPath(sdkMethod.pagingMetadata.continuationTokenResponseSegments));
                     break;
                 }
-                case 'responseheader': {
+                case "responseheader": {
                     const tokenHeader = respHeadersMap.get(tokenResp);
                     if (!tokenHeader) {
-                        throw new AdapterError('InternalError', `missing continuation token response header name ${tokenResp.name} for operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
+                        throw new AdapterError("InternalError", `missing continuation token response header name ${tokenResp.name} for operation ${sdkMethod.name}`, sdkMethod.__raw?.node);
                     }
                     responseToken = tokenHeader;
                     break;
                 }
                 default:
-                    throw new AdapterError('InternalError', `missing continuation token`, sdkMethod.__raw?.node);
+                    throw new AdapterError("InternalError", `missing continuation token`, sdkMethod.__raw?.node);
             }
             return new go.PageableStrategyContinuationToken(requestToken, responseToken);
         }
@@ -569,30 +580,30 @@ export class ClientAdapter {
         return undefined;
     }
     populateMethod(sdkMethod, method) {
-        if (method.kind === 'nextPageMethod') {
-            throw new AdapterError('UnsupportedTsp', `unsupported method kind ${sdkMethod.kind}`, sdkMethod.__raw?.node);
+        if (method.kind === "nextPageMethod") {
+            throw new AdapterError("UnsupportedTsp", `unsupported method kind ${sdkMethod.kind}`, sdkMethod.__raw?.node);
         }
         let prefix = method.receiver.type.name;
-        if (this.ta.ctx.emitContext.options['single-client']) {
-            prefix = '';
+        if (this.ta.ctx.emitContext.options["single-client"]) {
+            prefix = "";
         }
         if (go.isLROMethod(method)) {
-            prefix += 'Begin';
+            prefix += "Begin";
         }
         let optionalParamsGroupName = `${prefix}${method.name}Options`;
-        if (sdkMethod.access === 'internal') {
+        if (sdkMethod.access === "internal") {
             optionalParamsGroupName = uncapitalize(optionalParamsGroupName);
         }
-        let optsGroupName = 'options';
+        let optsGroupName = "options";
         // if there's an existing required parameter with the name options then pick something else.
         // optional params will be inside the options type, so they can never collide.
         for (const param of sdkMethod.parameters) {
             if (!param.optional && param.name === optsGroupName) {
-                optsGroupName = 'opts';
+                optsGroupName = "opts";
                 break;
             }
         }
-        method.optionalParamsGroup = new go.ParameterGroup(this.ta.getPkg(), optsGroupName, optionalParamsGroupName, false, 'method');
+        method.optionalParamsGroup = new go.ParameterGroup(this.ta.getPkg(), optsGroupName, optionalParamsGroupName, false, "method");
         method.optionalParamsGroup.docs.summary = createOptionsTypeDescription(optionalParamsGroupName, this.getMethodNameForDocComment(method));
         const respInfo = this.adaptResponseEnvelope(sdkMethod, method);
         method.returns = respInfo.respEnv;
@@ -600,8 +611,10 @@ export class ClientAdapter {
         // check if the method takes a binary body with an explicit content-type param.
         // if it does, then we need to fix up the body param to reference it. we must
         // do this after adapting all of the method parameters.
-        const binaryBodyParam = method.parameters.find((param) => param.kind === 'bodyParam' && param.bodyFormat === 'binary');
-        const contentTypeParam = method.parameters.find((param) => param.kind === 'headerScalarParam' && param.headerName.match(/^content-type$/i) && param.style !== 'literal');
+        const binaryBodyParam = method.parameters.find((param) => param.kind === "bodyParam" && param.bodyFormat === "binary");
+        const contentTypeParam = method.parameters.find((param) => param.kind === "headerScalarParam" &&
+            param.headerName.match(/^content-type$/i) &&
+            param.style !== "literal");
         if (binaryBodyParam && contentTypeParam) {
             // note that when content-type is a param, the defaultContentType on
             // the body param will be a '*/*' literal. we want to replace that
@@ -609,17 +622,19 @@ export class ClientAdapter {
             // it as a client-side default.
             const bodyParam = binaryBodyParam;
             switch (contentTypeParam.style) {
-                case 'optional':
+                case "optional":
                     // convert the literal to a client-side default
                     contentTypeParam.style = new go.ClientSideDefault(bodyParam.contentType);
                     bodyParam.contentType = new go.ParameterRef(contentTypeParam.name);
                     break;
-                case 'required':
+                case "required":
                     bodyParam.contentType = new go.ParameterRef(contentTypeParam.name);
                     break;
                 default: {
-                    const style = go.isClientSideDefault(contentTypeParam.style) ? 'client-side default' : contentTypeParam.style;
-                    throw new AdapterError('UnsupportedTsp', `unexpected content-type style ${style}`, sdkMethod.__raw?.node);
+                    const style = go.isClientSideDefault(contentTypeParam.style)
+                        ? "client-side default"
+                        : contentTypeParam.style;
+                    throw new AdapterError("UnsupportedTsp", `unexpected content-type style ${style}`, sdkMethod.__raw?.node);
                 }
             }
         }
@@ -637,7 +652,7 @@ export class ClientAdapter {
         const paramMapping = new Map();
         const pageableParamsMap = new Map();
         let optionalGroup;
-        if (method.kind !== 'nextPageMethod') {
+        if (method.kind !== "nextPageMethod") {
             // NextPageMethods don't have optional params
             optionalGroup = method.optionalParamsGroup;
             if (go.isLROMethod(method)) {
@@ -666,7 +681,7 @@ export class ClientAdapter {
             // operation param. each param corresponds to a field within the operation param.
             const opParam = allOpParams.find((opParam) => {
                 return opParam.correspondingMethodParams.find((methodParam) => {
-                    if (param.type.kind === 'model') {
+                    if (param.type.kind === "model") {
                         for (const property of param.type.properties) {
                             if (property === methodParam) {
                                 return true;
@@ -677,9 +692,11 @@ export class ClientAdapter {
                 });
             });
             if (!opParam) {
-                throw new AdapterError('InternalError', `didn't find operation parameter for method ${sdkMethod.name} parameter ${param.name}`, sdkMethod.__raw?.node);
+                throw new AdapterError("InternalError", `didn't find operation parameter for method ${sdkMethod.name} parameter ${param.name}`, sdkMethod.__raw?.node);
             }
-            if (opParam.kind === 'header' && opParam.serializedName.match(/^content-type$/i) && param.type.kind === 'constant') {
+            if (opParam.kind === "header" &&
+                opParam.serializedName.match(/^content-type$/i) &&
+                param.type.kind === "constant") {
                 // if the body param is optional, then the content-type param is also optional.
                 // for optional constants, this has the side effect of the param being treated like
                 // a flag which isn't what we want. so, we mark it as required. we ONLY do this
@@ -692,27 +709,32 @@ export class ClientAdapter {
             let adaptedParam;
             // for the @bodyRoot decorator opParam.type !== param.type which is obviously not a
             // spread parameter. we also need to check the usage flag to disambiguate these cases.
-            if (opParam.kind === 'body' && opParam.type.kind === 'model' && opParam.type !== param.type && opParam.type.usage & tcgc.UsageFlags.Spread) {
+            if (opParam.kind === "body" &&
+                opParam.type.kind === "model" &&
+                opParam.type !== param.type &&
+                opParam.type.usage & tcgc.UsageFlags.Spread) {
                 const paramStyle = this.adaptParameterStyle(param);
-                const paramName = getEscapedReservedName(helpers.getEffectiveName(param, paramStyle === 'required'), 'Param');
+                const paramName = getEscapedReservedName(helpers.getEffectiveName(param, paramStyle === "required"), "Param");
                 // if the param is required then it's always passed by value
-                const byVal = go.isRequiredParameter(paramStyle) ? true : helpers.isTypePassedByValue(param.type);
+                const byVal = go.isRequiredParameter(paramStyle)
+                    ? true
+                    : helpers.isTypePassedByValue(param.type);
                 const contentType = this.adaptContentType(opParam.defaultContentType);
                 const getSerializedNameFromProperty = function (property) {
-                    if (contentType === 'JSON') {
+                    if (contentType === "JSON") {
                         return property.serializationOptions.json?.name;
                     }
-                    if (contentType === 'XML') {
+                    if (contentType === "XML") {
                         return property.serializationOptions.xml?.name;
                     }
-                    if (contentType === 'binary') {
+                    if (contentType === "binary") {
                         return property.serializationOptions.multipart?.name;
                     }
                     return undefined;
                 };
                 switch (contentType) {
-                    case 'JSON':
-                    case 'XML': {
+                    case "JSON":
+                    case "XML": {
                         // find the corresponding field within the model param so we can get the serialized name
                         let serializedName;
                         for (const property of opParam.type.properties) {
@@ -722,12 +744,12 @@ export class ClientAdapter {
                             }
                         }
                         if (!serializedName) {
-                            throw new AdapterError('InternalError', `didn't find body model property for spread parameter ${param.name}`, param.__raw?.node);
+                            throw new AdapterError("InternalError", `didn't find body model property for spread parameter ${param.name}`, param.__raw?.node);
                         }
                         adaptedParam = new go.PartialBodyParameter(paramName, serializedName, contentType, this.ta.getWireType(param.type, true, true), paramStyle, byVal);
                         break;
                     }
-                    case 'binary':
+                    case "binary":
                         if (isMultipartBodyType(opParam.type)) {
                             adaptedParam = this.adaptMultipartFormParameter(param.name, opParam.type, paramStyle, byVal);
                         }
@@ -737,10 +759,10 @@ export class ClientAdapter {
                         }
                         break;
                     default:
-                        throw new AdapterError('UnsupportedTsp', `unsupported spread param content type ${contentType}`, opParam.__raw?.node);
+                        throw new AdapterError("UnsupportedTsp", `unsupported spread param content type ${contentType}`, opParam.__raw?.node);
                 }
             }
-            else if (param.type.kind === 'model' && opParam.kind !== 'body') {
+            else if (param.type.kind === "model" && opParam.kind !== "body") {
                 // Attempt to handle as a parameter group for non-body parameter
                 // TODO: Leverage body parameter as a part of parameter group
                 const modelProperties = param.type.properties;
@@ -783,15 +805,16 @@ export class ClientAdapter {
                         const adaptedPropertyParam = this.adaptMethodParameter(method, propertyOpParam);
                         adaptedPropertyParam.docs.summary = property.summary;
                         adaptedPropertyParam.docs.description = property.doc;
-                        if (adaptedPropertyParam.style === 'required' || adaptedPropertyParam.style === 'literal') {
+                        if (adaptedPropertyParam.style === "required" ||
+                            adaptedPropertyParam.style === "literal") {
                             // Required params stay in the named parameter group
                             // Create the param group if it doesn't exist yet
                             if (!paramGroup) {
                                 const paramStyle = this.adaptParameterStyle(param);
                                 const isRequired = go.isRequiredParameter(paramStyle);
-                                const paramName = getEscapedReservedName(helpers.getEffectiveName(param, isRequired), 'Param');
+                                const paramName = getEscapedReservedName(helpers.getEffectiveName(param, isRequired), "Param");
                                 paramGroup = new go.ParameterGroup(this.ta.getPkg(), paramName, paramGroupName, true, // param group with required params is always required
-                                'method');
+                                "method");
                                 // Use docs from model if present, otherwise generate default description
                                 if (param.type.summary || param.type.doc) {
                                     paramGroup.docs.summary = param.type.summary;
@@ -812,7 +835,7 @@ export class ClientAdapter {
                         else {
                             // Optional params are moved to the method's options type
                             if (!optionalGroup) {
-                                throw new AdapterError('InternalError', `optional parameter ${property.name} has no optional parameter group`, property.__raw?.node);
+                                throw new AdapterError("InternalError", `optional parameter ${property.name} has no optional parameter group`, property.__raw?.node);
                             }
                             adaptedPropertyParam.group = optionalGroup;
                             addParameterToMethod(adaptedPropertyParam, propertyOpParam);
@@ -824,24 +847,26 @@ export class ClientAdapter {
             }
             else {
                 adaptedParam = this.adaptMethodParameter(method, opParam);
-                if (method.kind !== 'nextPageMethod' && go.isPageableMethod(method)) {
+                if (method.kind !== "nextPageMethod" && go.isPageableMethod(method)) {
                     switch (adaptedParam.kind) {
-                        case 'headerScalarParam':
-                        case 'queryScalarParam':
+                        case "headerScalarParam":
+                        case "queryScalarParam":
                             pageableParamsMap.set(param, adaptedParam);
                     }
                 }
             }
             adaptedParam.docs.summary = param.summary;
             adaptedParam.docs.description = param.doc;
-            if (go.isClientSideDefault(adaptedParam.style) && !adaptedParam.docs.summary && !adaptedParam.docs.description) {
+            if (go.isClientSideDefault(adaptedParam.style) &&
+                !adaptedParam.docs.summary &&
+                !adaptedParam.docs.description) {
                 adaptedParam.docs.summary = helpers.getClientDefaultValueDoc(adaptedParam.style.defaultValue);
             }
             addParameterToMethod(adaptedParam, opParam);
-            if (adaptedParam.style !== 'required' && adaptedParam.style !== 'literal') {
+            if (adaptedParam.style !== "required" && adaptedParam.style !== "literal") {
                 // add optional method param to the options param group
                 if (!optionalGroup) {
-                    throw new AdapterError('InternalError', `optional parameter ${param.name} has no optional parameter group`, param.__raw?.node);
+                    throw new AdapterError("InternalError", `optional parameter ${param.name} has no optional parameter group`, param.__raw?.node);
                 }
                 adaptedParam.group = optionalGroup;
                 optionalGroup.params.push(adaptedParam);
@@ -872,11 +897,13 @@ export class ClientAdapter {
                 if (!method.receiver.type.parameters.find((v) => {
                     return v.name === adaptedParam.name;
                 })) {
-                    if (this.ta.codeModel.type === 'azure-arm' && adaptedParam.style !== 'literal' && adaptedParam.style !== 'required') {
-                        throw new AdapterError('UnsupportedTsp', 'optional client parameters for ARM is not supported', opParam.__raw?.node);
+                    if (this.ta.codeModel.type === "azure-arm" &&
+                        adaptedParam.style !== "literal" &&
+                        adaptedParam.style !== "required") {
+                        throw new AdapterError("UnsupportedTsp", "optional client parameters for ARM is not supported", opParam.__raw?.node);
                     }
                     method.receiver.type.parameters.push(adaptedParam);
-                    if (method.receiver.type.instance?.kind === 'constructable') {
+                    if (method.receiver.type.instance?.kind === "constructable") {
                         // if this is an instantiable client then also add
                         // the client parameter to all constructors
                         for (const ctor of method.receiver.type.instance.constructors) {
@@ -894,15 +921,15 @@ export class ClientAdapter {
     adaptContentType(contentTypeStr) {
         // we only recognize/support JSON, text, and XML content types, so assume anything else is binary
         // NOTE: we check XML before text in order to support text/xml
-        let contentType = 'binary';
+        let contentType = "binary";
         if (contentTypeStr.match(/json/i)) {
-            contentType = 'JSON';
+            contentType = "JSON";
         }
         else if (contentTypeStr.match(/xml/i)) {
-            contentType = 'XML';
+            contentType = "XML";
         }
         else if (contentTypeStr.match(/text/i)) {
-            contentType = 'Text';
+            contentType = "Text";
         }
         return contentType;
     }
@@ -929,31 +956,31 @@ export class ClientAdapter {
                     client.apiVersions.push(versionConst);
                 }
                 paramType = new go.Literal(versionConst, versionConst.name);
-                paramStyle = 'literal';
+                paramStyle = "literal";
             }
             else {
                 paramType = this.ta.getStringType();
-                paramStyle = opParam.optional ? 'optional' : 'required';
+                paramStyle = opParam.optional ? "optional" : "required";
             }
-            const paramLoc = opParam.onClient ? 'client' : 'method';
+            const paramLoc = opParam.onClient ? "client" : "method";
             let apiVersionParam;
             switch (opParam.kind) {
-                case 'header':
-                    apiVersionParam = new go.HeaderScalarParameter('apiVersion', opParam.serializedName, paramType, paramStyle, true, paramLoc);
+                case "header":
+                    apiVersionParam = new go.HeaderScalarParameter("apiVersion", opParam.serializedName, paramType, paramStyle, true, paramLoc);
                     break;
-                case 'path':
-                    apiVersionParam = new go.PathScalarParameter('apiVersion', opParam.serializedName, true, paramType, paramStyle, true, paramLoc);
+                case "path":
+                    apiVersionParam = new go.PathScalarParameter("apiVersion", opParam.serializedName, true, paramType, paramStyle, true, paramLoc);
                     break;
-                case 'query':
-                    apiVersionParam = new go.QueryScalarParameter('apiVersion', opParam.serializedName, true, paramType, paramStyle, true, paramLoc);
+                case "query":
+                    apiVersionParam = new go.QueryScalarParameter("apiVersion", opParam.serializedName, true, paramType, paramStyle, true, paramLoc);
                     break;
                 default:
-                    throw new AdapterError('UnsupportedTsp', `unsupported API version param kind ${opParam.kind}`, opParam.__raw?.node);
+                    throw new AdapterError("UnsupportedTsp", `unsupported API version param kind ${opParam.kind}`, opParam.__raw?.node);
             }
             apiVersionParam.isApiVersion = true;
             return apiVersionParam;
         }
-        let location = 'method';
+        let location = "method";
         const getClientParamsKey = function (opParam) {
             // include the param kind in the key name as a client param can be used
             // in different places across methods (path/query)
@@ -967,7 +994,7 @@ export class ClientAdapter {
             if (clientParam) {
                 return clientParam;
             }
-            location = 'client';
+            location = "client";
         }
         // we use the operation param's corresponding method
         // param as the source of truth during adaptation.
@@ -977,78 +1004,85 @@ export class ClientAdapter {
             // this is only applicable to spread params
             // which should have been handled earlier.
             // so, if we get here, we have a bug elsewhere
-            throw new AdapterError('InternalError', `unexpected correspondingMethodParams.length of ${opParam.correspondingMethodParams.length}`, opParam.__raw?.node);
+            throw new AdapterError("InternalError", `unexpected correspondingMethodParams.length of ${opParam.correspondingMethodParams.length}`, opParam.__raw?.node);
         }
         const methodParam = opParam.correspondingMethodParams[0];
         let paramStyle = this.adaptParameterStyle(methodParam);
-        if (opParam.kind === 'body') {
+        if (opParam.kind === "body") {
             const contentType = this.adaptContentType(opParam.defaultContentType);
             // only force modeled body params to be required (binary payloads can be optional)
-            if (contentType !== 'binary' && (method.httpMethod === 'patch' || method.httpMethod === 'put')) {
-                paramStyle = 'required';
+            if (contentType !== "binary" &&
+                (method.httpMethod === "patch" || method.httpMethod === "put")) {
+                paramStyle = "required";
             }
         }
-        const paramName = getEscapedReservedName(helpers.getEffectiveName(methodParam, paramStyle === 'required'), 'Param');
-        const byVal = go.isRequiredParameter(paramStyle) ? true : helpers.isTypePassedByValue(methodParam.type);
+        const paramName = getEscapedReservedName(helpers.getEffectiveName(methodParam, paramStyle === "required"), "Param");
+        const byVal = go.isRequiredParameter(paramStyle)
+            ? true
+            : helpers.isTypePassedByValue(methodParam.type);
         let adaptedParam;
         switch (opParam.kind) {
-            case 'body':
+            case "body":
                 if (isMultipartBodyType(opParam.type)) {
                     adaptedParam = this.adaptMultipartFormParameter(methodParam.name, opParam.type, paramStyle, byVal);
                 }
                 else {
                     const contentType = this.adaptContentType(opParam.defaultContentType);
                     let bodyType = this.ta.getWireType(methodParam.type, false, true);
-                    if (contentType === 'binary') {
+                    if (contentType === "binary") {
                         // tcgc models binary params as 'bytes' but we want an io.ReadSeekCloser
-                        bodyType = this.ta.getReadSeekCloser(methodParam.type.kind === 'array');
+                        bodyType = this.ta.getReadSeekCloser(methodParam.type.kind === "array");
                     }
                     const contentTypeLiteral = this.ta.getLiteral(this.ta.getStringType(), opParam.defaultContentType);
                     adaptedParam = new go.BodyParameter(paramName, contentType, contentTypeLiteral, bodyType, paramStyle, byVal);
-                    if (contentType === 'XML' && methodParam.type.kind === 'array') {
+                    if (contentType === "XML" && methodParam.type.kind === "array") {
                         // this is for compat with autorest.go
                         adaptedParam.xml = new go.XMLInfo();
                         adaptedParam.xml.wrapper = methodParam.type.name;
                     }
                 }
                 break;
-            case 'cookie':
+            case "cookie":
                 // TODO: currently we don't have Azure service using cookie parameter. need to add support if needed in the future.
-                throw new AdapterError('UnsupportedTsp', 'unsupported parameter type cookie', opParam.__raw?.node);
-            case 'header':
-                if (opParam.serializedName === 'x-ms-meta') {
+                throw new AdapterError("UnsupportedTsp", "unsupported parameter type cookie", opParam.__raw?.node);
+            case "header":
+                if (opParam.serializedName === "x-ms-meta") {
                     const type = this.ta.getWireType(methodParam.type, true, false);
-                    if (type.kind !== 'map') {
-                        throw new AdapterError('InternalError', `unexpected kind ${type.kind} for HeaderMapParameter ${methodParam.name}`, opParam.__raw?.node);
+                    if (type.kind !== "map") {
+                        throw new AdapterError("InternalError", `unexpected kind ${type.kind} for HeaderMapParameter ${methodParam.name}`, opParam.__raw?.node);
                     }
                     adaptedParam = new go.HeaderMapParameter(paramName, `${opParam.serializedName}-`, type, paramStyle, byVal, location);
                 }
                 else if (opParam.collectionFormat) {
-                    if (opParam.collectionFormat === 'multi' || opParam.collectionFormat === 'form') {
-                        throw new AdapterError('InternalError', `unexpected collection format ${opParam.collectionFormat} for HeaderCollectionParameter`, opParam.__raw?.node);
+                    if (opParam.collectionFormat === "multi" || opParam.collectionFormat === "form") {
+                        throw new AdapterError("InternalError", `unexpected collection format ${opParam.collectionFormat} for HeaderCollectionParameter`, opParam.__raw?.node);
                     }
                     // TODO: is hard-coded false for element type by value correct?
                     const type = this.ta.getWireType(methodParam.type, true, false);
-                    if (type.kind !== 'slice') {
-                        throw new AdapterError('InternalError', `unexpected kind ${type.kind} for HeaderCollectionParameter ${methodParam.name}`, opParam.__raw?.node);
+                    if (type.kind !== "slice") {
+                        throw new AdapterError("InternalError", `unexpected kind ${type.kind} for HeaderCollectionParameter ${methodParam.name}`, opParam.__raw?.node);
                     }
-                    adaptedParam = new go.HeaderCollectionParameter(paramName, opParam.serializedName, type, opParam.collectionFormat === 'simple' ? 'csv' : opParam.collectionFormat, paramStyle, byVal, location);
+                    adaptedParam = new go.HeaderCollectionParameter(paramName, opParam.serializedName, type, opParam.collectionFormat === "simple" ? "csv" : opParam.collectionFormat, paramStyle, byVal, location);
                 }
                 else {
                     adaptedParam = new go.HeaderScalarParameter(paramName, opParam.serializedName, this.adaptHeaderScalarType(methodParam.type, true), paramStyle, byVal, location);
                 }
                 break;
-            case 'path':
+            case "path":
                 adaptedParam = new go.PathScalarParameter(paramName, opParam.serializedName, !opParam.allowReserved, this.adaptPathScalarParameterType(methodParam.type), paramStyle, byVal, location);
                 break;
-            case 'query':
+            case "query":
                 if (opParam.collectionFormat) {
                     const type = this.ta.getWireType(methodParam.type, true, false);
-                    if (type.kind !== 'slice') {
-                        throw new AdapterError('InternalError', `unexpected kind ${type.kind} for QueryCollectionParameter ${methodParam.name}`, opParam.__raw?.node);
+                    if (type.kind !== "slice") {
+                        throw new AdapterError("InternalError", `unexpected kind ${type.kind} for QueryCollectionParameter ${methodParam.name}`, opParam.__raw?.node);
                     }
                     // TODO: unencoded query param
-                    adaptedParam = new go.QueryCollectionParameter(paramName, opParam.serializedName, true, type, opParam.collectionFormat === 'simple' ? 'csv' : opParam.collectionFormat === 'form' ? 'multi' : opParam.collectionFormat, paramStyle, byVal, location);
+                    adaptedParam = new go.QueryCollectionParameter(paramName, opParam.serializedName, true, type, opParam.collectionFormat === "simple"
+                        ? "csv"
+                        : opParam.collectionFormat === "form"
+                            ? "multi"
+                            : opParam.collectionFormat, paramStyle, byVal, location);
                 }
                 else {
                     // TODO: unencoded query param
@@ -1056,7 +1090,7 @@ export class ClientAdapter {
                 }
                 break;
         }
-        if (adaptedParam.location === 'client') {
+        if (adaptedParam.location === "client") {
             // track client parameter for later use
             this.clientParams.set(getClientParamsKey(opParam), adaptedParam);
         }
@@ -1076,7 +1110,7 @@ export class ClientAdapter {
             // tcgc wraps inline multipart params in a generated model with a single property.
             // unwrap to the inner property to get the actual param name and type.
             if (paramType.properties.length !== 1) {
-                throw new AdapterError('InternalError', `unexpected number of properties: ${paramType.properties.length}`, paramType.__raw?.node);
+                throw new AdapterError("InternalError", `unexpected number of properties: ${paramType.properties.length}`, paramType.__raw?.node);
             }
             const prop = paramType.properties[0];
             paramName = prop.name;
@@ -1088,29 +1122,31 @@ export class ClientAdapter {
         // only use MultipartContent for file parts with a fixed content type.
         // non-file parts (e.g. HttpPart<{ @body body: float64; @header contentType: "text/plain" }>)
         // should retain their underlying type (e.g. float64).
-        if (multipartOptions?.isFilePart && multipartOptions.contentType?.type.kind === 'constant' && multipartOptions.defaultContentTypes.length === 1) {
-            type = this.ta.getMultipartContent(paramAsSdkType.kind === 'array', multipartOptions.defaultContentTypes[0]);
+        if (multipartOptions?.isFilePart &&
+            multipartOptions.contentType?.type.kind === "constant" &&
+            multipartOptions.defaultContentTypes.length === 1) {
+            type = this.ta.getMultipartContent(paramAsSdkType.kind === "array", multipartOptions.defaultContentTypes[0]);
         }
-        else if (paramAsSdkType.kind === 'bytes' && paramAsSdkType.encode === 'bytes') {
+        else if (paramAsSdkType.kind === "bytes" && paramAsSdkType.encode === "bytes") {
             type = this.ta.getReadSeekCloser(false);
         }
         else {
             type = this.ta.getWireType(paramAsSdkType, true, true);
         }
-        paramName = getEscapedReservedName(helpers.getEffectiveName({ name: paramName, isExactName }, paramStyle === 'required'), 'Param');
+        paramName = getEscapedReservedName(helpers.getEffectiveName({ name: paramName, isExactName }, paramStyle === "required"), "Param");
         return new go.MultipartFormBodyParameter(paramName, type, paramStyle, byVal);
     }
     getMethodNameForDocComment(method) {
         let methodName;
         switch (method.kind) {
-            case 'lroMethod':
-            case 'lroPageableMethod':
+            case "lroMethod":
+            case "lroPageableMethod":
                 methodName = `Begin${method.name}`;
                 break;
-            case 'method':
+            case "method":
                 methodName = method.name;
                 break;
-            case 'pageableMethod':
+            case "pageableMethod":
                 methodName = `New${method.name}Pager`;
                 break;
         }
@@ -1119,18 +1155,20 @@ export class ClientAdapter {
     adaptResponseEnvelope(sdkMethod, method) {
         // TODO: add Envelope suffix if name collides with existing type
         let prefix = method.receiver.type.name;
-        if (this.ta.ctx.emitContext.options['single-client']) {
-            prefix = '';
+        if (this.ta.ctx.emitContext.options["single-client"]) {
+            prefix = "";
         }
         let respEnvName = `${prefix}${method.name}Response`;
-        if (sdkMethod.access === 'internal') {
+        if (sdkMethod.access === "internal") {
             respEnvName = uncapitalize(respEnvName);
         }
-        const customName = helpers.getClientOption('responseEnvelopeName', sdkMethod, this.ta.ctx.program);
+        const customName = helpers.getClientOption("responseEnvelopeName", sdkMethod, this.ta.ctx.program);
         if (customName) {
             respEnvName = customName;
         }
-        const respEnv = new go.ResponseEnvelope(respEnvName, { summary: createResponseEnvelopeDescription(respEnvName, this.getMethodNameForDocComment(method)) }, method);
+        const respEnv = new go.ResponseEnvelope(respEnvName, {
+            summary: createResponseEnvelopeDescription(respEnvName, this.getMethodNameForDocComment(method)),
+        }, method);
         this.ta.getPkg().responseEnvelopes.push(respEnv);
         const pageableRespHeadersMap = new Map();
         // we defer adding a literal content-type header to the response envelope
@@ -1146,10 +1184,11 @@ export class ClientAdapter {
                         continue;
                     }
                     let headerResp;
-                    if (httpHeader.serializedName === 'x-ms-meta' || httpHeader.serializedName === 'x-ms-or') {
+                    if (httpHeader.serializedName === "x-ms-meta" ||
+                        httpHeader.serializedName === "x-ms-or") {
                         const type = this.ta.getWireType(httpHeader.type, true, false);
-                        if (type.kind !== 'map') {
-                            throw new AdapterError('InternalError', `unexpected kind ${type.kind} for HeaderMapResponse ${httpHeader.name}`);
+                        if (type.kind !== "map") {
+                            throw new AdapterError("InternalError", `unexpected kind ${type.kind} for HeaderMapResponse ${httpHeader.name}`);
                         }
                         headerResp = new go.HeaderMapResponse(helpers.getEffectiveName(httpHeader), type, `${httpHeader.serializedName}-`);
                     }
@@ -1173,9 +1212,10 @@ export class ClientAdapter {
         }
         let sdkResponseType = sdkMethod.response.type;
         // since HEAD requests don't return a type, we must check this before checking sdkResponseType
-        if (method.httpMethod === 'head' && this.ta.ctx.emitContext.options['head-as-boolean'] === true) {
-            respEnv.result = new go.HeadAsBooleanResult('Success');
-            respEnv.result.docs.summary = 'Success indicates if the operation succeeded or failed.';
+        if (method.httpMethod === "head" &&
+            this.ta.ctx.emitContext.options["head-as-boolean"] === true) {
+            respEnv.result = new go.HeadAsBooleanResult("Success");
+            respEnv.result.docs.summary = "Success indicates if the operation succeeded or failed.";
         }
         if (!sdkResponseType) {
             if (literalContentTypeHeader) {
@@ -1187,43 +1227,48 @@ export class ClientAdapter {
                 respHeaders: pageableRespHeadersMap,
             };
         }
-        if (sdkResponseType.kind === 'nullable') {
+        if (sdkResponseType.kind === "nullable") {
             // unwrap the nullable type, this will only happen for operations with two responses and one of them does not have a body
             sdkResponseType = sdkResponseType.type;
         }
         // for paged methods, tcgc models the method response type as an Array<T>.
         // however, we want the synthesized paged response envelope as that's what Go returns.
-        if (sdkMethod.kind === 'lropaging' || sdkMethod.kind === 'paging') {
+        if (sdkMethod.kind === "lropaging" || sdkMethod.kind === "paging") {
             // grab the paged response envelope type from the operation responses
-            sdkResponseType = sdkMethod.kind === 'lropaging' ? sdkMethod.lroMetadata.finalResponse?.result : sdkMethod.operation.responses[0].type;
+            sdkResponseType =
+                sdkMethod.kind === "lropaging"
+                    ? sdkMethod.lroMetadata.finalResponse?.result
+                    : sdkMethod.operation.responses[0].type;
             if (!sdkResponseType) {
-                throw new AdapterError('InternalError', `paged method ${method.name} has no synthesized response type`, sdkMethod.__raw?.node);
+                throw new AdapterError("InternalError", `paged method ${method.name} has no synthesized response type`, sdkMethod.__raw?.node);
             }
-            else if (sdkResponseType.kind !== 'model') {
-                throw new AdapterError('UnsupportedTsp', `paged method ${method.name} synthesized response type has unexpected kind ${sdkResponseType.kind}`, sdkMethod.__raw?.node);
+            else if (sdkResponseType.kind !== "model") {
+                throw new AdapterError("UnsupportedTsp", `paged method ${method.name} synthesized response type has unexpected kind ${sdkResponseType.kind}`, sdkMethod.__raw?.node);
             }
         }
         // we have a response type, determine the content type
         let contentType;
-        if (sdkMethod.kind === 'lro' || sdkMethod.kind === 'lropaging') {
+        if (sdkMethod.kind === "lro" || sdkMethod.kind === "lropaging") {
             // we can't grovel through the operation responses for LROs as some of them
             // return only headers, thus have no content type. while it's highly likely
             // to only ever be JSON, this will be broken for LROs that return text/plain
             // or a binary response. the former seems unlikely, the latter though...??
             // TODO: https://github.com/Azure/typespec-azure/issues/535
-            contentType = 'JSON';
+            contentType = "JSON";
         }
-        else if (sdkResponseType.kind === 'bytes' && sdkResponseType.encode === 'bytes') {
+        else if (sdkResponseType.kind === "bytes" && sdkResponseType.encode === "bytes") {
             // bytes type with bytes encoding indicates a streaming binary response
-            contentType = 'binary';
+            contentType = "binary";
         }
-        else if (sdkResponseType.kind === 'union') {
+        else if (sdkResponseType.kind === "union") {
             // this is a multi-response operation, we assume the content-type to be JSON
-            contentType = 'JSON';
+            contentType = "JSON";
         }
         else {
             for (const httpResp of sdkMethod.operation.responses) {
-                if (!httpResp.type || !httpResp.defaultContentType || httpResp.type.kind !== sdkResponseType.kind) {
+                if (!httpResp.type ||
+                    !httpResp.defaultContentType ||
+                    httpResp.type.kind !== sdkResponseType.kind) {
                     continue;
                 }
                 contentType = this.adaptContentType(httpResp.defaultContentType);
@@ -1231,20 +1276,20 @@ export class ClientAdapter {
             }
         }
         if (!contentType) {
-            throw new AdapterError('InternalError', `didn't find HTTP response for kind ${sdkResponseType.kind} in method ${method.name}`, sdkResponseType.__raw?.node);
+            throw new AdapterError("InternalError", `didn't find HTTP response for kind ${sdkResponseType.kind} in method ${method.name}`, sdkResponseType.__raw?.node);
         }
-        if (contentType === 'binary') {
+        if (contentType === "binary") {
             if (literalContentTypeHeader) {
                 respEnv.headers.push(literalContentTypeHeader);
             }
-            respEnv.result = new go.BinaryResult('Body');
-            respEnv.result.docs.summary = 'Body contains the streaming response.';
+            respEnv.result = new go.BinaryResult("Body");
+            respEnv.result.docs.summary = "Body contains the streaming response.";
             return {
                 respEnv: respEnv,
                 respHeaders: pageableRespHeadersMap,
             };
         }
-        else if (sdkResponseType.kind === 'model') {
+        else if (sdkResponseType.kind === "model") {
             let modelType;
             const modelName = helpers.getEffectiveName(sdkResponseType).toUpperCase();
             for (const model of this.ta.getPkg().models) {
@@ -1254,9 +1299,9 @@ export class ClientAdapter {
                 }
             }
             if (!modelType) {
-                throw new AdapterError('InternalError', `didn't find model type name ${sdkResponseType.name} for response envelope ${respEnv.name}`, sdkResponseType.__raw?.node);
+                throw new AdapterError("InternalError", `didn't find model type name ${sdkResponseType.name} for response envelope ${respEnv.name}`, sdkResponseType.__raw?.node);
             }
-            if (modelType.kind === 'polymorphicModel') {
+            if (modelType.kind === "polymorphicModel") {
                 // For polymorphic models, check if we can find a concrete type that matches the discriminator value
                 // If no concrete type is found, create a PolymorphicResult that uses the interface type
                 // else use the concrete type as the result type
@@ -1266,15 +1311,15 @@ export class ClientAdapter {
                 }
             }
             if (respEnv.result === undefined) {
-                if (contentType !== 'JSON' && contentType !== 'XML') {
-                    throw new AdapterError('InternalError', `unexpected content type ${contentType} for model ${modelType.name}`);
+                if (contentType !== "JSON" && contentType !== "XML") {
+                    throw new AdapterError("InternalError", `unexpected content type ${contentType} for model ${modelType.name}`);
                 }
                 respEnv.result = new go.ModelResult(modelType, contentType);
             }
             respEnv.result.docs.summary = sdkResponseType.summary;
             respEnv.result.docs.description = sdkResponseType.doc;
         }
-        else if (sdkResponseType.kind === 'union') {
+        else if (sdkResponseType.kind === "union") {
             // multi-response
             const resultTypes = {};
             const possibleTypes = new Set();
@@ -1295,27 +1340,28 @@ export class ClientAdapter {
                     resultTypes[resp.statusCodes] = respType;
                 }
             }
-            respEnv.result = new go.AnyResult('Value', contentType, resultTypes);
-            respEnv.result.docs.summary = `Possible types are ${[...possibleTypes].sort().join(', ')}`;
+            respEnv.result = new go.AnyResult("Value", contentType, resultTypes);
+            respEnv.result.docs.summary = `Possible types are ${[...possibleTypes].sort().join(", ")}`;
         }
         else {
             const resultType = this.ta.getWireType(sdkResponseType, false, false);
             if (go.isMonomorphicResultType(resultType)) {
                 let fieldName;
                 let xmlInfo;
-                if (contentType === 'XML' && sdkResponseType.kind === 'array') {
+                if (contentType === "XML" && sdkResponseType.kind === "array") {
                     // this is for compat with autorest.go
                     xmlInfo = new go.XMLInfo();
                     fieldName = sdkResponseType.name;
                     const elementType = resultType.elementType;
                     const elementTypeXmlName = helpers.hasXMLInfo(elementType)?.name;
-                    xmlInfo.wraps = elementTypeXmlName ?? go.getTypeDeclaration(elementType, method.receiver.type.pkg);
+                    xmlInfo.wraps =
+                        elementTypeXmlName ?? go.getTypeDeclaration(elementType, method.receiver.type.pkg);
                 }
                 if (!fieldName) {
                     fieldName = this.recursiveTypeName(sdkResponseType, false);
                 }
                 // the monomorphicResponseFieldName decorator always wins when present
-                const customName = helpers.getClientOption('monomorphicResponseFieldName', sdkMethod, this.ta.ctx.program);
+                const customName = helpers.getClientOption("monomorphicResponseFieldName", sdkMethod, this.ta.ctx.program);
                 if (customName) {
                     fieldName = customName;
                 }
@@ -1323,7 +1369,7 @@ export class ClientAdapter {
                 respEnv.result.xml = xmlInfo;
             }
             else {
-                throw new AdapterError('InternalError', `invalid monomorphic result type ${resultType.kind}`, sdkResponseType.__raw?.node);
+                throw new AdapterError("InternalError", `invalid monomorphic result type ${resultType.kind}`, sdkResponseType.__raw?.node);
             }
         }
         return {
@@ -1345,49 +1391,49 @@ export class ClientAdapter {
     recursiveTypeName(type, fromArray) {
         if (!fromArray) {
             switch (type.kind) {
-                case 'array':
+                case "array":
                     return `${this.recursiveTypeName(type.valueType, true)}Array`;
-                case 'nullable':
+                case "nullable":
                     return this.recursiveTypeName(type.type, false);
-                case 'unknown':
-                    return this.ta.codeModel.options.rawJSONAsBytes ? 'RawJSON' : 'Interface';
+                case "unknown":
+                    return this.ta.codeModel.options.rawJSONAsBytes ? "RawJSON" : "Interface";
                 default:
-                    return 'Value';
+                    return "Value";
             }
         }
         switch (type.kind) {
-            case 'array':
+            case "array":
                 return `${this.recursiveTypeName(type.valueType, true)}Array`;
-            case 'boolean':
-                return 'Bool';
-            case 'bytes':
-                return 'ByteArray';
-            case 'enum':
-            case 'model':
+            case "boolean":
+                return "Bool";
+            case "bytes":
+                return "ByteArray";
+            case "enum":
+            case "model":
                 return helpers.getEffectiveName(type);
-            case 'utcDateTime':
-            case 'offsetDateTime':
-                return 'Time';
-            case 'decimal':
-            case 'decimal128':
-                return 'Float64';
-            case 'dict':
+            case "utcDateTime":
+            case "offsetDateTime":
+                return "Time";
+            case "decimal":
+            case "decimal128":
+                return "Float64";
+            case "dict":
                 return `MapOf${this.recursiveTypeName(type.valueType, fromArray)}`;
-            case 'float32':
-            case 'float64':
-            case 'int16':
-            case 'int32':
-            case 'int64':
-            case 'int8':
+            case "float32":
+            case "float64":
+            case "int16":
+            case "int32":
+            case "int64":
+            case "int8":
                 return capitalize(type.kind);
-            case 'nullable':
+            case "nullable":
                 return this.recursiveTypeName(type.type, fromArray);
-            case 'duration':
-            case 'string':
-            case 'url':
-                return 'String';
-            case 'unknown':
-                return this.ta.codeModel.options.rawJSONAsBytes ? 'RawJSON' : 'Interface';
+            case "duration":
+            case "string":
+            case "url":
+                return "String";
+            case "unknown":
+                return this.ta.codeModel.options.rawJSONAsBytes ? "RawJSON" : "Interface";
             default:
                 throw new Error(`unhandled monomorphic response type kind ${type.kind}`);
         }
@@ -1396,10 +1442,11 @@ export class ClientAdapter {
         const structType = new go.Struct(this.ta.getPkg(), paramGroup.groupName);
         structType.docs = paramGroup.docs;
         for (const param of paramGroup.params) {
-            if (param.style === 'literal') {
+            if (param.style === "literal") {
                 continue;
             }
-            let byValue = param.style === 'required' || (param.location === 'client' && go.isClientSideDefault(param.style));
+            let byValue = param.style === "required" ||
+                (param.location === "client" && go.isClientSideDefault(param.style));
             // if the param isn't required, check if it should be passed by value or not.
             // optional params that are implicitly nil-able shouldn't be pointer-to-type.
             if (!byValue) {
@@ -1422,29 +1469,29 @@ export class ClientAdapter {
         if (go.isHeaderScalarType(type)) {
             return type;
         }
-        throw new AdapterError('InternalError', `unexpected header scalar parameter type ${type.kind}`, sdkType.__raw?.node);
+        throw new AdapterError("InternalError", `unexpected header scalar parameter type ${type.kind}`, sdkType.__raw?.node);
     }
     adaptPathScalarParameterType(sdkType) {
         const type = this.ta.getWireType(sdkType, false, false);
         if (go.isPathScalarParameterType(type)) {
             return type;
         }
-        throw new AdapterError('InternalError', `unexpected path scalar parameter type ${sdkType.kind}`, sdkType.__raw?.node);
+        throw new AdapterError("InternalError", `unexpected path scalar parameter type ${sdkType.kind}`, sdkType.__raw?.node);
     }
     adaptQueryScalarParameterType(sdkType) {
         const type = this.ta.getWireType(sdkType, false, false);
         if (go.isQueryScalarParameterType(type)) {
             return type;
         }
-        throw new AdapterError('InternalError', `unexpected query scalar parameter type ${sdkType.kind}`, sdkType.__raw?.node);
+        throw new AdapterError("InternalError", `unexpected query scalar parameter type ${sdkType.kind}`, sdkType.__raw?.node);
     }
     adaptParameterStyle(param) {
         // NOTE: must check for constant type first as it will also set clientDefaultValue
-        if (param.type.kind === 'constant') {
+        if (param.type.kind === "constant") {
             if (param.optional) {
-                return 'flag';
+                return "flag";
             }
-            return 'literal';
+            return "literal";
         }
         else if (param.clientDefaultValue) {
             let adaptedType;
@@ -1456,21 +1503,21 @@ export class ClientAdapter {
             else {
                 const adaptedWireType = this.ta.getWireType(param.type, false, false);
                 if (!go.isLiteralValueType(adaptedWireType)) {
-                    throw new AdapterError('InternalError', `unexpected client side default kind ${adaptedWireType.kind} for parameter ${param.name}`, param.__raw?.node);
+                    throw new AdapterError("InternalError", `unexpected client side default kind ${adaptedWireType.kind} for parameter ${param.name}`, param.__raw?.node);
                 }
                 adaptedType = adaptedWireType;
             }
             return new go.ClientSideDefault(this.ta.getLiteral(adaptedType, param.clientDefaultValue, helpers.isExtensibleEnum(param.type)));
         }
         else if (param.optional) {
-            return 'optional';
+            return "optional";
         }
         else {
-            return 'required';
+            return "required";
         }
     }
     adaptHttpOperationExamples(sdkMethod, method, paramMapping) {
-        if (sdkMethod.operation.examples && sdkMethod.access !== 'internal') {
+        if (sdkMethod.operation.examples && sdkMethod.access !== "internal") {
             for (const example of sdkMethod.operation.examples) {
                 try {
                     const goExample = new go.MethodExample(example.name, { summary: example.doc }, example.filePath);
@@ -1479,14 +1526,14 @@ export class ClientAdapter {
                             // skip the api-version param as it's not a formal parameter
                             continue;
                         }
-                        else if (param.parameter.type.kind === 'constant') {
+                        else if (param.parameter.type.kind === "constant") {
                             // if the param's type is a constant then it's embedded
                             // in the code and not a formal parameter so skip it
                             continue;
                         }
                         const goParams = paramMapping.get(param.parameter);
                         if (!goParams) {
-                            throw new AdapterError('InternalError', `can not find go param for example param ${param.parameter.name}`);
+                            throw new AdapterError("InternalError", `can not find go param for example param ${param.parameter.name}`);
                         }
                         if (goParams.length > 1) {
                             // spread case
@@ -1533,7 +1580,7 @@ export class ClientAdapter {
                                     if (helpers.isOmittedResponseHeader(header.header, sdkMethod, this.ta.ctx.program)) {
                                         continue;
                                     }
-                                    throw new AdapterError('InternalError', `can not find go header for example header ${header.header.serializedName}`);
+                                    throw new AdapterError("InternalError", `can not find go header for example header ${header.header.serializedName}`);
                                 }
                                 goExample.responseEnvelope.headers.push(new go.ResponseHeaderExample(goHeader, this.adaptExampleType(header.value, goHeader.type)));
                             }
@@ -1543,20 +1590,20 @@ export class ClientAdapter {
                         // TODO: https://github.com/Azure/typespec-azure/issues/1688
                         if (response.bodyValue && method.returns.result) {
                             switch (method.returns.result.kind) {
-                                case 'anyResult':
+                                case "anyResult":
                                     // use the response type for 200 response
                                     goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.httpStatusCodeType[200]);
                                     break;
-                                case 'binaryResult':
-                                    goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, new go.Scalar('byte', false));
+                                case "binaryResult":
+                                    goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, new go.Scalar("byte", false));
                                     break;
-                                case 'modelResult':
+                                case "modelResult":
                                     goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.modelType);
                                     break;
-                                case 'monomorphicResult':
+                                case "monomorphicResult":
                                     goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.monomorphicType);
                                     break;
-                                case 'polymorphicResult':
+                                case "polymorphicResult":
                                     goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.interface);
                                     break;
                             }
@@ -1576,45 +1623,45 @@ export class ClientAdapter {
     }
     adaptExampleType(exampleType, goType) {
         switch (exampleType.kind) {
-            case 'string':
+            case "string":
                 switch (goType.kind) {
-                    case 'constant':
-                    case 'encodedBytes':
-                    case 'etag':
-                    case 'literal':
-                    case 'readSeekCloser':
-                    case 'scalar':
-                    case 'string':
-                    case 'time':
+                    case "constant":
+                    case "encodedBytes":
+                    case "etag":
+                    case "literal":
+                    case "readSeekCloser":
+                    case "scalar":
+                    case "string":
+                    case "time":
                         return new go.StringExample(exampleType.value, goType);
                 }
                 break;
-            case 'number':
+            case "number":
                 switch (goType.kind) {
-                    case 'constant':
-                    case 'literal':
-                    case 'scalar':
-                    case 'time':
+                    case "constant":
+                    case "literal":
+                    case "scalar":
+                    case "time":
                         return new go.NumberExample(exampleType.value, goType);
                 }
                 break;
-            case 'boolean':
+            case "boolean":
                 switch (goType.kind) {
-                    case 'constant':
-                    case 'literal':
-                    case 'scalar':
+                    case "constant":
+                    case "literal":
+                    case "scalar":
                         return new go.BooleanExample(exampleType.value, goType);
                 }
                 break;
-            case 'null':
+            case "null":
                 return new go.NullExample(goType);
-            case 'unknown':
-                if (goType.kind === 'any') {
+            case "unknown":
+                if (goType.kind === "any") {
                     return new go.AnyExample(exampleType.value);
                 }
                 break;
-            case 'array':
-                if (goType.kind === 'slice') {
+            case "array":
+                if (goType.kind === "slice") {
                     const ret = new go.ArrayExample(goType);
                     for (const v of exampleType.value) {
                         ret.value.push(this.adaptExampleType(v, goType.elementType));
@@ -1622,8 +1669,8 @@ export class ClientAdapter {
                     return ret;
                 }
                 break;
-            case 'dict':
-                if (goType.kind === 'map') {
+            case "dict":
+                if (goType.kind === "map") {
                     const ret = new go.DictionaryExample(goType);
                     for (const [k, v] of Object.entries(exampleType.value)) {
                         ret.value[k] = this.adaptExampleType(v, goType.valueType);
@@ -1631,14 +1678,17 @@ export class ClientAdapter {
                     return ret;
                 }
                 break;
-            case 'union':
-                throw new AdapterError('UnsupportedTsp', 'unsupported example type kind union');
-            case 'model':
-                if (goType.kind === 'interface' || goType.kind === 'model' || goType.kind === 'polymorphicModel') {
+            case "union":
+                throw new AdapterError("UnsupportedTsp", "unsupported example type kind union");
+            case "model":
+                if (goType.kind === "interface" ||
+                    goType.kind === "model" ||
+                    goType.kind === "polymorphicModel") {
                     let concreteType;
-                    if (goType.kind === 'interface') {
+                    if (goType.kind === "interface") {
                         concreteType = goType.possibleTypes.find((t) => t.discriminatorValue?.literal === exampleType.type.discriminatorValue ||
-                            (t.discriminatorValue?.literal).value === exampleType.type.discriminatorValue);
+                            (t.discriminatorValue?.literal).value ===
+                                exampleType.type.discriminatorValue);
                         if (concreteType === undefined) {
                             // can't find the sub type of a discriminated type, fallback to the base type
                             concreteType = goType.rootType;
@@ -1648,13 +1698,13 @@ export class ClientAdapter {
                         concreteType = goType;
                     }
                     if (concreteType === undefined) {
-                        throw new AdapterError('InternalError', `can not find concrete type for example type ${exampleType.type.name}`);
+                        throw new AdapterError("InternalError", `can not find concrete type for example type ${exampleType.type.name}`);
                     }
                     const ret = new go.StructExample(concreteType);
                     for (const [k, v] of Object.entries(exampleType.value)) {
                         const field = concreteType.fields.find((f) => f.serializedName === k);
                         if (!field) {
-                            throw new AdapterError('InternalError', `field with serializedName '${k}' not found in model '${concreteType.name}'.`);
+                            throw new AdapterError("InternalError", `field with serializedName '${k}' not found in model '${concreteType.name}'.`);
                         }
                         ret.value[field.name] = this.adaptExampleType(v, field.type);
                     }
@@ -1663,13 +1713,13 @@ export class ClientAdapter {
                         for (const [k, v] of Object.entries(exampleType.additionalPropertiesValue)) {
                             const filed = concreteType.fields.find((f) => f.annotations.isAdditionalProperties);
                             if (!filed) {
-                                throw new AdapterError('InternalError', `additional properties field not found in model '${concreteType.name}'.`);
+                                throw new AdapterError("InternalError", `additional properties field not found in model '${concreteType.name}'.`);
                             }
-                            if (filed.type.kind === 'map') {
+                            if (filed.type.kind === "map") {
                                 ret.additionalProperties[k] = this.adaptExampleType(v, filed.type.valueType);
                             }
                             else {
-                                throw new AdapterError('InternalError', `additional properties field type should be map type, but got '${filed.type.kind}' in model '${concreteType.name}'`);
+                                throw new AdapterError("InternalError", `additional properties field type should be map type, but got '${filed.type.kind}' in model '${concreteType.name}'`);
                             }
                         }
                     }
@@ -1677,7 +1727,7 @@ export class ClientAdapter {
                 }
                 break;
         }
-        throw new AdapterError('InternalError', `can not map go type into example type ${exampleType.kind}`);
+        throw new AdapterError("InternalError", `can not map go type into example type ${exampleType.kind}`);
     }
 }
 function isHttpStatusCodeRange(statusCode) {
@@ -1693,7 +1743,7 @@ function isMultipartBodyType(type) {
     // multipart body params are always a model type.
     // note that it's legal for models to have zero
     // properties, so they would never be multipart.
-    if (type.kind !== 'model' || type.properties.length === 0) {
+    if (type.kind !== "model" || type.properties.length === 0) {
         return false;
     }
     // check for multipart serialization options.