@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/utils/parameter-utils.ts

@@ -0,0 +1,192 @@
+import { getEncode, NoTarget, Program } from "@typespec/compiler";
+import { HttpOperationParameter } from "@typespec/http";
+import { reportDiagnostic } from "../lib.js";
+import { NameType, normalizeName, Schema, SchemaContext } from "../rlc-common/index.js";
+import { SdkContext } from "./interfaces.js";
+import { getTypeName, isArrayType, isObjectOrDictType } from "./model-utils.js";
+
+export interface ParameterSerializationInfo {
+  typeName: string;
+  wrapperType?: Schema;
+}
+
+export function getParameterSerializationInfo(
+  dpgContext: SdkContext,
+  parameter: HttpOperationParameter,
+  valueSchema: Schema,
+  operationGroup: string = "",
+  operationName: string = "",
+): ParameterSerializationInfo {
+  const schemaContext = [SchemaContext.Input];
+  const retVal: ParameterSerializationInfo = buildSerializationInfo(
+    getTypeName(valueSchema, schemaContext),
+  );
+  const prefix = `${operationGroup}_${operationName}_${parameter.name}`;
+  switch (parameter.type) {
+    case "path": {
+      if (parameter.allowReserved === true) {
+        const wrapperType = buildAllowReserved(
+          normalizeName(`${prefix}_PathParam`, NameType.Interface),
+          valueSchema,
+          parameter.name,
+        );
+        return buildSerializationInfo(wrapperType);
+      }
+      return retVal;
+    }
+    case "query": {
+      if (!isArrayType(valueSchema) && !isObjectOrDictType(valueSchema)) {
+        // if the value is a primitive type or other types, we will not generate a wrapper type
+        return retVal;
+      }
+      const name = normalizeName(`${prefix}_QueryParam`, NameType.Interface);
+      const encode = getEncode(dpgContext.program, parameter.param);
+      const format =
+        encode?.encoding === "ArrayEncoding.pipeDelimited" ||
+        encode?.encoding === "ArrayEncoding.spaceDelimited"
+          ? encode.encoding.replace("ArrayEncoding.", "")
+          : undefined;
+      let wrapperType: Schema = buildExplodeAndStyle(
+        name,
+        parameter.explode,
+        format ?? "form",
+        valueSchema,
+        parameter.name,
+      );
+      if (parameter.explode === true) {
+        if (format !== undefined) {
+          reportDiagnostic(dpgContext.program, {
+            code: "un-supported-format-cases",
+            format: {
+              paramName: parameter.name,
+              explode: String(parameter.explode),
+              format: format,
+            },
+            target: NoTarget,
+          });
+        }
+
+        if (dpgContext.rlcOptions?.compatibilityQueryMultiFormat) {
+          wrapperType = buildUnionType([wrapperType, { type: "string", name: "string" }]);
+        }
+        return buildSerializationInfo(wrapperType);
+      }
+
+      if (format === undefined) {
+        if (isArrayType(valueSchema)) {
+          wrapperType = buildUnionType([valueSchema, wrapperType]);
+        }
+        return buildSerializationInfo(wrapperType);
+      }
+      return buildSerializationInfo(wrapperType);
+    }
+    case "header": {
+      return buildSerializationInfo(
+        getHeaderSerializeTypeName(dpgContext.program, valueSchema, schemaContext),
+      );
+    }
+    default:
+      return retVal;
+  }
+}
+
+function buildSerializationInfo(typeOrSchema: string | Schema): ParameterSerializationInfo {
+  if (typeof typeOrSchema === "string") {
+    return {
+      typeName: typeOrSchema,
+    };
+  }
+  return {
+    typeName: getTypeName(typeOrSchema),
+    wrapperType: typeOrSchema,
+  };
+}
+
+function getHeaderSerializeTypeName(
+  program: Program,
+  schema: Schema,
+  usage?: SchemaContext[],
+): string {
+  const typeName = getTypeName(schema, usage);
+  const formattedName = (schema.alias ?? typeName).replace("Date | string", "string");
+  const canSerialize = isSerializable(schema);
+  if (canSerialize) {
+    return schema.alias ? typeName : formattedName;
+  }
+  reportDiagnostic(program, {
+    code: "unable-serialized-type",
+    format: { type: typeName },
+    target: NoTarget,
+  });
+  return "string";
+  function isSerializable(type: any) {
+    if (type.enum) {
+      return type.enum.every((i: any) => {
+        return isSerializable(i) || i.type === "null";
+      });
+    }
+    return ["string", "number", "boolean"].includes(type.type) || type.isConstant;
+  }
+}
+
+function buildAllowReserved(typeName: string, valueSchema: Schema, parameterName: string) {
+  return {
+    type: "object",
+    name: typeName,
+    description: `This is the wrapper object for the parameter \`${parameterName}\` with allowReserved set to true.`,
+    properties: {
+      value: {
+        ...valueSchema,
+        description: valueSchema.description ?? "Value of the parameter",
+        required: true,
+      },
+      allowReserved: {
+        type: `true`,
+        description: "Whether to allow reserved characters",
+        required: true,
+      },
+    },
+  };
+}
+
+function buildExplodeAndStyle(
+  typeName: string,
+  explode: boolean,
+  style: string,
+  valueSchema: Schema,
+  parameterName: string,
+) {
+  return {
+    type: "object",
+    name: typeName,
+    description: `This is the wrapper object for the parameter \`${parameterName}\` with explode set to ${explode} and style set to ${style}.`,
+    properties: {
+      value: {
+        ...valueSchema,
+        description: valueSchema.description ?? "Value of the parameter",
+        required: true,
+      },
+      explode: {
+        type: `${explode}`,
+        description: "Should we explode the value?",
+        required: true,
+      },
+      style: {
+        type: `"${style}"`,
+        description: "Style of the value",
+        required: true,
+      },
+    },
+  };
+}
+
+function buildUnionType(values: Schema[]) {
+  return {
+    name: "",
+    enum: values,
+    type: "union",
+    typeName: `${values.map((v) => getTypeName(v)).join(" | ")}`,
+    required: true,
+    description: undefined,
+  };
+}

