@azure-tools/typespec-go 0.8.7 → 0.8.8

package/dist/codegen.go/src/core/models.js

@@ -22,9 +22,9 @@ export function generateModels(pkg, options) {
         };
     }
     // this list of packages to import
-    const modelImports = new ImportManager();
-    const serdeImports = new ImportManager();
-    let modelText = helpers.contentPreamble(helpers.getPackageName(pkg));
+    const modelImports = new ImportManager(pkg);
+    const serdeImports = new ImportManager(pkg);
+    let modelText = helpers.contentPreamble(pkg);
     // we do model generation first as it can add imports to the imports list
     const modelDefs = generateModelDefs(modelImports, serdeImports, pkg, options);
     modelText += modelImports.text();
@@ -127,7 +127,7 @@ export function generateModels(pkg, options) {
     }
     let serdeText = '';
     if (serdeTextBody.length > 0) {
-        serdeText = helpers.contentPreamble(helpers.getPackageName(pkg));
+        serdeText = helpers.contentPreamble(pkg);
         serdeText += serdeImports.text();
         serdeText += serdeTextBody;
     }
@@ -136,6 +136,15 @@ export function generateModels(pkg, options) {
         serDe: serdeText
     };
 }
+/**
+ * converts model types to an array of ModelDef types
+ *
+ * @param modelImports the import manager for the models file
+ * @param serdeImports the import manager for the models_serde file
+ * @param pkg contains the package content
+ * @param options the Go emitter options
+ * @returns an array of ModelDefs
+ */
 function generateModelDefs(modelImports, serdeImports, pkg, options) {
     const models = pkg.models;
     const modelDefs = new Array();
@@ -174,16 +183,16 @@ function generateModelDefs(modelImports, serdeImports, pkg, options) {
             field.docs.description = descriptionMods.join('; ');
         }
         const serDeFormat = helpers.getSerDeFormat(model, pkg);
-        const modelDef = new ModelDef(model.name, serDeFormat, model.fields, model.docs);
-        for (const field of values(modelDef.Fields)) {
-            modelImports.addImportForType(field.type);
+        const modelDef = new ModelDef(model, serDeFormat);
+        for (const field of modelDef.Model.fields) {
+            modelImports.addForType(field.type);
         }
         if (model.kind === 'model' && serDeFormat === 'XML' && !model.annotations.omitSerDeMethods) {
             serdeImports.add('encoding/xml');
             let needsDateTimeMarshalling = false;
             let byteArrayFormat = false;
             for (const field of values(model.fields)) {
-                serdeImports.addImportForType(field.type);
+                serdeImports.addForType(field.type);
                 if (field.type.kind === 'time') {
                     needsDateTimeMarshalling = true;
                 }
@@ -193,14 +202,14 @@ function generateModelDefs(modelImports, serdeImports, pkg, options) {
             }
             // due to differences in XML marshallers/unmarshallers, we use different codegen than for JSON
             if (needsDateTimeMarshalling || model.xml?.wrapper || needsXMLArrayMarshalling(model) || byteArrayFormat) {
-                generateXMLMarshaller(model, modelDef, serdeImports);
+                generateXMLMarshaller(modelDef, serdeImports);
                 if (needsDateTimeMarshalling || byteArrayFormat) {
-                    generateXMLUnmarshaller(model, modelDef, serdeImports);
+                    generateXMLUnmarshaller(modelDef, serdeImports);
                 }
             }
             else if (needsXMLDictionaryHelper(model)) {
-                generateXMLMarshaller(model, modelDef, serdeImports);
-                generateXMLUnmarshaller(model, modelDef, serdeImports);
+                generateXMLMarshaller(modelDef, serdeImports);
+                generateXMLUnmarshaller(modelDef, serdeImports);
             }
             modelDefs.push(modelDef);
             continue;
@@ -216,8 +225,8 @@ function generateModelDefs(modelImports, serdeImports, pkg, options) {
             modelDef.SerDe.needsJSONPopulateMultipart = true;
         }
         else if (!model.annotations.omitSerDeMethods) {
-            generateJSONMarshaller(model, modelDef, serdeImports);
-            generateJSONUnmarshaller(model, modelDef, serdeImports, options);
+            generateJSONMarshaller(modelDef, serdeImports);
+            generateJSONUnmarshaller(modelDef, serdeImports, options);
         }
         modelDefs.push(modelDef);
     }
@@ -245,8 +254,8 @@ function generateDiscriminatorMarkerMethod(type, modelDef) {
     const typeName = type.rootType.name;
     const receiver = modelDef.receiverName();
     const interfaceMethod = `Get${typeName}`;
-    let method = `func (${receiver} *${modelDef.Name}) ${interfaceMethod}() *${typeName} {`;
-    if (type.rootType.name === modelDef.Name) {
+    let method = `func (${receiver} *${modelDef.Model.name}) ${interfaceMethod}() *${typeName} {`;
+    if (type.rootType.name === modelDef.Model.name) {
         // the marker method is on the discriminator itself, so just return the receiver
         method += ` return ${receiver} }\n\n`;
     }
@@ -259,13 +268,13 @@ function generateDiscriminatorMarkerMethod(type, modelDef) {
         }
         method += '\t}\n}\n\n';
     }
-    modelDef.Methods.push({ name: interfaceMethod, desc: `${interfaceMethod} implements the ${type.name} interface for type ${modelDef.Name}.`, text: method });
+    modelDef.Methods.push({ name: interfaceMethod, desc: `${interfaceMethod} implements the ${type.name} interface for type ${modelDef.Model.name}.`, text: method });
 }
 function generateToMultipartForm(modelDef) {
     const receiver = modelDef.receiverName();
-    let method = `func (${receiver} ${modelDef.Name}) toMultipartFormData() (map[string]any, error) {\n`;
+    let method = `func (${receiver} ${modelDef.Model.name}) toMultipartFormData() (map[string]any, error) {\n`;
     method += '\tobjectMap := make(map[string]any)\n';
-    for (const field of modelDef.Fields) {
+    for (const field of modelDef.Model.fields) {
         const fieldType = helpers.recursiveUnwrapMapSlice(field.type);
         let setField;
         let star = '';
@@ -284,28 +293,43 @@ function generateToMultipartForm(modelDef) {
         method += setField;
     }
     method += '\treturn objectMap, nil\n}\n\n';
-    modelDef.SerDe.methods.push({ name: 'toMultipartFormData', desc: `toMultipartFormData converts ${modelDef.Name} to multipart/form data.`, text: method });
+    modelDef.SerDe.methods.push({ name: 'toMultipartFormData', desc: `toMultipartFormData converts ${modelDef.Model.name} to multipart/form data.`, text: method });
 }
-function generateJSONMarshaller(modelType, modelDef, imports) {
-    if (modelType.kind === 'model' && modelType.fields.length === 0) {
+/**
+ * generates the MarshalJSON method for the provided type.
+ * the method impl is added to modelDef.SerDe.methods.
+ *
+ * @param modelDef the type for which to emit the method
+ * @param imports the import manager currently in scope
+ */
+function generateJSONMarshaller(modelDef, imports) {
+    if (modelDef.Model.kind === 'model' && modelDef.Model.fields.length === 0) {
         // non-discriminated types without content don't need a custom marshaller.
         // there is a case in network where child is allOf base and child has no properties.
         return;
     }
     imports.add('encoding/json');
-    const typeName = modelDef.Name;
+    const typeName = modelDef.Model.name;
     const receiver = modelDef.receiverName();
     let marshaller = `func (${receiver} ${typeName}) MarshalJSON() ([]byte, error) {\n`;
     marshaller += '\tobjectMap := make(map[string]any)\n';
-    marshaller += generateJSONMarshallerBody(modelType, modelDef, receiver, imports);
+    marshaller += generateJSONMarshallerBody(modelDef, receiver, imports);
     marshaller += '\treturn json.Marshal(objectMap)\n';
     marshaller += '}\n\n';
     modelDef.SerDe.methods.push({ name: 'MarshalJSON', desc: `MarshalJSON implements the json.Marshaller interface for type ${typeName}.`, text: marshaller });
 }
-function generateJSONMarshallerBody(modelType, modelDef, receiver, imports) {
+/**
+ * generates the contents of MarshalJSON that encode the target type
+ *
+ * @param modelDef the type being encoded
+ * @param receiver the name of the receiver in the MarshalJSON method
+ * @param imports the import manager currently in scope
+ * @returns the text for encoding the target type
+ */
+function generateJSONMarshallerBody(modelDef, receiver, imports) {
     let marshaller = '';
     let addlProps;
-    for (const field of values(modelType.fields)) {
+    for (const field of modelDef.Model.fields) {
         if (field.type.kind === 'map' && field.annotations.isAdditionalProperties) {
             addlProps = field.type;
             continue;
@@ -407,26 +431,43 @@ function generateJSONMarshallerBody(modelType, modelDef, receiver, imports) {
     }
     return marshaller;
 }
-function generateJSONUnmarshaller(modelType, modelDef, imports, options) {
+/**
+ * generates the UnmarshalJSON method for the provided type.
+ * the method impl is added to modelDef.SerDe.methods.
+ *
+ * @param modelDef the type for which to emit the method
+ * @param imports the import manager currently in scope
+ * @param options the Go emitter options
+ */
+function generateJSONUnmarshaller(modelDef, imports, options) {
     // there's a corner-case where a derived type might not add any new fields (Cookiecuttershark).
     // in this case skip adding the unmarshaller as it's not necessary and doesn't compile.
-    if (modelDef.Fields.length === 0) {
+    if (modelDef.Model.fields.length === 0) {
         return;
     }
     imports.add('encoding/json');
     imports.add('fmt');
-    const typeName = modelDef.Name;
+    const typeName = modelDef.Model.name;
     const receiver = modelDef.receiverName();
     let unmarshaller = `func (${receiver} *${typeName}) UnmarshalJSON(data []byte) error {\n`;
     unmarshaller += '\tvar rawMsg map[string]json.RawMessage\n';
     unmarshaller += '\tif err := json.Unmarshal(data, &rawMsg); err != nil {\n';
     unmarshaller += `\t\treturn fmt.Errorf("unmarshalling type %T: %v", ${receiver}, err)\n`;
     unmarshaller += '\t}\n';
-    unmarshaller += generateJSONUnmarshallerBody(modelType, modelDef, receiver, imports, options);
+    unmarshaller += generateJSONUnmarshallerBody(modelDef, receiver, imports, options);
     unmarshaller += '}\n\n';
     modelDef.SerDe.methods.push({ name: 'UnmarshalJSON', desc: `UnmarshalJSON implements the json.Unmarshaller interface for type ${typeName}.`, text: unmarshaller });
 }
-function generateJSONUnmarshallerBody(modelType, modelDef, receiver, imports, options) {
+/**
+ * generates the contents of UnmarshalJSON that decode the target type
+ *
+ * @param modelDef the type being decoded
+ * @param receiver the receiver for the UnmarshalJSON method
+ * @param imports the import manager currently in scope
+ * @param options the Go emitter options
+ * @returns the text for decoding the target type
+ */
+function generateJSONUnmarshallerBody(modelDef, receiver, imports, options) {
     // we almost always need to have an error check when unmarshaling the values.
     // however, fields that are raw JSON don't require any unmarshaling. so, if all
     // of the fields in a type are raw JSON, then the error check isn't necessary
@@ -438,10 +479,10 @@ function generateJSONUnmarshallerBody(modelType, modelDef, receiver, imports, op
         if (!addlProps.valueTypeByValue) {
             ref = '&';
         }
-        addlPropsText += `${tab}\t\t\t${receiver}.AdditionalProperties = ${go.getTypeDeclaration(addlProps)}{}\n`;
+        addlPropsText += `${tab}\t\t\t${receiver}.AdditionalProperties = ${go.getTypeDeclaration(addlProps, modelDef.Model.pkg)}{}\n`;
         addlPropsText += `${tab}\t\t}\n`;
         addlPropsText += `${tab}\t\tif val != nil {\n`;
-        let auxType = go.getTypeDeclaration(addlProps.valueType);
+        let auxType = go.getTypeDeclaration(addlProps.valueType, modelDef.Model.pkg);
         let assignment = `${ref}aux`;
         if (addlProps.valueType.kind === 'time') {
             imports.add('time');
@@ -460,14 +501,14 @@ function generateJSONUnmarshallerBody(modelType, modelDef, receiver, imports, op
         let unmarshalBody = '';
         let addlProps;
         unmarshalBody += '\t\tswitch key {\n';
-        for (const field of values(modelType.fields)) {
+        for (const field of modelDef.Model.fields) {
             if (field.type.kind === 'map' && field.annotations.isAdditionalProperties) {
                 addlProps = field.type;
                 continue;
             }
             unmarshalBody += `\t\tcase "${field.serializedName}":\n`;
             if (hasDiscriminatorInterface(field.type)) {
-                unmarshalBody += generateDiscriminatorUnmarshaller(field, receiver);
+                unmarshalBody += generateDiscriminatorUnmarshaller(modelDef.Model, field, receiver);
                 needsErrCheck = true;
             }
             else if (field.type.kind === 'time') {
@@ -581,7 +622,7 @@ function hasDiscriminatorInterface(item) {
     }
 }
 // returns the text for unmarshalling a discriminated type
-function generateDiscriminatorUnmarshaller(field, receiver) {
+function generateDiscriminatorUnmarshaller(modelType, field, receiver) {
     const startingIndentation = '\t\t\t';
     const propertyName = field.name;
     // these are the simple, non-nested cases (e.g. IterfaceType, []InterfaceType, map[string]InterfaceType)
@@ -597,12 +638,12 @@ function generateDiscriminatorUnmarshaller(field, receiver) {
     // nested case (e.g. [][]InterfaceType, map[string]map[string]InterfaceType etc)
     // first, unmarshal the raw data
     const rawTargetVar = `${field.serializedName}Raw`;
-    let text = `${startingIndentation}var ${rawTargetVar} ${recursiveGetDiscriminatorTypeName(field.type, true)}\n`;
+    let text = `${startingIndentation}var ${rawTargetVar} ${recursiveGetDiscriminatorTypeName(modelType, field.type, true)}\n`;
     text += `${startingIndentation}if err = json.Unmarshal(val, &${rawTargetVar}); err != nil {\n`;
     text += `${startingIndentation}\treturn err\n${startingIndentation}}\n`;
     // create a local instantiation of the final type
     const finalTargetVar = field.serializedName;
-    let finalTargetCtor = recursiveGetDiscriminatorTypeName(field.type, false);
+    let finalTargetCtor = recursiveGetDiscriminatorTypeName(modelType, field.type, false);
     if (field.type.kind === 'slice') {
         finalTargetCtor = `make(${finalTargetCtor}, len(${rawTargetVar}))`;
     }
@@ -612,7 +653,7 @@ function generateDiscriminatorUnmarshaller(field, receiver) {
     }
     text += `${startingIndentation}${finalTargetVar} := ${finalTargetCtor}\n`;
     // now populate the final type
-    text += recursivePopulateDiscriminator(field.type, receiver, rawTargetVar, finalTargetVar, startingIndentation, 1);
+    text += recursivePopulateDiscriminator(modelType, field.type, receiver, rawTargetVar, finalTargetVar, startingIndentation, 1);
     // finally, assign the final target to the property
     text += `${startingIndentation}${receiver}.${propertyName} = ${finalTargetVar}\n`;
     return text;
@@ -620,25 +661,36 @@ function generateDiscriminatorUnmarshaller(field, receiver) {
 // constructs the type name for a nested discriminated type
 // raw e.g. map[string]json.RawMessage, []json.RawMessage etc
 // !raw e.g. map[string]map[string]InterfaceType, [][]InterfaceType etc
-function recursiveGetDiscriminatorTypeName(item, raw) {
+function recursiveGetDiscriminatorTypeName(modelType, item, raw) {
     // when raw is true, stop recursing at the level before the leaf schema
     if (item.kind === 'slice') {
         if (!raw || item.elementType.kind !== 'interface') {
-            return `[]${recursiveGetDiscriminatorTypeName(item.elementType, raw)}`;
+            return `[]${recursiveGetDiscriminatorTypeName(modelType, item.elementType, raw)}`;
         }
     }
     else if (item.kind === 'map') {
         if (!raw || item.valueType.kind !== 'interface') {
-            return `map[string]${recursiveGetDiscriminatorTypeName(item.valueType, raw)}`;
+            return `map[string]${recursiveGetDiscriminatorTypeName(modelType, item.valueType, raw)}`;
         }
     }
     if (raw) {
         return 'json.RawMessage';
     }
-    return go.getTypeDeclaration(item);
+    return go.getTypeDeclaration(item, modelType.pkg);
 }
-// recursively constructs the text to populate a nested discriminator
-function recursivePopulateDiscriminator(item, receiver, rawSrc, dest, indent, nesting) {
+/**
+ * recursively constructs the text to populate a nested discriminator
+ *
+ * @param modelType the type that contains item
+ * @param item the type for which to create the population
+ * @param receiver the name of the receiver for the method to contain the expression
+ * @param rawSrc contains the raw unmarshaled JSON source
+ * @param dest the variable that will contain the result of the expression
+ * @param indent the current level of indentation (increases with each recursive call)
+ * @param nesting the current level of nesting (increments with each recursive call)
+ * @returns the text populating the discriminator
+ */
+function recursivePopulateDiscriminator(modelType, item, receiver, rawSrc, dest, indent, nesting) {
     let text = '';
     let interfaceName = '';
     let targetType = '';
@@ -646,50 +698,57 @@ function recursivePopulateDiscriminator(item, receiver, rawSrc, dest, indent, ne
         if (item.elementType.kind !== 'interface') {
             if (nesting > 1) {
                 // at nestling level 1, the destination var was already created in generateDiscriminatorUnmarshaller()
-                text += `${indent}${dest} = make(${recursiveGetDiscriminatorTypeName(item, false)}, len(${rawSrc}))\n`;
+                text += `${indent}${dest} = make(${recursiveGetDiscriminatorTypeName(modelType, item, false)}, len(${rawSrc}))\n`;
             }
             text += `${indent}for i${nesting} := range ${rawSrc} {\n`;
             rawSrc = `${rawSrc}[i${nesting}]`; // source becomes each element in the source slice
             dest = `${dest}[i${nesting}]`; // update destination to each element in the destination slice
-            text += recursivePopulateDiscriminator(item.elementType, receiver, rawSrc, dest, indent + '\t', nesting + 1);
+            text += recursivePopulateDiscriminator(modelType, item.elementType, receiver, rawSrc, dest, indent + '\t', nesting + 1);
             text += `${indent}}\n`;
             return text;
         }
         // we're at leaf node - 1, so get the interface from the element's type
-        interfaceName = go.getTypeDeclaration(item.elementType);
+        interfaceName = go.getTypeDeclaration(item.elementType, modelType.pkg);
         targetType = 'Array';
     }
     else if (item.kind === 'map') {
         if (item.valueType.kind !== 'interface') {
             if (nesting > 1) {
                 // at nestling level 1, the destination var was already created in generateDiscriminatorUnmarshaller()
-                text += `${indent}${dest} = ${recursiveGetDiscriminatorTypeName(item, false)}{}\n`;
+                text += `${indent}${dest} = ${recursiveGetDiscriminatorTypeName(modelType, item, false)}{}\n`;
             }
             text += `${indent}for k${nesting}, v${nesting} := range ${rawSrc} {\n`;
             rawSrc = `v${nesting}`; // source becomes the current value in the source map
             dest = `${dest}[k${nesting}]`; // update destination to the destination map's value for the current key
-            text += recursivePopulateDiscriminator(item.valueType, receiver, rawSrc, dest, indent + '\t', nesting + 1);
+            text += recursivePopulateDiscriminator(modelType, item.valueType, receiver, rawSrc, dest, indent + '\t', nesting + 1);
             text += `${indent}}\n`;
             return text;
         }
         // we're at leaf node - 1, so get the interface from the element's type
-        interfaceName = go.getTypeDeclaration(item.valueType);
+        interfaceName = go.getTypeDeclaration(item.valueType, modelType.pkg);
         targetType = 'Map';
     }
     text += `${indent}${dest}, err = unmarshal${interfaceName}${targetType}(${rawSrc})\n`;
     text += `${indent}if err != nil {\n${indent}\treturn fmt.Errorf("unmarshalling type %T: %v", ${receiver}, err)\n${indent}}\n`;
     return text;
 }
-function generateXMLMarshaller(modelType, modelDef, imports) {
+/**
+ * generates an implementation of MarshalXML for the provided type.
+ * the method impl is added to modelDef.SerDe.methods.
+ *
+ * @param modelDef the type for which to implement MarshalXML
+ * @param imports the import manager currently in scope
+ */
+function generateXMLMarshaller(modelDef, imports) {
     // only needed for types with time.Time, maps, or where the XML name doesn't match the type name
     const receiver = modelDef.receiverName();
-    const desc = `MarshalXML implements the xml.Marshaller interface for type ${modelDef.Name}.`;
-    let text = `func (${receiver} ${modelDef.Name}) MarshalXML(enc *xml.Encoder, start xml.StartElement) error {\n`;
-    if (modelType.xml?.wrapper) {
-        text += `\tstart.Name.Local = "${modelType.xml.wrapper}"\n`;
+    const desc = `MarshalXML implements the xml.Marshaller interface for type ${modelDef.Model.name}.`;
+    let text = `func (${receiver} ${modelDef.Model.name}) MarshalXML(enc *xml.Encoder, start xml.StartElement) error {\n`;
+    if (modelDef.Model.xml?.wrapper) {
+        text += `\tstart.Name.Local = "${modelDef.Model.xml.wrapper}"\n`;
     }
-    text += generateAliasType(modelType, receiver, true);
-    for (const field of values(modelDef.Fields)) {
+    text += generateAliasType(modelDef.Model, receiver, true);
+    for (const field of modelDef.Model.fields) {
         if (field.type.kind === 'slice') {
             text += `\tif ${receiver}.${field.name} != nil {\n`;
             text += `\t\taux.${field.name} = &${receiver}.${field.name}\n`;
@@ -710,16 +769,23 @@ function generateXMLMarshaller(modelType, modelDef, imports) {
     text += '}\n\n';
     modelDef.SerDe.methods.push({ name: 'MarshalXML', desc: desc, text: text });
 }
-function generateXMLUnmarshaller(modelType, modelDef, imports) {
+/**
+ * generates an implementation of UnmarshalXML for the provided type.
+ * the method impl is added to modelDef.SerDe.methods.
+ *
+ * @param modelDef the type for which to implement UnmarshalXML
+ * @param imports the import manager currently in scope
+ */
+function generateXMLUnmarshaller(modelDef, imports) {
     // non-polymorphic case, must be something with time.Time
     const receiver = modelDef.receiverName();
-    const desc = `UnmarshalXML implements the xml.Unmarshaller interface for type ${modelDef.Name}.`;
-    let text = `func (${receiver} *${modelDef.Name}) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) error {\n`;
-    text += generateAliasType(modelType, receiver, false);
+    const desc = `UnmarshalXML implements the xml.Unmarshaller interface for type ${modelDef.Model.name}.`;
+    let text = `func (${receiver} *${modelDef.Model.name}) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) error {\n`;
+    text += generateAliasType(modelDef.Model, receiver, false);
     text += '\tif err := dec.DecodeElement(aux, &start); err != nil {\n';
     text += '\t\treturn err\n';
     text += '\t}\n';
-    for (const field of values(modelDef.Fields)) {
+    for (const field of modelDef.Model.fields) {
         if (field.type.kind === 'time') {
             text += `\tif aux.${field.name} != nil && !(*time.Time)(aux.${field.name}).IsZero() {\n`;
             text += `\t\t${receiver}.${field.name} = (*time.Time)(aux.${field.name})\n\t}\n`;
@@ -740,13 +806,20 @@ function generateXMLUnmarshaller(modelType, modelDef, imports) {
     text += '}\n\n';
     modelDef.SerDe.methods.push({ name: 'UnmarshalXML', desc: desc, text: text });
 }
-// generates an alias type used by custom XML marshaller/unmarshaller
+/**
+ * generates an alias type used by custom XML marshaller/unmarshaller
+ *
+ * @param modelType the type for which to create the alias
+ * @param receiver the name of the receiver for the type's serde method
+ * @param forMarshal when true, indicates type is to be used in a marshaller (else an unmarshaller)
+ * @returns the text for an initialized type alias
+ */
 function generateAliasType(modelType, receiver, forMarshal) {
     let text = `\ttype alias ${modelType.name}\n`;
     text += '\taux := &struct {\n';
     text += '\t\t*alias\n';
     for (const field of values(modelType.fields)) {
-        const sn = getXMLSerialization(field, false);
+        const sn = getXMLSerialization(modelType, field);
         if (field.type.kind === 'time') {
             text += `\t\t${field.name} *${field.type.format} \`xml:"${sn}"\`\n`;
         }
@@ -754,7 +827,7 @@ function generateAliasType(modelType, receiver, forMarshal) {
             text += `\t\t${field.name} additionalProperties \`xml:"${sn}"\`\n`;
         }
         else if (field.type.kind === 'slice') {
-            text += `\t\t${field.name} *${go.getTypeDeclaration(field.type)} \`xml:"${sn}"\`\n`;
+            text += `\t\t${field.name} *${go.getTypeDeclaration(field.type, modelType.pkg)} \`xml:"${sn}"\`\n`;
         }
         else if (field.type.kind === 'encodedBytes') {
             text += `\t\t${field.name} *string \`xml:"${sn}"\`\n`;
@@ -778,6 +851,7 @@ function generateAliasType(modelType, receiver, forMarshal) {
     text += '\t}\n';
     return text;
 }
+/** used to track which serde helpers and methods are required for a struct */
 class SerDeInfo {
     methods;
     needsJSONPopulate;
@@ -794,27 +868,24 @@ class SerDeInfo {
         this.needsJSONPopulateMultipart = false;
     }
 }
-// represents model definition as a Go struct
+/** represents model definition as a Go struct */
 class ModelDef {
-    Name;
+    Model;
     Format;
-    Docs;
-    Fields;
     SerDe;
     Methods;
-    constructor(name, format, fields, docs) {
-        this.Name = name;
+    constructor(model, format) {
+        this.Model = model;
         this.Format = format;
-        this.Docs = docs;
-        this.Fields = fields;
         this.SerDe = new SerDeInfo();
         this.Methods = new Array();
     }
+    /** returns the text for the struct definition */
     text() {
-        let text = helpers.formatDocComment(this.Docs);
-        text += `type ${this.Name} struct {\n`;
+        let text = helpers.formatDocComment(this.Model.docs);
+        text += `type ${this.Model.name} struct {\n`;
         // group fields by required/optional/read-only in that order
-        this.Fields?.sort((lhs, rhs) => {
+        this.Model.fields.sort((lhs, rhs) => {
             if ((lhs.annotations.required && !rhs.annotations.required) || (!lhs.annotations.readOnly && rhs.annotations.readOnly)) {
                 return -1;
             }
@@ -827,7 +898,7 @@ class ModelDef {
         });
         // used to track when to add an extra \n between fields that have comments
         let first = true;
-        for (const field of values(this.Fields)) {
+        for (const field of this.Model.fields) {
             if (field.docs.summary || field.docs.description) {
                 if (!first) {
                     // add an extra new-line between fields IFF the field
@@ -836,7 +907,7 @@ class ModelDef {
                 }
                 text += helpers.formatDocComment(field.docs);
             }
-            let typeName = go.getTypeDeclaration(field.type);
+            let typeName = go.getTypeDeclaration(field.type, this.Model.pkg);
             if (field.type.kind === 'literal') {
                 // for constants we use the underlying type name
                 typeName = go.getLiteralTypeDeclaration(field.type.type);
@@ -846,7 +917,7 @@ class ModelDef {
                 serialization += ',omitempty';
             }
             else if (this.Format === 'XML') {
-                serialization = getXMLSerialization(field, false);
+                serialization = getXMLSerialization(this.Model, field);
             }
             let tag = '';
             // only emit tags for XML; JSON uses custom marshallers/unmarshallers
@@ -859,12 +930,20 @@ class ModelDef {
         text += '}\n\n';
         return text;
     }
+    /** returns the name to use for method receivers on this struct */
     receiverName() {
-        const typeName = this.Name;
+        const typeName = this.Model.name;
         return typeName[0].toLowerCase();
     }
 }
-export function getXMLSerialization(field, isResponseEnvelope) {
+/**
+ * returns the serialization options to use in the XML tag on a model field
+ *
+ * @param modelType the type that contains the field
+ * @param field the field for which to construct the tag's contents
+ * @returns the contents for the XML tag
+ */
+function getXMLSerialization(modelType, field) {
     let serialization = field.serializedName;
     // default to using the serialization name
     if (field.xml?.name) {
@@ -882,7 +961,7 @@ export function getXMLSerialization(field, isResponseEnvelope) {
     }
     else if (field.type.kind === 'slice') {
         // start with the serialized name of the element, preferring xml name if available
-        let inner = go.getTypeDeclaration(field.type.elementType);
+        let inner = go.getTypeDeclaration(field.type.elementType, modelType.pkg);
         if (field.xml?.name) {
             inner = field.xml.name;
         }
@@ -906,7 +985,7 @@ export function getXMLSerialization(field, isResponseEnvelope) {
         // </slideshow>
         // arrays in the response type are handled slightly different as we
         // unmarshal directly into them so no need to add the unwrapping.
-        if (field.xml?.wraps && !isResponseEnvelope) {
+        if (field.xml?.wraps) {
             serialization += `>${field.xml.wraps}`;
         }
         else {