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

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

@@ -2,9 +2,9 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import * as go from '../../../codemodel.go/src/index.js';
-import * as helpers from './helpers.js';
-import { ImportManager } from './imports.js';
+import * as go from "../../codemodel/index.js";
+import * as helpers from "./helpers.js";
+import { ImportManager } from "./imports.js";
 /**
  * Creates the content for the models.go file.
  *
@@ -16,8 +16,8 @@ import { ImportManager } from './imports.js';
 export function generateModels(pkg, options, emitter) {
     if (pkg.models.length === 0) {
         return {
-            models: '',
-            serDe: '',
+            models: "",
+            serDe: "",
         };
     }
     // this list of packages to import
@@ -36,7 +36,7 @@ export function generateModels(pkg, options, emitter) {
     let needsJSONPopulateByteArray = false;
     let needsJSONPopulateAny = false;
     let needsJSONPopulateMultipart = false;
-    let serdeTextBody = '';
+    let serdeTextBody = "";
     for (const modelDef of modelDefs) {
         modelText += modelDef.text(indent);
         modelDef.Methods.sort((a, b) => {
@@ -44,7 +44,7 @@ export function generateModels(pkg, options, emitter) {
         });
         for (const method of modelDef.Methods) {
             if (method.desc.length > 0) {
-                modelText += `${helpers.comment(method.desc, '// ', undefined, helpers.commentLength)}\n`;
+                modelText += `${helpers.comment(method.desc, "// ", undefined, helpers.commentLength)}\n`;
             }
             modelText += method.text;
         }
@@ -53,7 +53,7 @@ export function generateModels(pkg, options, emitter) {
         });
         for (const method of modelDef.SerDe.methods) {
             if (method.desc.length > 0) {
-                serdeTextBody += `${helpers.comment(method.desc, '// ', undefined, helpers.commentLength)}\n`;
+                serdeTextBody += `${helpers.comment(method.desc, "// ", undefined, helpers.commentLength)}\n`;
             }
             serdeTextBody += method.text;
         }
@@ -80,9 +80,9 @@ export function generateModels(pkg, options, emitter) {
         }
     }
     if (needsJSONPopulate) {
-        serdeImports.add('reflect');
-        serdeImports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore');
-        serdeTextBody += 'func populate(m map[string]any, k string, v any) {\n';
+        serdeImports.add("reflect");
+        serdeImports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore");
+        serdeTextBody += "func populate(m map[string]any, k string, v any) {\n";
         serdeTextBody += `${indent.get()}if v == nil {\n`;
         serdeTextBody += `${indent.push().get()}return\n`;
         serdeTextBody += `${indent.pop().get()}} else if azcore.IsNullValue(v) {\n`;
@@ -90,13 +90,14 @@ export function generateModels(pkg, options, emitter) {
         serdeTextBody += `${indent.pop().get()}} else if !reflect.ValueOf(v).IsNil() {\n`;
         serdeTextBody += `${indent.push().get()}m[k] = v\n`;
         serdeTextBody += `${indent.pop().get()}}\n`;
-        serdeTextBody += '}\n\n';
+        serdeTextBody += "}\n\n";
     }
     if (needsJSONPopulateTime) {
-        serdeImports.add('time');
-        serdeImports.add('reflect');
-        serdeImports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore');
-        serdeTextBody += 'func populateTime[T dateTimeConstraints](m map[string]any, k string, t *time.Time) {\n';
+        serdeImports.add("time");
+        serdeImports.add("reflect");
+        serdeImports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore");
+        serdeTextBody +=
+            "func populateTime[T dateTimeConstraints](m map[string]any, k string, t *time.Time) {\n";
         serdeTextBody += `${indent.get()}if t == nil {\n`;
         serdeTextBody += `${indent.push().get()}return\n`;
         serdeTextBody += `${indent.pop().get()}} else if azcore.IsNullValue(t) {\n`;
@@ -107,11 +108,11 @@ export function generateModels(pkg, options, emitter) {
         serdeTextBody += `${indent.get()}m[k] = (*T)(&newTime)\n`;
         indent.pop();
         serdeTextBody += `${indent.get()}}\n`;
-        serdeTextBody += '}\n\n';
+        serdeTextBody += "}\n\n";
     }
     if (needsJSONPopulateAny) {
-        serdeImports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore');
-        serdeTextBody += 'func populateAny(m map[string]any, k string, v any) {\n';
+        serdeImports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore");
+        serdeTextBody += "func populateAny(m map[string]any, k string, v any) {\n";
         serdeTextBody += `${indent.get()}if v == nil {\n`;
         serdeTextBody += `${indent.push().get()}return\n`;
         serdeTextBody += `${indent.pop().get()}} else if azcore.IsNullValue(v) {\n`;
@@ -119,12 +120,13 @@ export function generateModels(pkg, options, emitter) {
         serdeTextBody += `${indent.pop().get()}} else {\n`;
         serdeTextBody += `${indent.push().get()}m[k] = v\n`;
         serdeTextBody += `${indent.pop().get()}}\n`;
-        serdeTextBody += '}\n\n';
+        serdeTextBody += "}\n\n";
     }
     if (needsJSONPopulateByteArray) {
-        serdeImports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore');
-        serdeImports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
-        serdeTextBody += 'func populateByteArray[T any](m map[string]any, k string, b []T, convert func() any) {\n';
+        serdeImports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore");
+        serdeImports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
+        serdeTextBody +=
+            "func populateByteArray[T any](m map[string]any, k string, b []T, convert func() any) {\n";
         serdeTextBody += `${indent.get()}if azcore.IsNullValue(b) {\n`;
         serdeTextBody += `${indent.push().get()}m[k] = nil\n`;
         serdeTextBody += `${indent.pop().get()}} else if len(b) == 0 {\n`;
@@ -132,11 +134,11 @@ export function generateModels(pkg, options, emitter) {
         serdeTextBody += `${indent.pop().get()}} else {\n`;
         serdeTextBody += `${indent.push().get()}m[k] = convert()\n`;
         serdeTextBody += `${indent.pop().get()}}\n`;
-        serdeTextBody += '}\n\n';
+        serdeTextBody += "}\n\n";
     }
     if (needsJSONUnpopulate) {
-        serdeImports.add('fmt');
-        serdeTextBody += 'func unpopulate(data json.RawMessage, fn string, v any) error {\n';
+        serdeImports.add("fmt");
+        serdeTextBody += "func unpopulate(data json.RawMessage, fn string, v any) error {\n";
         serdeTextBody += `${indent.get()}if data == nil || string(data) == "null" {\n`;
         serdeTextBody += `${indent.push().get()}return nil\n`;
         serdeTextBody += `${indent.pop().get()}}\n`;
@@ -144,12 +146,13 @@ export function generateModels(pkg, options, emitter) {
         serdeTextBody += `${indent.push().get()}return fmt.Errorf("struct field %s: %v", fn, err)\n`;
         serdeTextBody += `${indent.pop().get()}}\n`;
         serdeTextBody += `${indent.get()}return nil\n`;
-        serdeTextBody += '}\n\n';
+        serdeTextBody += "}\n\n";
     }
     if (needsJSONUnpopulateTime) {
-        serdeImports.add('fmt');
-        serdeImports.add('time');
-        serdeTextBody += 'func unpopulateTime[T dateTimeConstraints](data json.RawMessage, fn string, t **time.Time) error {\n';
+        serdeImports.add("fmt");
+        serdeImports.add("time");
+        serdeTextBody +=
+            "func unpopulateTime[T dateTimeConstraints](data json.RawMessage, fn string, t **time.Time) error {\n";
         serdeTextBody += `${indent.get()}if data == nil || string(data) == "null" {\n`;
         serdeTextBody += `${indent.push().get()}return nil\n`;
         serdeTextBody += `${indent.pop().get()}}\n`;
@@ -160,35 +163,35 @@ export function generateModels(pkg, options, emitter) {
         serdeTextBody += `${indent.get()}newTime := time.Time(aux)\n`;
         serdeTextBody += `${indent.get()}*t = &newTime\n`;
         serdeTextBody += `${indent.get()}return nil\n`;
-        serdeTextBody += '}\n\n';
+        serdeTextBody += "}\n\n";
     }
     if (needsJSONPopulateMultipart) {
-        serdeImports.add('encoding/json');
-        serdeTextBody += 'func populateMultipartJSON(m map[string]any, k string, v any) error {\n';
+        serdeImports.add("encoding/json");
+        serdeTextBody += "func populateMultipartJSON(m map[string]any, k string, v any) error {\n";
         serdeTextBody += `${indent.get()}data, err := json.Marshal(v)\n`;
         serdeTextBody += `${indent.get()}if err != nil {\n`;
         serdeTextBody += `${indent.push().get()}return err\n`;
         serdeTextBody += `${indent.pop().get()}}\n`;
         serdeTextBody += `${indent.get()}m[k] = data\n`;
         serdeTextBody += `${indent.get()}return nil\n`;
-        serdeTextBody += '}\n\n';
+        serdeTextBody += "}\n\n";
     }
     if (needsJSONUnpopulateTime || needsJSONPopulateTime) {
-        const formats = new Array('datetime.PlainDate', 'datetime.PlainTime', 'datetime.RFC3339', 'datetime.Unix');
+        const formats = new Array("datetime.PlainDate", "datetime.PlainTime", "datetime.RFC3339", "datetime.Unix");
         serdeTextBody += `type dateTimeConstraints interface {\n`;
         // rfc1123 and rfc7231 are mutually exclusive based on the emitter
         switch (emitter) {
-            case 'openapi':
-                formats.push('datetime.RFC1123');
+            case "openapi":
+                formats.push("datetime.RFC1123");
                 break;
-            case 'tsp':
-                formats.push('datetime.RFC7231');
+            case "tsp":
+                formats.push("datetime.RFC7231");
                 break;
         }
-        serdeTextBody += `${indent.get()}${formats.sort().join(' | ')}\n`;
-        serdeTextBody += '}\n\n';
+        serdeTextBody += `${indent.get()}${formats.sort().join(" | ")}\n`;
+        serdeTextBody += "}\n\n";
     }
-    let serdeText = '';
+    let serdeText = "";
     if (serdeTextBody.length > 0) {
         serdeText = helpers.contentPreamble(pkg);
         serdeText += serdeImports.text();
@@ -215,61 +218,65 @@ function generateModelDefs(modelImports, serdeImports, pkg, options, indent) {
         for (const field of model.fields) {
             const descriptionMods = new Array();
             if (field.annotations.readOnly) {
-                descriptionMods.push('READ-ONLY');
+                descriptionMods.push("READ-ONLY");
             }
-            else if (field.annotations.required && (field.type.kind !== 'literal' || model.usage === go.UsageFlags.Output)) {
-                descriptionMods.push('REQUIRED');
+            else if (field.annotations.required &&
+                (field.type.kind !== "literal" || model.usage === go.UsageFlags.Output)) {
+                descriptionMods.push("REQUIRED");
             }
-            else if (field.type.kind === 'literal') {
+            else if (field.type.kind === "literal") {
                 if (!field.annotations.required) {
-                    descriptionMods.push('FLAG');
+                    descriptionMods.push("FLAG");
                 }
-                descriptionMods.push('CONSTANT');
+                descriptionMods.push("CONSTANT");
             }
-            if (field.type.kind === 'literal' && model.usage !== go.UsageFlags.Output) {
+            if (field.type.kind === "literal" && model.usage !== go.UsageFlags.Output) {
                 // add a comment with the const value for const properties that are sent over the wire
                 if (field.docs.description) {
-                    field.docs.description += '\n';
+                    field.docs.description += "\n";
                 }
                 else {
-                    field.docs.description = '';
+                    field.docs.description = "";
                 }
                 field.docs.description += `Field has constant value ${helpers.formatLiteralValue(field.type, false)}, any specified value is ignored.`;
             }
             if (field.docs.description) {
                 descriptionMods.push(field.docs.description);
             }
-            else if (field.type.kind === 'rawJSON') {
+            else if (field.type.kind === "rawJSON") {
                 // add a basic description if one isn't available
-                descriptionMods.push('The contents of this field are raw JSON.');
+                descriptionMods.push("The contents of this field are raw JSON.");
             }
-            field.docs.description = descriptionMods.join('; ');
+            field.docs.description = descriptionMods.join("; ");
         }
         const serDeFormat = helpers.getSerDeFormat(model, pkg);
         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');
+        if (model.kind === "model" && serDeFormat === "XML" && !model.annotations.omitSerDeMethods) {
+            serdeImports.add("encoding/xml");
             let needsDateTimeMarshalling = false;
             let byteArrayFormat = false;
             for (const field of model.fields) {
-                if (field.type.kind !== 'etag') {
+                if (field.type.kind !== "etag") {
                     // azcore.ETag un/marshals on its own so no need to
                     // import azcore as we don't explicitly reference the type
                     serdeImports.addForType(field.type);
                 }
-                if (field.type.kind === 'time') {
+                if (field.type.kind === "time") {
                     needsDateTimeMarshalling = true;
                 }
-                else if (field.type.kind === 'encodedBytes') {
+                else if (field.type.kind === "encodedBytes") {
                     byteArrayFormat = true;
                 }
             }
             // due to differences in XML marshallers/unmarshallers, we use different codegen than for JSON
             const needsXMLDictionaryUnmarshalling = needsXMLDictionaryHelper(model);
-            if (needsDateTimeMarshalling || model.xml?.name || needsXMLArrayMarshalling(model) || byteArrayFormat) {
+            if (needsDateTimeMarshalling ||
+                model.xml?.name ||
+                needsXMLArrayMarshalling(model) ||
+                byteArrayFormat) {
                 generateXMLMarshaller(modelDef, serdeImports, indent);
                 if (needsDateTimeMarshalling || needsXMLDictionaryUnmarshalling || byteArrayFormat) {
                     generateXMLUnmarshaller(modelDef, serdeImports, indent);
@@ -282,7 +289,7 @@ function generateModelDefs(modelImports, serdeImports, pkg, options, indent) {
             modelDefs.push(modelDef);
             continue;
         }
-        if (model.kind === 'polymorphicModel') {
+        if (model.kind === "polymorphicModel") {
             generateDiscriminatorMarkerMethod(model.interface, modelDef, indent);
             for (let parent = model.interface.parent; parent !== undefined; parent = parent.parent) {
                 generateDiscriminatorMarkerMethod(parent, modelDef, indent);
@@ -303,7 +310,7 @@ function generateModelDefs(modelImports, serdeImports, pkg, options, indent) {
 function needsXMLDictionaryHelper(modelType) {
     for (const field of modelType.fields) {
         // additional properties uses an internal wrapper type with its own serde impl
-        if (field.type.kind === 'map' && !field.annotations.isAdditionalProperties) {
+        if (field.type.kind === "map" && !field.annotations.isAdditionalProperties) {
             return true;
         }
     }
@@ -320,7 +327,7 @@ function needsXMLDictionaryHelper(modelType) {
  */
 function needsXMLArrayMarshalling(modelType) {
     for (const prop of modelType.fields) {
-        if (prop.type.kind === 'slice') {
+        if (prop.type.kind === "slice") {
             return true;
         }
     }
@@ -346,7 +353,11 @@ function generateDiscriminatorMarkerMethod(type, modelDef, indent) {
         }
         method += `${indent.pop().get()}}\n}\n\n`;
     }
-    modelDef.Methods.push({ name: interfaceMethod, desc: `${interfaceMethod} implements the ${type.name} interface for type ${modelDef.Model.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, indent) {
     const receiver = modelDef.receiverName();
@@ -354,15 +365,15 @@ function generateToMultipartForm(modelDef, indent) {
     method += `${indent.get()}objectMap := make(map[string]any)\n`;
     for (const field of modelDef.Model.fields) {
         const fieldType = helpers.recursiveUnwrapMapSlice(field.type);
-        let star = '';
+        let star = "";
         if (!field.byValue) {
-            star = '*';
+            star = "*";
         }
         if (!field.byValue) {
             method += `${indent.get()}if ${receiver}.${field.name} != nil {\n`;
             indent.push();
         }
-        if (fieldType.kind === 'model' && !fieldType.annotations.multipartFormData) {
+        if (fieldType.kind === "model" && !fieldType.annotations.multipartFormData) {
             method += `${indent.get()}if err := populateMultipartJSON(objectMap, "${field.serializedName}", ${star}${receiver}.${field.name}); err != nil {\n`;
             method += `${indent.push().get()}return nil, err\n`;
             method += `${indent.pop().get()}}\n`;
@@ -376,7 +387,11 @@ function generateToMultipartForm(modelDef, indent) {
         }
     }
     method += `${indent.get()}return objectMap, nil\n}\n\n`;
-    modelDef.SerDe.methods.push({ name: 'toMultipartFormData', desc: `toMultipartFormData converts ${modelDef.Model.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,
+    });
 }
 /**
  * generates the MarshalJSON method for the provided type.
@@ -387,20 +402,24 @@ function generateToMultipartForm(modelDef, indent) {
  * @param indent the indentation helper currently in scope
  */
 function generateJSONMarshaller(modelDef, imports, indent) {
-    if (modelDef.Model.kind === 'model' && modelDef.Model.fields.length === 0) {
+    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');
+    imports.add("encoding/json");
     const typeName = modelDef.Model.name;
     const receiver = modelDef.receiverName();
     let marshaller = `func (${receiver} ${typeName}) MarshalJSON() ([]byte, error) {\n`;
     marshaller += `${indent.get()}objectMap := make(map[string]any)\n`;
     marshaller += generateJSONMarshallerBody(modelDef, receiver, imports, indent);
     marshaller += `${indent.get()}return 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 });
+    marshaller += "}\n\n";
+    modelDef.SerDe.methods.push({
+        name: "MarshalJSON",
+        desc: `MarshalJSON implements the json.Marshaller interface for type ${typeName}.`,
+        text: marshaller,
+    });
 }
 /**
  * generates the contents of MarshalJSON that encode the target type
@@ -412,10 +431,10 @@ function generateJSONMarshaller(modelDef, imports, indent) {
  * @returns the text for encoding the target type
  */
 function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
-    let marshaller = '';
+    let marshaller = "";
     let addlProps;
     for (const field of modelDef.Model.fields) {
-        if (field.type.kind === 'map' && field.annotations.isAdditionalProperties) {
+        if (field.type.kind === "map" && field.annotations.isAdditionalProperties) {
             addlProps = field.type;
             continue;
         }
@@ -429,15 +448,15 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
                 marshaller += `${indent.get()}objectMap["${field.serializedName}"] = ${receiver}.${field.name}\n`;
             }
         }
-        else if (field.type.kind === 'encodedBytes') {
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+        else if (field.type.kind === "encodedBytes") {
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
             marshaller += `${indent.get()}populateByteArray(objectMap, "${field.serializedName}", ${receiver}.${field.name}, func() any {\n`;
             marshaller += `${indent.push().get()}return runtime.EncodeByteArray(${receiver}.${field.name}, runtime.Base64${field.type.encoding}Format)\n`;
             marshaller += `${indent.pop().get()}})\n`;
             modelDef.SerDe.needsJSONPopulateByteArray = true;
         }
-        else if (field.type.kind === 'slice' && field.type.elementType.kind === 'encodedBytes') {
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+        else if (field.type.kind === "slice" && field.type.elementType.kind === "encodedBytes") {
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
             marshaller += `${indent.get()}populateByteArray(objectMap, "${field.serializedName}", ${receiver}.${field.name}, func() any {\n`;
             marshaller += `${indent.push().get()}encodedValue := make([]string, len(${receiver}.${field.name}))\n`;
             marshaller += `${indent.get()}for i := 0; i < len(${receiver}.${field.name}); i++ {\n`;
@@ -447,13 +466,13 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
             marshaller += `${indent.pop().get()}})\n`;
             modelDef.SerDe.needsJSONPopulateByteArray = true;
         }
-        else if (field.type.kind === 'slice' && field.type.elementType.kind === 'time') {
+        else if (field.type.kind === "slice" && field.type.elementType.kind === "time") {
             const source = `${receiver}.${field.name}`;
-            let elementPtr = '*';
+            let elementPtr = "*";
             if (field.type.elementTypeByValue) {
-                elementPtr = '';
+                elementPtr = "";
             }
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
             marshaller += `${indent.get()}aux := make([]${elementPtr}datetime.${field.type.elementType.format}, len(${source}), len(${source}))\n`;
             marshaller += `${indent.get()}for i := 0; i < len(${source}); i++ {\n`;
             marshaller += `${indent.push().get()}aux[i] = (${elementPtr}datetime.${field.type.elementType.format})(${source}[i])\n`;
@@ -461,7 +480,7 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
             marshaller += `${indent.get()}populate(objectMap, "${field.serializedName}", aux)\n`;
             modelDef.SerDe.needsJSONPopulate = true;
         }
-        else if (field.type.kind === 'literal') {
+        else if (field.type.kind === "literal") {
             const setter = `objectMap["${field.serializedName}"] = ${helpers.formatLiteralValue(field.type, true)}`;
             if (!field.annotations.required) {
                 marshaller += `${indent.get()}if ${receiver}.${field.name} != nil {\n`;
@@ -472,40 +491,43 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
                 marshaller += `${indent.get()}${setter}\n`;
             }
         }
-        else if (field.type.kind === 'rawJSON') {
+        else if (field.type.kind === "rawJSON") {
             marshaller += `${indent.get()}populate(objectMap, "${field.serializedName}", json.RawMessage(${receiver}.${field.name}))\n`;
             modelDef.SerDe.needsJSONPopulate = true;
         }
         else {
             if (field.defaultValue) {
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
                 marshaller += `${indent.get()}if ${receiver}.${field.name} == nil {\n`;
                 marshaller += `${indent.push().get()}${receiver}.${field.name} = to.Ptr(${helpers.formatLiteralValue(field.defaultValue, true)})\n`;
                 marshaller += `${indent.pop().get()}}\n`;
             }
             let populate;
-            if (field.type.kind === 'time') {
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+            if (field.type.kind === "time") {
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
                 populate = `populateTime[datetime.${field.type.format}]`;
                 modelDef.SerDe.needsJSONPopulateTime = true;
             }
-            else if (field.type.kind === 'any') {
-                populate = 'populateAny';
+            else if (field.type.kind === "any") {
+                populate = "populateAny";
                 modelDef.SerDe.needsJSONPopulateAny = true;
             }
             else {
-                populate = 'populate';
+                populate = "populate";
                 modelDef.SerDe.needsJSONPopulate = true;
             }
-            if (field.type.kind === 'scalar' && (field.type.type.startsWith('uint') || field.type.type.startsWith('int')) && field.type.encodeAsString) {
+            if (field.type.kind === "scalar" &&
+                (field.type.type.startsWith("uint") || field.type.type.startsWith("int")) &&
+                field.type.encodeAsString) {
                 // TODO: need to handle map and slice type with underlying int as string type
-                imports.add('strconv');
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
-                if ((field.type.type.startsWith('uint') && field.type.type !== 'uint64') || (field.type.type.startsWith('int') && field.type.type !== 'int64')) {
-                    marshaller += `${indent.get()}${populate}(objectMap, "${field.serializedName}", to.Ptr(strconv.${field.type.type.startsWith('int') ? 'FormatInt' : 'FormatUint'}(${field.type.type.startsWith('int') ? 'int64' : 'uint64'}(*${receiver}.${field.name}), 10)))\n`;
+                imports.add("strconv");
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
+                if ((field.type.type.startsWith("uint") && field.type.type !== "uint64") ||
+                    (field.type.type.startsWith("int") && field.type.type !== "int64")) {
+                    marshaller += `${indent.get()}${populate}(objectMap, "${field.serializedName}", to.Ptr(strconv.${field.type.type.startsWith("int") ? "FormatInt" : "FormatUint"}(${field.type.type.startsWith("int") ? "int64" : "uint64"}(*${receiver}.${field.name}), 10)))\n`;
                 }
                 else {
-                    marshaller += `${indent.get()}${populate}(objectMap, "${field.serializedName}", to.Ptr(strconv.${field.type.type.startsWith('int') ? 'FormatInt' : 'FormatUint'}(*${receiver}.${field.name}, 10)))\n`;
+                    marshaller += `${indent.get()}${populate}(objectMap, "${field.serializedName}", to.Ptr(strconv.${field.type.type.startsWith("int") ? "FormatInt" : "FormatUint"}(*${receiver}.${field.name}, 10)))\n`;
                 }
             }
             else {
@@ -516,8 +538,8 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
     if (addlProps) {
         marshaller += `${indent.get()}if ${receiver}.AdditionalProperties != nil {\n`;
         marshaller += `${indent.push().get()}for key, val := range ${receiver}.AdditionalProperties {\n`;
-        let assignment = 'val';
-        if (addlProps.valueType.kind === 'time') {
+        let assignment = "val";
+        if (addlProps.valueType.kind === "time") {
             assignment = `(*${addlProps.valueType.format})(val)`;
         }
         marshaller += `${indent.push().get()}objectMap[key] = ${assignment}\n`;
@@ -541,8 +563,8 @@ function generateJSONUnmarshaller(modelDef, options, imports, indent) {
     if (modelDef.Model.fields.length === 0) {
         return;
     }
-    imports.add('encoding/json');
-    imports.add('fmt');
+    imports.add("encoding/json");
+    imports.add("fmt");
     const typeName = modelDef.Model.name;
     const receiver = modelDef.receiverName();
     let unmarshaller = `func (${receiver} *${typeName}) UnmarshalJSON(data []byte) error {\n`;
@@ -551,8 +573,12 @@ function generateJSONUnmarshaller(modelDef, options, imports, indent) {
     unmarshaller += `${indent.push().get()}return fmt.Errorf("unmarshalling type %T: %s", ${receiver}, err.Error())\n`;
     unmarshaller += `${indent.pop().get()}}\n`;
     unmarshaller += generateJSONUnmarshallerBody(modelDef, receiver, options, imports, indent);
-    unmarshaller += '}\n\n';
-    modelDef.SerDe.methods.push({ name: 'UnmarshalJSON', desc: `UnmarshalJSON implements the json.Unmarshaller interface for type ${typeName}.`, text: unmarshaller });
+    unmarshaller += "}\n\n";
+    modelDef.SerDe.methods.push({
+        name: "UnmarshalJSON",
+        desc: `UnmarshalJSON implements the json.Unmarshaller interface for type ${typeName}.`,
+        text: unmarshaller,
+    });
 }
 /**
  * generates the contents of UnmarshalJSON that decode the target type
@@ -573,17 +599,17 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
     const emitAddlProps = function (addlProps) {
         // indent is at the case body level when called
         let addlPropsText = `${indent.get()}if ${receiver}.AdditionalProperties == nil {\n`;
-        let ref = '';
+        let ref = "";
         if (!addlProps.valueTypeByValue) {
-            ref = '&';
+            ref = "&";
         }
         addlPropsText += `${indent.push().get()}${receiver}.AdditionalProperties = ${go.getTypeDeclaration(addlProps, modelDef.Model.pkg)}{}\n`;
         addlPropsText += `${indent.pop().get()}}\n`;
         addlPropsText += `${indent.get()}if val != nil {\n`;
         let auxType = go.getTypeDeclaration(addlProps.valueType, modelDef.Model.pkg);
         let assignment = `${ref}aux`;
-        if (addlProps.valueType.kind === 'time') {
-            imports.add('time');
+        if (addlProps.valueType.kind === "time") {
+            imports.add("time");
             auxType = addlProps.valueType.format;
             assignment = `(*time.Time)(${assignment})`;
         }
@@ -597,11 +623,11 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
     };
     const emitSwitchCase = function () {
         // indent is at level 2 (for loop body) when called
-        let unmarshalBody = '';
+        let unmarshalBody = "";
         let addlProps;
         unmarshalBody += `${indent.get()}switch key {\n`;
         for (const field of modelDef.Model.fields) {
-            if (field.type.kind === 'map' && field.annotations.isAdditionalProperties) {
+            if (field.type.kind === "map" && field.annotations.isAdditionalProperties) {
                 addlProps = field.type;
                 continue;
             }
@@ -611,17 +637,17 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
                 unmarshalBody += generateDiscriminatorUnmarshaller(modelDef.Model, field, receiver, indent);
                 needsErrCheck = true;
             }
-            else if (field.type.kind === 'time') {
+            else if (field.type.kind === "time") {
                 unmarshalBody += `${indent.get()}err = unpopulateTime[datetime.${field.type.format}](val, "${field.name}", &${receiver}.${field.name})\n`;
                 modelDef.SerDe.needsJSONUnpopulateTime = true;
                 needsErrCheck = true;
             }
-            else if (field.type.kind === 'slice' && field.type.elementType.kind === 'time') {
-                imports.add('time');
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
-                let elementPtr = '*';
+            else if (field.type.kind === "slice" && field.type.elementType.kind === "time") {
+                imports.add("time");
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
+                let elementPtr = "*";
                 if (field.type.elementTypeByValue) {
-                    elementPtr = '';
+                    elementPtr = "";
                 }
                 unmarshalBody += `${indent.get()}var aux []${elementPtr}datetime.${field.type.elementType.format}\n`;
                 unmarshalBody += `${indent.get()}err = unpopulate(val, "${field.name}", &aux)\n`;
@@ -631,15 +657,15 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
                 modelDef.SerDe.needsJSONUnpopulate = true;
                 needsErrCheck = true;
             }
-            else if (field.type.kind === 'encodedBytes') {
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+            else if (field.type.kind === "encodedBytes") {
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
                 unmarshalBody += `${indent.get()}if val != nil && string(val) != "null" {\n`;
                 unmarshalBody += `${indent.push().get()}err = runtime.DecodeByteArray(string(val), &${receiver}.${field.name}, runtime.Base64${field.type.encoding}Format)\n`;
                 unmarshalBody += `${indent.pop().get()}}\n`;
                 needsErrCheck = true;
             }
-            else if (field.type.kind === 'slice' && field.type.elementType.kind === 'encodedBytes') {
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+            else if (field.type.kind === "slice" && field.type.elementType.kind === "encodedBytes") {
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
                 unmarshalBody += `${indent.get()}var encodedValue []string\n`;
                 unmarshalBody += `${indent.get()}err = unpopulate(val, "${field.name}", &encodedValue)\n`;
                 unmarshalBody += `${indent.get()}if err == nil && len(encodedValue) > 0 {\n`;
@@ -653,22 +679,25 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
                 modelDef.SerDe.needsJSONUnpopulate = true;
                 needsErrCheck = true;
             }
-            else if (field.type.kind === 'rawJSON') {
+            else if (field.type.kind === "rawJSON") {
                 unmarshalBody += `${indent.get()}if string(val) != "null" {\n`;
                 unmarshalBody += `${indent.push().get()}${receiver}.${field.name} = val\n`;
                 unmarshalBody += `${indent.pop().get()}}\n`;
             }
-            else if (field.type.kind === 'scalar' && (field.type.type.startsWith('uint') || field.type.type.startsWith('int')) && field.type.encodeAsString) {
+            else if (field.type.kind === "scalar" &&
+                (field.type.type.startsWith("uint") || field.type.type.startsWith("int")) &&
+                field.type.encodeAsString) {
                 // TODO: need to handle map and slice type with underlying int as string type
-                imports.add('strconv');
+                imports.add("strconv");
                 unmarshalBody += `${indent.get()}var aux string\n`;
                 unmarshalBody += `${indent.get()}err = unpopulate(val, "${field.name}", &aux)\n`;
                 unmarshalBody += `${indent.get()}if err == nil {\n`;
                 indent.push();
-                unmarshalBody += `${indent.get()}var v ${field.type.type.startsWith('int') ? 'int64' : 'uint64'}\n`;
-                unmarshalBody += `${indent.get()}v, err = strconv.${field.type.type.startsWith('int') ? 'ParseInt' : 'ParseUint'}(aux, 10, 0)\n`;
+                unmarshalBody += `${indent.get()}var v ${field.type.type.startsWith("int") ? "int64" : "uint64"}\n`;
+                unmarshalBody += `${indent.get()}v, err = strconv.${field.type.type.startsWith("int") ? "ParseInt" : "ParseUint"}(aux, 10, 0)\n`;
                 unmarshalBody += `${indent.get()}if err == nil {\n`;
-                if ((field.type.type.startsWith('uint') && field.type.type !== 'uint64') || (field.type.type.startsWith('int') && field.type.type !== 'int64')) {
+                if ((field.type.type.startsWith("uint") && field.type.type !== "uint64") ||
+                    (field.type.type.startsWith("int") && field.type.type !== "int64")) {
                     unmarshalBody += `${indent.push().get()}${receiver}.${field.name} = to.Ptr(${field.type.type}(v))\n`;
                 }
                 else {
@@ -682,7 +711,7 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
             }
             else {
                 const unpopulateField = `err = unpopulate(val, "${field.name}", &${receiver}.${field.name})\n`;
-                if (field.type.kind === 'string' && field.annotations.unmarshalEmptyStringAsNil) {
+                if (field.type.kind === "string" && field.annotations.unmarshalEmptyStringAsNil) {
                     unmarshalBody += `${indent.get()}${helpers.buildIfBlock(indent, {
                         condition: `string(val) != \`""\``,
                         body: (indent) => `${indent.get()}${unpopulateField}`,
@@ -734,11 +763,11 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
 // recursively called for arrays and dictionaries.
 function hasDiscriminatorInterface(item) {
     switch (item.kind) {
-        case 'interface':
+        case "interface":
             return true;
-        case 'map':
+        case "map":
             return hasDiscriminatorInterface(item.valueType);
-        case 'slice':
+        case "slice":
             return hasDiscriminatorInterface(item.elementType);
         default:
             return false;
@@ -747,14 +776,14 @@ function hasDiscriminatorInterface(item) {
 // returns the text for unmarshalling a discriminated type
 function generateDiscriminatorUnmarshaller(modelType, field, receiver, indent) {
     const propertyName = field.name;
-    // these are the simple, non-nested cases (e.g. IterfaceType, []InterfaceType, map[string]InterfaceType)
-    if (field.type.kind === 'interface') {
+    // these are the simple, non-nested cases (e.g. InterfaceType, []InterfaceType, map[string]InterfaceType)
+    if (field.type.kind === "interface") {
         return `${indent.get()}${receiver}.${propertyName}, err = unmarshal${field.type.name}(val)\n`;
     }
-    else if (field.type.kind === 'slice' && field.type.elementType.kind === 'interface') {
+    else if (field.type.kind === "slice" && field.type.elementType.kind === "interface") {
         return `${indent.get()}${receiver}.${propertyName}, err = unmarshal${field.type.elementType.name}Array(val)\n`;
     }
-    else if (field.type.kind === 'map' && field.type.valueType.kind === 'interface') {
+    else if (field.type.kind === "map" && field.type.valueType.kind === "interface") {
         return `${indent.get()}${receiver}.${propertyName}, err = unmarshal${field.type.valueType.name}Map(val)\n`;
     }
     // nested case (e.g. [][]InterfaceType, map[string]map[string]InterfaceType etc)
@@ -767,7 +796,7 @@ function generateDiscriminatorUnmarshaller(modelType, field, receiver, indent) {
     // create a local instantiation of the final type
     const finalTargetVar = field.serializedName;
     let finalTargetCtor = recursiveGetDiscriminatorTypeName(modelType, field.type, false);
-    if (field.type.kind === 'slice') {
+    if (field.type.kind === "slice") {
         finalTargetCtor = `make(${finalTargetCtor}, len(${rawTargetVar}))`;
     }
     else {
@@ -786,18 +815,18 @@ function generateDiscriminatorUnmarshaller(modelType, field, receiver, indent) {
 // !raw e.g. map[string]map[string]InterfaceType, [][]InterfaceType etc
 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') {
+    if (item.kind === "slice") {
+        if (!raw || item.elementType.kind !== "interface") {
             return `[]${recursiveGetDiscriminatorTypeName(modelType, item.elementType, raw)}`;
         }
     }
-    else if (item.kind === 'map') {
-        if (!raw || item.valueType.kind !== 'interface') {
+    else if (item.kind === "map") {
+        if (!raw || item.valueType.kind !== "interface") {
             return `map[string]${recursiveGetDiscriminatorTypeName(modelType, item.valueType, raw)}`;
         }
     }
     if (raw) {
-        return 'json.RawMessage';
+        return "json.RawMessage";
     }
     return go.getTypeDeclaration(item, modelType.pkg);
 }
@@ -814,11 +843,11 @@ function recursiveGetDiscriminatorTypeName(modelType, item, raw) {
  * @returns the text populating the discriminator
  */
 function recursivePopulateDiscriminator(modelType, item, receiver, rawSrc, dest, indent, nesting) {
-    let text = '';
-    let interfaceName = '';
-    let targetType = '';
-    if (item.kind === 'slice') {
-        if (item.elementType.kind !== 'interface') {
+    let text = "";
+    let interfaceName = "";
+    let targetType = "";
+    if (item.kind === "slice") {
+        if (item.elementType.kind !== "interface") {
             if (nesting > 1) {
                 // at nestling level 1, the destination var was already created in generateDiscriminatorUnmarshaller()
                 text += `${indent.get()}${dest} = make(${recursiveGetDiscriminatorTypeName(modelType, item, false)}, len(${rawSrc}))\n`;
@@ -834,10 +863,10 @@ function recursivePopulateDiscriminator(modelType, item, receiver, rawSrc, dest,
         }
         // we're at leaf node - 1, so get the interface from the element's type
         interfaceName = go.getTypeDeclaration(item.elementType, modelType.pkg);
-        targetType = 'Array';
+        targetType = "Array";
     }
-    else if (item.kind === 'map') {
-        if (item.valueType.kind !== 'interface') {
+    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.get()}${dest} = ${recursiveGetDiscriminatorTypeName(modelType, item, false)}{}\n`;
@@ -853,7 +882,7 @@ function recursivePopulateDiscriminator(modelType, item, receiver, rawSrc, dest,
         }
         // we're at leaf node - 1, so get the interface from the element's type
         interfaceName = go.getTypeDeclaration(item.valueType, modelType.pkg);
-        targetType = 'Map';
+        targetType = "Map";
     }
     text += `${indent.get()}${dest}, err = unmarshal${interfaceName}${targetType}(${rawSrc})\n`;
     text += `${indent.get()}if err != nil {\n`;
@@ -878,16 +907,16 @@ function generateXMLMarshaller(modelDef, imports, indent) {
     }
     text += generateAliasType(modelDef.Model, receiver, true, imports, indent);
     for (const field of modelDef.Model.fields) {
-        if (field.type.kind === 'slice') {
+        if (field.type.kind === "slice") {
             text += `${indent.get()}if ${receiver}.${field.name} != nil {\n`;
             text += `${indent.push().get()}aux.${field.name} = &${receiver}.${field.name}\n`;
             text += `${indent.pop().get()}}\n`;
         }
-        else if (field.annotations.isAdditionalProperties || field.type.kind === 'map') {
+        else if (field.annotations.isAdditionalProperties || field.type.kind === "map") {
             text += `${indent.get()}aux.${field.name} = (additionalProperties)(${receiver}.${field.name})\n`;
         }
-        else if (field.type.kind === 'encodedBytes') {
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+        else if (field.type.kind === "encodedBytes") {
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
             text += `${indent.get()}if ${receiver}.${field.name} != nil {\n`;
             indent.push();
             text += `${indent.get()}encoded${field.name} := runtime.EncodeByteArray(${receiver}.${field.name}, runtime.Base64${field.type.encoding}Format)\n`;
@@ -897,8 +926,8 @@ function generateXMLMarshaller(modelDef, imports, indent) {
         }
     }
     text += `${indent.get()}return enc.EncodeElement(aux, start)\n`;
-    text += '}\n\n';
-    modelDef.SerDe.methods.push({ name: 'MarshalXML', desc: desc, text: text });
+    text += "}\n\n";
+    modelDef.SerDe.methods.push({ name: "MarshalXML", desc: desc, text: text });
 }
 /**
  * generates an implementation of UnmarshalXML for the provided type.
@@ -917,16 +946,16 @@ function generateXMLUnmarshaller(modelDef, imports, indent) {
     text += `${indent.push().get()}return err\n`;
     text += `${indent.pop().get()}}\n`;
     for (const field of modelDef.Model.fields) {
-        if (field.type.kind === 'time') {
+        if (field.type.kind === "time") {
             text += `${indent.get()}if aux.${field.name} != nil && !(*time.Time)(aux.${field.name}).IsZero() {\n`;
             text += `${indent.push().get()}${receiver}.${field.name} = (*time.Time)(aux.${field.name})\n`;
             text += `${indent.pop().get()}}\n`;
         }
-        else if (field.annotations.isAdditionalProperties || field.type.kind === 'map') {
+        else if (field.annotations.isAdditionalProperties || field.type.kind === "map") {
             text += `${indent.get()}${receiver}.${field.name} = (map[string]*string)(aux.${field.name})\n`;
         }
-        else if (field.type.kind === 'encodedBytes') {
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+        else if (field.type.kind === "encodedBytes") {
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
             text += `${indent.get()}if aux.${field.name} != nil {\n`;
             indent.push();
             text += `${indent.get()}if err := runtime.DecodeByteArray(*aux.${field.name}, &${receiver}.${field.name}, runtime.Base64${field.type.encoding}Format); err != nil {\n`;
@@ -937,8 +966,8 @@ function generateXMLUnmarshaller(modelDef, imports, indent) {
         }
     }
     text += `${indent.get()}return nil\n`;
-    text += '}\n\n';
-    modelDef.SerDe.methods.push({ name: 'UnmarshalXML', desc: desc, text: text });
+    text += "}\n\n";
+    modelDef.SerDe.methods.push({ name: "UnmarshalXML", desc: desc, text: text });
 }
 /**
  * generates an alias type used by custom XML marshaller/unmarshaller
@@ -954,33 +983,33 @@ function generateAliasType(modelType, receiver, forMarshal, imports, indent) {
     text += `${indent.push().get()}*alias\n`;
     for (const field of modelType.fields) {
         const sn = getXMLSerialization(field);
-        if (field.type.kind === 'time') {
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+        if (field.type.kind === "time") {
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
             text += `${indent.get()}${field.name} *datetime.${field.type.format} \`xml:"${sn}"\`\n`;
         }
-        else if (field.annotations.isAdditionalProperties || field.type.kind === 'map') {
+        else if (field.annotations.isAdditionalProperties || field.type.kind === "map") {
             text += `${indent.get()}${field.name} additionalProperties \`xml:"${sn}"\`\n`;
         }
-        else if (field.type.kind === 'slice') {
+        else if (field.type.kind === "slice") {
             text += `${indent.get()}${field.name} *${go.getTypeDeclaration(field.type, modelType.pkg)} \`xml:"${sn}"\`\n`;
         }
-        else if (field.type.kind === 'encodedBytes') {
+        else if (field.type.kind === "encodedBytes") {
             text += `${indent.get()}${field.name} *string \`xml:"${sn}"\`\n`;
         }
     }
     text += `${indent.pop().get()}}{\n`;
     let rec = receiver;
     if (forMarshal) {
-        rec = '&' + rec;
+        rec = "&" + rec;
     }
     text += `${indent.push().get()}alias: (*alias)(${rec}),\n`;
     if (forMarshal) {
         // emit code to initialize time fields
         for (const field of modelType.fields) {
-            if (field.type.kind !== 'time') {
+            if (field.type.kind !== "time") {
                 continue;
             }
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
             text += `${indent.get()}${field.name}: (*datetime.${field.type.format})(${receiver}.${field.name}),\n`;
         }
     }
@@ -1026,10 +1055,12 @@ class ModelDef {
         text += `type ${this.Model.name} struct {\n`;
         // group fields by required/optional/read-only in that order
         this.Model.fields.sort((lhs, rhs) => {
-            if ((lhs.annotations.required && !rhs.annotations.required) || (!lhs.annotations.readOnly && rhs.annotations.readOnly)) {
+            if ((lhs.annotations.required && !rhs.annotations.required) ||
+                (!lhs.annotations.readOnly && rhs.annotations.readOnly)) {
                 return -1;
             }
-            else if ((rhs.annotations.readOnly && !lhs.annotations.readOnly) || (!rhs.annotations.readOnly && lhs.annotations.readOnly)) {
+            else if ((rhs.annotations.readOnly && !lhs.annotations.readOnly) ||
+                (!rhs.annotations.readOnly && lhs.annotations.readOnly)) {
                 return 1;
             }
             else {
@@ -1043,31 +1074,31 @@ class ModelDef {
                 if (!first) {
                     // add an extra new-line between fields IFF the field
                     // has a comment and it's not the very first one.
-                    text += '\n';
+                    text += "\n";
                 }
                 text += helpers.formatDocComment(field.docs);
             }
             let typeName = go.getTypeDeclaration(field.type, this.Model.pkg);
-            if (field.type.kind === 'literal') {
+            if (field.type.kind === "literal") {
                 // for constants we use the underlying type name
                 typeName = go.getLiteralTypeDeclaration(field.type.type);
             }
             let serialization = field.serializedName;
-            if (this.Format === 'JSON') {
-                serialization += ',omitempty';
+            if (this.Format === "JSON") {
+                serialization += ",omitempty";
             }
-            else if (this.Format === 'XML') {
+            else if (this.Format === "XML") {
                 serialization = getXMLSerialization(field);
             }
-            let tag = '';
+            let tag = "";
             // only emit tags for XML; JSON uses custom marshallers/unmarshallers
-            if (this.Format === 'XML' && !field.annotations.isAdditionalProperties) {
+            if (this.Format === "XML" && !field.annotations.isAdditionalProperties) {
                 tag = ` \`xml:"${serialization}"\``;
             }
             text += `${indent.get()}${field.name} ${helpers.star(field.byValue)}${typeName}${tag}\n`;
             first = false;
         }
-        text += '}\n\n';
+        text += "}\n\n";
         return text;
     }
     /** returns the name to use for method receivers on this struct */
@@ -1086,19 +1117,19 @@ function getXMLSerialization(field) {
     let serialization = field.serializedName;
     // default to using the serialization name
     if (field.xml?.name) {
-        // xml can specifiy its own name, prefer that if available
+        // xml can specify its own name, prefer that if available
         serialization = field.xml.name;
     }
     else if (field.xml?.text) {
         // type has the x-ms-text attribute applied so it should be character data, not a node (https://github.com/Azure/autorest/tree/main/docs/extensions#x-ms-text)
         // see https://pkg.go.dev/encoding/xml#Unmarshal for what ,chardata actually means
-        serialization = ',chardata';
+        serialization = ",chardata";
     }
     if (field.xml?.attribute) {
         // value comes from an xml attribute
-        serialization += ',attr';
+        serialization += ",attr";
     }
-    else if (field.type.kind === 'slice') {
+    else if (field.type.kind === "slice") {
         // start with the serialized name of the element, preferring xml name if available
         let inner = field.serializedName;
         if (field.xml?.name) {