package/src/utils/resolve-project-root.ts

@@ -1,6 +1,6 @@
-import { fileURLToPath } from "url";
-import { dirname, resolve } from "path";
 import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
 
 /**
  * Recursively finds the nearest package.json file starting from the specified directory.
@@ -8,7 +8,7 @@ import { existsSync } from "fs";
  * @returns {string} path to the directory containing the package.json file.
  */
 export function resolveProjectRoot(
-  currentDir: string = dirname(fileURLToPath(import.meta.url))
+  currentDir: string = dirname(fileURLToPath(import.meta.url)),
 ): string {
   const packageJsonPath = resolve(currentDir, "package.json");
 

package/static/static-helpers/cloudSettingHelpers.ts

@@ -8,7 +8,7 @@ export enum AzureClouds {
   /** Azure China cloud */
   AZURE_CHINA_CLOUD = "AZURE_CHINA_CLOUD",
   /** Azure US government cloud */
-  AZURE_US_GOVERNMENT = "AZURE_US_GOVERNMENT"
+  AZURE_US_GOVERNMENT = "AZURE_US_GOVERNMENT",
 }
 
 /** The supported values for cloud setting as a string literal type */
@@ -20,22 +20,20 @@ export type AzureSupportedClouds = `${AzureClouds}`;
  * @returns The ARM endpoint URL for the specified cloud, or undefined if cloudSetting is undefined.
  * @throws {Error} Throws an error if an unknown cloud setting is provided.
  */
-export function getArmEndpoint(
-  cloudSetting?: AzureSupportedClouds
-): string | undefined {
+export function getArmEndpoint(cloudSetting?: AzureSupportedClouds): string | undefined {
   if (cloudSetting === undefined) {
     return undefined;
   }
   const cloudEndpoints: Record<keyof typeof AzureClouds, string> = {
     AZURE_CHINA_CLOUD: "https://management.chinacloudapi.cn/",
     AZURE_US_GOVERNMENT: "https://management.usgovcloudapi.net/",
-    AZURE_PUBLIC_CLOUD: "https://management.azure.com/"
+    AZURE_PUBLIC_CLOUD: "https://management.azure.com/",
   };
   if (cloudSetting in cloudEndpoints) {
     return cloudEndpoints[cloudSetting];
   } else {
     throw new Error(
-      `Unknown cloud setting: ${cloudSetting}. Please refer to the enum AzureClouds for possible values.`
+      `Unknown cloud setting: ${cloudSetting}. Please refer to the enum AzureClouds for possible values.`,
     );
   }
 }

package/static/static-helpers/multipartHelpers.ts

@@ -13,20 +13,20 @@ export type FileContents =
 export function createFilePartDescriptor(
   partName: string,
   fileInput: any,
-  defaultContentType?: string
+  defaultContentType?: string,
 ): any {
   if (fileInput.contents) {
     return {
       name: partName,
       body: fileInput.contents,
       contentType: fileInput.contentType ?? defaultContentType,
-      filename: fileInput.filename
+      filename: fileInput.filename,
     };
   } else {
     return {
       name: partName,
       body: fileInput,
-      contentType: defaultContentType
+      contentType: defaultContentType,
     };
   }
 }

package/static/static-helpers/pagingHelpers.ts

@@ -1,8 +1,4 @@
-import {
-  Client,
-  createRestError,
-  PathUncheckedResponse
-} from "@azure-rest/core-client";
+import { Client, createRestError, PathUncheckedResponse } from "@azure-rest/core-client";
 import { RestError } from "@azure/core-rest-pipeline";
 
 /**
@@ -31,7 +27,7 @@ export type ContinuablePage<TElement, TPage = TElement[]> = TPage & {
 export interface PagedAsyncIterableIterator<
   TElement,
   TPage = TElement[],
-  TPageSettings extends PageSettings = PageSettings
+  TPageSettings extends PageSettings = PageSettings,
 > {
   /**
    * The next method, part of the iteration protocol
@@ -40,17 +36,11 @@ export interface PagedAsyncIterableIterator<
   /**
    * The connection to the async iterator, part of the iteration protocol
    */
-  [Symbol.asyncIterator](): PagedAsyncIterableIterator<
-    TElement,
-    TPage,
-    TPageSettings
-  >;
+  [Symbol.asyncIterator](): PagedAsyncIterableIterator<TElement, TPage, TPageSettings>;
   /**
    * Return an AsyncIterableIterator that works a page at a time
    */
-  byPage: (
-    settings?: TPageSettings
-  ) => AsyncIterableIterator<ContinuablePage<TElement, TPage>>;
+  byPage: (settings?: TPageSettings) => AsyncIterableIterator<ContinuablePage<TElement, TPage>>;
 }
 
 /**
@@ -59,7 +49,7 @@ export interface PagedAsyncIterableIterator<
 export interface PagedResult<
   TElement,
   TPage = TElement[],
-  TPageSettings extends PageSettings = PageSettings
+  TPageSettings extends PageSettings = PageSettings,
 > {
   /**
    * Link to the first page of results.
@@ -68,15 +58,11 @@ export interface PagedResult<
   /**
    * A method that returns a page of results.
    */
-  getPage: (
-    pageLink?: string
-  ) => Promise<{ page: TPage; nextPageLink?: string } | undefined>;
+  getPage: (pageLink?: string) => Promise<{ page: TPage; nextPageLink?: string } | undefined>;
   /**
    * a function to implement the `byPage` method on the paged async iterator.
    */
-  byPage?: (
-    settings?: TPageSettings
-  ) => AsyncIterableIterator<ContinuablePage<TElement, TPage>>;
+  byPage?: (settings?: TPageSettings) => AsyncIterableIterator<ContinuablePage<TElement, TPage>>;
 
   /**
    * A function to extract elements from a page.
@@ -101,13 +87,13 @@ export function buildPagedAsyncIterator<
   TElement,
   TPage = TElement[],
   TPageSettings extends PageSettings = PageSettings,
-  TResponse extends PathUncheckedResponse = PathUncheckedResponse
+  TResponse extends PathUncheckedResponse = PathUncheckedResponse,
 >(
   client: Client,
   getInitialResponse: () => PromiseLike<TResponse>,
   processResponseBody: (result: TResponse) => PromiseLike<unknown>,
   expectedStatuses: string[],
-  options: BuildPagedAsyncIteratorOptions = {}
+  options: BuildPagedAsyncIteratorOptions = {},
 ): PagedAsyncIterableIterator<TElement, TPage, TPageSettings> {
   const itemName = options.itemName ?? "value";
   const nextLinkName = options.nextLinkName ?? "nextLink";
@@ -119,9 +105,7 @@ export function buildPagedAsyncIterator<
       if (pageLink === undefined) {
         result = await getInitialResponse();
       } else {
-        const resolvedPageLink = apiVersion
-          ? addApiVersionToUrl(pageLink, apiVersion)
-          : pageLink;
+        const resolvedPageLink = apiVersion ? addApiVersionToUrl(pageLink, apiVersion) : pageLink;
         result =
           nextLinkMethod === "POST"
             ? await client.pathUnchecked(resolvedPageLink).post()
@@ -133,15 +117,15 @@ export function buildPagedAsyncIterator<
       const values = getElements<TElement>(results, itemName) as TPage;
       return {
         page: values,
-        nextPageLink: nextLink
+        nextPageLink: nextLink,
       };
     },
     byPage: (settings?: TPageSettings) => {
       const { continuationToken } = settings ?? {};
       return getPageAsyncIterator(pagedResult, {
-        pageLink: continuationToken
+        pageLink: continuationToken,
       });
-    }
+    },
   };
   return getPagedAsyncIterator(pagedResult);
 }
@@ -157,13 +141,11 @@ export function buildPagedAsyncIterator<
 function getPagedAsyncIterator<
   TElement,
   TPage = TElement[],
-  TPageSettings extends PageSettings = PageSettings
+  TPageSettings extends PageSettings = PageSettings,
 >(
-  pagedResult: PagedResult<TElement, TPage, TPageSettings>
+  pagedResult: PagedResult<TElement, TPage, TPageSettings>,
 ): PagedAsyncIterableIterator<TElement, TPage, TPageSettings> {
-  const iter = getItemAsyncIterator<TElement, TPage, TPageSettings>(
-    pagedResult
-  );
+  const iter = getItemAsyncIterator<TElement, TPage, TPageSettings>(pagedResult);
   return {
     next() {
       return iter.next();
@@ -176,18 +158,14 @@ function getPagedAsyncIterator<
       ((settings?: TPageSettings) => {
         const { continuationToken } = settings ?? {};
         return getPageAsyncIterator(pagedResult, {
-          pageLink: continuationToken
+          pageLink: continuationToken,
         });
-      })
+      }),
   };
 }
 
-async function* getItemAsyncIterator<
-  TElement,
-  TPage,
-  TPageSettings extends PageSettings
->(
-  pagedResult: PagedResult<TElement, TPage, TPageSettings>
+async function* getItemAsyncIterator<TElement, TPage, TPageSettings extends PageSettings>(
+  pagedResult: PagedResult<TElement, TPage, TPageSettings>,
 ): AsyncIterableIterator<TElement> {
   const pages = getPageAsyncIterator(pagedResult);
   for await (const page of pages) {
@@ -195,20 +173,14 @@ async function* getItemAsyncIterator<
   }
 }
 
-async function* getPageAsyncIterator<
-  TElement,
-  TPage,
-  TPageSettings extends PageSettings
->(
+async function* getPageAsyncIterator<TElement, TPage, TPageSettings extends PageSettings>(
   pagedResult: PagedResult<TElement, TPage, TPageSettings>,
   options: {
     pageLink?: string;
-  } = {}
+  } = {},
 ): AsyncIterableIterator<ContinuablePage<TElement, TPage>> {
   const { pageLink } = options;
-  let response = await pagedResult.getPage(
-    pageLink ?? pagedResult.firstPageLink
-  );
+  let response = await pagedResult.getPage(pageLink ?? pagedResult.firstPageLink);
   if (!response) {
     return;
   }
@@ -236,13 +208,9 @@ function getNextLink(body: unknown, nextLinkName?: string): string | undefined {
 
   const nextLink = (body as Record<string, unknown>)[nextLinkName];
 
-  if (
-    typeof nextLink !== "string" &&
-    typeof nextLink !== "undefined" &&
-    nextLink !== null
-  ) {
+  if (typeof nextLink !== "string" && typeof nextLink !== "undefined" && nextLink !== null) {
     throw new RestError(
-      `Body Property ${nextLinkName} should be a string or undefined or null but got ${typeof nextLink}`
+      `Body Property ${nextLinkName} should be a string or undefined or null but got ${typeof nextLink}`,
     );
   }
 
@@ -260,7 +228,7 @@ function getElements<T = unknown>(body: unknown, itemName: string): T[] {
   const value = (body as Record<string, unknown>)[itemName] as T[];
   if (!Array.isArray(value)) {
     throw new RestError(
-      `Couldn't paginate response\n Body doesn't contain an array property with name: ${itemName}`
+      `Couldn't paginate response\n Body doesn't contain an array property with name: ${itemName}`,
     );
   }
 
@@ -270,14 +238,11 @@ function getElements<T = unknown>(body: unknown, itemName: string): T[] {
 /**
  * Checks if a request failed
  */
-function checkPagingRequest(
-  response: PathUncheckedResponse,
-  expectedStatuses: string[]
-): void {
+function checkPagingRequest(response: PathUncheckedResponse, expectedStatuses: string[]): void {
   if (!expectedStatuses.includes(response.status)) {
     throw createRestError(
       `Pagination failed with unexpected statusCode ${response.status}`,
-      response
+      response,
     );
   }
 }

package/static/static-helpers/pollingHelpers.ts

@@ -1,17 +1,13 @@
 import {
-  PollerLike,
+  OperationResponse,
   OperationState,
+  PollerLike,
   ResourceLocationConfig,
   RunningOperation,
   createHttpPoller,
-  OperationResponse
 } from "@azure/core-lro";
 
-import {
-  Client,
-  PathUncheckedResponse,
-  createRestError
-} from "@azure-rest/core-client";
+import { Client, PathUncheckedResponse, createRestError } from "@azure-rest/core-client";
 import { AbortSignalLike } from "@azure/abort-controller";
 
 export interface GetLongRunningPollerOptions<TResponse> {
@@ -43,29 +39,22 @@ export interface GetLongRunningPollerOptions<TResponse> {
    */
   apiVersion?: string;
 }
-export function getLongRunningPoller<
-  TResponse extends PathUncheckedResponse,
-  TResult = void
->(
+export function getLongRunningPoller<TResponse extends PathUncheckedResponse, TResult = void>(
   client: Client,
   processResponseBody: (result: TResponse) => Promise<TResult>,
   expectedStatuses: string[],
-  options: GetLongRunningPollerOptions<TResponse>
+  options: GetLongRunningPollerOptions<TResponse>,
 ): PollerLike<OperationState<TResult>, TResult> {
   const { restoreFrom, getInitialResponse, apiVersion } = options;
   if (!restoreFrom && !getInitialResponse) {
-    throw new Error(
-      "Either restoreFrom or getInitialResponse must be specified"
-    );
+    throw new Error("Either restoreFrom or getInitialResponse must be specified");
   }
   let initialResponse: TResponse | undefined = undefined;
   const pollAbortController = new AbortController();
   const poller: RunningOperation<TResponse> = {
     sendInitialRequest: async () => {
       if (!getInitialResponse) {
-        throw new Error(
-          "getInitialResponse is required when initializing a new poller"
-        );
+        throw new Error("getInitialResponse is required when initializing a new poller");
       }
       initialResponse = await getInitialResponse();
       return getLroResponse(initialResponse, expectedStatuses);
@@ -74,7 +63,7 @@ export function getLongRunningPoller<
       path: string,
       pollOptions?: {
         abortSignal?: AbortSignalLike;
-      }
+      },
     ) => {
       // The poll request would both listen to the user provided abort signal and the poller's own abort signal
       function abortListener(): void {
@@ -87,17 +76,15 @@ export function getLongRunningPoller<
         pollAbortController.abort();
       } else if (!abortSignal.aborted) {
         options.abortSignal?.addEventListener("abort", abortListener, {
-          once: true
+          once: true,
         });
         pollOptions?.abortSignal?.addEventListener("abort", abortListener, {
-          once: true
+          once: true,
         });
       }
       let response;
       try {
-        const pollingPath = apiVersion
-          ? addApiVersionToUrl(path, apiVersion)
-          : path;
+        const pollingPath = apiVersion ? addApiVersionToUrl(path, apiVersion) : path;
         response = await client.pathUnchecked(pollingPath).get({ abortSignal });
       } finally {
         options.abortSignal?.removeEventListener("abort", abortListener);
@@ -105,7 +92,7 @@ export function getLongRunningPoller<
       }
 
       return getLroResponse(response as TResponse, expectedStatuses);
-    }
+    },
   };
   return createHttpPoller(poller, {
     intervalInMs: options?.updateIntervalInMs,
@@ -113,7 +100,7 @@ export function getLongRunningPoller<
     restoreFrom: options?.restoreFrom,
     processResult: (result: unknown) => {
       return processResponseBody(result as TResponse);
-    }
+    },
   });
 }
 /**
@@ -124,7 +111,7 @@ export function getLongRunningPoller<
  */
 function getLroResponse<TResponse extends PathUncheckedResponse>(
   response: TResponse,
-  expectedStatuses: string[]
+  expectedStatuses: string[],
 ): OperationResponse<TResponse> {
   if (!expectedStatuses.includes(response.status)) {
     throw createRestError(response);
@@ -135,8 +122,8 @@ function getLroResponse<TResponse extends PathUncheckedResponse>(
     rawResponse: {
       ...response,
       statusCode: Number.parseInt(response.status),
-      body: response.body
-    }
+      body: response.body,
+    },
   };
 }
 

package/static/static-helpers/serialization/build-multi-collection.ts

@@ -1,7 +1,4 @@
-export function buildMultiCollection(
-  items: string[],
-  parameterName: string
-): string {
+export function buildMultiCollection(items: string[], parameterName: string): string {
   return items
     .map((item, index) => {
       if (index === 0) {

package/static/static-helpers/serialization/check-prop-undefined.ts

@@ -4,10 +4,7 @@
  * @param properties The list of property names to check on the item.
  * @returns True if all specified properties are undefined, otherwise false.
  */
-export function areAllPropsUndefined(
-  item: Record<string, any>,
-  properties: string[]
-): boolean {
+export function areAllPropsUndefined(item: Record<string, any>, properties: string[]): boolean {
   for (const property of properties) {
     if (item[property] !== undefined) {
       return false;

package/static/static-helpers/serialization/get-binary-response-browser.mts

@@ -5,7 +5,9 @@ import { HttpResponse, StreamableMethod } from "@azure-rest/core-client";
  * to bypass Core's default response handling. This works around an issue where binary bodies in Core
  * are coerced into UTF-8, regardless of whether the body is valid UTF-8 or not.
  */
-export async function getBinaryResponse(streamableMethod: StreamableMethod): Promise<HttpResponse & { body?: Uint8Array }> {
+export async function getBinaryResponse(
+  streamableMethod: StreamableMethod,
+): Promise<HttpResponse & { body?: Uint8Array }> {
   const response = await streamableMethod.asBrowserStream();
 
   if (response.body === undefined) {

package/static/static-helpers/serialization/get-binary-response.ts

@@ -7,7 +7,7 @@ import { Buffer } from "node:buffer";
  * are coerced into UTF-8, regardless of whether the body is valid UTF-8 or not.
  */
 export async function getBinaryResponse(
-  streamableMethod: StreamableMethod
+  streamableMethod: StreamableMethod,
 ): Promise<HttpResponse & { body?: Uint8Array }> {
   const response = await streamableMethod.asNodeStream();
   if (response.body === undefined) {
@@ -20,6 +20,6 @@ export async function getBinaryResponse(
 
   return {
     ...response,
-    body: Buffer.concat(bufs)
+    body: Buffer.concat(bufs),
   };
 }

package/static/static-helpers/serialization/get-binary-stream-response-browser.mts

@@ -7,9 +7,7 @@ import { NodeReadableStream } from "../platform-types-browser.mjs";
  * Error handling is left to the caller so that generated deserializers can apply
  * operation-specific error deserialization (per-status-code details, exception headers, etc.).
  */
-export async function getBinaryStreamResponse(
-  streamableMethod: StreamableMethod
-): Promise<
+export async function getBinaryStreamResponse(streamableMethod: StreamableMethod): Promise<
   HttpResponse & {
     blobBody?: Promise<Blob>;
     readableStreamBody?: NodeReadableStream;

package/static/static-helpers/serialization/get-binary-stream-response.ts

@@ -7,9 +7,7 @@ import { NodeReadableStream } from "../platform-types.js";
  * Error handling is left to the caller so that generated deserializers can apply
  * operation-specific error deserialization (per-status-code details, exception headers, etc.).
  */
-export async function getBinaryStreamResponse(
-  streamableMethod: StreamableMethod
-): Promise<
+export async function getBinaryStreamResponse(streamableMethod: StreamableMethod): Promise<
   HttpResponse & {
     blobBody?: Promise<Blob>;
     readableStreamBody?: NodeReadableStream;
@@ -19,6 +17,6 @@ export async function getBinaryStreamResponse(
   return {
     ...response,
     blobBody: undefined,
-    readableStreamBody: response.body
+    readableStreamBody: response.body,
   };
 }