@azure-tools/typespec-ts 0.54.0-dev.6 → 0.54.0-dev.8

package/src/metaTree.ts

@@ -1,5 +1,5 @@
-import { Schema as RlcType } from "./rlc-common/index.js";
 import { Type } from "@typespec/compiler";
+import { Schema as RlcType } from "./rlc-common/index.js";
 
 export interface RlcTypeMetadata {
   rlcType: RlcType;

package/src/modular/buildClassicalClient.ts

@@ -3,51 +3,36 @@ import {
   MethodDeclarationStructure,
   Scope,
   SourceFile,
-  StructureKind
+  StructureKind,
 } from "ts-morph";
-import { ModularEmitterOptions } from "./interfaces.js";
 import { NameType, normalizeName } from "../rlc-common/index.js";
-import {
-  buildUserAgentOptions,
-  getClientParametersDeclaration
-} from "./helpers/clientHelpers.js";
-import {
-  getClassicalClientName,
-  getClientName
-} from "./helpers/namingHelpers.js";
+import { buildUserAgentOptions, getClientParametersDeclaration } from "./helpers/clientHelpers.js";
+import { getClassicalClientName, getClientName } from "./helpers/namingHelpers.js";
+import { ModularEmitterOptions } from "./interfaces.js";
 
-import { SdkContext } from "../utils/interfaces.js";
-import { getDocsFromDescription } from "./helpers/docsHelpers.js";
-import { getOperationFunction } from "./helpers/operationHelpers.js";
-import {
-  getModularClientOptions,
-  isRLCMultiEndpoint
-} from "../utils/clientUtils.js";
-import { resolveReference } from "../framework/reference.js";
-import { useDependencies } from "../framework/hooks/useDependencies.js";
 import {
   InitializedByFlags,
   SdkClientType,
   SdkServiceMethod,
-  SdkServiceOperation
+  SdkServiceOperation,
 } from "@azure-tools/typespec-client-generator-core";
-import {
-  getMethodHierarchiesMap,
-  isTenantLevelOperation
-} from "../utils/operationUtil.js";
 import { useContext } from "../contextManager.js";
+import { useDependencies } from "../framework/hooks/useDependencies.js";
+import { resolveReference } from "../framework/reference.js";
 import { refkey } from "../framework/refkey.js";
-import {
-  PagingHelpers,
-  SimplePollerHelpers
-} from "./static-helpers-metadata.js";
+import { getModularClientOptions, isRLCMultiEndpoint } from "../utils/clientUtils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { getMethodHierarchiesMap, isTenantLevelOperation } from "../utils/operationUtil.js";
 import { AzurePollingDependencies } from "./external-dependencies.js";
 import { getPagingLROMethodName } from "./helpers/classicalOperationHelpers.js";
+import { getDocsFromDescription } from "./helpers/docsHelpers.js";
+import { getOperationFunction } from "./helpers/operationHelpers.js";
+import { PagingHelpers, SimplePollerHelpers } from "./static-helpers-metadata.js";
 
 export function buildClassicalClient(
   dpgContext: SdkContext,
   clientMap: [string[], SdkClientType<SdkServiceOperation>],
-  emitterOptions: ModularEmitterOptions
+  emitterOptions: ModularEmitterOptions,
 ) {
   const project = useContext("outputProject");
   const [_hierarchy, client] = clientMap;
@@ -55,11 +40,11 @@ export function buildClassicalClient(
   const modularClientName = getClientName(client);
   const classicalClientName = `${getClassicalClientName(client)}`;
   const classicalParams = getClientParametersDeclaration(client, dpgContext, {
-    requiredOnly: true
+    requiredOnly: true,
   });
   const contextParams = getClientParametersDeclaration(client, dpgContext, {
     onClientOnly: false,
-    requiredOnly: true
+    requiredOnly: true,
   });
   const srcPath = emitterOptions.modularOptions.sourceRoot;
   const { subfolder, rlcClientName } = getModularClientOptions(clientMap);
@@ -67,22 +52,19 @@ export function buildClassicalClient(
   const clientFile = project.createSourceFile(
     `${srcPath}/${subfolder && subfolder !== "" ? subfolder + "/" : ""}${normalizeName(
       classicalClientName,
-      NameType.File
-    )}.ts`
+      NameType.File,
+    )}.ts`,
   );
 
   clientFile.addExportDeclaration({
     isTypeOnly: true,
     namedExports: [`${classicalClientName}OptionalParams`],
-    moduleSpecifier: `./api/${normalizeName(
-      modularClientName,
-      NameType.File
-    )}Context.js`
+    moduleSpecifier: `./api/${normalizeName(modularClientName, NameType.File)}Context.js`,
   });
 
   const clientClass = clientFile.addClass({
     isExported: true,
-    name: `${classicalClientName}`
+    name: `${classicalClientName}`,
   });
 
   // Add the private client member. This will be the client context from /api
@@ -90,13 +72,13 @@ export function buildClassicalClient(
     clientClass.addProperty({
       name: "_client",
       type: `Client.${rlcClientName}`,
-      scope: Scope.Private
+      scope: Scope.Private,
     });
   } else {
     clientClass.addProperty({
       name: "_client",
       type: `${rlcClientName}`,
-      scope: Scope.Private
+      scope: Scope.Private,
     });
   }
   // Add the pipeline member. This will be the pipeline from /api
@@ -105,16 +87,13 @@ export function buildClassicalClient(
     type: resolveReference(dependencies.Pipeline),
     scope: Scope.Public,
     isReadonly: true,
-    docs: ["The pipeline used by this client to make requests"]
+    docs: ["The pipeline used by this client to make requests"],
   });
 
   const hasChildClient =
     client.children &&
     client.children.some((childClient) => {
-      return (
-        childClient.clientInitialization.initializedBy &
-        InitializedByFlags.Parent
-      );
+      return childClient.clientInitialization.initializedBy & InitializedByFlags.Parent;
     });
   if (hasChildClient) {
     clientClass.addProperty({
@@ -123,30 +102,24 @@ export function buildClassicalClient(
         return `${p.name}: ${p.type}`;
       })}}`,
       scope: Scope.Private,
-      docs: ["The parent client parameters that are used in the constructors."]
+      docs: ["The parent client parameters that are used in the constructors."],
     });
   }
 
   // Check if constructor overloads for subscriptionId is needed
   const hasSubscriptionIdParam = classicalParams.some(
-    (param) => param.name.toLowerCase() === "subscriptionid"
+    (param) => param.name.toLowerCase() === "subscriptionid",
   );
   const shouldSubscriptionIdOptional =
