@azure-tools/typespec-ts 0.51.0 → 0.51.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.51.0",
+  "version": "0.51.1",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -18,15 +18,15 @@
   "license": "MIT",
   "devDependencies": {
     "@azure-rest/core-client": "^2.3.1",
-    "@typespec/http-specs": "0.1.0-alpha.35-dev.1",
-    "@typespec/spector": "0.1.0-dev.0",
-    "@typespec/spec-api": "0.1.0-alpha.14-dev.1",
+    "@typespec/http-specs": "0.1.0-dev.2",
+    "@typespec/spector": "0.1.0-dev.3",
+    "@typespec/spec-api": "0.1.0-alpha.14-dev.3",
     "@typespec/tspd": "0.74.1",
-    "@azure-tools/azure-http-specs": "0.1.0-alpha.39-dev.2",
-    "@azure-tools/typespec-autorest": "^0.66.0",
-    "@azure-tools/typespec-azure-core": "^0.66.0",
-    "@azure-tools/typespec-azure-resource-manager": "^0.66.0",
-    "@azure-tools/typespec-client-generator-core": "^0.66.2",
+    "@azure-tools/azure-http-specs": "0.1.0-alpha.39-dev.7",
+    "@azure-tools/typespec-autorest": "^0.66.1",
+    "@azure-tools/typespec-azure-core": "^0.66.1",
+    "@azure-tools/typespec-azure-resource-manager": "^0.66.1",
+    "@azure-tools/typespec-client-generator-core": "^0.66.4",
     "@azure/abort-controller": "^2.1.2",
     "@azure/core-auth": "^1.6.0",
     "@azure/core-lro": "^3.1.0",
@@ -64,8 +64,8 @@
     "js-yaml": "^4.1.0"
   },
   "peerDependencies": {
-    "@azure-tools/typespec-azure-core": "^0.66.0",
-    "@azure-tools/typespec-client-generator-core": "^0.66.2",
+    "@azure-tools/typespec-azure-core": "^0.66.1",
+    "@azure-tools/typespec-client-generator-core": "^0.66.4",
     "@typespec/compiler": "^1.10.0",
     "@typespec/http": "^1.10.0",
     "@typespec/rest": "^0.80.0",
@@ -73,7 +73,7 @@
     "@typespec/xml": "^0.80.0"
   },
   "dependencies": {
-    "@azure-tools/rlc-common": "^0.51.0",
+    "@azure-tools/rlc-common": "^0.51.1",
     "fast-xml-parser": "^4.5.0",
     "fs-extra": "^11.1.0",
     "lodash": "^4.17.21",

package/src/index.ts

@@ -124,6 +124,12 @@ export async function $onEmit(context: EmitContext) {
   const program: Program = context.program;
   const emitterOptions: EmitterOptions = context.options;
   const dpgContext = await createContextWithDefaultOptions(context);
+
+  // Report any diagnostics from TCGC
+  if (dpgContext.diagnostics?.length > 0) {
+    program.reportDiagnostics(dpgContext.diagnostics);
+  }
+
   // Enrich the dpg context with path detail and common options
   await enrichDpgContext();
   const rlcOptions = dpgContext.rlcOptions ?? {};

package/src/lib.ts

@@ -92,6 +92,13 @@ export interface EmitterOptions {
    * Defaults to `false`.
    */
   "enable-storage-compat"?: boolean;
+  /**
+   * When set to true, TypeSpec `unknown` type will be translated to `Record<string, unknown>`
+   * instead of `any` in the generated Modular SDK. This is useful when migrating from HLC
+   * where `unknown` in swagger mapped to `Record<string, unknown>` in the SDK.
+   * (Modular SDK only) Defaults to `false`.
+   */
+  "treat-unknown-as-record"?: boolean;
 }
 
 export const RLCOptionsSchema: JSONSchemaType<EmitterOptions> = {
@@ -388,6 +395,12 @@ export const RLCOptionsSchema: JSONSchemaType<EmitterOptions> = {
       nullable: true,
       description:
         "When enabled, every regular (non-LRO, non-paging) operation return type is augmented with a `_response` property containing `rawResponse` (PathUncheckedResponse), `parsedBody`, and `parsedHeaders`. Defaults to `false`."
+    },
+    "treat-unknown-as-record": {
+      type: "boolean",
+      nullable: true,
+      description:
+        "When set to true, TypeSpec `unknown` type will be translated to `Record<string, unknown>` instead of `any` in the generated Modular SDK. This is useful when migrating from HLC where `unknown` in swagger mapped to `Record<string, unknown>`. (Modular SDK only) Defaults to `false`."
     }
   },
   required: []
@@ -573,7 +586,7 @@ const libDef = {
     "prefix-adding-in-enum-member": {
       severity: "warning",
       messages: {
-        default: paramMessage`Enum member name ${"memberName"} is normalized to ${"normalizedName"} with "_" prefix.`
+        default: paramMessage`Enum member name ${"memberName"} is not a valid TypeScript identifier. It has been renamed to ${"normalizedName"} using the enum type name ${"enumTypeName"} as prefix.`
       }
     },
     "default-value-object": {

package/src/modular/emitModels.ts

@@ -597,13 +597,14 @@ export function buildEnumTypes(
   type: SdkEnumType,
   reportMemberNameDiagnostic = false // if reportMemberNameDiagnostic is true, it will report diagnostic for enum member name
 ): [TypeAliasDeclarationStructure, EnumDeclarationStructure] {
+  const rawMembers = type.values.map((value) =>
+    emitEnumMember(context, value, reportMemberNameDiagnostic)
+  );
   const enumDeclaration: EnumDeclarationStructure = {
     kind: StructureKind.Enum,
     name: `Known${normalizeModelName(context, type)}`,
     isExported: true,
-    members: type.values.map((value) =>
-      emitEnumMember(context, value, reportMemberNameDiagnostic)
-    )
+    members: deduplicateEnumMemberNames(rawMembers)
   };
 
   const enumAsUnion: TypeAliasDeclarationStructure = {
@@ -650,27 +651,65 @@ function getExtensibleEnumDescription(
   ].join(" \n");
 }
 
+/**
+ * Deduplicates enum member names by appending a numeric suffix (_1, _2, ...)
+ * to all members that share the same normalized name.
+ * This handles cases where different values (e.g. "10" and "1.0") normalize
+ * to the same identifier.
+ */
+function deduplicateEnumMemberNames(
+  members: EnumMemberStructure[]
+): EnumMemberStructure[] {
+  const nameCount = new Map<string, number>();
+  for (const member of members) {
+    const name = member.name as string;
+    nameCount.set(name, (nameCount.get(name) ?? 0) + 1);
+  }
+  const nameCurrentIndex = new Map<string, number>();
+  return members.map((member) => {
+    const name = member.name as string;
+    if ((nameCount.get(name) ?? 0) > 1) {
+      const index = (nameCurrentIndex.get(name) ?? 0) + 1;
+      nameCurrentIndex.set(name, index);
+      return { ...member, name: `${name}_${index}` };
+    }
+    return member;
+  });
+}
+
 function emitEnumMember(
   context: SdkContext,
   member: SdkEnumValueType,
   reportMemberNameDiagnostic = false // if reportMemberNameDiagnostic is true, it will report diagnostic for enum member name
 ): EnumMemberStructure {
-  const normalizedMemberName = context.rlcOptions?.ignoreEnumMemberNameNormalize
+  const shouldNormalizeName = !member.name.startsWith("$DO_NOT_NORMALIZE$");
+  const enumTypeName = normalizeName(
+    member.enumType.name,
+    NameType.Interface,
+    true
+  );
+  let normalizedMemberName = context.rlcOptions?.ignoreEnumMemberNameNormalize
     ? fixLeadingNumber(member.name, NameType.EnumMemberName) // need to fix the leading number also for enum member
     : normalizeName(member.name, NameType.EnumMemberName, true);
+  // If the member name starts with _ due to a leading digit (not because the original has _),
+  // replace the _ prefix with the enum type name for a more descriptive identifier
   if (
-    reportMemberNameDiagnostic &&
+    shouldNormalizeName &&
     normalizedMemberName.toLowerCase().startsWith("_") &&
     !member.name.toLowerCase().startsWith("_")
   ) {
-    reportDiagnostic(context.program, {
-      code: "prefix-adding-in-enum-member",
-      format: {
-        memberName: member.name,
-        normalizedName: normalizedMemberName
-      },
-      target: NoTarget
-    });
+    normalizedMemberName = enumTypeName + normalizedMemberName.slice(1);
+    if (reportMemberNameDiagnostic) {
+      reportDiagnostic(context.program, {
+        code: "prefix-adding-in-enum-member",
+        format: {
+          memberName: member.name,
+          normalizedName: normalizedMemberName,
+          enumTypeName
+        },
+        target: NoTarget
+      });
+    }
   }
   const memberStructure: EnumMemberStructure = {
     kind: StructureKind.EnumMember,

package/src/modular/helpers/operationHelpers.ts

@@ -191,17 +191,9 @@ export function getDeserializePrivateFunction(
 
   // Check if we need to wrap the non-model return type
   const { shouldWrap, isBinary } = checkWrapNonModelReturn(context, operation);
-  // For binary wrap, the deserializer receives a StreamableMethod directly
-  const resultParamType =
-    shouldWrap && isBinary
-      ? resolveReference(dependencies.StreamableMethod)
-      : PathUncheckedResponseReference;
-  const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
-    {
-      name: "result",
-      type: resultParamType
-    }
-  ];
+  // For binary wrap, the deserializer receives PathUncheckedResponse & { blobBody, readableStreamBody }
+  // which is returned by getBinaryStreamResponse.
+  const isBinaryWrap = shouldWrap && isBinary;
   const isLroOnly = isLroOnlyOperation(operation);
   const isLroAndPaging = isLroAndPagingOperation(operation);
   const isPagingOnly = isPagingOnlyOperation(operation);
@@ -236,6 +228,16 @@ export function getDeserializePrivateFunction(
     returnType = { name: "", type: "void" };
   }
 
+  const resultParamName = "result";
+  const resultParamType = isBinaryWrap
+    ? `${PathUncheckedResponseReference} & ${returnType.type}`
+    : PathUncheckedResponseReference;
+  const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
+    {
+      name: resultParamName,
+      type: resultParamType
+    }
+  ];
   const functionStatement: OptionalKind<FunctionDeclarationStructure> = {
     isAsync: true,
     isExported: true,
@@ -247,17 +249,14 @@ export function getDeserializePrivateFunction(
   const createRestErrorReference = resolveReference(
     dependencies.createRestError
   );
-  // For binary wrap, parameter is StreamableMethod - skip status check
-  if (!(shouldWrap && isBinary)) {
-    statements.push(
-      `const expectedStatuses = ${getExpectedStatuses(operation)};`
-    );
-    statements.push(
-      `if(!expectedStatuses.includes(result.status)){`,
-      `${getExceptionThrowStatement(context, operation)}`,
-      "}"
-    );
-  }
+  statements.push(
+    `const expectedStatuses = ${getExpectedStatuses(operation)};`
+  );
+  statements.push(
+    `if(!expectedStatuses.includes(result.status)){`,
+    `${getExceptionThrowStatement(context, operation)}`,
+    "}"
+  );
   const deserializedType =
     isLroOnly || isLroAndPaging
       ? operation?.lroMetadata?.finalResponse?.result
@@ -396,19 +395,11 @@ export function getDeserializePrivateFunction(
       // Handle wrap-non-model-return for non-LRO, non-paging operations
       if (shouldWrap) {
         if (isBinary) {
-          const getBinaryResponseBodyReference = resolveReference(
-            SerializationHelpers.getBinaryResponseBody
-          );
-          const deserializeError = getExceptionDetails(
-            context,
-            operation
-          ).defaultDeserializer;
-          const deserializeErrorStr = deserializeError
-            ? `, ${deserializeError}`
-            : "";
+          // Binary wrap: getBinaryStream already resolved the stream,
+          // status check and error.details handling ran above.
+          // Return the platform-specific stream properties.
           statements.push(
-            `return ${getBinaryResponseBodyReference}(result, ${getExpectedStatuses(operation)}${deserializeErrorStr});
-`
+            `return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };`
           );
         } else {
           // Non-model response: wrap with body property
@@ -913,7 +904,8 @@ function getOperationSignatureParameters(
         !(
           p.isGeneratedName &&
           (p.name === "contentType" || p.name === "accept")
-        ) // skip tcgc generated contentType and accept header parameter
+        ) && // skip tcgc generated contentType and accept header parameter
+        getClientOptions(p, "headerCollectionPrefix") === undefined // skip headers with collection prefix
     )
     .map((p) => {
       return {
@@ -1011,6 +1003,7 @@ export function getOperationFunction(
       name: getOperationResponseTypeName(method),
       type: resolveReference(refkey(operation, "response"))
     };
+    bodyType = returnType.type;
   } else if (response.type) {
     const type = response.type;
 
@@ -1091,23 +1084,6 @@ export function getOperationFunction(
   const resultVarName = generateLocallyUniqueName("result", paramNames);
 
   const parameterList = parameters.map((p) => p.name).join(", ");
-  // For binary wrap, pass the StreamableMethod directly to the deserializer.
-  // The deserializer uses asBrowserStream()/asNodeStream() to build the wrapper.
-  if (wrapReturn && wrapReturnIsBinary) {
-    const streamableMethodVarName = generateLocallyUniqueName(
-      "streamableMethod",
-      paramNames
-    );
-    statements.push(
-      `const ${streamableMethodVarName} = _${name}Send(${parameterList});`
-    );
-    statements.push(`return _${name}Deserialize(${streamableMethodVarName});`);
-    return {
-      ...functionStatement,
-      statements
-    } as FunctionDeclarationStructure & { propertyName?: string };
-  }
-
   // When storage-compat is enabled, set up the onResponse interceptor before sending
   const storageCompatVarName = generateLocallyUniqueName(
     "_storageCompat",
@@ -1132,6 +1108,8 @@ export function getOperationFunction(
 
   // Special case for binary-only bodies: use helper to call streaming methods so that Core doesn't poison the response body by
   // doing a UTF-8 decode on the raw bytes.
+  // For binary wrap, use getBinaryStreamResponse which preserves blobBody/readableStreamBody properties.
+  // For non-wrapped binary, use getBinaryResponse which buffers the body into Uint8Array.
   if (response?.type?.kind === "bytes" && response.type.encode === "bytes") {
     const streamableMethodVarName = generateLocallyUniqueName(
       "streamableMethod",
@@ -1140,8 +1118,12 @@ export function getOperationFunction(
     statements.push(
       `const ${streamableMethodVarName} = _${name}Send(${sendParameterList});`
     );
+    const binaryHelper =
+      wrapReturn && wrapReturnIsBinary
+        ? SerializationHelpers.getBinaryStreamResponse
+        : SerializationHelpers.getBinaryResponse;
     statements.push(
-      `const ${resultVarName} = await ${resolveReference(SerializationHelpers.getBinaryResponse)}(${streamableMethodVarName});`
+      `const ${resultVarName} = await ${resolveReference(binaryHelper)}(${streamableMethodVarName});`
     );
   } else {
     statements.push(
@@ -1773,7 +1755,7 @@ export function getParameterMap(
       ? getHeaderSerializedName(param)
       : getPropertySerializedName(param);
 
-  if (isConstant(param.type)) {
+  if (isConstant(param.type) && !isOptional(param)) {
     return `"${serializedName}": ${getConstantValue(param.type)}`;
   }
 
@@ -3081,17 +3063,48 @@ export function checkWrapNonModelReturn(
   const type = response.type;
   const contentTypes = operation.operation.responses[0]?.contentTypes ?? [];
 
-  // Check if it's a binary (bytes with binary content type) response
+  // Determine whether to wrap based on the HLC PropertyKind mapping.
+  // HLC wraps with `body` only when the type is PropertyKind.Primitive or PropertyKind.Enum
+  // (i.e. NOT PropertyKind.Composite or PropertyKind.Dictionary).
+  // For array types, HLC uses the item's kind, not the array itself.
+  //
+  // Case: bytes with binary content type → binary wrap (isBinary=true)
+  //   HLC: bytes → binary payload → separate binary handling
   if (type.__raw && isBinaryPayload(context, type.__raw, contentTypes)) {
     return { shouldWrap: true, isBinary: true };
   }
 
-  // Check if it's a non-model, non-record type (array, scalar, enum, etc.)
-  if (type.kind !== "model" && type.kind !== "dict") {
-    return { shouldWrap: true, isBinary: false };
+  // Case: model array (e.g. Foo[]) → no wrap
+  //   HLC: model array → PropertyKind.Composite (item kind = model) → no body wrapper
+  //   Modular: array with valueType.kind === "model"
+  if (type.kind === "array" && type.valueType.kind === "model") {
+    return noWrap;
+  }
+
+  // Case: any object / Record (e.g. Record<string, unknown>) → no wrap
+  //   HLC: SchemaType.AnyObject → PropertyKind.Dictionary → no body wrapper
+  //   Modular: kind === "dict"
+  // Case: model → no wrap
+  //   HLC: model → PropertyKind.Composite → no body wrapper
+  //   Modular: kind === "model"
+  if (type.kind === "dict" || type.kind === "model") {
+    return noWrap;
+  }
+
+  // Case: unknown with treatUnknownAsRecord enabled → no wrap
+  //   When treatUnknownAsRecord is enabled, `unknown` is treated as Record<string, unknown>
+  //   which maps to HLC PropertyKind.Dictionary → no body wrapper
+  if (type.kind === "unknown" && context.rlcOptions?.treatUnknownAsRecord) {
+    return noWrap;
   }
 
-  return noWrap;
+  // Remaining cases → wrap with `body`:
+  //   - string   → HLC PropertyKind.Primitive → modular `string`
+  //   - boolean  → HLC PropertyKind.Primitive → modular `boolean`
+  //   - string[] → HLC PropertyKind.Primitive (array keeps item kind) → modular `string[]`
+  //   - any      → HLC PropertyKind.Primitive → modular `unknown` or `any`
+  //   - enum     → HLC PropertyKind.Enum → modular `KnownXxx | string`
+  return { shouldWrap: true, isBinary: false };
 }
 
 /**

package/src/modular/static-helpers-metadata.ts

@@ -59,10 +59,10 @@ export const SerializationHelpers = {
     name: "getBinaryResponse",
     location: "serialization/get-binary-response.ts"
   },
-  getBinaryResponseBody: {
+  getBinaryStreamResponse: {
     kind: "function",
-    name: "getBinaryResponseBody",
-    location: "serialization/get-binary-response-body.ts"
+    name: "getBinaryStreamResponse",
+    location: "serialization/get-binary-stream-response.ts"
   },
   areAllPropsUndefined: {
     kind: "function",

package/src/modular/type-expressions/get-type-expression.ts

@@ -40,7 +40,9 @@ export function getTypeExpression(
     case "enum":
       return getEnumExpression(context, type);
     case "unknown":
-      return "any";
+      return context.rlcOptions?.treatUnknownAsRecord
+        ? "Record<string, unknown>"
+        : "any";
     case "boolean":
       return "boolean";
     case "decimal":

package/src/transform/transfromRLCOptions.ts

@@ -93,6 +93,8 @@ function extractRLCOptions(
   const compatibilityQueryMultiFormat =
     emitterOptions["compatibility-query-multi-format"];
   const enableStorageCompat = emitterOptions["enable-storage-compat"] === true;
+  const treatUnknownAsRecord =
+    emitterOptions["treat-unknown-as-record"] === true;
   const typespecTitleMap = emitterOptions["typespec-title-map"];
   const hasSubscriptionId = getSubscriptionId(dpgContext);
   const ignoreNullableOnOptional = getIgnoreNullableOnOptional(
@@ -138,7 +140,8 @@ function extractRLCOptions(
     ignoreNullableOnOptional,
     wrapNonModelReturn,
     isMultiService,
-    enableStorageCompat
+    enableStorageCompat,
+    treatUnknownAsRecord
   };
 }
 

package/src/utils/clientUtils.ts

@@ -58,6 +58,8 @@ export function getRLCClients(
           service: service,
           type: service,
           services: [service],
+          subClients: [],
+          clientPath: clientName,
           arm: Boolean(dpgContext.arm),
           crossLanguageDefinitionId: `${getNamespaceFullName(
             service
@@ -77,6 +79,8 @@ export function getRLCClients(
       service: service,
       type: service,
       services: [service],
+      subClients: [],
+      clientPath: clientName,
       arm: Boolean(dpgContext.arm),
       crossLanguageDefinitionId: `${getNamespaceFullName(
         service

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

@@ -0,0 +1,23 @@
+import { HttpResponse, StreamableMethod } from "@azure-rest/core-client";
+
+/**
+ * Resolves a StreamableMethod into a binary stream response using browser streaming.
+ * Returns both the raw HttpResponse (for status/header inspection) and a blobBody Promise.
+ * 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<
+  HttpResponse & {
+    blobBody?: Promise<Blob>;
+    readableStreamBody?: NodeJS.ReadableStream;
+  }
+> {
+  const response = await streamableMethod.asBrowserStream();
+  return {
+    ...response,
+    blobBody: new Response(response.body).blob(),
+    readableStreamBody: undefined,
+  };
+}

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

@@ -0,0 +1,23 @@
+import { HttpResponse, StreamableMethod } from "@azure-rest/core-client";
+
+/**
+ * Resolves a StreamableMethod into a binary stream response using Node.js streaming.
+ * Returns both the raw HttpResponse (for status/header inspection) and the readable stream body.
+ * 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<
+  HttpResponse & {
+    blobBody?: Promise<Blob>;
+    readableStreamBody?: NodeJS.ReadableStream;
+  }
+> {
+  const response = await streamableMethod.asNodeStream();
+  return {
+    ...response,
+    blobBody: undefined,
+    readableStreamBody: response.body
+  };
+}

package/static/static-helpers/serialization/xml-helpers.ts

@@ -108,7 +108,7 @@ const defaultParserOptions = {
   trimValues: false, // Preserve whitespace in text content
   isArray: (
     _name: string,
-    _jpath: string,
+    _jpath: string | unknown,
     isLeafNode: boolean,
     isAttribute: boolean
   ) => {

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

@@ -1,22 +0,0 @@
-import { createRestError, StreamableMethod } from "@azure-rest/core-client";
-
-/**
- * Get the binary response body from a StreamableMethod, returning it as a Blob in browser environments and as a NodeJS.ReadableStream in Node.js environments. This function checks the response status against expected statuses and throws a RestError if the status is unexpected, optionally deserializing error details using a provided deserialization function.
- */
-export async function getBinaryResponseBody(
-  result: StreamableMethod,
-  expectedStatuses: string[] = ["200"],
-  deserializeError?: (error: any) => unknown
-): Promise<{ blobBody?: Promise<Blob>; readableStreamBody?: NodeJS.ReadableStream }> {
-  const browserStream = await result.asBrowserStream();
-  if (!expectedStatuses.includes(browserStream.status)) {
-    const error = createRestError(browserStream);
-    if (deserializeError) {
-      error.details = deserializeError(browserStream.body);
-    }
-
-    throw error;
-  }
-  return { blobBody: new Response(browserStream.body).blob(), readableStreamBody: undefined };
-
-}

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

@@ -1,24 +0,0 @@
-import { createRestError, StreamableMethod } from "@azure-rest/core-client";
-
-/**
- * Gets the binary response body from a StreamableMethod, returning it as a NodeJS.ReadableStream in Node.js environments. In browser environments, this function returns `undefined` for the stream and instead provides a `blobBody` that is a Promise resolving to a Blob, since browser environments do not support NodeJS.ReadableStream.
- */
-export async function getBinaryResponseBody(
-  result: StreamableMethod,
-  expectedStatuses: string[] = ["200"],
-  deserializeError?: (error: any) => unknown
-): Promise<{
-  blobBody?: Promise<Blob>;
-  readableStreamBody?: NodeJS.ReadableStream;
-}> {
-  const nodeStream = await result.asNodeStream();
-  if (!expectedStatuses.includes(nodeStream.status)) {
-    const error = createRestError(nodeStream);
-    if (deserializeError) {
-      error.details = deserializeError(nodeStream.body);
-    }
-
-    throw error;
-  }
-  return { blobBody: undefined, readableStreamBody: nodeStream.body };
-}