@azure-tools/typespec-go 0.8.6 → 0.8.8

package/dist/codegen.go/src/fake/servers.js

@@ -5,11 +5,11 @@
 import { camelCase, capitalize, uncapitalize } from '@azure-tools/codegen';
 import { values } from '@azure-tools/linq';
 import * as go from '../../../codemodel.go/src/index.js';
-import * as helpers from '../helpers.js';
-import { ImportManager } from '../imports.js';
-import { fixUpMethodName } from '../operations.js';
+import * as helpers from '../core/helpers.js';
+import { ImportManager } from '../core/imports.js';
+import { fixUpMethodName } from '../core/operations.js';
 import { generateServerInternal, RequiredHelpers } from './internal.js';
-import { CodegenError } from '../errors.js';
+import { CodegenError } from '../core/errors.js';
 // contains the generated content for all servers and the required helpers
 export class ServerContent {
     servers;
@@ -34,16 +34,21 @@ export function getServerName(client) {
     // for the fake server, we use the suffix Server instead of Client
     return capitalize(client.name.replace(/[C|c]lient$/, 'Server'));
 }
-export async function generateServers(codeModel) {
+/**
+ * Generates the contents for the *_server.go files.
+ *
+ * @param pkg contains the package content
+ * @returns the contents to generate or an empty object
+ */
+export function generateServers(pkg) {
     const operations = new Array();
-    const clientPkg = codeModel.packageName;
-    for (const client of values(codeModel.clients)) {
+    for (const client of values(pkg.parent.clients)) {
         if (client.clientAccessors.length === 0 && values(client.methods).all(method => { return helpers.isMethodInternal(method); })) {
             // client has no client accessors and no exported methods, skip it
             continue;
         }
         // the list of packages to import
-        const imports = new ImportManager();
+        const imports = new ImportManager(pkg);
         // add standard imports
         imports.add('errors');
         imports.add('fmt');
@@ -51,7 +56,7 @@ export async function generateServers(codeModel) {
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
         const serverName = getServerName(client);
         let content;
-        content = `// ${serverName} is a fake server for instances of the ${clientPkg}.${client.name} type.\n`;
+        content = `// ${serverName} is a fake server for instances of the ${go.getTypeDeclaration(client, pkg)} type.\n`;
         content += `type ${serverName} struct{\n`;
         // we might remove some operations from the list
         const finalMethods = new Array();
@@ -79,17 +84,17 @@ export async function generateServers(codeModel) {
             switch (method.kind) {
                 case 'lroMethod':
                 case 'lroPageableMethod':
-                    let respType = `${clientPkg}.${method.returns.name}`;
+                    let respType = go.getTypeDeclaration(method.returns, pkg);
                     if (method.kind === 'lroPageableMethod') {
-                        respType = `azfake.PagerResponder[${clientPkg}.${method.returns.name}]`;
+                        respType = `azfake.PagerResponder[${respType}]`;
                     }
                     serverResponse = `resp azfake.PollerResponder[${respType}], errResp azfake.ErrorResponder`;
                     break;
                 case 'method':
-                    serverResponse = `resp azfake.Responder[${clientPkg}.${method.returns.name}], errResp azfake.ErrorResponder`;
+                    serverResponse = `resp azfake.Responder[${go.getTypeDeclaration(method.returns, pkg)}], errResp azfake.ErrorResponder`;
                     break;
                 case 'pageableMethod':
-                    serverResponse = `resp azfake.PagerResponder[${clientPkg}.${method.returns.name}]`;
+                    serverResponse = `resp azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                     break;
             }
             const operationName = fixUpMethodName(method);
@@ -103,7 +108,7 @@ export async function generateServers(codeModel) {
                         successCodes.push(`${helpers.formatStatusCode(httpStatus)} (no return type)`);
                         continue;
                     }
-                    successCodes.push(`${helpers.formatStatusCode(httpStatus)} (returns ${go.getTypeDeclaration(result, clientPkg)})`);
+                    successCodes.push(`${helpers.formatStatusCode(httpStatus)} (returns ${go.getTypeDeclaration(result, pkg)})`);
                 }
                 content += '\t// HTTP status codes to indicate success:\n';
                 for (const successCode of successCodes) {
@@ -116,7 +121,7 @@ export async function generateServers(codeModel) {
                 }
                 content += `\t// HTTP status codes to indicate success: ${successCodes.join(', ')}\n`;
             }
-            content += `\t${operationName} func(${getAPIParametersSig(method, imports, clientPkg)}) (${serverResponse})\n\n`;
+            content += `\t${operationName} func(${getAPIParametersSig(pkg, method, imports)}) (${serverResponse})\n\n`;
             finalMethods.push(method);
             switch (method.kind) {
                 case 'lroMethod':
@@ -132,7 +137,7 @@ export async function generateServers(codeModel) {
         ///////////////////////////////////////////////////////////////////////////
         const serverTransport = `${serverName}Transport`;
         content += `// New${serverTransport} creates a new instance of ${serverTransport} with the provided implementation.\n`;
-        content += `// The returned ${serverTransport} instance is connected to an instance of ${clientPkg}.${client.name} via the\n`;
+        content += `// The returned ${serverTransport} instance is connected to an instance of ${go.getTypeDeclaration(client, pkg)} via the\n`;
         content += '// azcore.ClientOptions.Transporter field in the client\'s constructor parameters.\n';
         content += `func New${serverTransport}(srv *${serverName}) *${serverTransport} {\n`;
         if (countLROs === 0 && countPagers === 0) {
@@ -141,12 +146,12 @@ export async function generateServers(codeModel) {
         else {
             content += `\treturn &${serverTransport}{\n\t\tsrv: srv,\n`;
             for (const method of values(finalMethods)) {
-                let respType = `${clientPkg}.${method.returns.name}`;
+                let respType = go.getTypeDeclaration(method.returns, pkg);
                 switch (method.kind) {
                     case 'lroMethod':
                     case 'lroPageableMethod':
                         if (method.kind === 'lroPageableMethod') {
-                            respType = `azfake.PagerResponder[${clientPkg}.${method.returns.name}]`;
+                            respType = `azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                         }
                         requiredHelpers.tracker = true;
                         content += `\t\t${uncapitalize(fixUpMethodName(method))}: newTracker[azfake.PollerResponder[${respType}]](),\n`;
@@ -159,7 +164,7 @@ export async function generateServers(codeModel) {
             }
             content += '\t}\n}\n\n';
         }
-        content += `// ${serverTransport} connects instances of ${clientPkg}.${client.name} to instances of ${serverName}.\n`;
+        content += `// ${serverTransport} connects instances of ${go.getTypeDeclaration(client, pkg)} to instances of ${serverName}.\n`;
         content += `// Don't use this type directly, use New${serverTransport} instead.\n`;
         content += `type ${serverTransport} struct {\n`;
         content += `\tsrv *${serverName}\n`;
@@ -175,19 +180,19 @@ export async function generateServers(codeModel) {
         }
         for (const method of values(finalMethods)) {
             // create state machines for any pager/poller operations
-            let respType = `${clientPkg}.${method.returns.name}`;
+            let respType = go.getTypeDeclaration(method.returns, pkg);
             switch (method.kind) {
                 case 'lroMethod':
                 case 'lroPageableMethod':
                     if (method.kind === 'lroPageableMethod') {
-                        respType = `azfake.PagerResponder[${clientPkg}.${method.returns.name}]`;
+                        respType = `azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                     }
                     requiredHelpers.tracker = true;
                     content += `\t${uncapitalize(fixUpMethodName(method))} *tracker[azfake.PollerResponder[${respType}]]\n`;
                     break;
                 case 'pageableMethod':
                     requiredHelpers.tracker = true;
-                    content += `\t${uncapitalize(fixUpMethodName(method))} *tracker[azfake.PagerResponder[${clientPkg}.${method.returns.name}]]\n`;
+                    content += `\t${uncapitalize(fixUpMethodName(method))} *tracker[azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]]\n`;
                     break;
             }
         }
@@ -195,19 +200,19 @@ export async function generateServers(codeModel) {
         content += generateServerTransportDo(serverTransport, client, finalSubClients, finalMethods);
         content += generateServerTransportClientDispatch(serverTransport, finalSubClients, imports);
         content += generateServerTransportMethodDispatch(serverTransport, client, finalMethods);
-        content += generateServerTransportMethods(codeModel, serverTransport, finalMethods, imports);
+        content += generateServerTransportMethods(pkg, serverTransport, finalMethods, imports);
         content += `// set this to conditionally intercept incoming requests to ${serverTransport}\n`;
         content += `var ${getTransportInterceptorVarName(client)} interface {\n`;
         content += '\t// Do returns true if the server transport should use the returned response/error\n';
         content += '\tDo(*http.Request) (*http.Response, error, bool)\n}\n';
         ///////////////////////////////////////////////////////////////////////////
         // stitch everything together
-        let text = helpers.contentPreamble(codeModel, true, 'fake');
+        let text = helpers.contentPreamble(pkg);
         text += imports.text();
         text += content;
         operations.push(new OperationGroupContent(serverName, text));
     }
-    return new ServerContent(operations, generateServerInternal(codeModel, requiredHelpers));
+    return new ServerContent(operations, generateServerInternal(pkg, requiredHelpers));
 }
 function getTransportInterceptorVarName(client) {
     return `${camelCase(getServerName(client))}TransportInterceptor`;
@@ -294,11 +299,20 @@ function generateServerTransportMethodDispatch(serverTransport, client, finalMet
     content += '\t}\n}\n\n';
     return content;
 }
-function generateServerTransportMethods(codeModel, serverTransport, finalMethods, imports) {
+/**
+ * generates the server transport methods for a fake server transport
+ *
+ * @param pkg contains the package content
+ * @param serverTransport the name of the server transport type
+ * @param finalMethods the array of methods for which to generate the fake transports
+ * @param imports the import manager currently in scope
+ * @returns the text for the server transport methods
+ */
+function generateServerTransportMethods(pkg, serverTransport, finalMethods, imports) {
     if (finalMethods.length === 0) {
         return '';
     }
-    imports.add(helpers.getParentImport(codeModel));
+    imports.addForPkg(pkg.parent);
     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server');
     const receiverName = serverTransport[0].toLowerCase();
@@ -311,10 +325,10 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
             case 'lroMethod':
             case 'lroPageableMethod':
                 // must check LRO before pager as you can have paged LROs
-                content += dispatchForLROBody(codeModel.packageName, receiverName, method, imports);
+                content += dispatchForLROBody(pkg, receiverName, method, imports);
                 break;
             case 'method': {
-                content += dispatchForOperationBody(codeModel.packageName, receiverName, method, imports);
+                content += dispatchForOperationBody(pkg, receiverName, method, imports);
                 content += '\trespContent := server.GetResponseContent(respr)\n';
                 const formattedStatusCodes = helpers.formatStatusCodes(method.httpStatusCodes);
                 content += `\tif !contains([]int{${formattedStatusCodes}}, respContent.HTTPStatus) {\n`;
@@ -380,7 +394,7 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
                 break;
             }
             case 'pageableMethod':
-                content += dispatchForPagerBody(codeModel.packageName, receiverName, method, imports);
+                content += dispatchForPagerBody(pkg, receiverName, method, imports);
                 break;
             default:
                 method;
@@ -389,7 +403,17 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
     }
     return content;
 }
-function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
+/**
+ * generates the core dispatching logic for a server dispatch method.
+ * this code is common to all method types.
+ *
+ * @param pkg contains the package content
+ * @param receiverName the name of the receiver for the dispatch method
+ * @param method the method for which to emit dispatching logic
+ * @param imports the import manager currently in scope
+ * @returns the text for dispatching logic
+ */
+function dispatchForOperationBody(pkg, receiverName, method, imports) {
     const methodParamGroups = helpers.getMethodParamGroups(method);
     const numPathParams = values(methodParamGroups.pathParams).where((each) => { return !go.isLiteralParameter(each.style); }).count();
     let content = '';
@@ -437,7 +461,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
                             content += '\treq.Body.Close()\n';
                             break;
                         default: {
-                            let bodyTypeName = go.getTypeDeclaration(bodyParam.type, clientPkg);
+                            let bodyTypeName = go.getTypeDeclaration(bodyParam.type, pkg);
                             if (bodyParam.type.kind === 'time') {
                                 bodyTypeName = bodyParam.type.format;
                             }
@@ -465,15 +489,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
         content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
         content += '\treader := multipart.NewReader(req.Body, params["boundary"])\n';
         for (const param of multipartBodyParams) {
-            let pkgPrefix = '';
-            switch (param.type.kind) {
-                case 'constant':
-                case 'model':
-                case 'polymorphicModel':
-                    pkgPrefix = clientPkg + '.';
-                    break;
-            }
-            content += `\tvar ${param.name} ${pkgPrefix}${go.getTypeDeclaration(param.type)}\n`;
+            content += `\tvar ${param.name} ${go.getTypeDeclaration(param.type, pkg)}\n`;
         }
         content += '\tfor {\n';
         content += '\t\tvar part *multipart.Part\n';
@@ -549,7 +565,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
                         from = 'content';
                         break;
                 }
-                assignedValue = `${clientPkg}.${type.name}(${from})`;
+                assignedValue = `${go.getTypeDeclaration(type, pkg)}(${from})`;
             }
             else if (type.kind === 'scalar') {
                 switch (type.type) {
@@ -627,11 +643,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
     }
     else if (formBodyParams.length > 0) {
         for (const param of formBodyParams) {
-            let pkgPrefix = '';
-            if (param.type.kind === 'constant') {
-                pkgPrefix = clientPkg + '.';
-            }
-            content += `\tvar ${param.name} ${pkgPrefix}${go.getTypeDeclaration(param.type)}\n`;
+            content += `\tvar ${param.name} ${go.getTypeDeclaration(param.type, pkg)}\n`;
         }
         content += '\tif err := req.ParseForm(); err != nil {\n\t\treturn nil, &nonRetriableError{fmt.Errorf("failed parsing form data: %v", err)}\n\t}\n';
         content += '\tfor key := range req.Form {\n';
@@ -641,7 +653,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
             let assignedValue;
             switch (param.type.kind) {
                 case 'constant':
-                    assignedValue = `${go.getTypeDeclaration(param.type, clientPkg)}(req.FormValue(key))`;
+                    assignedValue = `${go.getTypeDeclaration(param.type, pkg)}(req.FormValue(key))`;
                     break;
                 case 'string':
                     assignedValue = 'req.FormValue(key)';
@@ -658,19 +670,19 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
         // construct the partial body params type and unmarshal it
         content += '\ttype partialBodyParams struct {\n';
         for (const partialBodyParam of partialBodyParams) {
-            content += `\t\t${capitalize(partialBodyParam.name)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type, clientPkg)} \`json:"${partialBodyParam.serializedName}"\`\n`;
+            content += `\t\t${capitalize(partialBodyParam.name)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type, pkg)} \`json:"${partialBodyParam.serializedName}"\`\n`;
         }
         content += '\t}\n';
         content += `\tbody, err := server.UnmarshalRequestAs${partialBodyParams[0].format}[partialBodyParams](req)\n`;
         content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
     }
-    const result = parseHeaderPathQueryParams(clientPkg, method, imports);
+    const result = parseHeaderPathQueryParams(pkg, method, imports);
     content += result.content;
     // translate each partial body param to its field within the unmarshalled body
     for (const partialBodyParam of partialBodyParams) {
         result.params.set(partialBodyParam.name, `${helpers.star(partialBodyParam.byValue)}body.${capitalize(partialBodyParam.name)}`);
     }
-    const apiCall = `:= ${receiverName}.srv.${fixUpMethodName(method)}(${populateApiParams(clientPkg, method, result.params, imports)})`;
+    const apiCall = `:= ${receiverName}.srv.${fixUpMethodName(method)}(${populateApiParams(pkg, method, result.params, imports)})`;
     if (method.kind === 'pageableMethod') {
         content += `resp ${apiCall}\n`;
         return content;
@@ -698,13 +710,22 @@ function getMethodStatusCodes(method) {
     }
     return statusCodes;
 }
-function dispatchForLROBody(clientPkg, receiverName, method, imports) {
+/**
+ * generates the dispatching logic for an LRO server dispatch method
+ *
+ * @param pkg contains the package contents
+ * @param receiverName the name of the receiver for the dispatch method
+ * @param method the LRO method for which to emit the dispatch logic
+ * @param imports the import manager currently in scope
+ * @returns the text for the LRO dispatch logic
+ */
+function dispatchForLROBody(pkg, receiverName, method, imports) {
     const operationName = fixUpMethodName(method);
     const localVarName = uncapitalize(operationName);
     const operationStateMachine = `${receiverName}.${uncapitalize(operationName)}`;
     let content = `\t${localVarName} := ${operationStateMachine}.get(req)\n`;
     content += `\tif ${localVarName} == nil {\n`;
-    content += dispatchForOperationBody(clientPkg, receiverName, method, imports);
+    content += dispatchForOperationBody(pkg, receiverName, method, imports);
     content += `\t\t${localVarName} = &respr\n`;
     content += `\t\t${operationStateMachine}.add(req, ${localVarName})\n`;
     content += '\t}\n\n';
@@ -719,18 +740,27 @@ function dispatchForLROBody(clientPkg, receiverName, method, imports) {
     content += '\treturn resp, nil\n';
     return content;
 }
-function dispatchForPagerBody(clientPkg, receiverName, method, imports) {
+/**
+ * generates the dispatching logic for a paged server dispatch method
+ *
+ * @param pkg contains the package contents
+ * @param receiverName the name of the receiver for the dispatch method
+ * @param method the pageable method for which to emit the dispatch logic
+ * @param imports the import manager currently in scope
+ * @returns the text for the pageable dispatch logic
+ */
+function dispatchForPagerBody(pkg, receiverName, method, imports) {
     const operationName = fixUpMethodName(method);
     const localVarName = uncapitalize(operationName);
     const operationStateMachine = `${receiverName}.${uncapitalize(operationName)}`;
     let content = `\t${localVarName} := ${operationStateMachine}.get(req)\n`;
     content += `\tif ${localVarName} == nil {\n`;
-    content += dispatchForOperationBody(clientPkg, receiverName, method, imports);
+    content += dispatchForOperationBody(pkg, receiverName, method, imports);
     content += `\t\t${localVarName} = &resp\n`;
     content += `\t\t${operationStateMachine}.add(req, ${localVarName})\n`;
     if (method.nextLinkName) {
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
-        content += `\t\tserver.PagerResponderInjectNextLinks(${localVarName}, req, func(page *${clientPkg}.${method.returns.name}, createLink func() string) {\n`;
+        content += `\t\tserver.PagerResponderInjectNextLinks(${localVarName}, req, func(page *${go.getTypeDeclaration(method.returns, pkg)}, createLink func() string) {\n`;
         content += `\t\t\tpage.${method.nextLinkName} = to.Ptr(createLink())\n`;
         content += '\t\t})\n';
     }
@@ -769,9 +799,15 @@ function createPathParamsRegex(method, pathParams) {
     }
     return urlPath;
 }
-// parses header/path/query params as required.
-// returns the parsing code and the params that contain the parsed values.
-function parseHeaderPathQueryParams(clientPkg, method, imports) {
+/**
+ * parses header/path/query params as required
+ *
+ * @param pkg contains the package contents
+ * @param method the method for which to emit parameter parsing logic
+ * @param imports the import manager currently in scope
+ * @returns the parsing code and the params that contain the parsed values
+ */
+function parseHeaderPathQueryParams(pkg, method, imports) {
     let content = '';
     const paramValues = new Map();
     const createLocalVariableName = function (param, suffix) {
@@ -864,10 +900,10 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 // for string-based enums, we perform the conversion as part of unescaping
                 requiredHelpers.parseWithCast = true;
                 paramVar = createLocalVariableName(param, 'Param');
-                content += `\t${paramVar}, err := parseWithCast(${paramValue}, func (v string) (${go.getTypeDeclaration(param.type, clientPkg)}, error) {\n`;
+                content += `\t${paramVar}, err := parseWithCast(${paramValue}, func (v string) (${go.getTypeDeclaration(param.type, pkg)}, error) {\n`;
                 content += `\t\tp, unescapeErr := url.${where}Unescape(v)\n`;
                 content += '\t\tif unescapeErr != nil {\n\t\t\treturn "", unescapeErr\n\t\t}\n';
-                content += `\t\treturn ${go.getTypeDeclaration(param.type, clientPkg)}(p), nil\n\t})\n`;
+                content += `\t\treturn ${go.getTypeDeclaration(param.type, pkg)}(p), nil\n\t})\n`;
             }
             else {
                 if (go.isRequiredParameter(param.style) &&
@@ -908,10 +944,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                     default:
                         throw new CodegenError('InternalError', `unhandled element kind ${param.type.elementType.kind}`);
                 }
-                let toType = go.getTypeDeclaration(param.type.elementType);
-                if (param.type.elementType.kind === 'constant') {
-                    toType = `${clientPkg}.${toType}`;
-                }
+                const toType = go.getTypeDeclaration(param.type.elementType, pkg);
                 content += `\t${paramVar} := make([]${toType}, len(${paramValue}))\n`;
                 content += `\tfor i := 0; i < len(${paramValue}); i++ {\n`;
                 let fromVar;
@@ -1092,7 +1125,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 parse = emitNumericConversion('v', param.type.type);
                 zeroValue = '0';
             }
-            const toConstType = go.getTypeDeclaration(param.type, clientPkg);
+            const toConstType = go.getTypeDeclaration(param.type, pkg);
             content += `\t${createLocalVariableName(param, 'Param')}, err := ${parseHelper}(${paramValue}, func(v string) (${toConstType}, error) {\n`;
             content += `\t\tp, parseErr := ${parse}\n`;
             content += `\t\tif parseErr != nil {\n\t\t\treturn ${zeroValue}, parseErr\n\t\t}\n`;
@@ -1103,7 +1136,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             // we check this last as it's a superset of the previous conditions
             requiredHelpers.getOptional = true;
             if (param.type.kind === 'constant') {
-                paramValue = `${go.getTypeDeclaration(param.type, clientPkg)}(${paramValue})`;
+                paramValue = `${go.getTypeDeclaration(param.type, pkg)}(${paramValue})`;
             }
             content += `\t${createLocalVariableName(param, 'Param')} := getOptional(${paramValue})\n`;
         }
@@ -1111,20 +1144,20 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
     // create the param groups and populate their values
     for (const paramGroup of values(paramGroups.keys())) {
         if (paramGroup.required) {
-            content += `\t${uncapitalize(paramGroup.name)} := ${clientPkg}.${paramGroup.groupName}{\n`;
+            content += `\t${uncapitalize(paramGroup.name)} := ${go.getTypeDeclaration(paramGroup, pkg)}{\n`;
             for (const param of values(paramGroups.get(paramGroup))) {
-                content += `\t\t${capitalize(param.name)}: ${getFinalParamValue(clientPkg, param, paramValues)},\n`;
+                content += `\t\t${capitalize(param.name)}: ${getFinalParamValue(pkg, param, paramValues)},\n`;
             }
             content += '\t}\n';
         }
         else {
-            content += `\tvar ${uncapitalize(paramGroup.name)} *${clientPkg}.${paramGroup.groupName}\n`;
+            content += `\tvar ${uncapitalize(paramGroup.name)} *${go.getTypeDeclaration(paramGroup, pkg)}\n`;
             const params = paramGroups.get(paramGroup);
             const paramNilCheck = new Array();
             for (const param of values(params)) {
                 // check array before body in case the body is just an array
                 if (param.type.kind === 'slice') {
-                    paramNilCheck.push(`len(${getFinalParamValue(clientPkg, param, paramValues)}) > 0`);
+                    paramNilCheck.push(`len(${getFinalParamValue(pkg, param, paramValues)}) > 0`);
                 }
                 else if (param.kind === 'bodyParam') {
                     if (param.bodyFormat === 'binary') {
@@ -1141,17 +1174,17 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                     paramNilCheck.push(`!reflect.ValueOf(${param.name}).IsZero()`);
                 }
                 else {
-                    paramNilCheck.push(`${getFinalParamValue(clientPkg, param, paramValues)} != nil`);
+                    paramNilCheck.push(`${getFinalParamValue(pkg, param, paramValues)} != nil`);
                 }
             }
             content += `\tif ${paramNilCheck.join(' || ')} {\n`;
-            content += `\t\t${uncapitalize(paramGroup.name)} = &${clientPkg}.${paramGroup.groupName}{\n`;
+            content += `\t\t${uncapitalize(paramGroup.name)} = &${go.getTypeDeclaration(paramGroup, pkg)}{\n`;
             for (const param of values(params)) {
                 let byRef = '&';
                 if (param.byValue || (!go.isRequiredParameter(param.style) && param.kind !== 'bodyParam' && !go.isFormBodyParameter(param) && param.kind !== 'multipartFormBodyParam')) {
                     byRef = '';
                 }
-                content += `\t\t\t${capitalize(param.name)}: ${byRef}${getFinalParamValue(clientPkg, param, paramValues)},\n`;
+                content += `\t\t\t${capitalize(param.name)}: ${byRef}${getFinalParamValue(pkg, param, paramValues)},\n`;
             }
             content += '\t\t}\n';
             content += '\t}\n';
@@ -1162,8 +1195,16 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
         params: paramValues
     };
 }
-// works in conjunction with parseHeaderPathQueryParams
-function populateApiParams(clientPkg, method, paramValues, imports) {
+/**
+ * generates the code to populate the method parameters that get passed to the fake
+ *
+ * @param pkg contains the package contents
+ * @param method the method to be called with the parsed parameters
+ * @param paramValues maps a parameter name to the value to be passed to the fake
+ * @param imports the import manager currently in scope
+ * @returns the text for the parameters to be passed to the fake
+ */
+function populateApiParams(pkg, method, paramValues, imports) {
     // FooOperation(req.Context(), matches[regex.SubexpIndex("resourceGroupName")], qp.Get("api-version"), nil)
     // this assumes that our caller has created matches and qp as required
     const params = new Array();
@@ -1189,8 +1230,8 @@ function populateApiParams(clientPkg, method, paramValues, imports) {
             params.push(uncapitalize(param.name));
             continue;
         }
-        imports.addImportForType(param.type);
-        params.push(getFinalParamValue(clientPkg, param, paramValues));
+        imports.addForType(param.type);
+        params.push(getFinalParamValue(pkg, param, paramValues));
     }
     return params.join(', ');
 }
@@ -1235,8 +1276,17 @@ function getRawParamValue(param) {
             throw new CodegenError('InternalError', `unhandled parameter ${param.name}`);
     }
 }
-// getFinalParamValue returns the "final" value of param to be passed to the fake.
-function getFinalParamValue(clientPkg, param, paramValues) {
+/**
+ * returns the final value of param to be passed to the fake.
+ * this is usually the value in paramValues but can be slightly
+ * different for some cases.
+ *
+ * @param pkg the contents of the package
+ * @param param the parameter being evaluated
+ * @param paramValues maps a parameter name to the value to be passed to the fake
+ * @returns the value to pass for the provided parameter
+ */
+function getFinalParamValue(pkg, param, paramValues) {
     let paramValue = paramValues.get(param.name);
     if (!paramValue) {
         // the param didn't require parsing so the "raw" value can be used
@@ -1259,7 +1309,7 @@ function getFinalParamValue(clientPkg, param, paramValues) {
         }
         else if (go.isHeaderParameter(param) && param.type.kind === 'constant' && param.type.type === 'string') {
             // since headers aren't escaped, we cast required, string-based enums inline
-            return `${go.getTypeDeclaration(param.type, clientPkg)}(${paramValue})`;
+            return `${go.getTypeDeclaration(param.type, pkg)}(${paramValue})`;
         }
     }
     else if (param.kind === 'partialBodyParam') {
@@ -1292,8 +1342,15 @@ function consolidateHostParams(params) {
     }
     return consolidatedParams;
 }
-// copied from generator/operations.ts but with a slight tweak to consolidate host parameters
-function getAPIParametersSig(method, imports, pkgName) {
+/**
+ * copied from generator/operations.ts but with a slight tweak to consolidate host parameters
+ *
+ * @param pkg the contents of the package
+ * @param method the method for which to generate the parameter signature
+ * @param imports the import manager currently in scope
+ * @returns the text for the method's parameter signature
+ */
+function getAPIParametersSig(pkg, method, imports) {
     const methodParams = helpers.getMethodParameters(method, consolidateHostParams);
     const params = new Array();
     if (method.kind !== 'pageableMethod') {
@@ -1305,7 +1362,7 @@ function getAPIParametersSig(method, imports, pkgName) {
         if (methodParam.kind === 'uriParam') {
             paramName = 'host';
         }
-        params.push(`${paramName} ${helpers.formatParameterTypeName(methodParam, pkgName)}`);
+        params.push(`${paramName} ${helpers.formatParameterTypeName(pkg, methodParam)}`);
     }
     return params.join(', ');
 }