-    dpgContext.arm &&
-    hasSubscriptionIdParam &&
-    hasTenantLevelOperations(client, dpgContext);
+    dpgContext.arm && hasSubscriptionIdParam && hasTenantLevelOperations(client, dpgContext);
 
   let constructor;
   if (shouldSubscriptionIdOptional) {
-    constructor = generateConstructorWithOverloads(
-      clientClass,
-      classicalParams,
-      client
-    );
+    constructor = generateConstructorWithOverloads(clientClass, classicalParams, client);
   } else {
     constructor = clientClass.addConstructor({
       docs: getDocsFromDescription(client.doc),
-      parameters: classicalParams
+      parameters: classicalParams,
     });
   }
 
@@ -157,12 +130,9 @@ export function buildClassicalClient(
         return `{...options, userAgentOptions: ${buildUserAgentOptions(
           constructor,
           emitterOptions,
-          "azsdk-js-client"
+          "azsdk-js-client",
         )}}`;
-      } else if (
-        x.toLowerCase() === "subscriptionid" &&
-        shouldSubscriptionIdOptional
-      ) {
+      } else if (x.toLowerCase() === "subscriptionid" && shouldSubscriptionIdOptional) {
         return `subscriptionId ?? ""`;
       } else {
         return x;
@@ -170,25 +140,22 @@ export function buildClassicalClient(
     });
 
   constructor.addStatements([
-    `this._client = create${modularClientName}(${paramNames.join(",")});`
+    `this._client = create${modularClientName}(${paramNames.join(",")});`,
   ]);
   constructor.addStatements(`this.pipeline = this._client.pipeline;`);
 
   if (hasChildClient && client.children) {
     constructor.addStatements(
-      `this._clientParams = {${classicalParams.map((p) => p.name).join(",")}};`
+      `this._clientParams = {${classicalParams.map((p) => p.name).join(",")}};`,
     );
     for (const childClient of client.children) {
-      const subfolder = normalizeName(
-        childClient.name.replace("Client", ""),
-        NameType.File
-      );
+      const subfolder = normalizeName(childClient.name.replace("Client", ""), NameType.File);
       clientFile.addImportDeclaration({
         moduleSpecifier: `./${subfolder}/${normalizeName(childClient.name, NameType.File)}.js`,
         namedImports: [
           `${getClassicalClientName(childClient)}`,
-          `${getClassicalClientName(childClient)}OptionalParams`
-        ]
+          `${getClassicalClientName(childClient)}OptionalParams`,
+        ],
       });
     }
   }
