@azure-tools/typespec-go 0.8.1 → 0.8.3

package/dist/typespec-go/src/tcgcadapter/clients.js

@@ -12,20 +12,20 @@ import { isTypePassedByValue } from './types.js';
 // used to convert SDK clients and their methods to Go code model types
 export class clientAdapter {
     ta;
-    opts;
+    ctx;
     // track all of the client and parameter group params across all operations
     // as not every option might contain them, and parameter groups can be shared
     // across multiple operations
     clientParams;
-    constructor(ta, opts) {
+    constructor(ta, ctx) {
         this.ta = ta;
-        this.opts = opts;
+        this.ctx = ctx;
         this.clientParams = new Map();
     }
     // converts all clients and their methods to Go code model types.
     // this includes parameter groups/options types and response envelopes.
     adaptClients(sdkPackage) {
-        if (this.opts['single-client'] && sdkPackage.clients.length > 1) {
+        if (this.ctx.options['single-client'] && sdkPackage.clients.length > 1) {
             throw new AdapterError('InvalidArgument', 'single-client cannot be enabled when there are multiple clients', NoTarget);
         }
         for (const sdkClient of sdkPackage.clients) {
@@ -78,14 +78,98 @@ export class clientAdapter {
             // the client name is simply "Client"
             docs.summary = `${clientName} contains the methods for the service.`;
         }
-        const goClient = new go.Client(clientName, docs, go.newClientOptions(this.ta.codeModel.type, clientName));
+        const goClient = new go.Client(clientName, docs);
         goClient.parent = parent;
+        // NOTE: per tcgc convention, if there is no param of kind credential
+        // it means that the client doesn't require any kind of authentication.
+        // HOWEVER, if there *is* a credential param, then the client *does not*
+        // automatically support unauthenticated requests. a credential with
+        // the noAuth scheme indicates support for unauthenticated requests.
+        // bit flags for auth types
+        let AuthTypes;
+        (function (AuthTypes) {
+            AuthTypes[AuthTypes["Default"] = 0] = "Default";
+            AuthTypes[AuthTypes["NoAuth"] = 1] = "NoAuth";
+            AuthTypes[AuthTypes["WithAuth"] = 2] = "WithAuth";
+            AuthTypes[AuthTypes["OmitAuth"] = 4] = "OmitAuth";
+        })(AuthTypes || (AuthTypes = {}));
+        // we skip generating client constructors when emitting into
+        // 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.
+        let authType = (this.ta.codeModel.options.omitConstructors || this.ta.codeModel.options.containingModule) ? AuthTypes.OmitAuth : AuthTypes.Default;
+        if (!this.ta.codeModel.options.omitConstructors && this.ta.codeModel.options.containingModule) {
+            // emit a diagnostic indicating that no ctors will be emitted due to containing-module.
+            this.ctx.program.reportDiagnostic({
+                code: 'UnsupportedConfiguration',
+                severity: 'warning',
+                message: 'cannot emit client constructors when containing-module is set',
+                target: sdkClient.__raw.type ?? NoTarget,
+            });
+        }
+        /**
+         * processes a credendial, 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
+         * @param cred the credential type to process
+         * @returns the AuthTypes enum for the credential that was handled, or AuthTypes.Default if none were specified/handled
+         */
+        const processCredential = (goClient, constructable, cred) => {
+            switch (cred.type) {
+                case 'noAuth':
+                    return AuthTypes.NoAuth;
+                case 'oauth2': {
+                    constructable.constructors.push(this.createTokenCredentialCtor(goClient, cred));
+                    return AuthTypes.WithAuth;
+                }
+                default:
+                    this.ctx.program.reportDiagnostic({
+                        code: 'UnsupportedAuthenticationScheme',
+                        severity: 'warning',
+                        message: `unsupported authentication scheme ${cred.type} will be omitted`,
+                        target: sdkClient.__raw.type ?? NoTarget,
+                    });
+                    // return WithAuth as the tsp specifies authentication.
+                    // this is to avoid adding a WithNoCredential() ctor to
+                    // clients that might not support it.
+                    return AuthTypes.WithAuth;
+            }
+        };
+        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;
+        }
         // anything other than public means non-instantiable client
         if (sdkClient.clientInitialization.initializedBy & tcgc.InitializedByFlags.Individually) {
+            goClient.instance = new go.Constructable(go.newClientOptions(this.ta.codeModel.type, clientName));
             for (const param of sdkClient.clientInitialization.parameters) {
                 switch (param.kind) {
                     case 'credential':
-                        // skip this for now as we don't generate client constructors
+                        if (authType === AuthTypes.OmitAuth) {
+                            continue;
+                        }
+                        switch (param.type.kind) {
+                            case 'credential':
+                                authType |= processCredential(goClient, goClient.instance, param.type.scheme);
+                                break;
+                            case 'union': {
+                                const variantKinds = new Array();
+                                for (const variantType of param.type.variantTypes) {
+                                    variantKinds.push(variantType.scheme.type);
+                                    // emit the support credential kinds and skip any unsupported ones.
+                                    // this prevents emitting the WithNoCredential constructor in cases
+                                    // where it might not actually be supported.
+                                    authType |= processCredential(goClient, goClient.instance, variantType.scheme);
+                                }
+                                // no supported credential types were specified
+                                if (authType === AuthTypes.Default) {
+                                    throw new AdapterError('UnsupportedTsp', `credential scheme types ${variantKinds.join()} NYI`, param.__raw?.node ?? NoTarget);
+                                }
+                                continue;
+                            }
+                        }
                         continue;
                     case 'endpoint': {
                         if (this.ta.codeModel.type === 'azure-arm') {
@@ -111,25 +195,29 @@ export class clientAdapter {
                             const templateArg = endpointType.templateArguments[i];
                             if (i === 0) {
                                 // the first template arg is always the endpoint parameter.
-                                // note that the types of the param and the field are different.
-                                // NOTE: we use param.name here instead of templateArg.name as
-                                // the former has the fixed name "endpoint" which is what we want.
-                                const adaptedParam = this.adaptURIParam(templateArg);
-                                adaptedParam.docs.summary = templateArg.summary;
-                                adaptedParam.docs.description = templateArg.doc;
+                                // NOTE: we force the endpoint param to be required, omitting
+                                // any potential for client-side default.
+                                const adaptedParam = this.adaptURIParam(templateArg, true);
+                                adaptedParam.docs.summary = param.summary;
+                                adaptedParam.docs.description = param.doc;
                                 goClient.parameters.push(adaptedParam);
                                 // if the server's URL is *only* the endpoint parameter then we're done.
                                 // this is the param.type.kind === 'endpoint' case.
                                 if (endpointType.serverUrl === `{${templateArg.serializedName}}`) {
                                     break;
                                 }
-                                goClient.templatedHost = endpointType.serverUrl;
+                                // 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}}/`, '');
+                                goClient.instance.endpoint = new go.SupplementalEndpoint(serverUrl);
                                 continue;
                             }
-                            const adaptedParam = this.adaptURIParam(templateArg);
+                            const adaptedParam = this.adaptURIParam(templateArg, false);
                             adaptedParam.docs.summary = templateArg.summary;
                             adaptedParam.docs.description = templateArg.doc;
-                            goClient.parameters.push(adaptedParam);
+                            adaptedParam.isApiVersion = templateArg.isApiVersionParam;
+                            goClient.instance.endpoint?.parameters.push(adaptedParam);
                         }
                         break;
                     }
@@ -139,15 +227,38 @@ export class clientAdapter {
                         // e.g. op withQueryApiVersion(@query("api-version") apiVersion: string)
                         // these get propagated to sdkMethod.operation.parameters thus they
                         // will be adapted in adaptMethodParameters()
+                        // for path-based API version params, we need to emit the field on the client
+                        // and handle it like a regular client parameter.
+                        //
+                        // for header/query API version params, we need to emit the correct values
+                        // for the APIVersionOptions{} struct so the policy can work. in this case,
+                        // no field should be emitted on the client.
                         continue;
                 }
             }
+            // if no authentication type was specified, or the noAuth scheme was
+            // explicitly specified, then include the WithNoCredential constructor
+            if (authType === AuthTypes.Default || (authType & AuthTypes.NoAuth) === AuthTypes.NoAuth) {
+                goClient.instance.constructors.push(new go.Constructor(`New${clientName}WithNoCredential`, new go.NoAuthentication()));
+            }
+            // propagate optional params to the optional params group
+            for (const param of goClient.parameters) {
+                if (!go.isRequiredParameter(param.style) && !go.isLiteralParameter(param.style) && goClient.instance.options.kind === 'clientOptions') {
+                    goClient.instance.options.params.push(param);
+                }
+            }
+            // if we created constructors, propagate the persisted client params to them
+            for (const constructor of goClient.instance.constructors) {
+                constructor.parameters = goClient.parameters;
+            }
         }
         else if (parent) {
             // this is a sub-client. it will share the client/host params of the parent.
             // NOTE: we must propagate parant params before a potential recursive call
             // to create a child client that will need to inherit our client params.
-            goClient.templatedHost = parent.templatedHost;
+            if (parent.instance?.kind === 'templatedHost') {
+                goClient.instance = parent.instance;
+            }
             // make a copy of the client params. this is to prevent
             // client method params from being shared across clients
             // as not all client method params might be uniform.
@@ -177,11 +288,47 @@ export class clientAdapter {
         }
         return goClient;
     }
-    adaptURIParam(sdkParam) {
-        const paramType = this.ta.getWireType(sdkParam.type, true, false);
+    /**
+     * creates a new Go client constructor using token credential authentication
+     *
+     * @param goClient the Go client for which to create the constructor
+     * @param cred the token credential type
+     * @returns a new Go client constructor using token credential authentication
+     */
+    createTokenCredentialCtor(goClient, cred) {
+        if (cred.flows.length === 0) {
+            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);
+        }
+        else if (cred.flows[0].scopes.length > 1) {
+            throw new AdapterError('InternalError', `too many scopes defined for credential type ${cred.type}`, cred.model);
+        }
+        return new go.Constructor(`New${goClient.name}`, new go.TokenAuthentication(cred.flows[0].scopes.map(each => each.value)));
+    }
+    /**
+     * creates a new Go URI parameter from the specified tcgc path parameter
+     *
+     * @param sdkParam the tcgc parameter to adapt
+     * @param forceRequired when true, the parameter is not optional regardless of authoring
+     * @returns the adapted URI parameter
+     */
+    adaptURIParam(sdkParam, forceRequired) {
+        let paramType;
+        if (sdkParam.isApiVersionParam) {
+            paramType = new go.String();
+        }
+        else {
+            paramType = this.ta.getWireType(sdkParam.type, true, false);
+        }
         if (go.isURIParameterType(paramType)) {
+            const style = forceRequired ? 'required' : this.adaptParameterStyle(sdkParam);
             // TODO: follow up with tcgc if serializedName should actually be optional
-            return new go.URIParameter(sdkParam.name, sdkParam.serializedName ? sdkParam.serializedName : sdkParam.name, paramType, this.adaptParameterStyle(sdkParam), isTypePassedByValue(sdkParam.type) || !sdkParam.optional, 'client');
+            const uriParam = new go.URIParameter(sdkParam.name, sdkParam.serializedName ? sdkParam.serializedName : sdkParam.name, paramType, style, isTypePassedByValue(sdkParam.type) || !sdkParam.optional, 'client');
+            uriParam.docs.summary = sdkParam.summary;
+            uriParam.docs.description = sdkParam.doc;
+            return uriParam;
         }
         throw new AdapterError('UnsupportedTsp', `unsupported URI parameter type ${paramType.kind}`, sdkParam.__raw?.node ?? NoTarget);
     }
@@ -205,13 +352,17 @@ export class clientAdapter {
         };
         let methodName = capitalize(ensureNameCase(sdkMethod.name));
         if (sdkMethod.access === 'internal') {
-            // 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.
-            methodName = getEscapedReservedName(uncapitalize(methodName), 'Method', ['internal']);
+            methodName = uncapitalize(methodName);
+            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']);
+            }
         }
         const statusCodes = getStatusCodes(sdkMethod.operation);
         if (sdkMethod.kind === 'basic') {
-            method = new go.Method(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
+            method = new go.SyncMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
         }
         else if (sdkMethod.kind === 'paging') {
             if (sdkMethod.pagingMetadata.nextLinkReInjectedParametersSegments !== undefined && sdkMethod.pagingMetadata.nextLinkReInjectedParametersSegments.length > 0) {
@@ -263,8 +414,8 @@ export class clientAdapter {
         if (method.kind === 'nextPageMethod') {
             throw new AdapterError('UnsupportedTsp', `unsupported method kind ${sdkMethod.kind}`, sdkMethod.__raw?.node ?? NoTarget);
         }
-        let prefix = method.client.name;
-        if (this.opts['single-client']) {
+        let prefix = method.receiver.type.name;
+        if (this.ctx.options['single-client']) {
             prefix = '';
         }
         if (go.isLROMethod(method)) {
@@ -285,7 +436,7 @@ export class clientAdapter {
         }
         method.optionalParamsGroup = new go.ParameterGroup(optsGroupName, optionalParamsGroupName, false, 'method');
         method.optionalParamsGroup.docs.summary = createOptionsTypeDescription(optionalParamsGroupName, this.getMethodNameForDocComment(method));
-        method.responseEnvelope = this.adaptResponseEnvelope(sdkMethod, method);
+        method.returns = this.adaptResponseEnvelope(sdkMethod, method);
         // find the api version param to use for the doc comment.
         // we can't use sdkMethod.apiVersions as that includes all
         // of the api versions supported by the service.
@@ -362,13 +513,16 @@ export class clientAdapter {
                 // a flag which isn't what we want. so, we mark it as required. we ONLY do this
                 // if the content-type is a constant (i.e. literal value).
                 // the content-type will be conditionally set based on the requiredness of the body.
-                opParam.optional = false;
+                // NOTE: we set this on the corresponding method param as it's used when adapting the style.
+                // header param will only have one corresponding method param.
+                opParam.correspondingMethodParams[0].optional = false;
             }
             let adaptedParam;
             if (opParam.kind === 'body' && opParam.type.kind === 'model' && opParam.type.kind !== param.type.kind) {
                 const paramStyle = this.adaptParameterStyle(param);
                 const paramName = getEscapedReservedName(ensureNameCase(param.name, paramStyle === 'required'), 'Param');
-                const byVal = isTypePassedByValue(param.type);
+                // if the param is required then it's always passed by value
+                const byVal = go.isRequiredParameter(paramStyle) ? true : isTypePassedByValue(param.type);
                 const contentType = this.adaptContentType(opParam.defaultContentType);
                 const getSerializedNameFromProperty = function (property) {
                     if (contentType === 'JSON') {
@@ -444,16 +598,18 @@ export class clientAdapter {
                 paramMapping.get(opParam)?.push(adaptedParam);
                 // if the adapted client param is a literal then don't add it to
                 // the array of client params as it's not a formal parameter.
-                if (go.isLiteralParameter(adaptedParam)) {
+                // the only exception is any api version parameter as we need this
+                // for generating client constructors.
+                if (go.isLiteralParameter(adaptedParam.style) && !go.isAPIVersionParameter(adaptedParam)) {
                     continue;
                 }
                 // we must check via param name and not reference equality. this is because a client param
                 // can be used in multiple ways. e.g. a client param "apiVersion" that's used as a path param
                 // in one method and a query param in another.
-                if (!method.client.parameters.find((v) => {
+                if (!method.receiver.type.parameters.find((v) => {
                     return v.name === adaptedParam.name;
                 })) {
-                    method.client.parameters.push(adaptedParam);
+                    method.receiver.type.parameters.push(adaptedParam);
                 }
             }
         }
@@ -477,103 +633,124 @@ export class clientAdapter {
     /**
      * adapts the provided operation parameter to a Go method parameter
      *
-     * @param param the operation parameter to adapt
+     * @param opParam the operation parameter to adapt
      * @param verb the HTTP verb used for the operation to which the parameter belongs
      * @returns the adapted Go method parameter
      */
-    adaptMethodParameter(param, verb) {
-        if (param.isApiVersionParam && param.clientDefaultValue) {
+    adaptMethodParameter(opParam, verb) {
+        if (opParam.isApiVersionParam) {
             // we emit the api version param inline as a literal, never as a param.
             // the ClientOptions.APIVersion setting is used to change the version.
-            const paramType = new go.Literal(new go.String(), param.clientDefaultValue);
-            switch (param.kind) {
+            const paramType = opParam.clientDefaultValue ? new go.Literal(new go.String(), opParam.clientDefaultValue) : new go.String();
+            const paramStyle = opParam.clientDefaultValue ? 'literal' : opParam.optional ? 'optional' : 'required';
+            const paramLoc = opParam.onClient ? 'client' : 'method';
+            let apiVersionParam;
+            switch (opParam.kind) {
                 case 'header':
-                    return new go.HeaderScalarParameter(param.name, param.serializedName, paramType, 'literal', true, 'method');
+                    apiVersionParam = new go.HeaderScalarParameter('apiVersion', opParam.serializedName, paramType, paramStyle, true, paramLoc);
+                    break;
                 case 'path':
-                    return new go.PathScalarParameter(param.name, param.serializedName, true, paramType, 'literal', true, 'method');
+                    apiVersionParam = new go.PathScalarParameter('apiVersion', opParam.serializedName, true, paramType, paramStyle, true, paramLoc);
+                    break;
                 case 'query':
-                    return new go.QueryScalarParameter(param.name, param.serializedName, true, paramType, 'literal', true, 'method');
+                    apiVersionParam = new go.QueryScalarParameter('apiVersion', opParam.serializedName, true, paramType, paramStyle, true, paramLoc);
+                    break;
                 default:
-                    throw new AdapterError('UnsupportedTsp', `unsupported API version param kind ${param.kind}`, param.__raw?.node ?? NoTarget);
+                    throw new AdapterError('UnsupportedTsp', `unsupported API version param kind ${opParam.kind}`, opParam.__raw?.node ?? NoTarget);
             }
+            apiVersionParam.isApiVersion = true;
+            return apiVersionParam;
         }
         let location = 'method';
-        const getClientParamsKey = function (param) {
+        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)
-            return `${param.name}-${param.kind}`;
+            return `${opParam.name}-${opParam.kind}`;
         };
-        if (param.onClient) {
+        // note that client params only show up in the operation
+        // params which is why we check opParam.onClient.
+        if (opParam.onClient) {
             // check if we've already adapted this client parameter
-            const clientParam = this.clientParams.get(getClientParamsKey(param));
+            const clientParam = this.clientParams.get(getClientParamsKey(opParam));
             if (clientParam) {
                 return clientParam;
             }
             location = 'client';
         }
-        let paramStyle = this.adaptParameterStyle(param);
-        if (param.kind === 'body' && (verb === 'patch' || verb === 'put')) {
+        // we use the operation param's corresponding method
+        // param as the source of truth during adaptation.
+        // however, note that some things are only on the
+        // operation param.
+        if (opParam.correspondingMethodParams.length > 1) {
+            // 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 ?? NoTarget);
+        }
+        const methodParam = opParam.correspondingMethodParams[0];
+        let paramStyle = this.adaptParameterStyle(methodParam);
+        if (opParam.kind === 'body' && (verb === 'patch' || verb === 'put')) {
             paramStyle = 'required';
         }
-        const paramName = getEscapedReservedName(ensureNameCase(param.name, paramStyle === 'required'), 'Param');
-        const byVal = isTypePassedByValue(param.type);
+        const paramName = getEscapedReservedName(ensureNameCase(methodParam.name, paramStyle === 'required'), 'Param');
+        const byVal = go.isRequiredParameter(paramStyle) ? true : isTypePassedByValue(methodParam.type);
         let adaptedParam;
-        switch (param.kind) {
+        switch (opParam.kind) {
             case 'body':
                 // TODO: form data? (non-multipart)
-                if (param.defaultContentType.match(/multipart/i)) {
-                    adaptedParam = new go.MultipartFormBodyParameter(paramName, this.ta.getWireType(param.type, false, true), paramStyle, byVal);
+                if (opParam.defaultContentType.match(/multipart/i)) {
+                    adaptedParam = new go.MultipartFormBodyParameter(paramName, this.ta.getWireType(methodParam.type, false, true), paramStyle, byVal);
                 }
                 else {
-                    const contentType = this.adaptContentType(param.defaultContentType);
-                    let bodyType = this.ta.getWireType(param.type, false, true);
+                    const contentType = this.adaptContentType(opParam.defaultContentType);
+                    let bodyType = this.ta.getWireType(methodParam.type, false, true);
                     if (contentType === 'binary') {
                         // tcgc models binary params as 'bytes' but we want an io.ReadSeekCloser
-                        bodyType = this.ta.getReadSeekCloser(param.type.kind === 'array');
+                        bodyType = this.ta.getReadSeekCloser(methodParam.type.kind === 'array');
                     }
-                    adaptedParam = new go.BodyParameter(paramName, contentType, `"${param.defaultContentType}"`, bodyType, paramStyle, byVal);
+                    adaptedParam = new go.BodyParameter(paramName, contentType, `"${opParam.defaultContentType}"`, bodyType, paramStyle, byVal);
                 }
                 break;
             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', param.__raw?.node ?? NoTarget);
+                throw new AdapterError('UnsupportedTsp', 'unsupported parameter type cookie', opParam.__raw?.node ?? NoTarget);
             case 'header':
-                if (param.collectionFormat) {
-                    if (param.collectionFormat === 'multi' || param.collectionFormat === 'form') {
-                        throw new AdapterError('InternalError', `unexpected collection format ${param.collectionFormat} for HeaderCollectionParameter`, param.__raw?.node ?? NoTarget);
+                if (opParam.collectionFormat) {
+                    if (opParam.collectionFormat === 'multi' || opParam.collectionFormat === 'form') {
+                        throw new AdapterError('InternalError', `unexpected collection format ${opParam.collectionFormat} for HeaderCollectionParameter`, opParam.__raw?.node ?? NoTarget);
                     }
                     // TODO: is hard-coded false for element type by value correct?
-                    const type = this.ta.getWireType(param.type, true, false);
+                    const type = this.ta.getWireType(methodParam.type, true, false);
                     if (type.kind !== 'slice') {
-                        throw new AdapterError('InternalError', `unexpected type ${go.getTypeDeclaration(type)} for HeaderCollectionParameter ${param.name}`, param.__raw?.node ?? NoTarget);
+                        throw new AdapterError('InternalError', `unexpected type ${go.getTypeDeclaration(type)} for HeaderCollectionParameter ${methodParam.name}`, opParam.__raw?.node ?? NoTarget);
                     }
-                    adaptedParam = new go.HeaderCollectionParameter(paramName, param.serializedName, type, param.collectionFormat === 'simple' ? 'csv' : param.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, param.serializedName, this.adaptHeaderScalarType(param.type, true), paramStyle, byVal, location);
+                    adaptedParam = new go.HeaderScalarParameter(paramName, opParam.serializedName, this.adaptHeaderScalarType(methodParam.type, true), paramStyle, byVal, location);
                 }
                 break;
             case 'path':
-                adaptedParam = new go.PathScalarParameter(paramName, param.serializedName, !param.allowReserved, this.adaptPathScalarParameterType(param.type), paramStyle, byVal, location);
+                adaptedParam = new go.PathScalarParameter(paramName, opParam.serializedName, !opParam.allowReserved, this.adaptPathScalarParameterType(methodParam.type), paramStyle, byVal, location);
                 break;
             case 'query':
-                if (param.collectionFormat) {
-                    const type = this.ta.getWireType(param.type, true, false);
+                if (opParam.collectionFormat) {
+                    const type = this.ta.getWireType(methodParam.type, true, false);
                     if (type.kind !== 'slice') {
-                        throw new AdapterError('InternalError', `unexpected type ${go.getTypeDeclaration(type)} for QueryCollectionParameter ${param.name}`, param.__raw?.node ?? NoTarget);
+                        throw new AdapterError('InternalError', `unexpected type ${go.getTypeDeclaration(type)} for QueryCollectionParameter ${methodParam.name}`, opParam.__raw?.node ?? NoTarget);
                     }
                     // TODO: unencoded query param
-                    adaptedParam = new go.QueryCollectionParameter(paramName, param.serializedName, true, type, param.collectionFormat === 'simple' ? 'csv' : (param.collectionFormat === 'form' ? 'multi' : param.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
-                    adaptedParam = new go.QueryScalarParameter(paramName, param.serializedName, true, this.adaptQueryScalarParameterType(param.type), paramStyle, byVal, location);
+                    adaptedParam = new go.QueryScalarParameter(paramName, opParam.serializedName, true, this.adaptQueryScalarParameterType(methodParam.type), paramStyle, byVal, location);
                 }
                 break;
         }
         if (adaptedParam.location === 'client') {
             // track client parameter for later use
-            this.clientParams.set(getClientParamsKey(param), adaptedParam);
+            this.clientParams.set(getClientParamsKey(opParam), adaptedParam);
         }
         return adaptedParam;
     }
@@ -591,12 +768,12 @@ export class clientAdapter {
                 methodName = `New${method.name}Pager`;
                 break;
         }
-        return `${method.client.name}.${methodName}`;
+        return `${method.receiver.type.name}.${methodName}`;
     }
     adaptResponseEnvelope(sdkMethod, method) {
         // TODO: add Envelope suffix if name collides with existing type
-        let prefix = method.client.name;
-        if (this.opts['single-client']) {
+        let prefix = method.receiver.type.name;
+        if (this.ctx.options['single-client']) {
             prefix = '';
         }
         let respEnvName = `${prefix}${method.name}Response`;
@@ -626,7 +803,7 @@ 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.opts['head-as-boolean'] === true) {
+        if (method.httpMethod === 'head' && this.ctx.options['head-as-boolean'] === true) {
             respEnv.result = new go.HeadAsBooleanResult('Success');
             respEnv.result.docs.summary = 'Success indicates if the operation succeeded or failed.';
         }
@@ -825,10 +1002,29 @@ export class clientAdapter {
             return 'literal';
         }
         else if (param.clientDefaultValue) {
-            const adaptedType = this.ta.getWireType(param.type, false, false);
-            if (!go.isLiteralValueType(adaptedType)) {
-                throw new AdapterError('InternalError', `unexpected client side default type ${go.getTypeDeclaration(adaptedType)} for parameter ${param.name}`, param.__raw?.node ?? NoTarget);
+            let adaptedType;
+            if (param.isApiVersionParam) {
+                // we force the API version param type to a string
+                // so it matches the ClientOptions.APIVersion type
+                adaptedType = new go.String();
+            }
+            else {
+                const adaptedWireType = this.ta.getWireType(param.type, false, false);
+                if (!go.isLiteralValueType(adaptedWireType)) {
+                    throw new AdapterError('InternalError', `unexpected client side default type ${go.getTypeDeclaration(adaptedWireType)} for parameter ${param.name}`, param.__raw?.node ?? NoTarget);
+                }
+                adaptedType = adaptedWireType;
+            }
+            if (adaptedType.kind === 'constant') {
+                // find the matching constant for the clientDefaultValue
+                for (const constValue of adaptedType.values) {
+                    if (constValue.value === param.clientDefaultValue) {
+                        return new go.ClientSideDefault(new go.Literal(adaptedType, constValue));
+                    }
+                }
+                throw new AdapterError('InternalError', `didn't find clientDefaultValue constant with value ${param.clientDefaultValue} for parameter`, param.__raw?.node ?? NoTarget);
             }
+            // non-constant clientDefaultValue
             return new go.ClientSideDefault(new go.Literal(adaptedType, param.clientDefaultValue));
         }
         else if (param.optional) {
@@ -839,7 +1035,7 @@ export class clientAdapter {
         }
     }
     adaptHttpOperationExamples(sdkMethod, method, paramMapping) {
-        if (sdkMethod.operation.examples) {
+        if (sdkMethod.operation.examples && sdkMethod.access !== 'internal') {
             for (const example of sdkMethod.operation.examples) {
                 const goExample = new go.MethodExample(example.name, { summary: example.doc }, example.filePath);
                 for (const param of example.parameters) {
@@ -877,9 +1073,9 @@ export class clientAdapter {
                 // only handle 200 response
                 const response = example.responses.find((v) => { return v.statusCode === 200; });
                 if (response) {
-                    goExample.responseEnvelope = new go.ResponseEnvelopeExample(method.responseEnvelope);
+                    goExample.responseEnvelope = new go.ResponseEnvelopeExample(method.returns);
                     for (const header of response.headers) {
-                        const goHeader = method.responseEnvelope.headers.find(h => h.headerName === header.header.serializedName);
+                        const goHeader = method.returns.headers.find(h => h.headerName === header.header.serializedName);
                         if (!goHeader) {
                             throw new AdapterError('InternalError', `can not find go header for example header ${header.header.serializedName}`, NoTarget);
                         }
@@ -888,8 +1084,8 @@ export class clientAdapter {
                     // there are some problems with LROs at present which can cause the result
                     // to be undefined even though the operation returns a response.
                     // TODO: https://github.com/Azure/typespec-azure/issues/1688
-                    if (response.bodyValue && method.responseEnvelope.result) {
-                        switch (method.responseEnvelope.result.kind) {
+                    if (response.bodyValue && method.returns.result) {
+                        switch (method.returns.result.kind) {
                             case 'anyResult':
                                 goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, new go.Any());
                                 break;
@@ -897,13 +1093,13 @@ export class clientAdapter {
                                 goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, new go.Scalar('byte', false));
                                 break;
                             case 'modelResult':
-                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.responseEnvelope.result.modelType);
+                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.modelType);
                                 break;
                             case 'monomorphicResult':
-                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.responseEnvelope.result.monomorphicType);
+                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.monomorphicType);
                                 break;
                             case 'polymorphicResult':
-                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.responseEnvelope.result.interface);
+                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.interface);
                                 break;
                         }
                     }
@@ -918,12 +1114,11 @@ export class clientAdapter {
                 switch (goType.kind) {
                     case 'constant':
                     case 'encodedBytes':
+                    case 'etag':
                     case 'literal':
                     case 'string':
                     case 'time':
                         return new go.StringExample(exampleType.value, goType);
-                    case 'qualifiedType':
-                        return new go.QualifiedExample(goType, exampleType.value);
                 }
                 break;
             case 'number':
@@ -1014,4 +1209,5 @@ export class clientAdapter {
 function isHttpStatusCodeRange(statusCode) {
     return statusCode.start !== undefined;
 }
+;
 //# sourceMappingURL=clients.js.map