@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/transform/transfrom-rlc-options.ts

@@ -0,0 +1,461 @@
+import { getHttpOperationWithCache } from "@azure-tools/typespec-client-generator-core";
+import { getDoc, NoTarget, Program } from "@typespec/compiler";
+import { getAuthentication } from "@typespec/http";
+import { EmitterOptions, reportDiagnostic } from "../lib.js";
+import { getClientParameters } from "../modular/helpers/client-helpers.js";
+import {
+  NameType,
+  normalizeName,
+  PackageDetails,
+  PackageFlavor,
+  pascalCase,
+  RLCOptions,
+  ServiceInfo,
+} from "../rlc-common/index.js";
+import { getRLCClients, listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { getSupportedHttpAuth } from "../utils/credential-utils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { getDefaultService } from "../utils/model-utils.js";
+import { detectModelConflicts } from "../utils/namespace-utils.js";
+import { getOperationName } from "../utils/operation-util.js";
+
+export function transformRLCOptions(
+  emitterOptions: EmitterOptions,
+  dpgContext: SdkContext,
+): RLCOptions {
+  // Extract the options from emitter option
+  const options = extractRLCOptions(
+    dpgContext,
+    emitterOptions,
+    dpgContext.generationPathDetail?.rootDir ?? "",
+  );
+  const batch = getRLCClients(dpgContext, options.isModularLibrary);
+  options.batch = batch;
+  return options;
+}
+function extractRLCOptions(
+  dpgContext: SdkContext,
+  emitterOptions: EmitterOptions,
+  generationRootDir: string,
+): RLCOptions {
+  const program = dpgContext.program;
+  // Compute isModularLibrary early - defaults to true unless explicitly set to false
+  const isModularLibrary = emitterOptions["is-modular-library"] !== false;
+  const includeShortcuts = getIncludeShortcuts(emitterOptions);
+  const packageDetails = getPackageDetails(program, emitterOptions, isModularLibrary);
+  const flavor = getFlavor(emitterOptions, packageDetails);
+  const moduleKind = getModuleKind(emitterOptions);
+  const serviceInfo = getServiceInfo(program, isModularLibrary);
+  const includeHeadersInResponse = emitterOptions["include-headers-in-response"] === true;
+  const azureSdkForJs = getAzureSdkForJs(emitterOptions, flavor);
+  const generateMetadata = getGenerateMetadata(emitterOptions);
+  const generateTest = getGenerateTest(emitterOptions, flavor);
+  const generateSample = getGenerateSample(dpgContext, emitterOptions);
+  const credentialInfo = getCredentialInfo(program, emitterOptions, isModularLibrary);
+  const azureOutputDirectory = getAzureOutputDirectory(generationRootDir);
+  const enableOperationGroup = getEnableOperationGroup(
+    dpgContext,
+    emitterOptions,
+    isModularLibrary,
+  );
+  const enableModelNamespace = getEnableModelNamespace(dpgContext, emitterOptions);
+  const hierarchyClient = getHierarchyClient(emitterOptions);
+  const clearOutputFolder = getClearOutputFolder(emitterOptions);
+  const multiClient = emitterOptions["multi-client"];
+  const isTypeSpecTest = emitterOptions["is-typespec-test"];
+  const title = emitterOptions.title;
+  const dependencyInfo = emitterOptions["dependency-info"];
+  const productDocLink = emitterOptions["product-doc-link"];
+  const compatibilityMode = emitterOptions["compatibility-mode"];
+  const compatibilityLro = emitterOptions["compatibility-lro"];
+  const experimentalExtensibleEnums = emitterOptions["experimental-extensible-enums"];
+  const ignorePropertyNameNormalize = emitterOptions["ignore-property-name-normalize"];
+  const ignoreEnumMemberNameNormalize = emitterOptions["ignore-enum-member-name-normalize"];
+  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 generateReactNativeTarget = emitterOptions["generate-react-native-target"] === true;
+  const hasSubscriptionId = getSubscriptionId(dpgContext);
+  const ignoreNullableOnOptional = getIgnoreNullableOnOptional(emitterOptions, flavor);
+  const wrapNonModelReturn = getWrapNonModelReturn(emitterOptions, flavor);
+  const isMultiService = (dpgContext.allServiceNamespaces?.length ?? 0) > 1;
+
+  return {
+    ...credentialInfo,
+    includeHeadersInResponse,
+    flavor,
+    moduleKind,
+    includeShortcuts,
+    packageDetails,
+    generateMetadata,
+    generateTest,
+    generateSample,
+    azureSdkForJs,
+    serviceInfo,
+    azureOutputDirectory,
+    sourceFrom: "TypeSpec",
+    enableOperationGroup,
+    enableModelNamespace,
+    hierarchyClient,
+    azureArm: dpgContext.arm,
+    clearOutputFolder,
+    multiClient,
+    isTypeSpecTest,
+    title,
+    dependencyInfo,
+    productDocLink,
+    isModularLibrary,
+    compatibilityMode,
+    compatibilityLro,
+    experimentalExtensibleEnums,
+    ignorePropertyNameNormalize,
+    compatibilityQueryMultiFormat,
+    typespecTitleMap,
+    ignoreEnumMemberNameNormalize,
+    hasSubscriptionId,
+    ignoreNullableOnOptional,
+    wrapNonModelReturn,
+    isMultiService,
+    enableStorageCompat,
+    treatUnknownAsRecord,
+    generateReactNativeTarget,
+  };
+}
+
+function processAuth(program: Program, isModularLibrary: boolean) {
+  const serviceNs = getDefaultService(program, isModularLibrary)?.type;
+  if (!serviceNs) {
+    return undefined;
+  }
+  const authorization = getAuthentication(program, serviceNs);
+  if (!authorization || !authorization.options) {
+    return undefined;
+  }
+  const securityInfo: RLCOptions = {};
+  for (const auth of getSupportedHttpAuth(program, authorization)) {
+    switch (auth.type) {
+      case "http":
+        securityInfo.addCredentials = true;
+        securityInfo.customHttpAuthHeaderName = "Authorization";
+        // If it is basic or bearer auth we should generate it as Basic or Bearer
+        securityInfo.customHttpAuthSharedKeyPrefix = ["basic", "bearer"].includes(
+          auth.scheme.toLowerCase(),
+        )
+          ? pascalCase(auth.scheme)
+          : auth.scheme;
+        break;
+      case "apiKey":
+        if (auth.in === "cookie") {
+          return undefined;
+        }
+        securityInfo.addCredentials = true;
+        securityInfo.credentialKeyHeaderName = auth.name;
+        break;
+      case "oauth2": {
+        const flow = auth.flows[0];
+        if (flow === undefined || !flow.scopes) {
+          return undefined;
+        }
+        securityInfo.addCredentials = true;
+        if (!securityInfo.credentialScopes) {
+          securityInfo.credentialScopes = [];
+        }
+        if (flow.scopes.length === 0) {
+          reportDiagnostic(program, {
+            code: "no-credential-scopes",
+            target: NoTarget,
+          });
+        }
+        // ignore the user_impersonation scope
+        if (
+          flow.scopes.length === 1 &&
+          flow.scopes[0] &&
+          flow.scopes[0].value.toLowerCase() === "user_impersonation"
+        ) {
+          return securityInfo;
+        }
+        securityInfo.credentialScopes.push(
+          ...flow.scopes.map((item) => {
+            return item.value;
+          }),
+        );
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return securityInfo;
+}
+
+function getEnableOperationGroup(
+  dpgContext: SdkContext,
+  emitterOptions: EmitterOptions,
+  isModularLibrary: boolean,
+) {
+  if (
+    emitterOptions["enable-operation-group"] === true ||
+    emitterOptions["enable-operation-group"] === false
+  ) {
+    return emitterOptions["enable-operation-group"];
+  }
+  // Only detect if existing name conflicts if customers don't set hierarchyClient to true
+  return detectIfNameConflicts(dpgContext, isModularLibrary);
+}
+
+function getEnableModelNamespace(dpgContext: SdkContext, emitterOptions: EmitterOptions) {
+  if (
+    emitterOptions["enable-model-namespace"] === true ||
+    emitterOptions["enable-model-namespace"] === false
+  ) {
+    return emitterOptions["enable-model-namespace"];
+  }
+  // Detect if existing name conflicts if customers didn't set the option explicitly
+  return detectModelConflicts(dpgContext);
+}
+
+function getHierarchyClient(emitterOptions: EmitterOptions) {
+  if (emitterOptions["hierarchy-client"] === true || emitterOptions["hierarchy-client"] === false) {
+    return emitterOptions["hierarchy-client"];
+  }
+  // enable hierarchy client by default if customers didn't set the option explicitly
+  return true;
+}
+
+function getClearOutputFolder(emitterOptions: EmitterOptions) {
+  return emitterOptions["clear-output-folder"] ? true : false;
+}
+
+function detectIfNameConflicts(dpgContext: SdkContext, isModularLibrary: boolean) {
+  const clients = getRLCClients(dpgContext, isModularLibrary);
+  for (const client of clients) {
+    // only consider it's conflict when there are conflicts in the same client
+    const nameSet = new Set<string>();
+    for (const op of listOperationsUnderRLCClient(client)) {
+      const route = getHttpOperationWithCache(dpgContext, op);
+      const name = getOperationName(dpgContext, route.operation);
+      if (nameSet.has(name)) {
+        return true;
+      } else {
+        nameSet.add(name);
+      }
+    }
+  }
+
+  // No conflicts if we didn't detect any
+  return false;
+}
+
+function getIgnoreNullableOnOptional(
+  emitterOptions: EmitterOptions,
+  flavor: PackageFlavor,
+): boolean {
+  // If explicitly set in options, use that value
+  if (emitterOptions["ignore-nullable-on-optional"] !== undefined) {
+    return Boolean(emitterOptions["ignore-nullable-on-optional"]);
+  }
+  // Default to true for Azure services (same as HLC behavior)
+  return flavor === "azure";
+}
+
+function getWrapNonModelReturn(emitterOptions: EmitterOptions, flavor: PackageFlavor): boolean {
+  // If explicitly set in options, use that value
+  if (emitterOptions["wrap-non-model-return"] !== undefined) {
+    return Boolean(emitterOptions["wrap-non-model-return"]);
+  }
+  // Default to true for Azure services to maintain HLC backward compatibility
+  return flavor === "azure";
+}
+
+function getIncludeShortcuts(emitterOptions: EmitterOptions) {
+  return Boolean(emitterOptions["include-shortcuts"]);
+}
+
+function getModuleKind(emitterOptions: EmitterOptions) {
+  return emitterOptions["module-kind"] ?? "esm";
+}
+
+function getFlavor(emitterOptions: EmitterOptions, packageDetails?: PackageDetails): PackageFlavor {
+  const flavor = emitterOptions.flavor;
+
+  if (flavor !== undefined) {
+    if (flavor.toLowerCase() === "azure") {
+      return "azure";
+    } else {
+      return undefined;
+    }
+  }
+
+  const branded = emitterOptions.branded;
+  if (branded !== undefined) {
+    return branded ? "azure" : undefined;
+  }
+
+  const scopeName = packageDetails?.scopeName;
+  if (
+    scopeName !== undefined &&
+    (scopeName.startsWith("azure") || scopeName.startsWith("msinternal"))
+  ) {
+    return "azure";
+  } else {
+    return undefined;
+  }
+}
+function buildPackageDetails(
+  program: Program,
+  emitterOptions: EmitterOptions,
+  isModularLibrary: boolean,
+): PackageDetails {
+  const defaultDetail = {
+    name: "@msinternal/unamedpackage",
+    nameWithoutScope: "unamedpackage",
+    version: "1.0.0-beta.1",
+  };
+  const isVersionUserProvided = Boolean(emitterOptions["package-details"]?.version);
+  const packageDetails: PackageDetails = {
+    ...emitterOptions["package-details"],
+    name:
+      emitterOptions["package-details"]?.name ??
+      normalizeName(
+        emitterOptions?.title ?? getDefaultService(program, isModularLibrary)?.title ?? "",
+        NameType.Class,
+      ),
+    version: emitterOptions["package-details"]?.version ?? "1.0.0-beta.1",
+    isVersionUserProvided,
+  };
+  if (emitterOptions["package-details"]?.name) {
+    const nameParts = emitterOptions["package-details"]?.name.split("/");
+    if (nameParts.length === 2) {
+      packageDetails.nameWithoutScope = nameParts[1];
+      packageDetails.scopeName = nameParts[0]?.replace("@", "");
+    }
+  }
+  return packageDetails ?? defaultDetail;
+}
+
+function getPackageDetails(
+  program: Program,
+  emitterOptions: EmitterOptions,
+  isModularLibrary: boolean,
+): PackageDetails {
+  return buildPackageDetails(program, emitterOptions, isModularLibrary);
+}
+
+function getServiceInfo(program: Program, isModularLibrary: boolean): ServiceInfo {
+  const defaultService = getDefaultService(program, isModularLibrary);
+  return {
+    title: defaultService?.title,
+    description: defaultService && getDoc(program, defaultService.type),
+  };
+}
+
+function getAzureSdkForJs(emitterOptions: EmitterOptions, flavor: PackageFlavor) {
+  return flavor !== "azure"
+    ? false
+    : emitterOptions["azure-sdk-for-js"] === undefined ||
+        emitterOptions["azure-sdk-for-js"] === null
+      ? true
+      : Boolean(emitterOptions["azure-sdk-for-js"]);
+}
+
+function getGenerateMetadata(emitterOptions: EmitterOptions) {
+  if (
+    emitterOptions["generate-metadata"] === undefined ||
+    emitterOptions["generate-metadata"] === null
+  ) {
+    return undefined;
+  }
+  return Boolean(emitterOptions["generate-metadata"]);
+}
+
+/**
+ * In azure scope, by default we generate test.
+ * @param emitterOptions
+ * @returns
+ */
+function getGenerateTest(emitterOptions: EmitterOptions, flavor: PackageFlavor) {
+  // Disable generateTest if azureSdkForJS is false
+  if (!getAzureSdkForJs(emitterOptions, flavor)) {
+    return false;
+  }
+  return emitterOptions["generate-test"];
+}
+
+/**
+ * In azure scope, by default we generate test.
+ * @param emitterOptions
+ * @returns
+ */
+function getGenerateSample(dpgContext: SdkContext, emitterOptions: EmitterOptions) {
+  if (dpgContext.arm && emitterOptions["generate-sample"] === undefined) {
+    return true;
+  }
+  if (
+    emitterOptions["generate-sample"] === undefined ||
+    emitterOptions["generate-sample"] === null
+  ) {
+    return undefined;
+  }
+  return Boolean(emitterOptions["generate-sample"]);
+}
+
+export function getCredentialInfo(
+  program: Program,
+  emitterOptions: EmitterOptions,
+  isModularLibrary: boolean = true,
+) {
+  const securityInfo = processAuth(program, isModularLibrary);
+  const addCredentials =
+    emitterOptions["add-credentials"] === false
+      ? false
+      : securityInfo
+        ? securityInfo.addCredentials
+        : emitterOptions["add-credentials"];
+  const credentialScopes =
+    securityInfo && securityInfo.credentialScopes
+      ? securityInfo.credentialScopes
+      : emitterOptions["credential-scopes"];
+  const credentialKeyHeaderName =
+    securityInfo && securityInfo.credentialKeyHeaderName
+      ? securityInfo.credentialKeyHeaderName
+      : emitterOptions["credential-key-header-name"];
+  const customHttpAuthHeaderName =
+    securityInfo && securityInfo.customHttpAuthHeaderName
+      ? securityInfo.customHttpAuthHeaderName
+      : emitterOptions["custom-http-auth-header-name"];
+  const customHttpAuthSharedKeyPrefix =
+    securityInfo && securityInfo.customHttpAuthSharedKeyPrefix
+      ? securityInfo.customHttpAuthSharedKeyPrefix
+      : emitterOptions["custom-http-auth-shared-key-prefix"];
+  return {
+    addCredentials,
+    credentialScopes,
+    credentialKeyHeaderName,
+    customHttpAuthHeaderName,
+    customHttpAuthSharedKeyPrefix,
+  };
+}
+
+function getAzureOutputDirectory(emitterOutputDir: string): string | undefined {
+  const sdkFolder = emitterOutputDir;
+  const sdkReletivePath = sdkFolder?.replace(/\/$/, "").split("/").slice(-3).join("/");
+  return sdkReletivePath?.substring(0, 3) === "sdk" ? sdkReletivePath : undefined;
+}
+
+export function getSubscriptionId(dpgContext: SdkContext) {
+  //TODO Need consider multi-client cases, skip multi-client cases check for now
+  if (dpgContext.rlcOptions?.multiClient) {
+    return;
+  }
+  for (const client of dpgContext.sdkPackage.clients) {
+    if (
+      getClientParameters(client, dpgContext)
+        .map((item) => item.name)
+        .includes("subscriptionId")
+    ) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/utils/client-utils.ts

@@ -0,0 +1,162 @@
+import {
+  InitializedByFlags,
+  listAllServiceNamespaces,
+  listClients,
+  SdkClient,
+  SdkClientType,
+  SdkServiceOperation,
+} from "@azure-tools/typespec-client-generator-core";
+import {
+  getNamespaceFullName,
+  Interface,
+  isTemplateDeclaration,
+  isTemplateDeclarationOrInstance,
+  Namespace,
+  Operation,
+} from "@typespec/compiler";
+import { ModularClientOptions } from "../modular/interfaces.js";
+import { NameType, normalizeName } from "../rlc-common/index.js";
+import { SdkContext } from "./interfaces.js";
+
+export function getRLCClients(dpgContext: SdkContext, isModularLibrary?: boolean): SdkClient[] {
+  const modular = isModularLibrary ?? dpgContext.rlcOptions?.isModularLibrary ?? false;
+  const clients = listClients(dpgContext);
+  const rawServiceNamespaces =
+    dpgContext.allServiceNamespaces ?? listAllServiceNamespaces(dpgContext);
+
+  // For one client in Modular: Return the client from listClients with multi-service support
+  if (modular && clients.length === 1) {
+    return clients.map((client) => {
+      const services = client.services;
+      return {
+        ...client,
+        services: services,
+        crossLanguageDefinitionId: `${getNamespaceFullName(services[0]!)}.${client.name}`,
+      };
+    });
+  } else {
+    // For RLC and multiple clients in Modular:
+    // Flatten all services and return one client per service
+    const services = new Set<Namespace>();
+    clients.forEach((c) => {
+      const clientService = c.services;
+      clientService.forEach((ns) => services.add(ns));
+    });
+
+    if (services.size > 0) {
+      return [...services.values()].map((service) => {
+        const clientName = service.name + "Client";
+        return {
+          kind: "SdkClient",
+          name: clientName,
+          service: service,
+          type: service,
+          services: [service],
+          subClients: [],
+          clientPath: clientName,
+          arm: Boolean(dpgContext.arm),
+          crossLanguageDefinitionId: `${getNamespaceFullName(service)}.${clientName}`,
+          subOperationGroups: [],
+        };
+      });
+    }
+  }
+
+  // Fallback to raw service namespaces if no clients found
+  return rawServiceNamespaces.map((service) => {
+    const clientName = service.name + "Client";
+    return {
+      kind: "SdkClient",
+      name: clientName,
+      service: service,
+      type: service,
+      services: [service],
+      subClients: [],
+      clientPath: clientName,
+      arm: Boolean(dpgContext.arm),
+      crossLanguageDefinitionId: `${getNamespaceFullName(service)}.${clientName}`,
+      subOperationGroups: [],
+    };
+  });
+}
+
+export function listOperationsUnderRLCClient(client: SdkClient): Operation[] {
+  const operations = [];
+  const serviceArray = client.services;
+  const queue: (Namespace | Interface)[] = [...serviceArray];
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    if (
+      current.decorators.some(
+        (d) =>
+          d.definition?.name === "@client" &&
+          getNamespaceFullName(d.definition?.namespace) === "Azure.ClientGenerator.Core",
+      ) &&
+      !serviceArray.includes(current as Namespace)
+    ) {
+      continue;
+    }
+    operations.push(
+      ...[...current.operations.values()].filter(
+        (op) => isTemplateDeclarationOrInstance(op) === false,
+      ),
+    );
+    if (current.kind === "Namespace") {
+      queue.push(...current.namespaces.values());
+      queue.push(
+        ...[...current.interfaces.values()].filter((i) => isTemplateDeclaration(i) === false),
+      );
+    }
+  }
+  return operations;
+}
+
+export function isRLCMultiEndpoint(dpgContext: SdkContext): boolean {
+  return getRLCClients(dpgContext).length > 1;
+}
+
+export function getModularClientOptions(clientMap: [string[], SdkClientType<SdkServiceOperation>]) {
+  const [hierarchy, client] = clientMap;
+  const clientOptions: ModularClientOptions = {
+    rlcClientName: `${client.name.replace(/Client$/, "")}Context`,
+  };
+  clientOptions.subfolder = hierarchy.join("/");
+  return clientOptions;
+}
+
+export function getClientHierarchyMap(
+  context: SdkContext,
+): [string[], SdkClientType<SdkServiceOperation>][] {
+  const clientMap: [string[], SdkClientType<SdkServiceOperation>][] = [];
+  const individualClients = context.sdkPackage.clients.filter((client) => {
+    return client.clientInitialization.initializedBy & InitializedByFlags.Individually;
+  });
+  const clients = individualClients.map((client) => {
+    return [
+      context.sdkPackage.clients.length > 1
+        ? [normalizeName(client.name.replace("Client", ""), NameType.File)]
+        : [],
+      client,
+    ];
+  }) as [string[], SdkClientType<SdkServiceOperation>][];
+  for (let i = 0; i < clients.length; i++) {
+    const [hierarchy, client] = clients[i]!;
+    clientMap.push([hierarchy, client]);
+    const childClientsToGenerate = client.children?.filter((child) => {
+      return (
+        child.clientInitialization.initializedBy & InitializedByFlags.Individually ||
+        child.clientInitialization.initializedBy & InitializedByFlags.Parent
+      );
+    });
+    if (childClientsToGenerate && childClientsToGenerate.length > 0) {
+      childClientsToGenerate.forEach((child) => {
+        const childHierarchy = [
+          ...hierarchy,
+          normalizeName(child.name.replace("Client", ""), NameType.File),
+        ];
+        clients.push([childHierarchy, child]);
+      });
+    }
+  }
+  return clientMap;
+}

package/src/utils/credential-utils.ts

@@ -0,0 +1,74 @@
+import { SdkClientInitializationType } from "@azure-tools/typespec-client-generator-core";
+import { NoTarget, Program } from "@typespec/compiler";
+import { Authentication, HttpAuth } from "@typespec/http";
+import { reportDiagnostic } from "../lib.js";
+
+/**
+ * Get supported HTTP authentication schemes and filter out unsupported ones.
+ * @param program used to report diagnostics
+ * @param authorization authentication object
+ * @returns supported HTTP authentication schemes
+ */
+export function getSupportedHttpAuth(program: Program, authorization: Authentication): HttpAuth[] {
+  const authList = [];
+  for (const option of authorization.options) {
+    for (const auth of option.schemes) {
+      switch (auth.type) {
+        case "apiKey":
+          if (isSupportedKeyCredential(auth)) {
+            authList.push(auth);
+          } else {
+            // just skip un-supported authentication and report a warning
+            reportDiagnostic(program, {
+              code: "un-supported-credential",
+              format: {
+                credentialType: `${auth.type} ${auth.in}`,
+              },
+              target: NoTarget,
+            });
+          }
+          break;
+        default:
+          authList.push(auth);
+          break;
+      }
+    }
+  }
+
+  return authList;
+}
+
+export function isSupportedKeyCredential(auth: HttpAuth): boolean {
+  return (auth.type === "apiKey" && auth.in === "header") || auth.type === "http";
+}
+
+export function isSupportedTokenCredential(auth: HttpAuth): boolean {
+  return auth.type === "oauth2";
+}
+
+export function hasKeyCredential(initialization: SdkClientInitializationType) {
+  const authScheme = getAuthScheme(initialization);
+  return authScheme.some((auth) => isSupportedKeyCredential(auth));
+}
+
+export function hasTokenCredential(initialization: SdkClientInitializationType) {
+  const authScheme = getAuthScheme(initialization);
+  return authScheme.some((auth) => isSupportedTokenCredential(auth));
+}
+
+function getAuthScheme(initialization: SdkClientInitializationType): HttpAuth[] {
+  const credentialParams = initialization.parameters?.find((param) => param.kind === "credential");
+  if (!credentialParams) {
+    return [];
+  }
+  const kind = credentialParams.type.kind;
+  const authScheme: HttpAuth[] = [];
+  if (kind === "credential") {
+    authScheme.push(credentialParams.type.scheme);
+  } else if (kind === "union") {
+    for (const param of credentialParams.type.variantTypes) {
+      authScheme.push(param.scheme);
+    }
+  }
+  return authScheme;
+}