@azure-tools/typespec-go 0.14.3 → 0.15.0

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

@@ -2,12 +2,12 @@
  *  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 naming from '../../../naming.go/src/naming.js';
-import * as helpers from './helpers.js';
-import { ImportManager } from './imports.js';
-import { fixUpMethodName } from './operations.js';
-import { CodegenError } from './errors.js';
+import * as go from "../../codemodel/index.js";
+import * as naming from "../../naming/naming.js";
+import { CodegenError } from "./errors.js";
+import * as helpers from "./helpers.js";
+import { ImportManager } from "./imports.js";
+import { fixUpMethodName } from "./operations.js";
 // represents the generated content for an example
 export class ExampleContent {
     name;
@@ -31,10 +31,10 @@ export function generateExamples(pkg, target, options) {
     if (pkg.src.clients.length === 0) {
         return examples;
     }
-    const azureARM = target === 'azure-arm';
+    const azureARM = target === "azure-arm";
     for (const client of pkg.src.clients) {
         // client must be constructable to create a sample
-        if (client.instance?.kind != 'constructable') {
+        if (client.instance?.kind !== "constructable") {
             continue;
         }
         const imports = new ImportManager(pkg);
@@ -42,12 +42,12 @@ export function generateExamples(pkg, target, options) {
         if (client.methods.length > 0) {
             // add standard imports for clients with methods.
             // clients that are purely hierarchical (i.e. having no APIs) won't need them.
-            imports.add('context');
-            imports.add('log');
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azidentity');
+            imports.add("context");
+            imports.add("log");
+            imports.add("github.com/Azure/azure-sdk-for-go/sdk/azidentity");
             imports.addForPkg(pkg.src);
         }
-        let clientFactoryParams = new Array();
+        let clientFactoryParams;
         if (options.factoryGatherAllParams) {
             clientFactoryParams = helpers.getAllClientParameters(pkg.src, target);
         }
@@ -58,13 +58,13 @@ export function generateExamples(pkg, target, options) {
         for (const param of clientFactoryParams) {
             clientFactoryParamsMap.set(param.name, param);
         }
-        let exampleText = '';
+        let exampleText = "";
         for (const method of client.methods) {
             for (const example of method.examples) {
                 const indent = new helpers.Indentation();
                 // function signature
                 exampleText += `// Generated from example definition: ${example.filePath}\n`;
-                const exampleFuncNamePrefix = method.examples.length > 1 ? `_${helpers.camelCase(example.name)}` : '';
+                const exampleFuncNamePrefix = method.examples.length > 1 ? `_${helpers.camelCase(example.name)}` : "";
                 exampleText += `func Example${client.name}_${fixUpMethodName(method)}${exampleFuncNamePrefix}() {\n`;
                 // create credential
                 exampleText += `${indent.get()}cred, err := azidentity.NewDefaultAzureCredential(nil)\n`;
@@ -76,7 +76,7 @@ export function generateExamples(pkg, target, options) {
                 // create client
                 const clientParameters = [];
                 for (const param of method.parameters) {
-                    if (param.location === 'client') {
+                    if (param.location === "client") {
                         if (go.isLiteralParameter(param.style)) {
                             continue;
                         }
@@ -87,7 +87,7 @@ export function generateExamples(pkg, target, options) {
                     }
                 }
                 // TODO: client optional parameters
-                let clientRef = '';
+                let clientRef;
                 if (azureARM) {
                     // since not all operation has all the client factory required parameters, we need to fake for the missing ones
                     const clientFactoryParamsExample = [];
@@ -97,10 +97,13 @@ export function generateExamples(pkg, target, options) {
                             clientFactoryParamsExample.push(clientFactoryParam);
                         }
                         else {
-                            clientFactoryParamsExample.push({ parameter: clientParam, value: generateFakeExample(clientParam.type, clientParam.name) });
+                            clientFactoryParamsExample.push({
+                                parameter: clientParam,
+                                value: generateFakeExample(clientParam.type, clientParam.name),
+                            });
                         }
                     }
-                    exampleText += `${indent.get()}clientFactory, err := ${go.getPackageName(pkg.src)}.NewClientFactory(${clientFactoryParamsExample.map((p) => getExampleValue(pkg, p.value, '\t', imports, p.parameter.byValue)).join(', ')}, nil)\n`;
+                    exampleText += `${indent.get()}clientFactory, err := ${go.getPackageName(pkg.src)}.NewClientFactory(${clientFactoryParamsExample.map((p) => getExampleValue(pkg, p.value, "\t", imports, p.parameter.byValue)).join(", ")}, nil)\n`;
                     exampleText += `${indent.get()}if err != nil {\n`;
                     exampleText += `${indent.push().get()}log.Fatalf("failed to create client: %v", err)\n`;
                     exampleText += `${indent.pop().get()}}\n`;
@@ -116,25 +119,28 @@ export function generateExamples(pkg, target, options) {
                             clientPrivateParameters.push(existingParam);
                         }
                         else {
-                            clientPrivateParameters.push({ parameter: ctorParam, value: generateFakeExample(ctorParam.type, ctorParam.name) });
+                            clientPrivateParameters.push({
+                                parameter: ctorParam,
+                                value: generateFakeExample(ctorParam.type, ctorParam.name),
+                            });
                         }
                     }
                     if (clientPrivateParameters.length > 0) {
-                        clientRef += `${clientPrivateParameters.map((p) => getExampleValue(pkg, p.value, '\t', imports, p.parameter.byValue).slice(1)).join(', ')}`;
+                        clientRef += `${clientPrivateParameters.map((p) => getExampleValue(pkg, p.value, "\t", imports, p.parameter.byValue).slice(1)).join(", ")}`;
                     }
                     clientRef += `)`;
                 }
                 else {
-                    exampleText += `${indent.get()}client, err := ${go.getPackageName(client.instance.constructors[0].pkg)}.${client.instance.constructors[0].name}(${clientParameters.map((p) => getExampleValue(pkg, p.value, '\t', imports, p.parameter.byValue).slice(1)).join(', ')}, cred, nil)\n`;
+                    exampleText += `${indent.get()}client, err := ${go.getPackageName(client.instance.constructors[0].pkg)}.${client.instance.constructors[0].name}(${clientParameters.map((p) => getExampleValue(pkg, p.value, "\t", imports, p.parameter.byValue).slice(1)).join(", ")}, cred, nil)\n`;
                     exampleText += `${indent.get()}if err != nil {\n`;
                     exampleText += `${indent.push().get()}log.Fatalf("failed to create client: %v", err)\n`;
                     exampleText += `${indent.pop().get()}}\n`;
-                    clientRef = 'client';
+                    clientRef = "client";
                 }
                 // call method, using getMethodParameters for correct ordering (including required param groups)
                 const renderedParams = [];
                 for (const methodParam of helpers.getMethodParameters(method)) {
-                    if (methodParam.kind === 'paramGroup') {
+                    if (methodParam.kind === "paramGroup") {
                         if (methodParam === method.optionalParamsGroup)
                             continue;
                         imports.addForPkg(methodParam.pkg);
@@ -144,7 +150,7 @@ export function generateExamples(pkg, target, options) {
                                 continue;
                             fieldTexts.push(`${naming.capitalize(groupParam.name)}: ${getParamExampleValue(pkg, groupParam, example, imports)}`);
                         }
-                        renderedParams.push(`${go.getPackageName(methodParam.pkg)}.${methodParam.groupName}{${fieldTexts.join(', ')}}`);
+                        renderedParams.push(`${go.getPackageName(methodParam.pkg)}.${methodParam.groupName}{${fieldTexts.join(", ")}}`);
                     }
                     else {
                         if (!shouldRenderParam(methodParam, example))
@@ -152,47 +158,48 @@ export function generateExamples(pkg, target, options) {
                         renderedParams.push(getParamExampleValue(pkg, methodParam, example, imports));
                     }
                 }
-                const methodOptionalParameters = example.optionalParamsGroup.filter((p) => p.parameter.location === 'method');
+                const methodOptionalParameters = example.optionalParamsGroup.filter((p) => p.parameter.location === "method");
                 const checkResponse = example.responseEnvelope !== undefined;
-                let methodOptionalParametersText = 'nil';
+                let methodOptionalParametersText = "nil";
                 if (methodOptionalParameters.length > 0) {
                     methodOptionalParametersText = `&${go.getPackageName(method.optionalParamsGroup.pkg)}.${method.optionalParamsGroup.groupName}{\n`;
                     methodOptionalParametersText += methodOptionalParameters
-                        .map((p) => `${naming.capitalize(p.parameter.name)}: ${getExampleValue(pkg, p.value, '\t', imports, isParamByValue(p)).slice(1)}`)
-                        .join(',\n');
+                        .map((p) => `${naming.capitalize(p.parameter.name)}: ${getExampleValue(pkg, p.value, "\t", imports, isParamByValue(p)).slice(1)}`)
+                        .join(",\n");
                     methodOptionalParametersText += `}`;
                 }
                 switch (method.kind) {
-                    case 'lroMethod':
-                    case 'lroPageableMethod':
-                        exampleText += `${indent.get()}poller, err := ${clientRef}.${fixUpMethodName(method)}(ctx, ${renderedParams.join(', ')}${renderedParams.length > 0 ? ', ' : ''}${methodOptionalParametersText.split('\n').join('\n' + indent.get())})\n`;
+                    case "lroMethod":
+                    case "lroPageableMethod":
+                        exampleText += `${indent.get()}poller, err := ${clientRef}.${fixUpMethodName(method)}(ctx, ${renderedParams.join(", ")}${renderedParams.length > 0 ? ", " : ""}${methodOptionalParametersText.split("\n").join("\n" + indent.get())})\n`;
                         exampleText += `${indent.get()}if err != nil {\n`;
                         exampleText += `${indent.push().get()}log.Fatalf("failed to finish the request: %v", err)\n`;
                         exampleText += `${indent.pop().get()}}\n`;
-                        exampleText += `${indent.get()}${checkResponse ? 'res' : '_'}, err ${checkResponse ? ':=' : '='} poller.PollUntilDone(ctx, nil)\n`;
+                        exampleText += `${indent.get()}${checkResponse ? "res" : "_"}, err ${checkResponse ? ":=" : "="} poller.PollUntilDone(ctx, nil)\n`;
                         exampleText += `${indent.get()}if err != nil {\n`;
                         exampleText += `${indent.push().get()}log.Fatalf("failed to poll the result: %v", err)\n`;
                         exampleText += `${indent.pop().get()}}\n`;
                         break;
-                    case 'method':
-                        exampleText += `${indent.get()}${checkResponse ? 'res' : '_'}, err ${checkResponse ? ':=' : '='} ${clientRef}.${fixUpMethodName(method)}(ctx, ${renderedParams.join(', ')}${renderedParams.length > 0 ? ', ' : ''}${methodOptionalParametersText.split('\n').join('\n' + indent.get())})\n`;
+                    case "method":
+                        exampleText += `${indent.get()}${checkResponse ? "res" : "_"}, err ${checkResponse ? ":=" : "="} ${clientRef}.${fixUpMethodName(method)}(ctx, ${renderedParams.join(", ")}${renderedParams.length > 0 ? ", " : ""}${methodOptionalParametersText.split("\n").join("\n" + indent.get())})\n`;
                         exampleText += `${indent.get()}if err != nil {\n`;
                         exampleText += `${indent.push().get()}log.Fatalf("failed to finish the request: %v", err)\n`;
                         exampleText += `${indent.pop().get()}}\n`;
                         break;
-                    case 'pageableMethod':
-                        exampleText += `${indent.get()}pager := ${clientRef}.${fixUpMethodName(method)}(${renderedParams.join(', ')}${renderedParams.length > 0 ? ', ' : ''}${methodOptionalParametersText.split('\n').join('\n' + indent.get())})\n`;
+                    case "pageableMethod":
+                        exampleText += `${indent.get()}pager := ${clientRef}.${fixUpMethodName(method)}(${renderedParams.join(", ")}${renderedParams.length > 0 ? ", " : ""}${methodOptionalParametersText.split("\n").join("\n" + indent.get())})\n`;
                         break;
                     default:
                         method;
                 }
                 // check response
-                if ((method.kind === 'lroPageableMethod' || method.kind === 'pageableMethod') && example.responseEnvelope) {
-                    let resultName = 'pager';
-                    if (method.kind === 'lroPageableMethod') {
-                        resultName = 'res';
+                if ((method.kind === "lroPageableMethod" || method.kind === "pageableMethod") &&
+                    example.responseEnvelope) {
+                    let resultName = "pager";
+                    if (method.kind === "lroPageableMethod") {
+                        resultName = "res";
                     }
-                    const itemType = method.returns.result.modelType.fields.find((f) => f.type.kind === 'slice');
+                    const itemType = method.returns.result.modelType.fields.find((f) => f.type.kind === "slice");
                     exampleText += `${indent.get()}for ${resultName}.More() {\n`;
                     exampleText += `${indent.push().get()}page, err := ${resultName}.NextPage(ctx)\n`;
                     exampleText += `${indent.get()}if err != nil {\n`;
@@ -205,11 +212,11 @@ export function generateExamples(pkg, target, options) {
                     exampleText += `${indent.get()}// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.\n`;
                     exampleText += `${indent.get()}// page = ${go.getPackageName(example.responseEnvelope.response.method.receiver.type.pkg)}.${example.responseEnvelope.response.name}{\n`;
                     for (const header of example.responseEnvelope.headers ?? []) {
-                        exampleText += `${indent.get()}// \t${header.header.fieldName}: ${getExampleValue(pkg, header.value, '', undefined, header.header.byValue)
-                            .split('\n')
+                        exampleText += `${indent.get()}// \t${header.header.fieldName}: ${getExampleValue(pkg, header.value, "", undefined, header.header.byValue)
+                            .split("\n")
                             .join(`\n${indent.get()}// \t`)},\n`;
                     }
-                    exampleText += `${indent.get()}// \t${example.responseEnvelope.result.type.name}: ${getExampleValue(pkg, example.responseEnvelope.result, '', undefined, true).split('\n').join(`\n${indent.get()}// \t`)},\n`;
+                    exampleText += `${indent.get()}// \t${example.responseEnvelope.result.type.name}: ${getExampleValue(pkg, example.responseEnvelope.result, "", undefined, true).split("\n").join(`\n${indent.get()}// \t`)},\n`;
                     exampleText += `${indent.get()}// }\n`;
                     exampleText += `${indent.pop().get()}}\n`;
                 }
@@ -221,23 +228,25 @@ export function generateExamples(pkg, target, options) {
                     exampleText += `${indent.get()}// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.\n`;
                     exampleText += `${indent.get()}// res = ${go.getPackageName(example.responseEnvelope.response.method.receiver.type.pkg)}.${example.responseEnvelope.response.name}{\n`;
                     for (const header of example.responseEnvelope?.headers ?? []) {
-                        exampleText += `${indent.get()}// \t${header.header.fieldName}: ${getExampleValue(pkg, header.value, '', undefined, header.header.byValue)
-                            .split('\n')
+                        exampleText += `${indent.get()}// \t${header.header.fieldName}: ${getExampleValue(pkg, header.value, "", undefined, header.header.byValue)
+                            .split("\n")
                             .join(`\n${indent.get()}// \t`)},\n`;
                     }
                     if (example.responseEnvelope?.result) {
                         // modelResult and polymorphicResult are anonymously embedded by value in the response struct.
                         // monomorphicResult has an explicit byValue property. all other result types default to by value.
                         let resultByValue = true;
-                        let resultFieldName = fieldName ? fieldName : (example.responseEnvelope?.result.type).name;
-                        if (method.returns.result?.kind === 'monomorphicResult') {
+                        let resultFieldName = fieldName
+                            ? fieldName
+                            : (example.responseEnvelope?.result.type).name;
+                        if (method.returns.result?.kind === "monomorphicResult") {
                             resultByValue = method.returns.result.byValue;
                         }
-                        else if (method.returns.result?.kind === 'polymorphicResult') {
+                        else if (method.returns.result?.kind === "polymorphicResult") {
                             resultFieldName = method.returns.result.interface.name;
                             resultByValue = false;
                         }
-                        exampleText += `${indent.get()}// \t${resultFieldName}: ${getExampleValue(pkg, example.responseEnvelope.result, '', undefined, resultByValue).split('\n').join(`\n${indent.get()}// \t`)},\n`;
+                        exampleText += `${indent.get()}// \t${resultFieldName}: ${getExampleValue(pkg, example.responseEnvelope.result, "", undefined, resultByValue).split("\n").join(`\n${indent.get()}// \t`)},\n`;
                     }
                     exampleText += `${indent.get()}// }\n`;
                 }
@@ -245,7 +254,7 @@ export function generateExamples(pkg, target, options) {
             }
         }
         // if no example, then do not generate example file
-        if (exampleText === '')
+        if (exampleText === "")
             continue;
         // stitch it all together
         let text = helpers.contentPreamble(pkg);
@@ -257,80 +266,80 @@ export function generateExamples(pkg, target, options) {
 }
 function getExampleValue(pkg, example, indent, imports, byValue = false, inArray = false) {
     switch (example.kind) {
-        case 'string': {
+        case "string": {
             let exampleText = `"${escapeString(example.value)}"`;
-            if (example.type.kind === 'constant') {
+            if (example.type.kind === "constant") {
                 exampleText = getConstantValue(pkg, example.type, example.value);
             }
-            else if (example.type.kind === 'time') {
+            else if (example.type.kind === "time") {
                 exampleText = getTimeValue(example.type, example.value, imports);
             }
-            else if (example.type.kind === 'encodedBytes') {
+            else if (example.type.kind === "encodedBytes") {
                 exampleText = `[]byte("${escapeString(example.value)}")`;
             }
-            else if (example.type.kind === 'literal' && example.type.type.kind === 'constant') {
+            else if (example.type.kind === "literal" && example.type.type.kind === "constant") {
                 exampleText = getConstantValue(pkg, example.type.type, example.type.literal.value);
             }
-            else if (example.type.kind === 'etag') {
+            else if (example.type.kind === "etag") {
                 imports?.add(example.type.module);
                 exampleText = `${go.getTypeDeclaration(example.type, pkg)}("${escapeString(example.value)}")`;
             }
-            else if (example.type.kind === 'scalar' && example.type.type === 'byte') {
+            else if (example.type.kind === "scalar" && example.type.type === "byte") {
                 exampleText = `io.NopCloser(bytes.NewReader([]byte("${escapeString(example.value)}")))`;
             }
-            else if (example.type.kind === 'readSeekCloser') {
-                imports?.add('bytes');
-                imports?.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
+            else if (example.type.kind === "readSeekCloser") {
+                imports?.add("bytes");
+                imports?.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming");
                 exampleText = `streaming.NopCloser(bytes.NewReader([]byte("${escapeString(example.value)}")))`;
             }
             return `${indent}${getPointerValue(example.type, exampleText, byValue, imports)}`;
         }
-        case 'number': {
+        case "number": {
             let exampleText = `${example.value}`;
             switch (example.type.kind) {
-                case 'constant':
+                case "constant":
                     exampleText = `${indent}${getConstantValue(pkg, example.type, example.value)}`;
                     break;
-                case 'time':
+                case "time":
                     exampleText = getTimeValue(example.type, example.value, imports);
                     break;
             }
             return `${indent}${getPointerValue(example.type, exampleText, byValue, imports)}`;
         }
-        case 'boolean': {
+        case "boolean": {
             let exampleText = `${example.value}`;
-            if (example.type.kind === 'constant') {
+            if (example.type.kind === "constant") {
                 exampleText = `${indent}${getConstantValue(pkg, example.type, example.value)}`;
             }
             return `${indent}${getPointerValue(example.type, exampleText, byValue, imports)}`;
         }
-        case 'null':
+        case "null":
             return `${indent}nil`;
-        case 'any':
+        case "any":
             return jsonToGo(example.value, indent);
-        case 'array': {
+        case "array": {
             const isElementByValue = example.type.elementTypeByValue;
             // if polymorphic, need to add type name in array, so inArray will be set to false
             // if other case, no need to add type name in array, so inArray will be set to true
-            const isElementPolymorphic = example.type.elementType.kind === 'interface';
+            const isElementPolymorphic = example.type.elementType.kind === "interface";
             let exampleText = `${indent}${getRef(byValue)}${go.getTypeDeclaration(example.type, pkg)}{\n`;
             for (const element of example.value) {
-                exampleText += `${getExampleValue(pkg, element, indent + '\t', imports, isElementByValue && !isElementPolymorphic, !isElementPolymorphic)},\n`;
+                exampleText += `${getExampleValue(pkg, element, indent + "\t", imports, isElementByValue && !isElementPolymorphic, !isElementPolymorphic)},\n`;
             }
             exampleText += `${indent}}`;
             return exampleText;
         }
-        case 'dictionary': {
+        case "dictionary": {
             let exampleText = `${indent}${getRef(byValue)}${go.getTypeDeclaration(example.type, pkg)}{\n`;
             const isValueByValue = example.type.valueTypeByValue;
-            const isValuePolymorphic = example.type.valueType.kind === 'interface';
+            const isValuePolymorphic = example.type.valueType.kind === "interface";
             for (const key in example.value) {
-                exampleText += `${indent}\t"${key}": ${getExampleValue(pkg, example.value[key], indent + '\t', imports, isValueByValue && !isValuePolymorphic).slice(indent.length + 1)},\n`;
+                exampleText += `${indent}\t"${key}": ${getExampleValue(pkg, example.value[key], indent + "\t", imports, isValueByValue && !isValuePolymorphic).slice(indent.length + 1)},\n`;
             }
             exampleText += `${indent}}`;
             return exampleText;
         }
-        case 'model': {
+        case "model": {
             let exampleText = `${indent}${getRef(byValue)}${go.getTypeDeclaration(example.type, pkg)}{\n`;
             if (inArray) {
                 exampleText = `${indent}{\n`;
@@ -338,31 +347,31 @@ function getExampleValue(pkg, example, indent, imports, byValue = false, inArray
             for (const field in example.value) {
                 const goField = example.type.fields.find((f) => f.name === field);
                 const isFieldByValue = goField.byValue ?? false;
-                const isFieldPolymorphic = goField.type.kind === 'interface';
-                exampleText += `${indent}\t${field}: ${getExampleValue(pkg, example.value[field], indent + '\t', imports, isFieldByValue && !isFieldPolymorphic).slice(indent.length + 1)},\n`;
+                const isFieldPolymorphic = goField.type.kind === "interface";
+                exampleText += `${indent}\t${field}: ${getExampleValue(pkg, example.value[field], indent + "\t", imports, isFieldByValue && !isFieldPolymorphic).slice(indent.length + 1)},\n`;
             }
             if (example.additionalProperties) {
                 const additionalPropertiesField = example.type.fields.find((f) => f.annotations.isAdditionalProperties);
-                if (additionalPropertiesField.type.kind !== 'map') {
-                    throw new CodegenError('InternalError', `additional properties field type should be map type`);
+                if (additionalPropertiesField.type.kind !== "map") {
+                    throw new CodegenError("InternalError", `additional properties field type should be map type`);
                 }
                 const isAdditionalPropertiesFieldByValue = additionalPropertiesField.type.valueTypeByValue ?? false;
-                const isAdditionalPropertiesPolymorphic = additionalPropertiesField.type.valueType.kind === 'interface';
+                const isAdditionalPropertiesPolymorphic = additionalPropertiesField.type.valueType.kind === "interface";
                 exampleText += `${indent}\t${additionalPropertiesField.name}: ${getRef(additionalPropertiesField.byValue)}${go.getTypeDeclaration(additionalPropertiesField.type, pkg)}{\n`;
                 for (const key in example.additionalProperties) {
-                    exampleText += `${indent}\t"${key}": ${getExampleValue(pkg, example.additionalProperties[key], indent + '\t', imports, isAdditionalPropertiesFieldByValue && !isAdditionalPropertiesPolymorphic).slice(indent.length + 1)},\n`;
+                    exampleText += `${indent}\t"${key}": ${getExampleValue(pkg, example.additionalProperties[key], indent + "\t", imports, isAdditionalPropertiesFieldByValue && !isAdditionalPropertiesPolymorphic).slice(indent.length + 1)},\n`;
                 }
                 exampleText += `${indent}},\n`;
             }
             exampleText += `${indent}}`;
             return exampleText;
         }
-        case 'tokenCredential':
+        case "tokenCredential":
             return example.value;
     }
 }
 function getRef(byValue) {
-    return byValue ? '' : '&';
+    return byValue ? "" : "&";
 }
 function getConstantValue(pkg, type, value) {
     for (const constantValue of type.values) {
@@ -371,7 +380,7 @@ function getConstantValue(pkg, type, value) {
         }
     }
     switch (type.type) {
-        case 'string':
+        case "string":
             return `${go.getTypeDeclaration(type, pkg)}("${value}")`;
         default:
             return `${go.getTypeDeclaration(type, pkg)}(${value})`;
@@ -385,13 +394,13 @@ function getTimeValue(type, value, imports) {
         RFC3339: helpers.RFC3339Format,
     };
     if (type.format in formatMap) {
-        imports?.add('time');
+        imports?.add("time");
         const format = formatMap[type.format];
         return `func() time.Time { t, _ := time.Parse(${format}, "${value}"); return t}()`;
     }
     else {
-        imports?.add('strconv');
-        imports?.add('time');
+        imports?.add("strconv");
+        imports?.add("time");
         return `func() time.Time { t, _ := strconv.ParseInt(${value}, 10, 64); return time.Unix(t, 0).UTC()}()`;
     }
 }
@@ -400,62 +409,62 @@ function getPointerValue(type, valueString, byValue, imports) {
         return valueString;
     }
     switch (type.kind) {
-        case 'any':
-        case 'constant':
-        case 'constantDef':
-        case 'etag':
-        case 'string':
-        case 'time':
+        case "any":
+        case "constant":
+        case "constantDef":
+        case "etag":
+        case "string":
+        case "time":
             if (imports)
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
             return `to.Ptr(${valueString})`;
-        case 'literal':
+        case "literal":
             // unwrap the literal and delegate to the inner type's case
             return getPointerValue(type.type, valueString, byValue, imports);
-        case 'scalar': {
-            if (type.type === 'byte') {
+        case "scalar": {
+            if (type.type === "byte") {
                 return valueString;
             }
-            let prtType = '';
+            let prtType;
             switch (type.type) {
                 case `bool`:
                 case `rune`:
-                    prtType = 'Ptr';
+                    prtType = "Ptr";
                     break;
                 default:
                     prtType = `Ptr[${type.type}]`;
             }
             if (imports)
-                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
+                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
             return `to.${prtType}(${valueString})`;
         }
-        case 'readSeekCloser':
+        case "readSeekCloser":
             return valueString;
         default:
             return `&${valueString}`;
     }
 }
 function jsonToGo(value, indent) {
-    if (typeof value === 'string') {
+    if (typeof value === "string") {
         return `${indent}"${escapeString(value)}"`;
     }
-    else if (typeof value === 'number' || typeof value === 'bigint') {
+    else if (typeof value === "number" || typeof value === "bigint") {
         return `${indent}${value}`;
     }
-    else if (typeof value === 'boolean') {
+    else if (typeof value === "boolean") {
         return `${indent}${value}`;
     }
-    else if (typeof value === 'undefined') {
+    else if (typeof value === "undefined") {
         return `${indent}nil`;
     }
-    else if (typeof value === 'object') {
+    else if (typeof value === "object") {
         if (value === null) {
             return `${indent}nil`;
         }
         else if (Array.isArray(value)) {
             let result = `${indent}[]any{\n`;
             for (const item of value) {
-                result += `${jsonToGo(item, indent + '\t')},\n`;
+                result += `${jsonToGo(item, indent + "\t")},\n`;
             }
             result += `${indent}}`;
             return result;
@@ -463,70 +472,76 @@ function jsonToGo(value, indent) {
         else {
             let result = `${indent}map[string]any{\n`;
             for (const key in value) {
-                result += `${indent}\t"${key}": ${jsonToGo(value[key], indent + '\t').slice(indent.length + 1)},\n`;
+                result += `${indent}\t"${key}": ${jsonToGo(value[key], indent + "\t").slice(indent.length + 1)},\n`;
             }
             result += `${indent}}`;
             return result;
         }
     }
-    return '';
+    return "";
 }
 function generateFakeExample(goType, name) {
     switch (goType.kind) {
-        case 'any':
+        case "any":
             return new go.NullExample(goType);
-        case 'constant':
+        case "constant":
             switch (goType.type) {
-                case 'bool':
+                case "bool":
                     return new go.BooleanExample(goType.values[0].value, goType);
-                case 'string':
+                case "string":
                     return new go.StringExample(goType.values[0].value, goType);
                 default:
                     return new go.NumberExample(goType.values[0].value, goType);
             }
-        case 'literal':
+        case "literal":
             return new go.StringExample(goType.literal, goType);
-        case 'scalar':
+        case "scalar":
             switch (goType.type) {
-                case 'bool':
+                case "bool":
                     return new go.BooleanExample(false, goType);
-                case 'byte':
-                case 'rune':
-                    return new go.StringExample(`<${name ?? 'test'}>`, goType);
+                case "byte":
+                case "rune":
+                    return new go.StringExample(`<${name ?? "test"}>`, goType);
                 default:
                     return new go.NumberExample(0, goType);
             }
-        case 'string':
-            return new go.StringExample(`<${name ?? 'test'}>`, goType);
-        case 'tokenCredential':
+        case "string":
+            return new go.StringExample(`<${name ?? "test"}>`, goType);
+        case "tokenCredential":
             // we hard code the credential var name to cred
-            return new go.TokenCredentialExample('cred');
-        case 'encodedBytes':
-            return new go.StringExample(`<${name ?? 'test'}>`, goType);
-        case 'time':
+            return new go.TokenCredentialExample("cred");
+        case "encodedBytes":
+            return new go.StringExample(`<${name ?? "test"}>`, goType);
+        case "time":
             // use a placeholder date value for time types
-            return new go.StringExample('2006-01-02T15:04:05Z', goType);
-        case 'etag':
-            return new go.StringExample(`<${name ?? 'etag'}>`, goType);
-        case 'model':
-        case 'polymorphicModel':
+            return new go.StringExample("2006-01-02T15:04:05Z", goType);
+        case "etag":
+            return new go.StringExample(`<${name ?? "etag"}>`, goType);
+        case "model":
+        case "polymorphicModel":
             // return an empty struct example for model types
             return new go.StructExample(goType);
-        case 'slice':
+        case "slice":
             // return an empty array example for slice types
             return new go.ArrayExample(goType);
-        case 'map':
+        case "map":
             // return an empty map example for map types
             return new go.DictionaryExample(goType);
-        case 'interface':
+        case "interface":
             // for interface types, use the root type (which is a PolymorphicModel) to create an example
             return new go.StructExample(goType.rootType);
         default:
-            throw new CodegenError('InternalError', `unhandled fake example kind ${goType.kind}`);
+            throw new CodegenError("InternalError", `unhandled fake example kind ${goType.kind}`);
     }
 }
 function escapeString(str) {
-    return str.split('\\').join('\\\\').split('"').join('\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+    return str
+        .split("\\")
+        .join("\\\\")
+        .split('"')
+        .join('\\"')
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r");
 }
 /**
  * returns true if the parameter's example value should be passed by value,
@@ -539,8 +554,8 @@ function escapeString(str) {
  */
 function isParamByValue(p) {
     switch (p.parameter.type.kind) {
-        case 'interface':
-            return p.value.kind === 'null';
+        case "interface":
+            return p.value.kind === "null";
         default:
             return p.parameter.byValue;
     }
@@ -564,9 +579,9 @@ function shouldRenderParam(param, example) {
 function getParamExampleValue(pkg, param, example, imports) {
     const paramExample = example.parameters.find((p) => p.parameter.name === param.name);
     if (paramExample) {
-        return getExampleValue(pkg, paramExample.value, '\t', imports, isParamByValue(paramExample)).slice(1);
+        return getExampleValue(pkg, paramExample.value, "\t", imports, isParamByValue(paramExample)).slice(1);
     }
     const fakeValue = generateFakeExample(param.type, param.name);
-    return getExampleValue(pkg, fakeValue, '\t', imports, param.byValue).slice(1);
+    return getExampleValue(pkg, fakeValue, "\t", imports, param.byValue).slice(1);
 }
 //# sourceMappingURL=example.js.map