@@ -196,10 +163,7 @@ export function buildClassicalClient(
   if (client.children) {
     client.children
       .filter((childClient) => {
-        return (
-          childClient.clientInitialization.initializedBy &
-          InitializedByFlags.Parent
-        );
+        return childClient.clientInitialization.initializedBy & InitializedByFlags.Parent;
       })
       .forEach((childClient) => {
         addChildClient(dpgContext, clientClass, client, childClient);
@@ -210,14 +174,10 @@ export function buildClassicalClient(
   return clientFile;
 }
 
-function importAllApis(
-  clientFile: SourceFile,
-  srcPath: string,
-  subfolder: string
-) {
+function importAllApis(clientFile: SourceFile, srcPath: string, subfolder: string) {
   const project = clientFile.getProject();
   const apiModels = project.getSourceFile(
-    `${srcPath}/${subfolder && subfolder !== "" ? subfolder + "/" : ""}api/index.ts`
+    `${srcPath}/${subfolder && subfolder !== "" ? subfolder + "/" : ""}api/index.ts`,
   );
 
   if (!apiModels) {
@@ -228,25 +188,21 @@ function importAllApis(
 
   clientFile.addImportDeclaration({
     moduleSpecifier: `./api/index.js`,
-    namedImports: exported
+    namedImports: exported,
   });
 }
 
 function generateMethod(
   context: SdkContext,
   clientType: string,
-  method: [string[], SdkServiceMethod<SdkServiceOperation>]
+  method: [string[], SdkServiceMethod<SdkServiceOperation>],
 ): MethodDeclarationStructure[] {
   const res: MethodDeclarationStructure[] = [];
   const declaration = getOperationFunction(context, method, clientType);
   const methodName = declaration.propertyName ?? declaration.name ?? "FIXME";
-  const methodParams =
-    declaration.parameters?.filter((p) => p.name !== "context") ?? [];
+  const methodParams = declaration.parameters?.filter((p) => p.name !== "context") ?? [];
   const declarationRefKey = resolveReference(refkey(method[1], "api"));
-  const methodParamStr = [
-    "this._client",
-    ...methodParams.map((p) => p.name)
-  ].join(", ");
+  const methodParamStr = ["this._client", ...methodParams.map((p) => p.name)].join(", ");
 
   res.push({
     docs: declaration.docs,
@@ -254,30 +210,17 @@ function generateMethod(
     kind: StructureKind.Method,
     returnType: declaration.returnType,
     parameters: methodParams,
-    statements: `return ${declarationRefKey}(${methodParamStr})`
+    statements: `return ${declarationRefKey}(${methodParamStr})`,
   });
 
   // add LRO helper methods if applicable
-  if (
-    context.rlcOptions?.compatibilityLro &&
-    declaration?.isLro &&
-    !declaration?.isLroPaging
-  ) {
-    const operationStateReference = resolveReference(
-      AzurePollingDependencies.OperationState
-    );
-    const simplePollerLikeReference = resolveReference(
-      SimplePollerHelpers.SimplePollerLike
-    );
-    const getSimplePollerReference = resolveReference(
-      SimplePollerHelpers.getSimplePoller
-    );
+  if (context.rlcOptions?.compatibilityLro && declaration?.isLro && !declaration?.isLroPaging) {
+    const operationStateReference = resolveReference(AzurePollingDependencies.OperationState);
+    const simplePollerLikeReference = resolveReference(SimplePollerHelpers.SimplePollerLike);
+    const getSimplePollerReference = resolveReference(SimplePollerHelpers.getSimplePoller);
     const returnType = declaration?.lroFinalReturnType ?? "void";
     const beginName = normalizeName(`begin_${methodName}`, NameType.Method);
-    const beginAndWaitName = normalizeName(
-      `${beginName}_andWait`,
-      NameType.Method
-    );
+    const beginAndWaitName = normalizeName(`${beginName}_andWait`, NameType.Method);
     // add begin method
     res.push({
       isAsync: true,
@@ -288,7 +231,7 @@ function generateMethod(
       parameters: methodParams,
       statements: `const poller = ${declarationRefKey}(${methodParamStr});
                   await poller.submitted();
-                  return ${getSimplePollerReference}(poller);`
+                  return ${getSimplePollerReference}(poller);`,
     });
     // add begin and wait method
     res.push({
@@ -298,17 +241,17 @@ function generateMethod(
       kind: StructureKind.Method,
       returnType: `Promise<${returnType}>`,
       parameters: methodParams,
-      statements: `return await ${declarationRefKey}(${methodParamStr});`
+      statements: `return await ${declarationRefKey}(${methodParamStr});`,
     });
   } // For LRO+Paging operations, use different return types and implementation
   else if (context.rlcOptions?.compatibilityLro && declaration?.isLroPaging) {
     const returnType = declaration?.lropagingFinalReturnType ?? "void";
     const pagedAsyncIterableIteratorReference = resolveReference(
-      PagingHelpers.PagedAsyncIterableIterator
+      PagingHelpers.PagedAsyncIterableIterator,
     );
     const beginListAndWaitName = normalizeName(
       `${getPagingLROMethodName(methodName)}`,
-      NameType.Method
+      NameType.Method,
     );
     // add begin and wait method for LRO+Paging - directly returns paged iterator
     res.push({
@@ -318,7 +261,7 @@ function generateMethod(
       kind: StructureKind.Method,
       returnType: `${pagedAsyncIterableIteratorReference}<${returnType}>`,
       parameters: methodParams,
-      statements: `return ${declarationRefKey}(${methodParamStr});`
+      statements: `return ${declarationRefKey}(${methodParamStr});`,
     });
   }
 
@@ -327,7 +270,7 @@ function generateMethod(
 function buildClientOperationGroups(
   clientMap: [string[], SdkClientType<SdkServiceOperation>],
   dpgContext: SdkContext,
-  clientClass: ClassDeclaration
+  clientClass: ClassDeclaration,
 ) {
   let clientType = "Client";
   const [_hierarchy, client] = clientMap;
@@ -347,14 +290,8 @@ function buildClientOperationGroups(
     } else {
       // The `rawGroupName` is used to any places where we need normalized name twice so we need to keep the raw as PascalCase.
       const rawGroupName = normalizeName(prefixes[0] ?? "", NameType.Interface);
-      const operationName = `_get${normalizeName(
-        rawGroupName,
-        NameType.OperationGroup
-      )}Operations`;
-      const propertyType = `${normalizeName(
-        rawGroupName,
-        NameType.OperationGroup
-      )}Operations`;
+      const operationName = `_get${normalizeName(rawGroupName, NameType.OperationGroup)}Operations`;
+      const propertyType = `${normalizeName(rawGroupName, NameType.OperationGroup)}Operations`;
       // The `groupName` is used to any places where we don't need normalized name again
       const groupName = normalizeName(rawGroupName, NameType.Property);
       const existProperty = clientClass.getProperties().filter((p) => {
@@ -363,17 +300,15 @@ function buildClientOperationGroups(
       if (!existProperty || existProperty.length === 0) {
         clientClass.addProperty({
           name: groupName,
-          type: resolveReference(
-            refkey(propertyType, layer, "classicOperations")
-          ),
+          type: resolveReference(refkey(propertyType, layer, "classicOperations")),
           scope: Scope.Public,
           isReadonly: true,
-          docs: ["The operation groups for " + groupName]
+          docs: ["The operation groups for " + groupName],
         });
         clientClass
           .getConstructors()[0]
           ?.addStatements(
-            `this.${groupName} = ${resolveReference(refkey(operationName, layer, "getClassicOperations"))}(this._client)`
+            `this.${groupName} = ${resolveReference(refkey(operationName, layer, "getClassicOperations"))}(this._client)`,
           );
       }
     }
@@ -384,50 +319,42 @@ function addChildClient(
   context: SdkContext,
   clientClass: ClassDeclaration,
   parentClient: SdkClientType<SdkServiceOperation>,
-  client: SdkClientType<SdkServiceOperation>
+  client: SdkClientType<SdkServiceOperation>,
 ) {
   const parentParams = getClientParametersDeclaration(parentClient, context, {
-    requiredOnly: true
+    requiredOnly: true,
   });
   const clientParams = getClientParametersDeclaration(client, context, {
-    requiredOnly: true
+    requiredOnly: true,
   });
   const diffParams = clientParams.filter((p) => {
-    return !parentParams.some(
-      (pp) => pp.name === p.name && pp.name !== "options"
-    );
+    return !parentParams.some((pp) => pp.name === p.name && pp.name !== "options");
   });
   const name = getClassicalClientName(client);
   const getChildClientFunction = clientClass.addMethod({
     docs: getDocsFromDescription(client.doc),
     name: `get${name}`,
     returnType: `${getClassicalClientName(client)}`,
-    parameters: diffParams
+    parameters: diffParams,
   });
   getChildClientFunction.addStatements(
     `return new ${getClassicalClientName(client)}(
       ${parentParams
         .filter((p) => !p.name.includes("options"))
         .map((p) => `this._clientParams.${p.name}`)
-        .join(",")}${
-        parentParams.filter((p) => !p.name.includes("options")).length > 0
-          ? ","
-          : ""
-      }
+        .join(",")}${parentParams.filter((p) => !p.name.includes("options")).length > 0 ? "," : ""}
       ${diffParams
         .filter((p) => p.name !== "options")
         .map((p) => `${p.name}`)
-        .join(
-          ","
-        )}${diffParams.filter((p) => p.name !== "options").length > 0 ? "," : ""}
+        .join(",")}${diffParams.filter((p) => p.name !== "options").length > 0 ? "," : ""}
       { ...this._clientParams.options, ...options }
-    )`
+    )`,
   );
 }
 
 function hasTenantLevelOperations(
   client: SdkClientType<SdkServiceOperation>,
-  dpgContext: SdkContext
+  dpgContext: SdkContext,
 ): boolean {
   const methodMap = getMethodHierarchiesMap(dpgContext, client);
 
@@ -446,12 +373,10 @@ function hasTenantLevelOperations(
 function generateConstructorWithOverloads(
   clientClass: ClassDeclaration,
   classicalParams: any[],
-  client: SdkClientType<SdkServiceOperation>
+  client: SdkClientType<SdkServiceOperation>,
 ) {
   const filteredParams = classicalParams.filter(
-    (p) =>
-      p.name.toLowerCase() !== "subscriptionid" &&
-      p.name.toLowerCase() !== "options"
+    (p) => p.name.toLowerCase() !== "subscriptionid" && p.name.toLowerCase() !== "options",
   );
 
   const clientConstructor = clientClass.addConstructor({
@@ -461,14 +386,14 @@ function generateConstructorWithOverloads(
       {
         name: "subscriptionIdOrOptions",
         type: `string | ${getClassicalClientName(client)}OptionalParams`,
-        hasQuestionToken: true
+        hasQuestionToken: true,
       },
       {
         name: "options",
         type: `${getClassicalClientName(client)}OptionalParams`,
-        hasQuestionToken: true
-      }
-    ]
+        hasQuestionToken: true,
+      },
+    ],
   });
 
   clientConstructor.addOverload({
@@ -477,23 +402,21 @@ function generateConstructorWithOverloads(
       {
         name: "options",
         type: `${getClassicalClientName(client)}OptionalParams`,
-        hasQuestionToken: true
-      }
-    ]
+        hasQuestionToken: true,
+      },
+    ],
   });
 
   clientConstructor.addOverload({
     parameters: [
       ...filteredParams,
-      ...classicalParams.filter(
-        (p) => p.name.toLowerCase() === "subscriptionid"
-      ),
+      ...classicalParams.filter((p) => p.name.toLowerCase() === "subscriptionid"),
       {
         name: "options",
         type: `${getClassicalClientName(client)}OptionalParams`,
-        hasQuestionToken: true
-      }
-    ]
+        hasQuestionToken: true,
+      },
+    ],
   });
 
   clientConstructor.addStatements([
@@ -504,7 +427,7 @@ function generateConstructorWithOverloads(
     `} else if (typeof subscriptionIdOrOptions === "object") {`,
     `  options = subscriptionIdOrOptions;`,
     `}`,
-    `options = options ?? {};`
+    `options = options ?? {};`,
   ]);
 
   return clientConstructor;

package/src/modular/buildClassicalOperationGroups.ts

@@ -1,42 +1,31 @@
-import { NameType } from "../rlc-common/index.js";
+import { SdkClientType, SdkServiceOperation } from "@azure-tools/typespec-client-generator-core";
 import { SourceFile } from "ts-morph";
+import { useContext } from "../contextManager.js";
+import { NameType } from "../rlc-common/index.js";
+import { getModularClientOptions } from "../utils/clientUtils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { getMethodHierarchiesMap } from "../utils/operationUtil.js";
 import { getClassicalOperation } from "./helpers/classicalOperationHelpers.js";
 import { getClassicalLayerPrefix } from "./helpers/namingHelpers.js";
 import { ModularEmitterOptions } from "./interfaces.js";
-import { SdkContext } from "../utils/interfaces.js";
-import { getMethodHierarchiesMap } from "../utils/operationUtil.js";
-import {
-  SdkClientType,
-  SdkServiceOperation
-} from "@azure-tools/typespec-client-generator-core";
-import { getModularClientOptions } from "../utils/clientUtils.js";
-import { useContext } from "../contextManager.js";
 
 export function buildClassicOperationFiles(
   dpgContext: SdkContext,
   clientMap: [string[], SdkClientType<SdkServiceOperation>],
-  emitterOptions: ModularEmitterOptions
+  emitterOptions: ModularEmitterOptions,
 ) {
   // const sdkPackage = dpgContext.sdkPackage;
   const project = useContext("outputProject");
   const [_hierarchy, client] = clientMap;
   const { subfolder } = getModularClientOptions(clientMap);
-  const classicOperationFiles: Map<string, SourceFile> = new Map<
-    string,
-    SourceFile
-  >();
+  const classicOperationFiles: Map<string, SourceFile> = new Map<string, SourceFile>();
   const methodMap = getMethodHierarchiesMap(dpgContext, client);
   for (const [prefixKey, operations] of methodMap) {
     const prefixes = prefixKey.split("/");
     if (prefixes.length > 0 && prefixKey !== "") {
       const classicOperationFileName =
         prefixes.length > 0
-          ? `${getClassicalLayerPrefix(
-              prefixes,
-              NameType.File,
-              "/",
-              prefixes.length - 1
-            )}/index`
+          ? `${getClassicalLayerPrefix(prefixes, NameType.File, "/", prefixes.length - 1)}/index`
           : // When the program has no operation groups defined all operations are put
             // into a nameless operation group. We'll call this operations.
             "index";
@@ -47,12 +36,9 @@ export function buildClassicOperationFiles(
         project.createSourceFile(
           `${srcPath}/${
             subfolder && subfolder !== "" ? subfolder + "/" : ""
-          }classic/${classicOperationFileName}.ts`
+          }classic/${classicOperationFileName}.ts`,
         );
-      getClassicalOperation(dpgContext, clientMap, classicFile, [
-        prefixes,
-        operations
-      ]);
+      getClassicalOperation(dpgContext, clientMap, classicFile, [prefixes, operations]);
       classicOperationFiles.set(classicOperationFileName, classicFile);
     }
   }
@@ -62,12 +48,7 @@ export function buildClassicOperationFiles(
       for (let layer = 0; layer < prefixes.length - 1; layer++) {
         const classicOperationFileName =
           prefixes.length > 0
-            ? `${getClassicalLayerPrefix(
-                prefixes,
-                NameType.File,
-                "/",
-                layer
-              )}/index`
+            ? `${getClassicalLayerPrefix(prefixes, NameType.File, "/", layer)}/index`
             : // When the program has no operation groups defined all operations are put
               // into a nameless operation group. We'll call this operations.
               "index";
@@ -77,15 +58,9 @@ export function buildClassicOperationFiles(
           project.createSourceFile(
             `${srcPath}/${
               subfolder && subfolder !== "" ? subfolder + "/" : ""
-            }classic/${classicOperationFileName}.ts`
+            }classic/${classicOperationFileName}.ts`,
           );
-        getClassicalOperation(
-          dpgContext,
-          clientMap,
-          classicFile,
-          [prefixes, operations],
-          layer
-        );
+        getClassicalOperation(dpgContext, clientMap, classicFile, [prefixes, operations], layer);
         classicOperationFiles.set(classicOperationFileName, classicFile);
       }
     }